Merge 5a7010c into 415ba4b

package.json

@@ -44,37 +44,37 @@
     "node": ">= 10.0"
   },
   "dependencies": {
-    "commander": "^8.2.0",
+    "commander": "^8.3.0",
     "cross-fetch": "^3.1.4",
-    "debug": "^4.3.2",
+    "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.3"
+    "typescript": "^4.5.2"
   },
   "devDependencies": {
     "@dtsgenerator/do-nothing": "^2.5.1",
-    "@dtsgenerator/eslint-config": "^0.4.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.10.3",
+    "@types/node": "^16.11.12",
     "cross-env": "^7.0.3",
-    "eslint": "^7.32.0",
-    "husky": "^7.0.2",
-    "lint-staged": "^11.2.0",
-    "mocha": "^9.1.2",
+    "eslint": "^8.4.1",
+    "husky": "^7.0.4",
+    "lint-staged": "^12.1.2",
+    "mocha": "^9.1.3",
     "nyc": "^15.1.0",
-    "prettier": "^2.4.1",
+    "prettier": "^2.5.1",
     "rimraf": "^3.0.2",
-    "source-map-support": "^0.5.20",
-    "ts-node": "^10.2.1"
+    "source-map-support": "^0.5.21",
+    "ts-node": "^10.4.0"
   },
   "lint-staged": {
     "**/*.ts": [

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

src/core/astBuilder.ts

@@ -322,7 +322,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;
         }

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)
                 );
@@ -458,11 +428,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();

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(),
+    };
+}

src/core/utils.ts

@@ -63,7 +63,7 @@ export function mergeSchema(a: any, b: any): any {
     if ('$ref' in a || '$ref' in b) {
         return { $ref: b['$ref'] || a['$ref'] };
     }
-    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}`);

test/core/jsonSchema_test.ts

@@ -1,4 +1,5 @@
 import assert from 'assert';
+import { JsonSchema } from '../../src/core';
 import { selectSchemaType } from '../../src/core/jsonSchema';
 
 describe('selectSchemaType test', () => {
@@ -90,7 +91,7 @@ describe('selectSchemaType test', () => {
     });
     it('schema is invalid', () => {
         assert.throws(() => {
-            selectSchemaType('invalid schema' as any);
+            selectSchemaType('invalid schema' as JsonSchema);
         });
     });
 });

test/error_case_test.ts

@@ -25,10 +25,10 @@ describe('error schema test', () => {
         }
     });
     it('unknown type schema', async () => {
-        const schema: any = {
+        const schema: JsonSchemaDraft04.Schema = {
             id: '/test/unknown_type',
             type: 'hoge',
-        };
+        } as any;
         try {
             await dtsgenerator({ contents: [parseSchema(schema)] });
             assert.fail();
@@ -38,15 +38,15 @@ describe('error schema test', () => {
         }
     });
     it('unknown type property', async () => {
-        const schema: any = {
+        const schema: JsonSchemaDraft04.Schema = {
             id: '/test/unknown_property',
             type: 'object',
             properties: {
                 name: {
                     type: 'fuga',
                 },
             },
-        };
+        } as any;
         try {
             await dtsgenerator({ contents: [parseSchema(schema)] });
             assert.fail();
@@ -99,7 +99,7 @@ describe('error schema test', () => {
         }
     });
     it('invalid format schema', async () => {
-        const schema =
+        const schema: JsonSchemaDraft04.Schema =
             'This string is not schema data and invalid JSON format {.' as any;
         try {
             await dtsgenerator({ contents: [parseSchema(schema)] });

test/snapshot_test.ts

@@ -2,7 +2,7 @@ import assert from 'assert';
 import fs from 'fs';
 import path from 'path';
 import dtsgenerator from '../src/core';
-import { clearToDefault, setConfig } from '../src/core/config';
+import { clearToDefault, Config, setConfig } from '../src/core/config';
 import { parseFileContent, parseSchema } from '../src/core/type';
 
 const fixturesDir = path.join(__dirname, 'snapshots');
@@ -26,7 +26,7 @@ describe('Snapshot testing', () => {
                     expectedFileName
                 );
                 const configFilePath = path.join(fixtureDir, configFileName);
-                const config = fs.existsSync(configFilePath)
+                const config: Partial<Config> = fs.existsSync(configFilePath)
                     ? require(configFilePath)
                     : {};
 

test/utils_test.ts

@@ -68,7 +68,7 @@ describe('root utils test', () => {
             ]);
         });
         it('throw error on getting files', () => {
-            assert.rejects(() => globFiles(null as any));
+            assert.rejects(() => globFiles(null as unknown as string));
         });
     });