dtsgenerator/dist/core/dtsGenerator.js

"use strict";
Object.defineProperty(exports, "__esModule", { value: true });
var tslib_1 = require("tslib");
var debug_1 = tslib_1.__importDefault(require("debug"));
var jsonSchema_1 = require("./jsonSchema");
var utils = tslib_1.__importStar(require("./utils"));
var debug = debug_1.default('dtsgen');
var typeMarker = Symbol();
var DtsGenerator = (function () {
    function DtsGenerator(resolver, convertor) {
        this.resolver = resolver;
        this.convertor = convertor;
    }
    DtsGenerator.prototype.generate = function () {
        return tslib_1.__awaiter(this, void 0, void 0, function () {
            var map, result;
            return tslib_1.__generator(this, function (_a) {
                switch (_a.label) {
                    case 0:
                        debug('generate type definition files.');
                        return [4, this.resolver.resolve()];
                    case 1:
                        _a.sent();
                        map = this.convertor.buildSchemaMergedMap(this.resolver.getAllRegisteredSchema(), typeMarker);
                        this.convertor.start();
                        this.walk(map);
                        result = this.convertor.end();
                        return [2, result];
                }
            });
        });
    };
    DtsGenerator.prototype.walk = function (map) {
        var keys = Object.keys(map).sort();
        try {
            for (var keys_1 = tslib_1.__values(keys), keys_1_1 = keys_1.next(); !keys_1_1.done; keys_1_1 = keys_1.next()) {
                var key = keys_1_1.value;
                var value = map[key];
                if (value.hasOwnProperty(typeMarker)) {
                    var schema = value[typeMarker];
                    debug("  walk doProcess: schemaId=" + schema.id.getAbsoluteId());
                    this.walkSchema(schema);
                    delete value[typeMarker];
                }
                if (typeof value === 'object' && Object.keys(value).length > 0) {
                    this.convertor.startNest(key);
                    this.walk(value);
                    this.convertor.endNest();
                }
            }
        }
        catch (e_1_1) { e_1 = { error: e_1_1 }; }
        finally {
            try {
                if (keys_1_1 && !keys_1_1.done && (_a = keys_1.return)) _a.call(keys_1);
            }
            finally { if (e_1) throw e_1.error; }
        }
        var e_1, _a;
    };
    DtsGenerator.prototype.walkSchema = function (schema) {
        var normalized = this.normalizeContent(schema);
        this.currentSchema = normalized;
        this.convertor.outputComments(normalized);
        var type = normalized.content.type;
        switch (type) {
            case 'object':
            case 'any':
                return this.generateTypeModel(normalized);
            case 'array':
                return this.generateTypeCollection(normalized);
            default:
                return this.generateDeclareType(normalized);
        }
    };
    DtsGenerator.prototype.normalizeContent = function (schema, pointer) {
        if (pointer != null) {
            schema = jsonSchema_1.getSubSchema(schema, pointer);
        }
        var content = schema.content;
        if (typeof content === 'boolean') {
            content = content ? {} : { not: {} };
        }
        else {
            if (content.allOf) {
                var work = content;
                try {
                    for (var _a = tslib_1.__values(content.allOf), _b = _a.next(); !_b.done; _b = _a.next()) {
                        var sub = _b.value;
                        if (typeof sub === 'object' && sub.$ref) {
                            var ref = this.resolver.dereference(sub.$ref);
                            sub = this.normalizeContent(ref).content;
                        }
                        utils.mergeSchema(work, sub);
                    }
                }
                catch (e_2_1) { e_2 = { error: e_2_1 }; }
                finally {
                    try {
                        if (_b && !_b.done && (_c = _a.return)) _c.call(_a);
                    }
                    finally { if (e_2) throw e_2.error; }
                }
                delete content.allOf;
                content = work;
            }
            var types = content.type;
            if (types === undefined && (content.properties || content.additionalProperties)) {
                content.type = 'object';
            }
            else if (Array.isArray(types)) {
                var reduced = utils.reduceTypes(types);
                content.type = reduced.length === 1 ? reduced[0] : reduced;
            }
        }
        return Object.assign({}, schema, { content: content });
        var e_2, _c;
    };
    DtsGenerator.prototype.generateDeclareType = function (schema) {
        this.convertor.outputExportType(schema.id);
        this.generateTypeProperty(schema, true);
    };
    DtsGenerator.prototype.generateTypeModel = function (schema) {
        this.convertor.startInterfaceNest(schema.id);
        if (schema.content.type === 'any') {
            this.convertor.outputRawValue('[name: string]: any; // any', true);
        }
        this.generateProperties(schema);
        this.convertor.endInterfaceNest();
    };
    DtsGenerator.prototype.generateTypeCollection = function (schema) {
        this.convertor.outputExportType(schema.id);
        this.generateArrayTypeProperty(schema, true);
    };
    DtsGenerator.prototype.generateProperties = function (baseSchema) {
        var content = baseSchema.content;
        if (content.additionalProperties) {
            this.convertor.outputRawValue('[name: string]: ');
            var schema = this.normalizeContent(baseSchema, '/additionalProperties');
            if (content.additionalProperties === true) {
                this.convertor.outputStringTypeName(schema, 'any', true);
            }
            else {
                this.generateTypeProperty(schema, true);
            }
        }
        if (content.properties) {
            try {
                for (var _a = tslib_1.__values(Object.keys(content.properties)), _b = _a.next(); !_b.done; _b = _a.next()) {
                    var propertyName = _b.value;
                    var schema = this.normalizeContent(baseSchema, '/properties/' + propertyName);
                    this.convertor.outputComments(schema);
                    this.convertor.outputPropertyName(schema, propertyName, baseSchema.content.required);
                    this.generateTypeProperty(schema);
                }
            }
            catch (e_3_1) { e_3 = { error: e_3_1 }; }
            finally {
                try {
                    if (_b && !_b.done && (_c = _a.return)) _c.call(_a);
                }
                finally { if (e_3) throw e_3.error; }
            }
        }
        var e_3, _c;
    };
    DtsGenerator.prototype.generateTypeProperty = function (schema, terminate) {
        var _this = this;
        if (terminate === void 0) { terminate = true; }
        var content = schema.content;
        if (content.$ref) {
            var ref = this.resolver.dereference(content.$ref);
            if (ref.id == null) {
                throw new Error('target referenced id is nothing: ' + content.$ref);
            }
            var refSchema = this.normalizeContent(ref);
            return this.convertor.outputTypeIdName(refSchema, this.currentSchema, terminate);
        }
        if (content.anyOf || content.oneOf) {
            this.generateArrayedType(schema, content.anyOf, '/anyOf/', terminate);
            this.generateArrayedType(schema, content.oneOf, '/oneOf/', terminate);
            return;
        }
        if (content.enum) {
            return this.convertor.outputArrayedType(schema, content.enum, function (value) {
                if (content.type === 'integer') {
                    _this.convertor.outputRawValue('' + value);
                }
                else {
                    _this.convertor.outputRawValue("\"" + value + "\"");
                }
            }, terminate);
        }
        this.generateType(schema, terminate);
    };
    DtsGenerator.prototype.generateArrayedType = function (baseSchema, contents, path, terminate) {
        var _this = this;
        if (contents) {
            this.convertor.outputArrayedType(baseSchema, contents, function (_content, index) {
                var schema = _this.normalizeContent(baseSchema, path + index);
                if (schema.id.isEmpty()) {
                    _this.generateTypeProperty(schema, false);
                }
                else {
                    _this.convertor.outputTypeIdName(schema, _this.currentSchema, false);
                }
            }, terminate);
        }
    };
    DtsGenerator.prototype.generateArrayTypeProperty = function (schema, terminate) {
        if (terminate === void 0) { terminate = true; }
        var items = schema.content.items;
        var minItems = schema.content.minItems;
        if (items == null) {
            this.convertor.outputStringTypeName(schema, 'any[]', terminate);
        }
        else if (!Array.isArray(items)) {
            this.generateTypeProperty(this.normalizeContent(schema, '/items'), false);
            this.convertor.outputStringTypeName(schema, '[]', terminate);
        }
        else if (items.length === 0 && minItems === undefined) {
            this.convertor.outputStringTypeName(schema, 'any[]', terminate);
        }
        else {
            var effectiveMaxItems = 1 + Math.max(minItems || 0, items.length);
            for (var unionIndex = minItems === undefined ? 1 : minItems; unionIndex <= effectiveMaxItems; unionIndex++) {
                this.convertor.outputRawValue('[');
                for (var i = 0; i < unionIndex; i++) {
                    if (i > 0) {
                        this.convertor.outputRawValue(', ');
                    }
                    if (i < items.length) {
                        var type = this.normalizeContent(schema, '/items/' + i);
                        if (type.id.isEmpty()) {
                            this.generateTypeProperty(type, false);
                        }
                        else {
                            this.convertor.outputTypeIdName(type, this.currentSchema, false);
                        }
                    }
                    else {
                        if (i < effectiveMaxItems - 1) {
                            this.convertor.outputStringTypeName(schema, 'Object', false, false);
                        }
                        else {
                            this.convertor.outputStringTypeName(schema, 'any', false, false);
                        }
                    }
                }
                this.convertor.outputRawValue(']');
                if (unionIndex < effectiveMaxItems) {
                    this.convertor.outputRawValue(' | ');
                }
            }
            this.convertor.outputStringTypeName(schema, '', terminate);
        }
    };
    DtsGenerator.prototype.generateType = function (schema, terminate, outputOptional) {
        var _this = this;
        if (outputOptional === void 0) { outputOptional = true; }
        var type = schema.content.type;
        if (type == null) {
            this.convertor.outputPrimitiveTypeName(schema, 'any', terminate, outputOptional);
        }
        else if (typeof type === 'string') {
            this.generateTypeName(schema, type, terminate, outputOptional);
        }
        else {
            var types = utils.reduceTypes(type);
            if (types.length <= 1) {
                schema.content.type = types[0];
                this.generateType(schema, terminate, outputOptional);
            }
            else {
                this.convertor.outputArrayedType(schema, types, function (t) {
                    _this.generateTypeName(schema, t, false, false);
                }, terminate);
            }
        }
    };
    DtsGenerator.prototype.generateTypeName = function (schema, type, terminate, outputOptional) {
        if (outputOptional === void 0) { outputOptional = true; }
        var tsType = utils.toTSType(type, schema.content);
        if (tsType) {
            this.convertor.outputPrimitiveTypeName(schema, tsType, terminate, outputOptional);
        }
        else if (type === 'object') {
            this.convertor.startTypeNest();
            this.generateProperties(schema);
            this.convertor.endTypeNest(terminate);
        }
        else if (type === 'array') {
            this.generateArrayTypeProperty(schema, terminate);
        }
        else {
            throw new Error('unknown type: ' + type);
        }
    };
    return DtsGenerator;
}());
exports.default = DtsGenerator;