dtsgenerator 3.13.0 → 3.15.0

package/.eslintrc.json

@@ -4,17 +4,13 @@
     "@dtsgenerator"
   ],
   "rules": {
-    "@typescript-eslint/no-explicit-any": 0,
-    "import/order": ["error", { "alphabetize": { "order": "asc" } }]
+    "@typescript-eslint/no-explicit-any": 0
   },
   "overrides": [
     {
       "files": [
         "**/*_test.ts"
       ],
-      "env": {
-        "mocha": true
-      },
       "rules": {
         "@typescript-eslint/ban-ts-comment": 0,
         "@typescript-eslint/no-empty-interface": 0,

package/.prettierignore

@@ -0,0 +1 @@
+/test/snapshots

package/README.md

@@ -143,6 +143,26 @@ Output debug message by [debug](https://www.npmjs.com/package/debug) library.
 
 ## ChangeLog
 
+### [v3.15.0](https://github.com/horiuchi/dtsgenerator/releases/tag/v3.15.0) (2022-02-06)
+
+- features:
+  - Support mobile wallet media types(`application/jwt` and `application/vnd.apple.pkpass`) for #530. Thank you @eostrom :+1:
+
+### [v3.14.0](https://github.com/horiuchi/dtsgenerator/releases/tag/v3.14.0) (2022-01-27)
+
+- features:
+  - Support the nested `allOf` and `oneOf` schema for #513. Thank you for your report @Cry0nicS :+1:
+
+### [v3.13.2](https://github.com/horiuchi/dtsgenerator/releases/tag/v3.13.2) (2021-10-08)
+
+- features:
+  - Fix the type generation malformed objects with number-like keys for #523. Thank you for your report @DamianOsipiuk :+1:
+
+### [v3.13.1](https://github.com/horiuchi/dtsgenerator/releases/tag/v3.13.1) (2021-09-29)
+
+- features:
+  - Change the plug-in interface, the PluginContext::inputSchemas to IterableIterator for #521. Thank you @djrollins :+1:
+
 ### [v3.13.0](https://github.com/horiuchi/dtsgenerator/releases/tag/v3.13.0) (2021-08-31)
 
 - features:

package/SupportedFeatures.md

@@ -112,5 +112,7 @@ The base JSON Schema version is Draft-07
 - `application/x-www-form-urlencoded`
 - `application/*+json`
 - `application/octet-stream`
+- `application/jwt`
+- `application/vnd.apple.pkpass`
 - `multipart/form-data`
 - `text/*`

package/dist/core/astBuilder.d.ts

@@ -21,6 +21,7 @@ export declare function buildIndexSignatureNode(name: string, indexType: ts.Type
 export declare function buildTypeLiteralNode(elements: ts.TypeElement[]): ts.TypeNode;
 export declare function buildFreeFormObjectTypeLiteralNode(): ts.TypeNode;
 export declare function buildUnionTypeNode<T>(types: T[], builder: (t: T, index: number) => ts.TypeNode, terminate: boolean): ts.TypeNode;
+export declare function buildIntersectionTypeNode(types: readonly ts.TypeNode[], terminate: boolean): ts.TypeNode;
 export declare function buildTupleTypeNode(types: ts.TypeNode | ts.TypeNode[], minItems?: number, maxItems?: number, additionalItems?: ts.TypeNode | false): ts.TypeNode;
 export declare function buildTypeReferenceNode(schema: NormalizedSchema, currentSchema: Schema): ts.TypeReferenceNode;
 export declare function addComment<T extends ts.Node>(node: T, schema: NormalizedSchema, terminate: boolean): T;

package/dist/core/astBuilder.js

@@ -1,6 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.addOptionalInformation = exports.addComment = exports.buildTypeReferenceNode = exports.buildTupleTypeNode = exports.buildUnionTypeNode = exports.buildFreeFormObjectTypeLiteralNode = exports.buildTypeLiteralNode = exports.buildIndexSignatureNode = exports.buildPropertySignature = exports.buildTypeAliasNode = exports.buildInterfaceNode = exports.buildNamespaceNode = exports.buildBooleanLiteralTypeNode = exports.buildNumericLiteralTypeNode = exports.buildStringLiteralTypeNode = exports.buildNullKeyword = exports.buildSimpleArrayNode = exports.buildStringKeyword = exports.buildVoidKeyword = exports.buildUnknownKeyword = exports.buildNeverKeyword = exports.buildAnyKeyword = exports.buildKeyword = void 0;
+exports.addOptionalInformation = exports.addComment = exports.buildTypeReferenceNode = exports.buildTupleTypeNode = exports.buildIntersectionTypeNode = exports.buildUnionTypeNode = exports.buildFreeFormObjectTypeLiteralNode = exports.buildTypeLiteralNode = exports.buildIndexSignatureNode = exports.buildPropertySignature = exports.buildTypeAliasNode = exports.buildInterfaceNode = exports.buildNamespaceNode = exports.buildBooleanLiteralTypeNode = exports.buildNumericLiteralTypeNode = exports.buildStringLiteralTypeNode = exports.buildNullKeyword = exports.buildSimpleArrayNode = exports.buildStringKeyword = exports.buildVoidKeyword = exports.buildUnknownKeyword = exports.buildNeverKeyword = exports.buildAnyKeyword = exports.buildKeyword = void 0;
 const tslib_1 = require("tslib");
 const ts = (0, tslib_1.__importStar)(require("typescript"));
 const config_1 = (0, tslib_1.__importDefault)(require("./config"));
@@ -9,9 +9,6 @@ function buildTypeNameIdentifier(name) {
     return ts.factory.createIdentifier((0, validateIdentifier_1.toValidIdentifier)(name, config_1.default.target));
 }
 function buildPropertyNameIdentifier(name) {
-    if (/^\d/.test(name)) {
-        name = '$' + name;
-    }
     if ((0, validateIdentifier_1.checkInvalidCharacter)(name, config_1.default.target)) {
         return ts.factory.createIdentifier(name);
     }
@@ -125,6 +122,14 @@ function buildUnionTypeNode(types, builder, terminate) {
     return ts.factory.createParenthesizedType(node);
 }
 exports.buildUnionTypeNode = buildUnionTypeNode;
+function buildIntersectionTypeNode(types, terminate) {
+    const node = ts.factory.createIntersectionTypeNode(types);
+    if (terminate) {
+        return node;
+    }
+    return ts.factory.createParenthesizedType(node);
+}
+exports.buildIntersectionTypeNode = buildIntersectionTypeNode;
 function buildTupleTypeNode(types, minItems, maxItems, additionalItems) {
     function typesIsArray(types) {
         return Array.isArray(types);

package/dist/core/dtsGenerator.d.ts

@@ -5,12 +5,12 @@ export default class DtsGenerator {
     private contents;
     constructor(contents: Schema[]);
     generate(): Promise<string>;
-    private buildSchemaMergedMap;
     private getPlugins;
     private getPreProcess;
     private getPostProcess;
     private walk;
     private walkSchema;
+    private parseSchema;
     private normalizeContent;
     private normalizeSchemaContent;
     private generateDeclareType;
@@ -18,8 +18,10 @@ export default class DtsGenerator {
     private generateTypeCollection;
     private generateProperties;
     private generateTypeProperty;
+    private generateLiteralTypeProperty;
+    private checkExistOtherType;
     private generateLiteralTypeNode;
-    private generateArrayedType;
+    private generateUnionType;
     private generateArrayTypeProperty;
     private generateType;
     private generateTypeName;

package/dist/core/dtsGenerator.js

@@ -9,9 +9,9 @@ const config_1 = (0, tslib_1.__importDefault)(require("./config"));
 const jsonSchema_1 = require("./jsonSchema");
 const referenceResolver_1 = (0, tslib_1.__importDefault)(require("./referenceResolver"));
 const type_1 = require("./type");
+const typeTree_1 = require("./typeTree");
 const utils = (0, tslib_1.__importStar)(require("./utils"));
 const debug = (0, debug_1.default)('dtsgen');
-const typeMarker = Symbol();
 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,28 +44,6 @@ 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 = (0, jsonPointer_1.get)(map, path, true);
-            if (parent == null) {
-                (0, 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 = [];
@@ -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,19 +117,19 @@ 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) {
@@ -253,13 +233,9 @@ class DtsGenerator {
             }
         }
         if (content.patternProperties) {
-            const schemasTypes = [];
-            for (const propertyName of Object.keys(content.patternProperties)) {
-                const schema = this.normalizeContent(baseSchema, '/patternProperties/' + (0, 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/jsonSchema.js

@@ -256,7 +256,7 @@ function searchAllSubSchema(schema, onFoundSchema, onFoundReference) {
                 return;
             }
             for (const mime of Object.keys(types)) {
-                if (/^text\/|^(?:application\/x-www-form-urlencoded$|^application\/([a-z0-9-_.]+\+)?json)$|^application\/octet-stream$|^multipart\/form-data$/.test(mime)) {
+                if (/^text\/|^(?:application\/x-www-form-urlencoded$|^application\/([a-z0-9-_.]+\+)?json)$|^application\/octet-stream$|^application\/jwt$|^application\/vnd.apple.pkpass$|^multipart\/form-data$/.test(mime)) {
                     const mt = types[mime];
                     setSubId(mt.schema, keys);
                 }
@@ -391,10 +391,10 @@ function selectSchemaType(content) {
     }
     if ('$schema' in content) {
         const schema = (_a = content['$schema']) !== null && _a !== void 0 ? _a : '';
-        if (schema === 'http://json-schema.org/schema') {
+        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);
+        const match = /^https?:\/\/json-schema\.org\/(?:draft\/(\d{4}-\d{2})|draft-(\d+))\/schema#?$/.exec(schema);
         if (match) {
             if (match[1] != null) {
                 switch (match[1]) {

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/type.d.ts

@@ -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/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

@@ -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/package.json

@@ -1,6 +1,6 @@
 {
   "name": "dtsgenerator",
-  "version": "3.13.0",
+  "version": "3.15.0",
   "description": "TypeScript d.ts file generator for JSON Schema file",
   "bin": {
     "dtsgen": "bin/dtsgen"
@@ -44,37 +44,37 @@
     "node": ">= 10.0"
   },
   "dependencies": {
-    "commander": "^8.1.0",
-    "cross-fetch": "^3.1.4",
-    "debug": "^4.3.2",
-    "glob": "^7.1.7",
+    "commander": "^9.0.0",
+    "cross-fetch": "^3.1.5",
+    "debug": "^4.3.3",
+    "glob": "^7.2.0",
     "https-proxy-agent": "^5.0.0",
     "js-yaml": "^4.1.0",
     "tslib": "^2.3.1",
-    "typescript": "^4.4.2"
+    "typescript": "^4.5.5"
   },
   "devDependencies": {
     "@dtsgenerator/do-nothing": "^2.5.1",
-    "@dtsgenerator/eslint-config": "^0.2.0",
+    "@dtsgenerator/eslint-config": "^0.5.0",
     "@dtsgenerator/replace-namespace": "^1.5.1",
     "@dtsgenerator/single-quote": "^1.6.1",
-    "@istanbuljs/nyc-config-typescript": "^1.0.1",
+    "@istanbuljs/nyc-config-typescript": "^1.0.2",
     "@types/debug": "^4.1.7",
-    "@types/glob": "^7.1.4",
-    "@types/js-yaml": "^4.0.3",
+    "@types/glob": "^7.2.0",
+    "@types/js-yaml": "^4.0.5",
     "@types/mkdirp": "^1.0.2",
-    "@types/mocha": "^9.0.0",
-    "@types/node": "^16.7.8",
+    "@types/mocha": "^9.1.0",
+    "@types/node": "^16.11.22",
     "cross-env": "^7.0.3",
-    "eslint": "^7.32.0",
-    "husky": "^7.0.2",
-    "lint-staged": "^11.1.2",
-    "mocha": "^9.1.1",
+    "eslint": "^8.8.0",
+    "husky": "^7.0.4",
+    "lint-staged": "^12.3.3",
+    "mocha": "^9.2.0",
     "nyc": "^15.1.0",
-    "prettier": "^2.3.2",
+    "prettier": "^2.5.1",
     "rimraf": "^3.0.2",
-    "source-map-support": "^0.5.19",
-    "ts-node": "^10.2.1"
+    "source-map-support": "^0.5.21",
+    "ts-node": "^10.4.0"
   },
   "lint-staged": {
     "**/*.ts": [

package/src/commandOptions.ts

@@ -47,7 +47,7 @@ function parse(options: CommandOptions, argv: string[]): commander.Command {
     }
 
     // eslint-disable-next-line @typescript-eslint/no-var-requires,@typescript-eslint/no-unsafe-assignment
-    const pkg: Record<string, any> = require('../package.json');
+    const pkg: Record<string, string> = require('../package.json');
 
     // <hoge> is required, [hoge] is optional
     program

package/src/core/astBuilder.ts

@@ -9,9 +9,6 @@ function buildTypeNameIdentifier(name: string): ts.Identifier {
     return ts.factory.createIdentifier(toValidIdentifier(name, config.target));
 }
 function buildPropertyNameIdentifier(name: string): ts.PropertyName {
-    if (/^\d/.test(name)) {
-        name = '$' + name;
-    }
     if (checkInvalidCharacter(name, config.target)) {
         return ts.factory.createIdentifier(name);
     } else {
@@ -198,6 +195,17 @@ export function buildUnionTypeNode<T>(
     return ts.factory.createParenthesizedType(node);
 }
 
+export function buildIntersectionTypeNode(
+    types: readonly ts.TypeNode[],
+    terminate: boolean
+): ts.TypeNode {
+    const node = ts.factory.createIntersectionTypeNode(types);
+    if (terminate) {
+        return node;
+    }
+    return ts.factory.createParenthesizedType(node);
+}
+
 export function buildTupleTypeNode(
     types: ts.TypeNode | ts.TypeNode[],
     minItems?: number,
@@ -325,7 +333,7 @@ function getComment(schema: NormalizedSchema): string[] {
     function protectComment(str: string): string {
         return str.replace(/\*\//g, '*\u200B/'); // Unicode [ZERO WIDTH SPACE]
     }
-    function appendComment(value?: string): void {
+    function appendComment(value?: any): void {
         if (value == null) {
             return;
         }

package/src/core/dtsGenerator.ts

@@ -1,6 +1,6 @@
 import Debug from 'debug';
 import * as ts from 'typescript';
-import { get, set, tilde } from '../jsonPointer';
+import { tilde } from '../jsonPointer';
 import * as ast from './astBuilder';
 import config from './config';
 import { getSubSchema, NormalizedSchema } from './jsonSchema';
@@ -13,10 +13,10 @@ import {
     PreProcessHandler,
     loadPlugin,
 } from './type';
+import { buildTypeTree, TypeTree } from './typeTree';
 import * as utils from './utils';
 
 const debug = Debug('dtsgen');
-const typeMarker = Symbol();
 
 interface PluginConfig {
     plugin: Plugin;
@@ -42,11 +42,8 @@ export default class DtsGenerator {
         this.contents.forEach((schema) => this.resolver.registerSchema(schema));
         await this.resolver.resolve();
 
-        // eslint-disable-next-line @typescript-eslint/no-unsafe-assignment
-        const map = this.buildSchemaMergedMap(
-            this.resolver.getAllRegisteredSchema()
-        );
-        const root = this.walk(map, true);
+        const tree = buildTypeTree(this.resolver.getAllRegisteredSchema());
+        const root = this.walk(tree);
         const file = ts.createSourceFile(
             '_.d.ts',
             '',
@@ -77,31 +74,6 @@ export default class DtsGenerator {
         return transformedContent;
     }
 
-    private buildSchemaMergedMap(schemas: IterableIterator<Schema>): any {
-        const map: any = {};
-        const paths: { path: string[]; type: Schema }[] = [];
-        for (const type of schemas) {
-            const path = type.id.toNames();
-            paths.push({ path, type });
-        }
-
-        for (const item of paths) {
-            const path = item.path;
-            // eslint-disable-next-line @typescript-eslint/no-unsafe-assignment
-            const parent = get(map, path, true);
-            if (parent == null) {
-                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.');
-        }
-        // eslint-disable-next-line @typescript-eslint/no-unsafe-return
-        return map;
-    }
-
     private async getPlugins(): Promise<{
         pre: PluginConfig[];
         post: PluginConfig[];
@@ -169,24 +141,22 @@ export default class DtsGenerator {
         return result;
     }
 
-    private walk(map: any, root: boolean): ts.Statement[] {
+    private walk(tree: TypeTree, root = true): ts.Statement[] {
         const result: ts.Statement[] = [];
-        const keys = Object.keys(map).sort();
+        const keys = [...tree.children.keys()].sort();
         for (const key of keys) {
-            // eslint-disable-next-line @typescript-eslint/no-unsafe-assignment,@typescript-eslint/no-unsafe-member-access
-            const value = map[key];
-            if (
-                typeof value === 'object' &&
-                Object.prototype.hasOwnProperty.call(value, typeMarker)
-            ) {
-                // eslint-disable-next-line @typescript-eslint/no-unsafe-member-access
-                const schema = value[typeMarker] as Schema;
+            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)
                 );
@@ -199,25 +169,33 @@ export default class DtsGenerator {
         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),
+            ast.addComment(
+                this.parseSchema(normalized, root),
+                normalized,
+                true
+            ),
             normalized,
             true
         );
     }
 
+    private parseSchema(
+        schema: NormalizedSchema,
+        root = false
+    ): ts.DeclarationStatement {
+        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);
+        }
+    }
+
     private normalizeContent(
         schema: Schema,
         pointer?: string
@@ -361,18 +339,21 @@ export default class DtsGenerator {
             }
         }
         if (content.patternProperties) {
-            const schemasTypes = [];
-            for (const propertyName of Object.keys(content.patternProperties)) {
-                const schema = this.normalizeContent(
-                    baseSchema,
-                    '/patternProperties/' + tilde(propertyName)
-                );
-                schemasTypes.push(this.generateTypeProperty(schema));
-            }
+            const properties = Object.keys(content.patternProperties);
             const node = ast.buildPropertySignature(
                 { content: { readOnly: false } } as NormalizedSchema,
                 'pattern',
-                ts.createUnionTypeNode(schemasTypes),
+                ast.buildUnionTypeNode(
+                    properties,
+                    (propertyName) =>
+                        this.generateTypeProperty(
+                            this.normalizeContent(
+                                baseSchema,
+                                '/patternProperties/' + tilde(propertyName)
+                            )
+                        ),
+                    true
+                ),
                 baseSchema.content.required,
                 true
             );
@@ -380,9 +361,7 @@ export default class DtsGenerator {
                 ts.addSyntheticTrailingComment(
                     node,
                     ts.SyntaxKind.MultiLineCommentTrivia,
-                    ` Patterns: ${Object.keys(content.patternProperties).join(
-                        ' | '
-                    )} `
+                    ` Patterns: ${properties.join(' | ')} `
                 )
             );
         }
@@ -401,20 +380,21 @@ export default class DtsGenerator {
                 );
             }
             const refSchema = this.normalizeContent(ref);
-            const node = ast.buildTypeReferenceNode(
-                refSchema,
-                this.currentSchema
-            );
-            return ast.addOptionalInformation(
-                ast.addComment(node, 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(
+            return this.generateUnionType(
                 schema,
                 content.anyOf,
                 mergeContent,
@@ -425,7 +405,7 @@ export default class DtsGenerator {
         if (content.oneOf) {
             const mergeContent = Object.assign({}, content);
             delete mergeContent.oneOf;
-            return this.generateArrayedType(
+            return this.generateUnionType(
                 schema,
                 content.oneOf,
                 mergeContent,
@@ -433,6 +413,13 @@ export default class DtsGenerator {
                 terminate
             );
         }
+        return this.generateLiteralTypeProperty(schema, terminate);
+    }
+    private generateLiteralTypeProperty(
+        schema: NormalizedSchema,
+        terminate = true
+    ): ts.TypeNode {
+        const content = schema.content;
         if (content.enum) {
             return ast.buildUnionTypeNode(
                 content.enum,
@@ -449,6 +436,25 @@ export default class DtsGenerator {
             return this.generateType(schema, terminate);
         }
     }
+    private checkExistOtherType(
+        content: JsonSchemaObject,
+        base: NormalizedSchema
+    ): ts.TypeNode | undefined {
+        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 as ts.TypeLiteralNode;
+            if (
+                node.members.length === 1 &&
+                node.members[0].kind === ts.SyntaxKind.IndexSignature
+            ) {
+                return undefined;
+            }
+        }
+        return result;
+    }
     private generateLiteralTypeNode(
         content: JsonSchemaObject,
         value: any
@@ -458,11 +464,11 @@ export default class DtsGenerator {
             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();
@@ -478,39 +484,51 @@ export default class DtsGenerator {
         return ast.buildStringLiteralTypeNode(String(value));
     }
 
-    private generateArrayedType(
+    private generateUnionType(
         baseSchema: NormalizedSchema,
         contents: JsonSchema[],
-        mergeContent: JsonSchema,
+        mergeContent: JsonSchemaObject,
         path: string,
         terminate: boolean
     ): ts.TypeNode {
-        return ast.addOptionalInformation(
+        const merged: boolean[] = [];
+        const children = contents.map((_, index) => {
+            const schema = this.normalizeContent(
+                baseSchema,
+                path + index.toString()
+            );
+            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(
-                    contents,
-                    (_, 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,
+                    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
                 ),
@@ -520,6 +538,10 @@ export default class DtsGenerator {
             baseSchema,
             terminate
         );
+        if (baseType != null && allRef) {
+            return ast.buildIntersectionTypeNode([baseType, result], terminate);
+        }
+        return result;
     }
 
     private generateArrayTypeProperty(

package/src/core/jsonSchema.ts

@@ -379,7 +379,7 @@ export function searchAllSubSchema(
             }
             for (const mime of Object.keys(types)) {
                 if (
-                    /^text\/|^(?:application\/x-www-form-urlencoded$|^application\/([a-z0-9-_.]+\+)?json)$|^application\/octet-stream$|^multipart\/form-data$/.test(
+                    /^text\/|^(?:application\/x-www-form-urlencoded$|^application\/([a-z0-9-_.]+\+)?json)$|^application\/octet-stream$|^application\/jwt$|^application\/vnd.apple.pkpass$|^multipart\/form-data$/.test(
                         mime
                     )
                 ) {
@@ -555,11 +555,11 @@ export function selectSchemaType(content: JsonSchema | OpenApiSchema): {
     }
     if ('$schema' in content) {
         const schema = content['$schema'] ?? '';
-        if (schema === 'http://json-schema.org/schema') {
+        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(
+            /^https?:\/\/json-schema\.org\/(?:draft\/(\d{4}-\d{2})|draft-(\d+))\/schema#?$/.exec(
                 schema
             );
         if (match) {

package/src/core/referenceResolver.ts

@@ -21,7 +21,7 @@ export default class ReferenceResolver {
     public getAllRegisteredSchema(): IterableIterator<Schema> {
         return this.schemaCache.values();
     }
-    public getAllRegisteredIdAndSchema(): Iterator<[string, Schema]> {
+    public getAllRegisteredIdAndSchema(): IterableIterator<[string, Schema]> {
         return this.schemaCache.entries();
     }
 

package/src/core/type.ts

@@ -114,7 +114,7 @@ function deepCopy(obj: any): any {
 
 export interface PluginContext {
     option: boolean | Record<string, unknown>;
-    inputSchemas: Iterator<[string, Schema]>;
+    inputSchemas: IterableIterator<[string, Schema]>;
 }
 
 export type PreProcessHandler = (contents: Schema[]) => Schema[];

package/src/core/typeTree.ts

@@ -0,0 +1,39 @@
+import { Schema } from './type';
+
+export interface TypeTree {
+    children: Map<string, TypeTree>;
+    schema?: Schema;
+}
+
+export function buildTypeTree(schemas: IterableIterator<Schema>): TypeTree {
+    const tree: TypeTree = 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;
+}
+
+function setTypeToTree(tree: TypeTree, paths: string[], type: Schema): void {
+    if (paths.length === 0) {
+        throw new Error('The paths is nothing for set the type to TypeTree.');
+    }
+    let t: TypeTree = 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(): TypeTree {
+    return {
+        children: new Map(),
+    };
+}

package/src/core/utils.ts

@@ -52,18 +52,16 @@ export function reduceTypes(types: SimpleTypes[]): SimpleTypes[] {
         return types;
     }
     const set = new Set<SimpleTypes>(types);
-    if (set.delete('integer')) {
-        set.add('number');
-    }
     return Array.from(set.values());
 }
 
 // eslint-disable-next-line @typescript-eslint/explicit-module-boundary-types
-export function mergeSchema(a: any, b: any): any {
+export function mergeSchema(a: any, b: any): boolean {
     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: string) => {
+    Object.keys(b as object).forEach((key: string) => {
         const value = b[key];
         if (a[key] != null && typeof value !== typeof a[key]) {
             debug(`mergeSchema warning: type is mismatched, key=${key}`);
@@ -72,11 +70,11 @@ export function mergeSchema(a: any, b: any): any {
             // eslint-disable-next-line @typescript-eslint/no-unsafe-call
             a[key] = (a[key] ?? []).concat(value);
         } else if (value != null && typeof value === 'object') {
-            a[key] = mergeSchema(a[key] || {}, value);
+            a[key] ??= {};
+            mergeSchema(a[key], value);
         } else {
             a[key] = value;
         }
     });
-    // eslint-disable-next-line @typescript-eslint/no-unsafe-return
-    return a;
+    return true;
 }