dtsgenerator/dist/core/astBuilder.js

"use strict";
Object.defineProperty(exports, "__esModule", { value: true });
exports.addOptionalInformation = exports.addComment = exports.buildTypeReferenceNode = exports.buildTupleTypeNode = exports.buildUnionTypeNode = exports.buildTypeLiteralNode = exports.buildIndexSignatureNode = exports.buildPropertySignature = exports.buildTypeAliasNode = exports.buildInterfaceNode = exports.buildNamespaceNode = exports.buildBooleanLiteralTypeNode = exports.buildNumericLiteralTypeNode = exports.buildStringLiteralTypeNode = exports.buildSimpleArrayNode = exports.buildStringKeyword = exports.buildUnknownKeyword = exports.buildNeverKeyword = exports.buildAnyKeyword = exports.buildKeyword = void 0;
var tslib_1 = require("tslib");
var ts = tslib_1.__importStar(require("typescript"));
var config_1 = tslib_1.__importDefault(require("./config"));
var validateIdentifier_1 = require("./validateIdentifier");
function buildTypeNameIdentifier(name) {
    return ts.createIdentifier(validateIdentifier_1.toValidIdentifier(name, config_1.default.target));
}
function buildPropertyNameIdentifier(name) {
    if (/^\d/.test(name)) {
        name = '$' + name;
    }
    if (validateIdentifier_1.checkInvalidCharacter(name, config_1.default.target)) {
        return ts.createIdentifier(name);
    }
    else {
        return ts.createStringLiteral(name);
    }
}
function buildKeyword(kind) {
    return ts.createKeywordTypeNode(kind);
}
exports.buildKeyword = buildKeyword;
function buildAnyKeyword() {
    return buildKeyword(ts.SyntaxKind.AnyKeyword);
}
exports.buildAnyKeyword = buildAnyKeyword;
function buildNeverKeyword() {
    return buildKeyword(ts.SyntaxKind.NeverKeyword);
}
exports.buildNeverKeyword = buildNeverKeyword;
function buildUnknownKeyword() {
    return buildKeyword(ts.SyntaxKind.UnknownKeyword);
}
exports.buildUnknownKeyword = buildUnknownKeyword;
function buildStringKeyword() {
    return buildKeyword(ts.SyntaxKind.StringKeyword);
}
exports.buildStringKeyword = buildStringKeyword;
function buildSimpleArrayNode(element) {
    return ts.createArrayTypeNode(element);
}
exports.buildSimpleArrayNode = buildSimpleArrayNode;
function buildStringLiteralTypeNode(s) {
    return ts.createLiteralTypeNode(ts.createStringLiteral(s));
}
exports.buildStringLiteralTypeNode = buildStringLiteralTypeNode;
function buildNumericLiteralTypeNode(n) {
    return ts.createLiteralTypeNode(ts.createNumericLiteral(n));
}
exports.buildNumericLiteralTypeNode = buildNumericLiteralTypeNode;
function buildBooleanLiteralTypeNode(b) {
    return ts.createLiteralTypeNode(b ? ts.createTrue() : ts.createFalse());
}
exports.buildBooleanLiteralTypeNode = buildBooleanLiteralTypeNode;
function buildNamespaceNode(name, statements, root) {
    var modifiers = root
        ? [ts.createModifier(ts.SyntaxKind.DeclareKeyword)]
        : undefined;
    return ts.createModuleDeclaration(undefined, modifiers, buildTypeNameIdentifier(name), ts.createModuleBlock(statements), ts.NodeFlags.Namespace |
        ts.NodeFlags.ExportContext |
        ts.NodeFlags.ContextFlags);
}
exports.buildNamespaceNode = buildNamespaceNode;
function buildInterfaceNode(id, members, root) {
    var name = getLastTypeName(id);
    var modifiers = root
        ? [ts.createModifier(ts.SyntaxKind.DeclareKeyword)]
        : [ts.createModifier(ts.SyntaxKind.ExportKeyword)];
    return ts.createInterfaceDeclaration(undefined, modifiers, buildTypeNameIdentifier(name), undefined, undefined, members);
}
exports.buildInterfaceNode = buildInterfaceNode;
function buildTypeAliasNode(id, type, root) {
    var name = getLastTypeName(id);
    var modifiers = root
        ? [ts.createModifier(ts.SyntaxKind.DeclareKeyword)]
        : [ts.createModifier(ts.SyntaxKind.ExportKeyword)];
    return ts.createTypeAliasDeclaration(undefined, modifiers, buildTypeNameIdentifier(name), undefined, type);
}
exports.buildTypeAliasNode = buildTypeAliasNode;
function buildPropertySignature(schema, propertyName, valueType, required, isPattern) {
    var content = schema.content;
    var modifiers = 'readOnly' in content && content.readOnly
        ? [ts.createModifier(ts.SyntaxKind.ReadonlyKeyword)]
        : undefined;
    var questionToken = required == null || required.indexOf(propertyName) < 0
        ? ts.createToken(ts.SyntaxKind.QuestionToken)
        : undefined;
    if (isPattern) {
        return ts.createIndexSignature(undefined, modifiers, [
            ts.createParameter([], [], undefined, ts.createIdentifier('pattern'), undefined, ts.createTypeReferenceNode('string', []), undefined),
        ], valueType);
    }
    return ts.createPropertySignature(modifiers, buildPropertyNameIdentifier(propertyName), questionToken, valueType, undefined);
}
exports.buildPropertySignature = buildPropertySignature;
function buildIndexSignatureNode(name, indexType, valueType) {
    return ts.createIndexSignature(undefined, undefined, [
        ts.createParameter(undefined, undefined, undefined, buildTypeNameIdentifier(name), undefined, indexType, undefined),
    ], valueType);
}
exports.buildIndexSignatureNode = buildIndexSignatureNode;
function buildTypeLiteralNode(elements) {
    return ts.createTypeLiteralNode(elements);
}
exports.buildTypeLiteralNode = buildTypeLiteralNode;
function buildUnionTypeNode(types, builder, terminate) {
    var node = ts.createUnionTypeNode(types.map(builder));
    if (terminate) {
        return node;
    }
    return ts.createParenthesizedType(node);
}
exports.buildUnionTypeNode = buildUnionTypeNode;
function buildTupleTypeNode(types, minItems, maxItems) {
    var nodes = [];
    var itemCount = maxItems != null ? maxItems : Math.max(types.length, minItems || 0);
    for (var i = 0; i < itemCount; i++) {
        var node = i < types.length ? types[i] : buildAnyKeyword();
        if (minItems == null || i >= minItems) {
            node = ts.createOptionalTypeNode(node);
        }
        nodes.push(node);
    }
    if (maxItems == null) {
        nodes.push(ts.createRestTypeNode(ts.createArrayTypeNode(buildAnyKeyword())));
    }
    return ts.createTupleTypeNode(nodes);
}
exports.buildTupleTypeNode = buildTupleTypeNode;
function buildTypeReferenceNode(schema, currentSchema) {
    var typeName = getTypename(schema.id, currentSchema);
    if (typeName.length === 0) {
        throw new Error('TypeName array must not be empty.');
    }
    var node = buildTypeNameIdentifier(typeName[0]);
    for (var i = 1; i < typeName.length; i++) {
        node = ts.createQualifiedName(node, buildTypeNameIdentifier(typeName[i]));
    }
    return ts.createTypeReferenceNode(node, undefined);
}
exports.buildTypeReferenceNode = buildTypeReferenceNode;
function getTypename(id, baseSchema) {
    var e_1, _a;
    var result = id.toNames();
    var baseId = baseSchema.id;
    if (baseId) {
        var baseTypes = baseId.toNames().slice(0, -1);
        try {
            for (var baseTypes_1 = tslib_1.__values(baseTypes), baseTypes_1_1 = baseTypes_1.next(); !baseTypes_1_1.done; baseTypes_1_1 = baseTypes_1.next()) {
                var type = baseTypes_1_1.value;
                if (result.length === 1) {
                    break;
                }
                if (result[0] === type) {
                    result.shift();
                }
                else {
                    break;
                }
            }
        }
        catch (e_1_1) { e_1 = { error: e_1_1 }; }
        finally {
            try {
                if (baseTypes_1_1 && !baseTypes_1_1.done && (_a = baseTypes_1.return)) _a.call(baseTypes_1);
            }
            finally { if (e_1) throw e_1.error; }
        }
    }
    return result;
}
function addComment(node, schema, terminate) {
    var e_2, _a;
    var comments = getComment(schema);
    if (comments.length === 0) {
        return node;
    }
    else if (!terminate && comments.length === 1) {
        return ts.addSyntheticLeadingComment(node, ts.SyntaxKind.MultiLineCommentTrivia, " " + comments[0] + " ", false);
    }
    else {
        var result = '*\n';
        try {
            for (var comments_1 = tslib_1.__values(comments), comments_1_1 = comments_1.next(); !comments_1_1.done; comments_1_1 = comments_1.next()) {
                var comment = comments_1_1.value;
                result += ' * ' + comment + '\n';
            }
        }
        catch (e_2_1) { e_2 = { error: e_2_1 }; }
        finally {
            try {
                if (comments_1_1 && !comments_1_1.done && (_a = comments_1.return)) _a.call(comments_1);
            }
            finally { if (e_2) throw e_2.error; }
        }
        result += ' ';
        return ts.addSyntheticLeadingComment(node, ts.SyntaxKind.MultiLineCommentTrivia, result, true);
    }
}
exports.addComment = addComment;
function getComment(schema) {
    var e_3, _a;
    var content = schema.content;
    var comments = [];
    function protectComment(str) {
        return str.replace(/\*\//g, '*\u200B/');
    }
    function appendComment(value) {
        if (value == null) {
            return;
        }
        var s = typeof value === 'string' ? value : JSON.stringify(value, null, 2);
        var lines = s.split('\n').map(function (line) { return protectComment(line); });
        comments = comments.concat.apply(comments, tslib_1.__spread(lines));
    }
    if ('$comment' in content) {
        appendComment(content.$comment);
    }
    appendComment(content.title);
    appendComment(content.description);
    if ('example' in content || 'examples' in content) {
        appendComment('example:');
        if ('example' in content) {
            appendComment(content.example);
        }
        if ('examples' in content) {
            if (content.examples) {
                try {
                    for (var _b = tslib_1.__values(content.examples), _c = _b.next(); !_c.done; _c = _b.next()) {
                        var e = _c.value;
                        appendComment(e);
                    }
                }
                catch (e_3_1) { e_3 = { error: e_3_1 }; }
                finally {
                    try {
                        if (_c && !_c.done && (_a = _b.return)) _a.call(_b);
                    }
                    finally { if (e_3) throw e_3.error; }
                }
            }
        }
    }
    return comments;
}
function addOptionalInformation(node, schema, terminate) {
    var format = schema.content.format;
    var pattern = schema.content.pattern;
    if (!format && !pattern) {
        return node;
    }
    var comment = '';
    if (format) {
        comment += ' ' + format;
    }
    if (pattern) {
        comment += ' ' + pattern;
    }
    if (!terminate) {
        comment += ' ';
    }
    var kind = terminate
        ? ts.SyntaxKind.SingleLineCommentTrivia
        : ts.SyntaxKind.MultiLineCommentTrivia;
    return ts.addSyntheticTrailingComment(node, kind, comment, false);
}
exports.addOptionalInformation = addOptionalInformation;
function getLastTypeName(id) {
    var names = id.toNames();
    if (names.length > 0) {
        return names[names.length - 1];
    }
    else {
        return '';
    }
}
//# sourceMappingURL=astBuilder.js.map