dtsgenerator 3.18.0 → 3.19.1

package/src/core/astBuilder.ts

@@ -17,7 +17,7 @@ function buildPropertyNameIdentifier(name: string): ts.PropertyName {
 }
 
 export function buildKeyword(
-    kind: ts.KeywordTypeSyntaxKind
+    kind: ts.KeywordTypeSyntaxKind,
 ): ts.KeywordTypeNode {
     return ts.factory.createKeywordTypeNode(kind);
 }
@@ -41,7 +41,7 @@ export function buildSimpleArrayNode(element: ts.TypeNode): ts.ArrayTypeNode {
 }
 export function buildNullKeyword(): ts.LiteralTypeNode {
     return ts.factory.createLiteralTypeNode(
-        ts.factory.createToken(ts.SyntaxKind.NullKeyword)
+        ts.factory.createToken(ts.SyntaxKind.NullKeyword),
     );
 }
 export function buildStringLiteralTypeNode(s: string): ts.LiteralTypeNode {
@@ -52,14 +52,14 @@ export function buildNumericLiteralTypeNode(n: string): ts.LiteralTypeNode {
 }
 export function buildBooleanLiteralTypeNode(b: boolean): ts.LiteralTypeNode {
     return ts.factory.createLiteralTypeNode(
-        b ? ts.factory.createTrue() : ts.factory.createFalse()
+        b ? ts.factory.createTrue() : ts.factory.createFalse(),
     );
 }
 
 export function buildNamespaceNode(
     name: string,
     statements: ts.Statement[],
-    root: boolean
+    root: boolean,
 ): ts.ModuleDeclaration {
     const modifiers = root
         ? [ts.factory.createModifier(ts.SyntaxKind.DeclareKeyword)]
@@ -70,14 +70,14 @@ export function buildNamespaceNode(
         ts.factory.createModuleBlock(statements),
         ts.NodeFlags.Namespace |
             ts.NodeFlags.ExportContext |
-            ts.NodeFlags.ContextFlags
+            ts.NodeFlags.ContextFlags,
     );
 }
 
 export function buildInterfaceNode(
     id: SchemaId,
     members: ts.TypeElement[],
-    root: boolean
+    root: boolean,
 ): ts.InterfaceDeclaration {
     const name = getLastTypeName(id);
     const modifiers = root
@@ -88,14 +88,14 @@ export function buildInterfaceNode(
         buildTypeNameIdentifier(name),
         undefined,
         undefined,
-        members
+        members,
     );
 }
 
 export function buildTypeAliasNode(
     id: SchemaId,
     type: ts.TypeNode,
-    root: boolean
+    root: boolean,
 ): ts.TypeAliasDeclaration {
     const name = getLastTypeName(id);
     const modifiers = root
@@ -105,7 +105,7 @@ export function buildTypeAliasNode(
         modifiers,
         buildTypeNameIdentifier(name),
         undefined,
-        type
+        type,
     );
 }
 
@@ -114,7 +114,7 @@ export function buildPropertySignature(
     propertyName: string,
     valueType: ts.TypeNode,
     required: string[] | undefined,
-    isPattern: boolean | undefined
+    isPattern: boolean | undefined,
 ): ts.PropertySignature | ts.IndexSignatureDeclaration {
     const modifiers = undefined;
     const questionToken =
@@ -131,24 +131,24 @@ export function buildPropertySignature(
                     ts.factory.createIdentifier('pattern'),
                     undefined,
                     ts.factory.createTypeReferenceNode('string', []),
-                    undefined
+                    undefined,
                 ),
             ],
-            valueType
+            valueType,
         );
     }
     return ts.factory.createPropertySignature(
         modifiers,
         buildPropertyNameIdentifier(propertyName),
         questionToken,
-        valueType
+        valueType,
     );
 }
 
 export function buildIndexSignatureNode(
     name: string,
     indexType: ts.TypeNode,
-    valueType: ts.TypeNode
+    valueType: ts.TypeNode,
 ): ts.IndexSignatureDeclaration {
     return ts.factory.createIndexSignature(
         undefined,
@@ -159,10 +159,10 @@ export function buildIndexSignatureNode(
                 buildTypeNameIdentifier(name),
                 undefined,
                 indexType,
-                undefined
+                undefined,
             ),
         ],
-        valueType
+        valueType,
     );
 }
 
