typescript-to-json-schema-extra/dist/src/SchemaGenerator.js

Some extra features for typescript-to-json-schema

"use strict";
var __assign = (this && this.__assign) || Object.assign || function(t) {
    for (var s, i = 1, n = arguments.length; i < n; i++) {
        s = arguments[i];
        for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))
            t[p] = s[p];
    }
    return t;
};
var ts = require("typescript");
var dist_1 = require("typescript-to-json-schema/dist");
var SchemaGenerator = (function () {
    function SchemaGenerator(program, nodeParser, typeFormatter) {
        this.program = program;
        this.nodeParser = nodeParser;
        this.typeFormatter = typeFormatter;
    }
    SchemaGenerator.prototype.createSchemas = function (filter) {
        var rootNodes = this.findRootNodes(filter);
        var schemas = {};
        for (var name in rootNodes) {
            if (rootNodes.hasOwnProperty(name)) {
                schemas[name] = this.createSchemaFromNode(rootNodes[name]);
            }
        }
        return schemas;
    };
    SchemaGenerator.prototype.createSchema = function (fullName) {
        return this.createSchemaFromNode(this.findRootNode(fullName));
    };
    SchemaGenerator.prototype.createSchemaFromNode = function (node) {
        var rootType = this.nodeParser.createType(node, new dist_1.Context());
        var schema = __assign({ $schema: "http://json-schema.org/draft-04/schema#", definitions: this.getRootChildDefinitions(rootType), extra: {
                filename: node.getSourceFile().path,
            } }, this.getRootTypeDefinition(rootType));
        if (node.kind === ts.SyntaxKind.EnumDeclaration) {
            schema.extra.members = node.members.map(function (m) { return m.name.getText(); });
        }
        return schema;
    };
    SchemaGenerator.prototype.findRootNode = function (fullName) {
        var allTypes = this.findRootNodes(function (fileName) { return true; });
        var rootNode = allTypes[fullName];
        if (!rootNode) {
            throw new dist_1.NoRootTypeError(fullName);
        }
        return rootNode;
    };
    SchemaGenerator.prototype.findRootNodes = function (filter) {
        var _this = this;
        var typeChecker = this.program.getTypeChecker();
        var allTypes = {};
        this.program.getSourceFiles().forEach(function (sourceFile) {
            if (filter(sourceFile.fileName)) {
                _this.inspectNode(sourceFile, typeChecker, allTypes);
            }
        });
        return allTypes;
    };
    SchemaGenerator.prototype.inspectNode = function (node, typeChecker, allTypes) {
        var _this = this;
        if (node.kind === ts.SyntaxKind.InterfaceDeclaration ||
            node.kind === ts.SyntaxKind.EnumDeclaration ||
            node.kind === ts.SyntaxKind.TypeAliasDeclaration) {
            if (!this.isExportType(node)) {
                return;
            }
            else if (this.isGenericType(node)) {
                return;
            }
            allTypes[this.getFullName(node, typeChecker)] = node;
        }
        else {
            ts.forEachChild(node, function (subnode) { return _this.inspectNode(subnode, typeChecker, allTypes); });
        }
    };
    SchemaGenerator.prototype.isExportType = function (node) {
        var localSymbol = node.localSymbol;
        return localSymbol ? (localSymbol.flags & ts.SymbolFlags.Export) !== 0 : false;
    };
    SchemaGenerator.prototype.isGenericType = function (node) {
        return (node.typeParameters &&
            node.typeParameters.length > 0);
    };
    SchemaGenerator.prototype.getFullName = function (node, typeChecker) {
        var symbol = node.symbol;
        return typeChecker.getFullyQualifiedName(symbol).replace(/".*"\./, "");
    };
    SchemaGenerator.prototype.getRootTypeDefinition = function (rootType) {
        return this.typeFormatter.getDefinition(rootType);
    };
    SchemaGenerator.prototype.getRootChildDefinitions = function (rootType) {
        var _this = this;
        return this.typeFormatter.getChildren(rootType)
            .filter(function (child) { return child instanceof dist_1.DefinitionType; })
            .reduce(function (result, child) {
            return (__assign({}, result, (_a = {}, _a[child.getId()] = _this.typeFormatter.getDefinition(child.getType()), _a)));
            var _a;
        }, {});
    };
    return SchemaGenerator;
}());
exports.SchemaGenerator = SchemaGenerator;
//# sourceMappingURL=SchemaGenerator.js.map