Implement handling of remapping unresolved types

Author: socsieng

example/package-lock.json

@@ -12,6 +12,6 @@
   "license": "ISC",
   "devDependencies": {},
   "dependencies": {
-    "typedoc-plugin-typescript-declaration": "^0.2.7"
+    "typedoc-plugin-typescript-declaration": "^0.2.9"
   }
 }

example/package.json

@@ -1,6 +1,6 @@
 {
   "name": "typedoc-plugin-typescript-declaration",
-  "version": "0.2.8",
+  "version": "0.2.9",
   "description": "Typedoc plugin to render to typescript declaration file",
   "main": "dist/index.js",
   "bin": {

package-lock.json

@@ -0,0 +1,135 @@
+import {
+  ArrayType,
+  ConditionalType,
+  IndexedAccessType,
+  IntersectionType,
+  IntrinsicType,
+  PredicateType,
+  ProjectReflection,
+  ReferenceType,
+  Reflection,
+  ReflectionKind,
+  SignatureReflection,
+  TupleType,
+  Type,
+  TypeOperatorType,
+  UnionType,
+  UnknownType,
+} from 'typedoc/dist/lib/models';
+import { DeclarationReflection } from 'typedoc';
+
+export default class UnresolvedTypesMapper {
+  private _project: ProjectReflection;
+  private _knownReflectionNames: Set<string>;
+  private _knownReflections: Set<Reflection>;
+  private _currentReflections: Set<Reflection>;
+
+  constructor(project: ProjectReflection) {
+    this._project = project;
+    this._knownReflectionNames = new Set<string>();
+    this._knownReflections = new Set<Reflection>();
+    this._currentReflections = new Set<Reflection>();
+  }
+
+  public clearKnownReflections() {
+    this._knownReflectionNames.clear();
+    this._knownReflections.clear();
+  }
+
+  public registerKnownReflection(reflection: Reflection) {
+    this._knownReflections.add(reflection);
+    if (reflection.kindOf(ReflectionKind.ClassOrInterface | ReflectionKind.TypeAlias | ReflectionKind.SomeModule)) {
+      this._knownReflectionNames.add(reflection.name);
+    }
+  }
+
+  public registerKnownReflections(reflections: Reflection[]) {
+    reflections.forEach(reflection => {
+      this.registerKnownReflection(reflection);
+    });
+  }
+
+  public resolve() {
+    this._currentReflections.clear();
+    Object.values(this._project.reflections).forEach(reflection => this._currentReflections.add(reflection));
+
+    this.getReflectionsByInstanceType(this._project, DeclarationReflection).forEach(reflection => {
+      reflection.extendedTypes = reflection.extendedTypes?.filter(t => this.isMapped(t));
+      reflection.type = this.remapType(reflection.type);
+    });
+
+    this.getReflectionsByInstanceType(this._project, SignatureReflection).forEach(reflection => {
+      reflection.type = this.remapType(reflection.type);
+      reflection.parameters?.forEach(p => p.type = this.remapType(p.type));
+      reflection.typeParameters?.forEach(p => p.type = this.remapType(p.type));
+    });
+  }
+
+  private isKnown(type: Type) {
+    if (type instanceof ReferenceType) {
+      return this._knownReflectionNames.has(type.name);
+    }
+    return false;
+  }
+
+  private isRemoved(reflection: Reflection) {
+    return this._knownReflections.has(reflection) && !this._currentReflections.has(reflection);
+  }
+
+  private isUnmapped(type: Type | undefined) {
+    return  (type instanceof ReferenceType)
+      && (!type.reflection || this.isRemoved(type.reflection))
+      && !type.typeArguments
+      && this.isKnown(type);
+  }
+
+  private isMapped(type: Type | undefined) {
+    return !this.isUnmapped(type);
+  }
+
+  private remapType<T extends Type | undefined>(type: T): T extends undefined ? undefined : T;
+  private remapType(type: Type | undefined) {
+    if (type instanceof UnionType) {
+      let items = type.types.filter(t => this.isMapped(t));
+      if (items.length === 0) {
+        items = type.types.map(t => this.remapType(t));
+      } else if (items.length === 1) {
+        const item = items[0];
+        if ((item instanceof IntrinsicType) && (item.name === 'undefined' || item.name === 'null')) {
+          items = type.types.map(t => this.remapType(t));
+        }
+      }
+
+      if (items.length === 1) {
+        return items[0];
+      } else {
+        type.types = items;
+      }
+    } else if (type instanceof IntersectionType) {
+      type.types = type.types.map(t => this.remapType(t));
+    } else if (type instanceof ArrayType) {
+      type.elementType = this.remapType(type.elementType);
+    } else if (type instanceof PredicateType) {
+      type.targetType = this.remapType(type.targetType);
+    } else if (type instanceof TupleType) {
+      type.elements = type.elements.map(t => this.remapType(t));
+    } else if (type instanceof ReferenceType && type.typeArguments) {
+      type.typeArguments = type.typeArguments.map(t => this.remapType(t)!);
+    } else if (type instanceof ConditionalType) {
+      type.checkType = this.remapType(type.checkType);
+      type.extendsType = this.remapType(type.extendsType);
+      type.trueType = this.remapType(type.trueType);
+      type.falseType = this.remapType(type.falseType)
+    } else if ((type instanceof TypeOperatorType) && this.isUnmapped(type.target)) {
+      return new UnknownType('unknown');
+    } else if ((type instanceof IndexedAccessType) && this.isUnmapped(type.objectType)) {
+      return new UnknownType('unknown');
+    }
+
+    return this.isUnmapped(type) ? new UnknownType('unknown') : type;
+  }
+
+  private getReflectionsByInstanceType<T extends Reflection>(project: ProjectReflection, func: { new(...args: any[]): T }): T[] {
+    return Object.values(project.reflections).filter(r => r instanceof func) as unknown as T[];
+  }
+}

package.json

@@ -3,12 +3,14 @@ import { CliApplication } from './cli-application';
 import { KeyOfPlugin } from './keyof-plugin';
 import { OmitTagsPlugin } from './omit-tags-plugin';
 import { TypeScriptDeclarationPlugin } from './typescript-declaration-plugin';
+import { UnresolvedTypesPlugin } from './unresolved-types-plugin';
 import { VersionFilterPlugin } from './version-filter-plugin';
 
 const options = [
   ...VersionFilterPlugin.options,
   ...KeyOfPlugin.options,
   ...OmitTagsPlugin.options,
+  ...UnresolvedTypesPlugin.options,
   ...TypeScriptDeclarationPlugin.options,
 ];
 
@@ -20,6 +22,7 @@ module.exports = (PluginHost: Application) => {
   app.converter.addComponent('version-filter', new VersionFilterPlugin(app.converter));
   app.converter.addComponent('keyof-comment', new KeyOfPlugin(app.converter));
   app.converter.addComponent('omit-tags', new OmitTagsPlugin(app.converter));
+  app.converter.addComponent('unresolved-types', new UnresolvedTypesPlugin(app.converter));
 
   const declarationPlugin = app.renderer.addComponent('typescript-declaration', new TypeScriptDeclarationPlugin(app.renderer));
 

src/convert/unresolved-types-mapper.ts

@@ -22,7 +22,7 @@ export default abstract class SignatureRenderer extends ReflectionRenderer {
 
   protected renderReturnType(method: SignatureReflection): string {
     if (method.type) {
-      return `${method.parent?.kind === ReflectionKind.TypeLiteral ? ' =>': ':'} ${TypeFormatter.format(method.type, { includeConstraints: false })}`;
+      return `${method.parent?.kind === ReflectionKind.TypeLiteral && method.kind !== ReflectionKind.IndexSignature ? ' =>': ':'} ${TypeFormatter.format(method.type, { includeConstraints: false })}`;
     }
     return '';
   }

src/index.ts

@@ -1,4 +1,15 @@
-import { ArrayType, ConditionalType, IndexedAccessType, IntrinsicType, PredicateType, ReferenceType, TypeOperatorType, TypeParameterType, UnionType } from 'typedoc/dist/lib/models';
+import {
+  ArrayType,
+  ConditionalType,
+  IndexedAccessType,
+  IntrinsicType,
+  PredicateType,
+  ReferenceType,
+  StringLiteralType,
+  TypeOperatorType,
+  TypeParameterType,
+  UnionType,
+} from 'typedoc/dist/lib/models';
 import TypeFormatter from './type-formatter';
 
 it('should format intrinsic type', () => {
@@ -61,9 +72,9 @@ it('should format conditional type', () => {
 it('should format indexed access type', () => {
   const type = new IndexedAccessType(
     new IntrinsicType('object'), // object type
-    new IntrinsicType('string'), // index type
+    new StringLiteralType('string'), // index type
   );
-  expect(TypeFormatter.format(type)).toEqual('{ [key: string]: object }');
+  expect(TypeFormatter.format(type)).toEqual('object["string"]');
 });
 
 it('should format predecate type', () => {

src/render/signature-renderer.ts

@@ -29,7 +29,7 @@ export default class TypeFormatter {
 
     if (type.type === 'indexedAccess') {
       const indexType = type as IndexedAccessType;
-      return `{ [key: ${TypeFormatter.format(indexType.indexType)}]: ${TypeFormatter.format(indexType.objectType)} }`;
+      return `${TypeFormatter.format(indexType.objectType)}[${TypeFormatter.format(indexType.indexType)}]`;
     }
 
     if (type.type === 'intersection') {

src/render/type-formatter.spec.ts

@@ -17,14 +17,15 @@ export default class TypeLiteralRenderer extends ContainerRenderer {
 
     const member = node as DeclarationReflection;
 
-    if (member.children) {
+    if (member.children || member.indexSignature) {
+      const children = [...(member.children || []), member.indexSignature].filter(c => c);
       if (node.parent?.kind === ReflectionKind.TypeAlias) {
         const body = this.renderBody(member, 1, ',');
         if (body) {
           lines.push('{', body, '}');
         }
       } else {
-        lines.push(join(' ', '{', member.children.map(c => ReflectionFormatter.instance().render(c)).join(', '), '}'));
+        lines.push(join(' ', '{', children.map(c => ReflectionFormatter.instance().render(c)).join(', '), '}'));
       }
     } else if (member.signatures) {
       lines.push(ReflectionFormatter.instance().render(member.signatures[0]));