@@ -179,7 +179,7 @@ export function buildFreeFormObjectTypeLiteralNode(): ts.TypeNode {
 export function buildUnionTypeNode<T>(
     types: T[],
     builder: (t: T, index: number) => ts.TypeNode,
-    terminate: boolean
+    terminate: boolean,
 ): ts.TypeNode {
     const node = ts.factory.createUnionTypeNode(types.map(builder));
     if (terminate) {
@@ -190,7 +190,7 @@ export function buildUnionTypeNode<T>(
 
 export function buildIntersectionTypeNode(
     types: readonly ts.TypeNode[],
-    terminate: boolean
+    terminate: boolean,
 ): ts.TypeNode {
     const node = ts.factory.createIntersectionTypeNode(types);
     if (terminate) {
@@ -203,7 +203,7 @@ export function buildTupleTypeNode(
     types: ts.TypeNode | ts.TypeNode[],
     minItems?: number,
     maxItems?: number,
-    additionalItems?: ts.TypeNode | false
+    additionalItems?: ts.TypeNode | false,
 ): ts.TypeNode {
     function typesIsArray<T>(types: T | T[]): types is T[] {
         return Array.isArray(types);
@@ -247,9 +247,9 @@ export function buildTupleTypeNode(
                         ? additionalItems !== undefined
                             ? (additionalItems as ts.TypeNode)
                             : buildAnyKeyword()
-                        : types
-                )
-            )
+                        : types,
+                ),
+            ),
         );
     }
     return ts.factory.createTupleTypeNode(nodes);
@@ -257,7 +257,7 @@ export function buildTupleTypeNode(
 
 export function buildTypeReferenceNode(
     schema: NormalizedSchema,
-    currentSchema: Schema
+    currentSchema: Schema,
 ): ts.TypeReferenceNode {
     const typeName = getTypename(schema.id, currentSchema);
     let node: ts.EntityName | undefined;
@@ -267,7 +267,7 @@ export function buildTypeReferenceNode(
         } else {
             node = ts.factory.createQualifiedName(
                 node,
-                buildTypeNameIdentifier(name)
+                buildTypeNameIdentifier(name),
             );
         }
     }
@@ -296,7 +296,7 @@ function getTypename(id: SchemaId, baseSchema: Schema): string[] {
 export function addComment<T extends ts.Node>(
     node: T,
     schema: NormalizedSchema,
-    terminate: boolean
+    terminate: boolean,
 ): T {
     const comments = getComment(schema);
     if (comments.length === 0) {
@@ -306,7 +306,7 @@ export function addComment<T extends ts.Node>(
             node,
             ts.SyntaxKind.MultiLineCommentTrivia,
             ` ${comments[0] ?? ''} `,
-            false
+            false,
         );
     } else {
         let result = '*\n';
@@ -318,7 +318,7 @@ export function addComment<T extends ts.Node>(
             node,
             ts.SyntaxKind.MultiLineCommentTrivia,
             result,
-            true
+            true,
         );
     }
 }
@@ -363,7 +363,7 @@ function getComment(schema: NormalizedSchema): string[] {
 export function addOptionalInformation<T extends ts.Node>(
     node: T,
     schema: NormalizedSchema,
-    terminate: boolean
+    terminate: boolean,
 ): T {
     const format = schema.content.format;
     const pattern = schema.content.pattern;

package/src/core/config.ts

@@ -85,7 +85,7 @@ export async function showConfig(version: string, c: Config): Promise<void> {
     console.log('Plugins: count=' + plugins.length.toString());
     for (const p of plugins) {
         console.log(
-            `  ${p.meta.name}@${p.meta.version}: ${p.meta.description ?? ''}`
+            `  ${p.meta.name}@${p.meta.version}: ${p.meta.description ?? ''}`,
         );
     }
     console.log();

package/src/core/dtsGenerator.ts

@@ -49,7 +49,7 @@ export default class DtsGenerator {
             '',
             config.target,
             false,
-            ts.ScriptKind.TS
+            ts.ScriptKind.TS,
         );
         Object.assign(file, {
             statements: ts.factory.createNodeArray(root),
@@ -67,7 +67,7 @@ export default class DtsGenerator {
                   return printer.printNode(
                       ts.EmitHint.SourceFile,
                       transformedNodes,
-                      file
+                      file,
                   );
               })();
 
@@ -96,7 +96,7 @@ export default class DtsGenerator {
         return { pre, post };
     }
     private async getPreProcess(
-        pre: PluginConfig[]
+        pre: PluginConfig[],
     ): Promise<PreProcessHandler[]> {
         debug('load pre process plugin.');
         const result: PreProcessHandler[] = [];
@@ -112,14 +112,14 @@ export default class DtsGenerator {
                 debug(
                     '  pre process plugin:',
                     pc.plugin.meta.name,
-                    pc.plugin.meta.description
+                    pc.plugin.meta.description,
                 );
             }
         }
         return result;
     }
     private async getPostProcess(
-        post: PluginConfig[]
+        post: PluginConfig[],
     ): Promise<ts.TransformerFactory<ts.SourceFile>[]> {
         debug('load post process plugin.');
         const result: ts.TransformerFactory<ts.SourceFile>[] = [];
@@ -133,9 +133,9 @@ export default class DtsGenerator {
             if (factory != null) {
                 result.push(factory);
                 debug(
-                    '  pre process plugin:',
+                    '  post process plugin:',
                     pc.plugin.meta.name,
-                    pc.plugin.meta.description
+                    pc.plugin.meta.description,
                 );
             }
         }
@@ -153,13 +153,13 @@ export default class DtsGenerator {
             if (value.schema !== undefined) {
                 const schema = value.schema;
                 debug(
-                    `  walk doProcess: key=${key} schemaId=${schema.id.getAbsoluteId()}`
+                    `  walk doProcess: key=${key} schemaId=${schema.id.getAbsoluteId()}`,
                 );
                 result.push(this.walkSchema(schema, root));
             }
             if (value.children.size > 0) {
                 result.push(
-                    ast.buildNamespaceNode(key, this.walk(value, false), root)
+                    ast.buildNamespaceNode(key, this.walk(value, false), root),
                 );
             }
         }
@@ -174,16 +174,16 @@ export default class DtsGenerator {
             ast.addComment(
                 this.parseSchema(normalized, root),
                 normalized,
-                true
+                true,
             ),
             normalized,
-            true
+            true,
         );
     }
 
     private parseSchema(
         schema: NormalizedSchema,
-        root = false
+        root = false,
     ): ts.DeclarationStatement {
         const type = schema.content.type;
         switch (type) {
@@ -199,7 +199,7 @@ export default class DtsGenerator {
 
     private normalizeContent(
         schema: Schema,
-        pointer?: string
+        pointer?: string,
     ): NormalizedSchema {
         if (pointer != null) {
             schema = getSubSchema(schema, pointer);
@@ -232,7 +232,7 @@ export default class DtsGenerator {
             }
             if (
                 content.type === undefined &&
-                (content.properties || content.additionalProperties)
+                (content.properties ?? content.additionalProperties)
             ) {
                 content.type = 'object';
             }
@@ -259,14 +259,16 @@ export default class DtsGenerator {
     }
     private generateDeclareType(
         schema: NormalizedSchema,
-        root: boolean
+        root: boolean,
     ): ts.DeclarationStatement {
         const content = schema.content;
         if (
+            /* eslint-disable @typescript-eslint/prefer-nullish-coalescing */
             content.$ref ||
             content.oneOf ||
             content.anyOf ||
             content.enum ||
+            /* eslint-enable @typescript-eslint/prefer-nullish-coalescing */
             'const' in content ||
             content.type !== 'object'
         ) {
@@ -280,19 +282,19 @@ export default class DtsGenerator {
 
     private generateAnyTypeModel(
         schema: NormalizedSchema,
-        root: boolean
+        root: boolean,
     ): ts.DeclarationStatement {
         const member = ast.buildIndexSignatureNode(
             'name',
             ast.buildStringKeyword(),
-            ast.buildAnyKeyword()
+            ast.buildAnyKeyword(),
         );
         return ast.buildInterfaceNode(schema.id, [member], root);
     }
 
     private generateTypeCollection(
         schema: NormalizedSchema,
-        root: boolean
+        root: boolean,
     ): ts.DeclarationStatement {
         const type = this.generateArrayTypeProperty(schema);
         return ast.buildTypeAliasNode(schema.id, type, root);
@@ -304,7 +306,7 @@ export default class DtsGenerator {
         if (content.additionalProperties) {
             const schema = this.normalizeContent(
                 baseSchema,
-                '/additionalProperties'
+                '/additionalProperties',
             );
             const valueType =
                 content.additionalProperties === true
@@ -313,7 +315,7 @@ export default class DtsGenerator {
             const node = ast.buildIndexSignatureNode(
                 'name',
                 ast.buildStringKeyword(),
-                valueType
+                valueType,
             );
             result.push(ast.addOptionalInformation(node, schema, true));
         }
@@ -321,21 +323,21 @@ export default class DtsGenerator {
             for (const propertyName of Object.keys(content.properties)) {
                 const schema = this.normalizeContent(
                     baseSchema,
-                    '/properties/' + tilde(propertyName)
+                    '/properties/' + tilde(propertyName),
                 );
                 const node = ast.buildPropertySignature(
                     schema,
                     propertyName,
                     this.generateTypeProperty(schema),
                     baseSchema.content.required,
-                    false
+                    false,
                 );
                 result.push(
                     ast.addOptionalInformation(
                         ast.addComment(node, schema, true),
                         schema,
-                        true
-                    )
+                        true,
+                    ),
                 );
             }
         }
@@ -350,27 +352,27 @@ export default class DtsGenerator {
                         this.generateTypeProperty(
                             this.normalizeContent(
                                 baseSchema,
-                                '/patternProperties/' + tilde(propertyName)
-                            )
+                                '/patternProperties/' + tilde(propertyName),
+                            ),
                         ),
-                    true
+                    true,
                 ),
                 baseSchema.content.required,
-                true
+                true,
             );
             result.push(
                 ts.addSyntheticTrailingComment(
                     node,
                     ts.SyntaxKind.MultiLineCommentTrivia,
-                    ` Patterns: ${properties.join(' | ')} `
-                )
+                    ` Patterns: ${properties.join(' | ')} `,
+                ),
             );
         }
         return result;
     }
     private generateTypeProperty(
         schema: NormalizedSchema,
-        terminate = true
+        terminate = true,
     ): ts.TypeNode {
         const content = schema.content;
         if (content.$ref) {
@@ -380,10 +382,10 @@ export default class DtsGenerator {
                 ast.addComment(
                     ast.buildTypeReferenceNode(refSchema, this.currentSchema),
                     refSchema,
-                    false
+                    false,
                 ),
                 refSchema,
-                false
+                false,
             );
             return node;
         }
@@ -395,7 +397,7 @@ export default class DtsGenerator {
                 content.anyOf,
                 mergeContent,
                 '/anyOf/',
-                terminate
+                terminate,
             );
         }
         if (content.oneOf) {
@@ -406,14 +408,14 @@ export default class DtsGenerator {
                 content.oneOf,
                 mergeContent,
                 '/oneOf/',
-                terminate
+                terminate,
             );
         }
         return this.generateLiteralTypeProperty(schema, terminate);
     }
     private generateLiteralTypeProperty(
         schema: NormalizedSchema,
-        terminate = true
+        terminate = true,
     ): ts.TypeNode {
         const content = schema.content;
         if (content.enum) {
@@ -422,7 +424,7 @@ export default class DtsGenerator {
                 (value) => {
                     return this.generateLiteralTypeNode(content, value);
                 },
-                terminate
+                terminate,
             );
         } else if (content.not) {
             return ast.buildVoidKeyword();
@@ -434,7 +436,7 @@ export default class DtsGenerator {
     }
     private checkExistOtherType(
         content: JsonSchemaObject,
-        base: NormalizedSchema
+        base: NormalizedSchema,
     ): ts.TypeNode | undefined {
         const schema = Object.assign({}, base, { content });
         const result = this.generateLiteralTypeProperty(schema, false);
@@ -453,7 +455,7 @@ export default class DtsGenerator {
     }
     private generateLiteralTypeNode(
         content: JsonSchemaObject,
-        value: any
+        value: any,
     ): ts.LiteralTypeNode {
         switch (content.type) {
             case 'integer':
@@ -485,13 +487,13 @@ export default class DtsGenerator {
         contents: JsonSchema[],
         mergeContent: JsonSchemaObject,
         path: string,
-        terminate: boolean
+        terminate: boolean,
     ): ts.TypeNode {
         const merged: boolean[] = [];
         const children = contents.map((_, index) => {
             const schema = this.normalizeContent(
                 baseSchema,
-                path + index.toString()
+                path + index.toString(),
             );
             merged.push(utils.mergeSchema(schema.content, mergeContent));
             return schema;
@@ -508,31 +510,31 @@ export default class DtsGenerator {
                             ? ast.addOptionalInformation(
                                   this.generateTypeProperty(schema, false),
                                   schema,
-                                  false
+                                  false,
                               )
                             : ast.addOptionalInformation(
                                   ast.buildTypeReferenceNode(
                                       schema,
-                                      this.currentSchema
+                                      this.currentSchema,
                                   ),
                                   schema,
-                                  false
+                                  false,
                               );
                         if (baseType != null && !allRef && !merged[index]) {
                             return ast.buildIntersectionTypeNode(
                                 [baseType, node],
-                                false
+                                false,
                             );
                         }
                         return node;
                     },
-                    terminate
+                    terminate,
                 ),
                 baseSchema,
-                false
+                false,
             ),
             baseSchema,
-            terminate
+            terminate,
         );
         if (baseType != null && allRef) {
             return ast.buildIntersectionTypeNode([baseType, result], terminate);
@@ -542,7 +544,7 @@ export default class DtsGenerator {
 
     private generateArrayTypeProperty(
         schema: NormalizedSchema,
-        terminate = true
+        terminate = true,
     ): ts.TypeNode {
         const items = schema.content.items;
         const minItems = schema.content.minItems;
@@ -573,13 +575,13 @@ export default class DtsGenerator {
                 maxItems === undefined
             ) {
                 return ast.buildSimpleArrayNode(
-                    ast.addOptionalInformation(node, subSchema, false)
+                    ast.addOptionalInformation(node, subSchema, false),
                 );
             } else {
                 return ast.addOptionalInformation(
                     ast.buildTupleTypeNode(node, minItems, maxItems),
                     schema,
-                    terminate
+                    terminate,
                 );
             }
         } else if (
@@ -591,9 +593,7 @@ export default class DtsGenerator {
             return additionalItemsNode === false
                 ? ast.buildTupleTypeNode([], 0, 0, additionalItemsNode)
                 : ast.buildSimpleArrayNode(
-                      additionalItemsNode === undefined
-                          ? ast.buildAnyKeyword()
-                          : additionalItemsNode
+                      additionalItemsNode ?? ast.buildAnyKeyword(),
                   );
         } else if (
             minItems != null &&
@@ -606,7 +606,7 @@ export default class DtsGenerator {
             for (let i = 0; i < items.length; i++) {
                 const type = this.normalizeContent(
                     schema,
-                    '/items/' + i.toString()
+                    '/items/' + i.toString(),
                 );
                 if (type.id.isEmpty()) {
                     types.push(this.generateTypeProperty(type, false));
@@ -615,11 +615,11 @@ export default class DtsGenerator {
                         ast.addOptionalInformation(
                             ast.buildTypeReferenceNode(
                                 type,
-                                this.currentSchema
+                                this.currentSchema,
                             ),
                             type,
-                            false
-                        )
+                            false,
+                        ),
                     );
                 }
             }
@@ -630,17 +630,17 @@ export default class DtsGenerator {
                     types,
                     minItems,
                     maxItems,
-                    additionalItemsNode
+                    additionalItemsNode,
                 ),
                 schema,
-                terminate
+                terminate,
             );
         }
     }
 
     private generateType(
         schema: NormalizedSchema,
-        terminate: boolean
+        terminate: boolean,
     ): ts.TypeNode {
         const type = schema.content.type;
         if (type == null) {
@@ -658,7 +658,7 @@ export default class DtsGenerator {
                     (t) => {
                         return this.generateTypeName(schema, t, false);
                     },
-                    terminate
+                    terminate,
                 );
             }
         }
@@ -666,7 +666,7 @@ export default class DtsGenerator {
     private generateTypeName(
         schema: NormalizedSchema,
         type: string,
-        terminate: boolean
+        terminate: boolean,
     ): ts.TypeNode {
         const tsType = utils.toTSType(type, schema.content);
         if (tsType) {