@spec2ts/core/lib/common.js

Core module for @spec2ts modules, includes codegen helpers and common parsing methods

"use strict";
Object.defineProperty(exports, "__esModule", { value: true });
exports.isKeywordTypeNode = exports.isKeywordTypeName = exports.block = exports.replaceNode = exports.appendNodes = exports.createKeywordType = exports.createQuestionToken = exports.getString = exports.getName = exports.modifier = exports.keywordType = exports.questionDotToken = exports.questionToken = void 0;
const ts = require("typescript");
exports.questionToken = ts.factory.createToken(ts.SyntaxKind.QuestionToken);
exports.questionDotToken = ts.factory.createToken(ts.SyntaxKind.QuestionDotToken);
exports.keywordType = {
    any: ts.factory.createKeywordTypeNode(ts.SyntaxKind.AnyKeyword),
    number: ts.factory.createKeywordTypeNode(ts.SyntaxKind.NumberKeyword),
    object: ts.factory.createKeywordTypeNode(ts.SyntaxKind.ObjectKeyword),
    string: ts.factory.createKeywordTypeNode(ts.SyntaxKind.StringKeyword),
    boolean: ts.factory.createKeywordTypeNode(ts.SyntaxKind.BooleanKeyword),
    bigint: ts.factory.createKeywordTypeNode(ts.SyntaxKind.BigIntKeyword),
    symbol: ts.factory.createKeywordTypeNode(ts.SyntaxKind.SymbolKeyword),
    this: ts.factory.createThisTypeNode(),
    void: ts.factory.createKeywordTypeNode(ts.SyntaxKind.VoidKeyword),
    unknown: ts.factory.createKeywordTypeNode(ts.SyntaxKind.UnknownKeyword),
    undefined: ts.factory.createKeywordTypeNode(ts.SyntaxKind.UndefinedKeyword),
    null: ts.factory.createLiteralTypeNode(ts.factory.createNull()),
    never: ts.factory.createKeywordTypeNode(ts.SyntaxKind.NeverKeyword)
};
exports.modifier = {
    async: ts.factory.createModifier(ts.SyntaxKind.AsyncKeyword),
    export: ts.factory.createModifier(ts.SyntaxKind.ExportKeyword)
};
function getName(name) {
    if (ts.isIdentifier(name)) {
        return name.escapedText;
    }
    if (ts.isLiteralExpression(name)) {
        return name.text;
    }
    return "";
}
exports.getName = getName;
function getString(expr) {
    if (ts.isIdentifier(expr)) {
        return expr.escapedText.toString();
    }
    if (ts.isLiteralExpression(expr)) {
        return expr.text;
    }
    return "";
}
exports.getString = getString;
function createQuestionToken(token) {
    if (!token)
        return undefined;
    if (token === true)
        return exports.questionToken;
    return token;
}
exports.createQuestionToken = createQuestionToken;
function createKeywordType(type) {
    return exports.keywordType[type];
}
exports.createKeywordType = createKeywordType;
function appendNodes(array, ...nodes) {
    return ts.factory.createNodeArray([...array, ...nodes]);
}
exports.appendNodes = appendNodes;
function replaceNode(array, oldNode, newNode) {
    const i = array.indexOf(oldNode);
    if (i === -1)
        return array;
    return ts.factory.createNodeArray([
        ...array.slice(0, i),
        newNode,
        ...array.slice(i + 1)
    ]);
}
exports.replaceNode = replaceNode;
function block(...statements) {
    return ts.factory.createBlock(statements, true);
}
exports.block = block;
function isKeywordTypeName(type) {
    return type in exports.keywordType;
}
exports.isKeywordTypeName = isKeywordTypeName;
function isKeywordTypeNode(node) {
    if (!node)
        return false;
    return node.kind === ts.SyntaxKind.AnyKeyword ||
        node.kind === ts.SyntaxKind.UnknownKeyword ||
        node.kind === ts.SyntaxKind.NumberKeyword ||
        node.kind === ts.SyntaxKind.BigIntKeyword ||
        node.kind === ts.SyntaxKind.ObjectKeyword ||
        node.kind === ts.SyntaxKind.BooleanKeyword ||
        node.kind === ts.SyntaxKind.StringKeyword ||
        node.kind === ts.SyntaxKind.SymbolKeyword ||
        node.kind === ts.SyntaxKind.ThisKeyword ||
        node.kind === ts.SyntaxKind.VoidKeyword ||
        node.kind === ts.SyntaxKind.UndefinedKeyword ||
        node.kind === ts.SyntaxKind.NullKeyword ||
        node.kind === ts.SyntaxKind.NeverKeyword;
}
exports.isKeywordTypeNode = isKeywordTypeNode;