dtsgenerator 3.12.1 → 3.14.0

package/dist/core/dtsGenerator.js

@@ -1,17 +1,17 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 const tslib_1 = require("tslib");
-const debug_1 = tslib_1.__importDefault(require("debug"));
-const ts = tslib_1.__importStar(require("typescript"));
+const debug_1 = (0, tslib_1.__importDefault)(require("debug"));
+const ts = (0, tslib_1.__importStar)(require("typescript"));
 const jsonPointer_1 = require("../jsonPointer");
-const ast = tslib_1.__importStar(require("./astBuilder"));
-const config_1 = tslib_1.__importDefault(require("./config"));
+const ast = (0, tslib_1.__importStar)(require("./astBuilder"));
+const config_1 = (0, tslib_1.__importDefault)(require("./config"));
 const jsonSchema_1 = require("./jsonSchema");
-const referenceResolver_1 = tslib_1.__importDefault(require("./referenceResolver"));
+const referenceResolver_1 = (0, tslib_1.__importDefault)(require("./referenceResolver"));
 const type_1 = require("./type");
-const utils = tslib_1.__importStar(require("./utils"));
-const debug = debug_1.default('dtsgen');
-const typeMarker = Symbol();
+const typeTree_1 = require("./typeTree");
+const utils = (0, tslib_1.__importStar)(require("./utils"));
+const debug = (0, debug_1.default)('dtsgen');
 class DtsGenerator {
     constructor(contents) {
         this.resolver = new referenceResolver_1.default();
@@ -26,8 +26,8 @@ class DtsGenerator {
         debug('generate type definition files.');
         this.contents.forEach((schema) => this.resolver.registerSchema(schema));
         await this.resolver.resolve();
-        const map = this.buildSchemaMergedMap(this.resolver.getAllRegisteredSchema());
-        const root = this.walk(map, true);
+        const tree = (0, typeTree_1.buildTypeTree)(this.resolver.getAllRegisteredSchema());
+        const root = this.walk(tree);
         const file = ts.createSourceFile('_.d.ts', '', config_1.default.target, false, ts.ScriptKind.TS);
         Object.assign(file, {
             statements: ts.factory.createNodeArray(root),
@@ -44,33 +44,11 @@ class DtsGenerator {
         result.dispose();
         return transformedContent;
     }
-    buildSchemaMergedMap(schemas) {
-        const map = {};
-        const paths = [];
-        for (const type of schemas) {
-            const path = type.id.toNames();
-            paths.push({ path, type });
-        }
-        for (const item of paths) {
-            const path = item.path;
-            const parent = jsonPointer_1.get(map, path, true);
-            if (parent == null) {
-                jsonPointer_1.set(map, path, { [typeMarker]: item.type });
-            }
-            else {
-                Object.assign(parent, { [typeMarker]: item.type });
-            }
-        }
-        if (Object.keys(map).length === 0) {
-            throw new Error('There is no schema in the input contents.');
-        }
-        return map;
-    }
     async getPlugins() {
         const pre = [];
         const post = [];
         for (const [name, option] of Object.entries(config_1.default.plugins)) {
-            const plugin = await type_1.loadPlugin(name, option);
+            const plugin = await (0, type_1.loadPlugin)(name, option);
             if (plugin == null) {
                 continue;
             }
@@ -117,18 +95,20 @@ class DtsGenerator {
         }
         return result;
     }
-    walk(map, root) {
+    walk(tree, root = true) {
         const result = [];
-        const keys = Object.keys(map).sort();
+        const keys = [...tree.children.keys()].sort();
         for (const key of keys) {
-            const value = map[key];
-            if (typeof value === 'object' &&
-                Object.prototype.hasOwnProperty.call(value, typeMarker)) {
-                const schema = value[typeMarker];
+            const value = tree.children.get(key);
+            if (value === undefined) {
+                continue;
+            }
+            if (value.schema !== undefined) {
+                const schema = value.schema;
                 debug(`  walk doProcess: key=${key} schemaId=${schema.id.getAbsoluteId()}`);
                 result.push(this.walkSchema(schema, root));
             }
-            if (typeof value === 'object' && Object.keys(value).length > 0) {
+            if (value.children.size > 0) {
                 result.push(ast.buildNamespaceNode(key, this.walk(value, false), root));
             }
         }
@@ -137,23 +117,23 @@ class DtsGenerator {
     walkSchema(schema, root) {
         const normalized = this.normalizeContent(schema);
         this.currentSchema = normalized;
-        const getNode = () => {
-            const type = normalized.content.type;
-            switch (type) {
-                case 'any':
-                    return this.generateAnyTypeModel(normalized, root);
-                case 'array':
-                    return this.generateTypeCollection(normalized, root);
-                case 'object':
-                default:
-                    return this.generateDeclareType(normalized, root);
-            }
-        };
-        return ast.addOptionalInformation(ast.addComment(getNode(), normalized, true), normalized, true);
+        return ast.addOptionalInformation(ast.addComment(this.parseSchema(normalized, root), normalized, true), normalized, true);
+    }
+    parseSchema(schema, root = false) {
+        const type = schema.content.type;
+        switch (type) {
+            case 'any':
+                return this.generateAnyTypeModel(schema, root);
+            case 'array':
+                return this.generateTypeCollection(schema, root);
+            case 'object':
+            default:
+                return this.generateDeclareType(schema, root);
+        }
     }
     normalizeContent(schema, pointer) {
         if (pointer != null) {
-            schema = jsonSchema_1.getSubSchema(schema, pointer);
+            schema = (0, jsonSchema_1.getSubSchema)(schema, pointer);
         }
         return Object.assign(schema, {
             content: this.normalizeSchemaContent(schema.content),
@@ -247,19 +227,15 @@ class DtsGenerator {
         }
         if (content.properties) {
             for (const propertyName of Object.keys(content.properties)) {
-                const schema = this.normalizeContent(baseSchema, '/properties/' + jsonPointer_1.tilde(propertyName));
+                const schema = this.normalizeContent(baseSchema, '/properties/' + (0, jsonPointer_1.tilde)(propertyName));
                 const node = ast.buildPropertySignature(schema, propertyName, this.generateTypeProperty(schema), baseSchema.content.required, false);
                 result.push(ast.addOptionalInformation(ast.addComment(node, schema, true), schema, true));
             }
         }
         if (content.patternProperties) {
-            const schemasTypes = [];
-            for (const propertyName of Object.keys(content.patternProperties)) {
-                const schema = this.normalizeContent(baseSchema, '/patternProperties/' + jsonPointer_1.tilde(propertyName));
-                schemasTypes.push(this.generateTypeProperty(schema));
-            }
-            const node = ast.buildPropertySignature({ content: { readOnly: false } }, 'pattern', ts.createUnionTypeNode(schemasTypes), baseSchema.content.required, true);
-            result.push(ts.addSyntheticTrailingComment(node, ts.SyntaxKind.MultiLineCommentTrivia, ` Patterns: ${Object.keys(content.patternProperties).join(' | ')} `));
+            const properties = Object.keys(content.patternProperties);
+            const node = ast.buildPropertySignature({ content: { readOnly: false } }, 'pattern', ast.buildUnionTypeNode(properties, (propertyName) => this.generateTypeProperty(this.normalizeContent(baseSchema, '/patternProperties/' + (0, jsonPointer_1.tilde)(propertyName))), true), baseSchema.content.required, true);
+            result.push(ts.addSyntheticTrailingComment(node, ts.SyntaxKind.MultiLineCommentTrivia, ` Patterns: ${properties.join(' | ')} `));
         }
         return result;
     }
@@ -271,19 +247,23 @@ class DtsGenerator {
                 throw new Error('target referenced id is nothing: ' + content.$ref);
             }
             const refSchema = this.normalizeContent(ref);
-            const node = ast.buildTypeReferenceNode(refSchema, this.currentSchema);
-            return ast.addOptionalInformation(ast.addComment(node, refSchema, false), refSchema, false);
+            const node = ast.addOptionalInformation(ast.addComment(ast.buildTypeReferenceNode(refSchema, this.currentSchema), refSchema, false), refSchema, false);
+            return node;
         }
         if (content.anyOf) {
             const mergeContent = Object.assign({}, content);
             delete mergeContent.anyOf;
-            return this.generateArrayedType(schema, content.anyOf, mergeContent, '/anyOf/', terminate);
+            return this.generateUnionType(schema, content.anyOf, mergeContent, '/anyOf/', terminate);
         }
         if (content.oneOf) {
             const mergeContent = Object.assign({}, content);
             delete mergeContent.oneOf;
-            return this.generateArrayedType(schema, content.oneOf, mergeContent, '/oneOf/', terminate);
+            return this.generateUnionType(schema, content.oneOf, mergeContent, '/oneOf/', terminate);
         }
+        return this.generateLiteralTypeProperty(schema, terminate);
+    }
+    generateLiteralTypeProperty(schema, terminate = true) {
+        const content = schema.content;
         if (content.enum) {
             return ast.buildUnionTypeNode(content.enum, (value) => {
                 return this.generateLiteralTypeNode(content, value);
@@ -299,17 +279,32 @@ class DtsGenerator {
             return this.generateType(schema, terminate);
         }
     }
+    checkExistOtherType(content, base) {
+        const schema = Object.assign({}, base, { content });
+        const result = this.generateLiteralTypeProperty(schema, false);
+        if (result.kind === ts.SyntaxKind.AnyKeyword) {
+            return undefined;
+        }
+        else if (result.kind === ts.SyntaxKind.TypeLiteral) {
+            const node = result;
+            if (node.members.length === 1 &&
+                node.members[0].kind === ts.SyntaxKind.IndexSignature) {
+                return undefined;
+            }
+        }
+        return result;
+    }
     generateLiteralTypeNode(content, value) {
         switch (content.type) {
             case 'integer':
             case 'number':
                 return ast.buildNumericLiteralTypeNode(String(value));
             case 'boolean':
-                return ast.buildBooleanLiteralTypeNode(value);
+                return ast.buildBooleanLiteralTypeNode(Boolean(value));
             case 'null':
                 return ast.buildNullKeyword();
             case 'string':
-                return ast.buildStringLiteralTypeNode(value);
+                return ast.buildStringLiteralTypeNode(String(value));
         }
         if (value === null) {
             return ast.buildNullKeyword();
@@ -324,17 +319,28 @@ class DtsGenerator {
         }
         return ast.buildStringLiteralTypeNode(String(value));
     }
-    generateArrayedType(baseSchema, contents, mergeContent, path, terminate) {
-        return ast.addOptionalInformation(ast.addComment(ast.buildUnionTypeNode(contents, (_, index) => {
+    generateUnionType(baseSchema, contents, mergeContent, path, terminate) {
+        const merged = [];
+        const children = contents.map((_, index) => {
             const schema = this.normalizeContent(baseSchema, path + index.toString());
-            utils.mergeSchema(schema.content, mergeContent);
-            if (schema.id.isEmpty()) {
-                return ast.addOptionalInformation(this.generateTypeProperty(schema, false), schema, false);
-            }
-            else {
-                return ast.addOptionalInformation(ast.buildTypeReferenceNode(schema, this.currentSchema), schema, false);
+            merged.push(utils.mergeSchema(schema.content, mergeContent));
+            return schema;
+        });
+        const allRef = merged.every((b) => !b);
+        const baseType = this.checkExistOtherType(mergeContent, baseSchema);
+        const result = ast.addOptionalInformation(ast.addComment(ast.buildUnionTypeNode(children, (schema, index) => {
+            const node = schema.id.isEmpty()
+                ? ast.addOptionalInformation(this.generateTypeProperty(schema, false), schema, false)
+                : ast.addOptionalInformation(ast.buildTypeReferenceNode(schema, this.currentSchema), schema, false);
+            if (baseType != null && !allRef && !merged[index]) {
+                return ast.buildIntersectionTypeNode([baseType, node], false);
             }
+            return node;
         }, terminate), baseSchema, false), baseSchema, terminate);
+        if (baseType != null && allRef) {
+            return ast.buildIntersectionTypeNode([baseType, result], terminate);
+        }
+        return result;
     }
     generateArrayTypeProperty(schema, terminate = true) {
         const items = schema.content.items;

package/dist/core/index.js

@@ -3,13 +3,13 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.SchemaId = void 0;
 const tslib_1 = require("tslib");
 const config_1 = require("./config");
-const dtsGenerator_1 = tslib_1.__importDefault(require("./dtsGenerator"));
+const dtsGenerator_1 = (0, tslib_1.__importDefault)(require("./dtsGenerator"));
 var schemaId_1 = require("./schemaId");
-Object.defineProperty(exports, "SchemaId", { enumerable: true, get: function () { return tslib_1.__importDefault(schemaId_1).default; } });
-tslib_1.__exportStar(require("./type"), exports);
+Object.defineProperty(exports, "SchemaId", { enumerable: true, get: function () { return (0, tslib_1.__importDefault)(schemaId_1).default; } });
+(0, tslib_1.__exportStar)(require("./type"), exports);
 async function dtsGenerator(options) {
     if (options.config) {
-        config_1.setConfig(options.config);
+        (0, config_1.setConfig)(options.config);
     }
     const generator = new dtsGenerator_1.default(options.contents);
     return await generator.generate();

package/dist/core/jsonSchema.js

@@ -2,8 +2,8 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.selectSchemaType = exports.searchAllSubSchema = exports.setId = exports.getId = exports.getSubSchema = void 0;
 const tslib_1 = require("tslib");
-const JsonPointer = tslib_1.__importStar(require("../jsonPointer"));
-const schemaId_1 = tslib_1.__importDefault(require("./schemaId"));
+const JsonPointer = (0, tslib_1.__importStar)(require("../jsonPointer"));
+const schemaId_1 = (0, tslib_1.__importDefault)(require("./schemaId"));
 const type_1 = require("./type");
 function getSubSchema(rootSchema, pointer, id) {
     const content = JsonPointer.get(rootSchema.content, JsonPointer.parse(pointer));
@@ -36,7 +36,7 @@ const Draft04Id = 'id';
 const Draft07Id = '$id';
 function getId(type, content) {
     var _a, _b;
-    if (type_1.isJsonSchemaDraft04(content, type)) {
+    if ((0, type_1.isJsonSchemaDraft04)(content, type)) {
         return (_a = content[Draft04Id]) !== null && _a !== void 0 ? _a : '';
     }
     else {
@@ -46,7 +46,7 @@ function getId(type, content) {
 exports.getId = getId;
 function setId(type, content, id) {
     var _a, _b;
-    if (type_1.isJsonSchemaDraft04(content, type)) {
+    if ((0, type_1.isJsonSchemaDraft04)(content, type)) {
         (_a = content[Draft04Id]) !== null && _a !== void 0 ? _a : (content[Draft04Id] = id);
     }
     else {
@@ -382,6 +382,7 @@ function searchAllSubSchema(schema, onFoundSchema, onFoundReference) {
 }
 exports.searchAllSubSchema = searchAllSubSchema;
 function selectSchemaType(content) {
+    var _a;
     if (typeof content === 'boolean') {
         return { type: 'Draft07' };
     }
@@ -389,10 +390,21 @@ function selectSchemaType(content) {
         throw new Error(`expect parameter of type object, received ${typeof content}`);
     }
     if ('$schema' in content) {
-        const { $schema: schema } = content;
-        const match = /http:\/\/json-schema\.org\/draft-(\d+)\/schema#?/.exec(schema !== null && schema !== void 0 ? schema : '');
+        const schema = (_a = content['$schema']) !== null && _a !== void 0 ? _a : '';
+        if (/^https?:\/\/json-schema.org\/schema#?$/.test(schema)) {
+            return { type: 'Latest' };
+        }
+        const match = /^https?:\/\/json-schema\.org\/(?:draft\/(\d{4}-\d{2})|draft-(\d+))\/schema#?$/.exec(schema);
         if (match) {
-            const version = Number(match[1]);
+            if (match[1] != null) {
+                switch (match[1]) {
+                    case '2019-09':
+                        return { type: '2019-09' };
+                    case '2020-12':
+                        return { type: '2020-12' };
+                }
+            }
+            const version = Number(match[2]);
             if (version <= 4) {
                 return { type: 'Draft04' };
             }

package/dist/core/referenceResolver.d.ts

@@ -5,7 +5,7 @@ export default class ReferenceResolver {
     private readonly referenceCache;
     dereference(refId: string): Schema;
     getAllRegisteredSchema(): IterableIterator<Schema>;
-    getAllRegisteredIdAndSchema(): Iterator<[string, Schema]>;
+    getAllRegisteredIdAndSchema(): IterableIterator<[string, Schema]>;
     resolve(): Promise<void>;
     private searchParentSchema;
     registerSchema(schema: Schema): void;

package/dist/core/referenceResolver.js

@@ -2,11 +2,11 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 const tslib_1 = require("tslib");
 require("cross-fetch/polyfill");
-const debug_1 = tslib_1.__importDefault(require("debug"));
+const debug_1 = (0, tslib_1.__importDefault)(require("debug"));
 const jsonSchema_1 = require("./jsonSchema");
-const schemaId_1 = tslib_1.__importDefault(require("./schemaId"));
+const schemaId_1 = (0, tslib_1.__importDefault)(require("./schemaId"));
 const type_1 = require("./type");
-const debug = debug_1.default('dtsgen');
+const debug = (0, debug_1.default)('dtsgen');
 class ReferenceResolver {
     constructor() {
         this.schemaCache = new Map();
@@ -41,7 +41,7 @@ class ReferenceResolver {
                 if (refSchema == null && id.isFetchable()) {
                     try {
                         debug(`fetch remote schema: id=[${fileId}].`);
-                        const s = await type_1.readSchemaFromUrl(fileId);
+                        const s = await (0, type_1.readSchemaFromUrl)(fileId);
                         this.registerSchema(s);
                     }
                     catch (e) {
@@ -62,7 +62,7 @@ class ReferenceResolver {
                         error.push(`The $ref targets root is not found: ${id.getAbsoluteId()}`);
                         continue;
                     }
-                    const targetSchema = jsonSchema_1.getSubSchema(rootSchema, id.getJsonPointerHash(), id);
+                    const targetSchema = (0, jsonSchema_1.getSubSchema)(rootSchema, id.getJsonPointerHash(), id);
                     this.addSchema(targetSchema);
                     this.registerSchema(targetSchema);
                     this.referenceCache.set(id.getAbsoluteId(), targetSchema);
@@ -96,7 +96,7 @@ class ReferenceResolver {
     }
     registerSchema(schema) {
         debug(`register schema: schemaId=[${schema.id.getAbsoluteId()}].`);
-        jsonSchema_1.searchAllSubSchema(schema, (subSchema) => {
+        (0, jsonSchema_1.searchAllSubSchema)(schema, (subSchema) => {
             this.addSchema(subSchema);
         }, (refId) => {
             this.addReference(refId);

package/dist/core/schemaId.js

@@ -1,7 +1,7 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 const tslib_1 = require("tslib");
-const url = tslib_1.__importStar(require("url"));
+const url = (0, tslib_1.__importStar)(require("url"));
 const validateIdentifier_1 = require("./validateIdentifier");
 class SchemaId {
     constructor(inputId, parentIds) {

package/dist/core/type.d.ts

@@ -7,7 +7,7 @@ import SchemaId from './schemaId';
 export import ts = require('typescript');
 export declare type JsonSchema = JsonSchemaDraft04.Schema | JsonSchemaDraft07.Schema;
 export declare type JsonSchemaObject = JsonSchemaDraft04.Schema | JsonSchemaDraft07.SchemaObject;
-export declare type SchemaType = 'Draft04' | 'Draft07';
+export declare type SchemaType = 'Draft04' | 'Draft07' | '2019-09' | '2020-12' | 'Latest';
 export declare function isJsonSchemaDraft04(_content: JsonSchemaObject, type: SchemaType): _content is JsonSchemaDraft04.Schema;
 export declare type $Ref = OpenApisV3.SchemaJson.Definitions.Reference | OpenApisV2.SchemaJson.Definitions.JsonReference;
 export interface Schema {
@@ -24,7 +24,7 @@ export declare function readSchemaFromUrl(url: string): Promise<Schema>;
 export declare function parseFileContent(content: string, filename?: string): JsonSchema;
 export interface PluginContext {
     option: boolean | Record<string, unknown>;
-    inputSchemas: Iterator<[string, Schema]>;
+    inputSchemas: IterableIterator<[string, Schema]>;
 }
 export declare type PreProcessHandler = (contents: Schema[]) => Schema[];
 export declare type Plugin = {

package/dist/core/type.js

@@ -2,25 +2,25 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.loadPlugin = exports.parseFileContent = exports.readSchemaFromUrl = exports.readSchemasFromFile = exports.readSchemaFromStdin = exports.parseSchema = exports.isJsonSchemaDraft04 = void 0;
 const tslib_1 = require("tslib");
-const fs = tslib_1.__importStar(require("fs"));
+const fs = (0, tslib_1.__importStar)(require("fs"));
 const path_1 = require("path");
 const js_yaml_1 = require("js-yaml");
 const utils_1 = require("../utils");
 const jsonSchema_1 = require("./jsonSchema");
-const schemaId_1 = tslib_1.__importDefault(require("./schemaId"));
+const schemaId_1 = (0, tslib_1.__importDefault)(require("./schemaId"));
 exports.ts = require("typescript");
 function isJsonSchemaDraft04(_content, type) {
     return type === 'Draft04';
 }
 exports.isJsonSchemaDraft04 = isJsonSchemaDraft04;
 function parseSchema(content, url) {
-    const { type, openApiVersion } = jsonSchema_1.selectSchemaType(content);
+    const { type, openApiVersion } = (0, jsonSchema_1.selectSchemaType)(content);
     let id;
     if (typeof content !== 'boolean') {
         if (url != null) {
-            jsonSchema_1.setId(type, content, url);
+            (0, jsonSchema_1.setId)(type, content, url);
         }
-        id = jsonSchema_1.getId(type, content);
+        id = (0, jsonSchema_1.getId)(type, content);
     }
     return {
         type,
@@ -31,13 +31,13 @@ function parseSchema(content, url) {
 }
 exports.parseSchema = parseSchema;
 async function readSchemaFromStdin() {
-    const data = await utils_1.readStream(process.stdin);
+    const data = await (0, utils_1.readStream)(process.stdin);
     const content = parseFileContent(data);
     return parseSchema(content);
 }
 exports.readSchemaFromStdin = readSchemaFromStdin;
 async function readSchemasFromFile(pattern) {
-    const files = await utils_1.globFiles(pattern);
+    const files = await (0, utils_1.globFiles)(pattern);
     return Promise.all(files.map(async (file) => {
         const data = await fs.promises.readFile(file, {
             encoding: 'utf8',
@@ -48,17 +48,17 @@ async function readSchemasFromFile(pattern) {
 }
 exports.readSchemasFromFile = readSchemasFromFile;
 async function readSchemaFromUrl(url) {
-    const data = await utils_1.readUrl(url);
+    const data = await (0, utils_1.readUrl)(url);
     const content = parseFileContent(data, url);
     return parseSchema(content, url);
 }
 exports.readSchemaFromUrl = readSchemaFromUrl;
 function parseFileContent(content, filename) {
-    const ext = filename ? path_1.extname(filename).toLowerCase() : '';
+    const ext = filename ? (0, path_1.extname)(filename).toLowerCase() : '';
     const maybeYaml = ext === '.yaml' || ext === '.yml';
     try {
         if (maybeYaml) {
-            return deepCopy(js_yaml_1.load(content));
+            return deepCopy((0, js_yaml_1.load)(content));
         }
         else {
             return JSON.parse(content);
@@ -69,7 +69,7 @@ function parseFileContent(content, filename) {
             return JSON.parse(content);
         }
         else {
-            return deepCopy(js_yaml_1.load(content));
+            return deepCopy((0, js_yaml_1.load)(content));
         }
     }
 }
@@ -81,7 +81,7 @@ async function loadPlugin(name, option) {
     if (!option) {
         return undefined;
     }
-    const mod = (await Promise.resolve().then(() => tslib_1.__importStar(require(name))));
+    const mod = (await Promise.resolve().then(() => (0, tslib_1.__importStar)(require(name))));
     if (!(mod === null || mod === void 0 ? void 0 : mod.default)) {
         console.warn(`The plugin (${name}) is invalid module. That is not default export format.`);
         return undefined;

package/dist/core/typeTree.d.ts

@@ -0,0 +1,6 @@
+import { Schema } from './type';
+export interface TypeTree {
+    children: Map<string, TypeTree>;
+    schema?: Schema;
+}
+export declare function buildTypeTree(schemas: IterableIterator<Schema>): TypeTree;

package/dist/core/typeTree.js

@@ -0,0 +1,34 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.buildTypeTree = void 0;
+function buildTypeTree(schemas) {
+    const tree = buildTree();
+    for (const type of schemas) {
+        setTypeToTree(tree, type.id.toNames(), type);
+    }
+    if (tree.children.size === 0) {
+        throw new Error('There is no schema in the input contents.');
+    }
+    return tree;
+}
+exports.buildTypeTree = buildTypeTree;
+function setTypeToTree(tree, paths, type) {
+    if (paths.length === 0) {
+        throw new Error('The paths is nothing for set the type to TypeTree.');
+    }
+    let t = tree;
+    for (const key of paths) {
+        let next = t.children.get(key);
+        if (next === undefined) {
+            next = buildTree();
+            t.children.set(key, next);
+        }
+        t = next;
+    }
+    t.schema = type;
+}
+function buildTree() {
+    return {
+        children: new Map(),
+    };
+}

package/dist/core/utils.d.ts

@@ -4,4 +4,4 @@ import { JsonSchemaObject } from './type';
 import SimpleTypes = JsonSchemaDraft04.Schema.Definitions.SimpleTypes;
 export declare function toTSType(type: string, debugSource?: JsonSchemaObject): ts.KeywordTypeSyntaxKind | ts.SyntaxKind.NullKeyword | undefined;
 export declare function reduceTypes(types: SimpleTypes[]): SimpleTypes[];
-export declare function mergeSchema(a: any, b: any): any;
+export declare function mergeSchema(a: any, b: any): boolean;

package/dist/core/utils.js

@@ -2,9 +2,9 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.mergeSchema = exports.reduceTypes = exports.toTSType = void 0;
 const tslib_1 = require("tslib");
-const debug_1 = tslib_1.__importDefault(require("debug"));
-const ts = tslib_1.__importStar(require("typescript"));
-const debug = debug_1.default('dtsgen');
+const debug_1 = (0, tslib_1.__importDefault)(require("debug"));
+const ts = (0, tslib_1.__importStar)(require("typescript"));
+const debug = (0, debug_1.default)('dtsgen');
 function toTSType(type, debugSource) {
     switch (type) {
         case 'any':
@@ -39,18 +39,16 @@ function reduceTypes(types) {
         return types;
     }
     const set = new Set(types);
-    if (set.delete('integer')) {
-        set.add('number');
-    }
     return Array.from(set.values());
 }
 exports.reduceTypes = reduceTypes;
 function mergeSchema(a, b) {
     if ('$ref' in a || '$ref' in b) {
-        return { $ref: b['$ref'] || a['$ref'] };
+        a.$ref = b.$ref || a.$ref;
+        return false;
     }
     Object.keys(b).forEach((key) => {
-        var _a;
+        var _a, _b;
         const value = b[key];
         if (a[key] != null && typeof value !== typeof a[key]) {
             debug(`mergeSchema warning: type is mismatched, key=${key}`);
@@ -59,12 +57,13 @@ function mergeSchema(a, b) {
             a[key] = ((_a = a[key]) !== null && _a !== void 0 ? _a : []).concat(value);
         }
         else if (value != null && typeof value === 'object') {
-            a[key] = mergeSchema(a[key] || {}, value);
+            (_b = a[key]) !== null && _b !== void 0 ? _b : (a[key] = {});
+            mergeSchema(a[key], value);
         }
         else {
             a[key] = value;
         }
     });
-    return a;
+    return true;
 }
 exports.mergeSchema = mergeSchema;

package/dist/utils.d.ts

@@ -1,5 +1,9 @@
 /// <reference types="node" />
 import glob from 'glob';
-export declare function readStream(stream: NodeJS.ReadStream, encoding?: BufferEncoding): Promise<string>;
+import { CommandOptions } from './commandOptions';
+import { Config } from './core/config';
+export declare function readStream(stream: NodeJS.ReadableStream, encoding?: BufferEncoding): Promise<string>;
 export declare function readUrl(url: string): Promise<string>;
+export declare function buildProxyOptions(url: string): RequestInit | undefined;
 export declare function globFiles(pattern: string, options?: glob.IOptions): Promise<string[]>;
+export declare function readConfig(options: CommandOptions): Partial<Config>;