Emit typed memberFields instead of memberKeys

Author: rubensworks

lib/generate/Generator.ts

@@ -9,6 +9,7 @@ import { ClassLoader } from '../parse/ClassLoader';
 import { CommentLoader } from '../parse/CommentLoader';
 import { ConstructorLoader } from '../parse/ConstructorLoader';
 import { GenericsLoader } from '../parse/GenericsLoader';
+import { MemberLoader } from '../parse/MemberLoader';
 import type { PackageMetadata } from '../parse/PackageMetadataLoader';
 import { PackageMetadataLoader } from '../parse/PackageMetadataLoader';
 import { ParameterLoader } from '../parse/ParameterLoader';
@@ -97,6 +98,10 @@ export class Generator {
       const extensionsUnresolved = parameterLoader.loadAllExtensionData(classAndInterfaceIndex);
       const extensions = await parameterResolver.resolveAllExtensionData(extensionsUnresolved, classAndInterfaceIndex);
 
+      // Load members data
+      const membersUnresolved = new MemberLoader({ parameterLoader }).getMembers(classAndInterfaceIndex);
+      const members = await parameterResolver.resolveAllMemberParameterData(membersUnresolved);
+
       // Load external components
       const externalModulesLoader = new ExternalModulesLoader({
         pathDestination,
@@ -120,6 +125,7 @@ export class Generator {
         classConstructors: constructors,
         classGenerics: generics,
         classExtensions: extensions,
+        classMembers: members,
         externalComponents,
         contextParser: new ContextParser({
           documentLoader: new PrefetchedDocumentLoader({

lib/parse/ClassIndex.ts

@@ -61,8 +61,6 @@ export interface ClassLoaded extends ClassReference {
   comment?: string;
   // The generic types of this class
   generics: GenericTypes;
-  // The keys of all members
-  memberKeys: string[];
 }
 
 /**
@@ -99,8 +97,14 @@ export interface InterfaceLoaded extends ClassReference {
   comment?: string;
   // The generic types of this class
   generics: GenericTypes;
-  // The keys of all members
-  memberKeys: string[];
+}
+
+/**
+ * A member field of a class or interface.
+ */
+export interface MemberField {
+  name: string;
+  range: TypeNode | undefined;
 }
 
 /**

lib/parse/ClassLoader.ts

@@ -6,21 +6,21 @@ import type {
   TSModuleBlock,
   TSModuleDeclaration,
   TSTypeAliasDeclaration,
-  ClassBody,
-  TSInterfaceBody,
 } from '@typescript-eslint/types/dist/ts-estree';
 import type { AST, TSESTreeOptions } from '@typescript-eslint/typescript-estree';
 import { AST_NODE_TYPES } from '@typescript-eslint/typescript-estree';
 import type { Logger } from 'winston';
 import type { ResolutionContext } from '../resolution/ResolutionContext';
-import type { ClassLoaded,
+import type {
+  ClassLoaded,
   ClassReference,
   ClassReferenceLoaded,
   EnumLoaded,
   GenericTypes,
   InterfaceLoaded,
   TypeLoaded,
-  GenericallyTyped } from './ClassIndex';
+  GenericallyTyped,
+} from './ClassIndex';
 import type { CommentLoader } from './CommentLoader';
 
 /**
@@ -202,7 +202,6 @@ export class ClassLoader {
           ast,
           abstract: declaration.abstract,
           generics: this.collectGenericTypes(declaration),
-          memberKeys: this.collectClassMembers(declaration.body),
         });
       }
 
@@ -216,7 +215,6 @@ export class ClassLoader {
           ast,
           abstract: declaration.abstract,
           generics: this.collectGenericTypes(declaration),
-          memberKeys: this.collectClassMembers(declaration.body),
         });
       }
 
@@ -231,7 +229,6 @@ export class ClassLoader {
             declaration,
             ast,
             generics: this.collectGenericTypes(declaration),
-            memberKeys: this.collectClassMembers(declaration.body),
           });
         }
 
@@ -244,7 +241,6 @@ export class ClassLoader {
             declaration,
             ast,
             generics: this.collectGenericTypes(declaration),
-            memberKeys: this.collectClassMembers(declaration.body),
           });
         }
       }
@@ -676,31 +672,6 @@ export class ClassLoader {
       exportAssignment,
     };
   }
-
-  /**
-   * Obtain the class member keys.
-   * This should correspond to the keys that are available within the `keyof` range of this class
-   * @param body A class or interface body
-   */
-  public collectClassMembers(body: ClassBody | TSInterfaceBody): string[] {
-    const members: string[] = [];
-    for (const element of body.body) {
-      // eslint-disable-next-line @typescript-eslint/switch-exhaustiveness-check
-      switch (element.type) {
-        case AST_NODE_TYPES.ClassProperty:
-        case AST_NODE_TYPES.TSAbstractClassProperty:
-        case AST_NODE_TYPES.MethodDefinition:
-        case AST_NODE_TYPES.TSAbstractMethodDefinition:
-        case AST_NODE_TYPES.TSPropertySignature:
-        case AST_NODE_TYPES.TSMethodSignature:
-          if (element.key.type === 'Identifier') {
-            members.push(element.key.name);
-          }
-          break;
-      }
-    }
-    return members;
-  }
 }
 
 export interface ClassLoaderArgs {

lib/parse/MemberLoader.ts

@@ -0,0 +1,79 @@
+import { AST_NODE_TYPES } from '@typescript-eslint/typescript-estree';
+import type { ClassReferenceLoaded, ClassReferenceLoadedClassOrInterface, ClassIndex } from './ClassIndex';
+
+import type { MemberParameterData, ParameterLoader, ParameterRangeUnresolved } from './ParameterLoader';
+
+/**
+ * Loads the member data of classes.
+ */
+export class MemberLoader {
+  private readonly parameterLoader: ParameterLoader;
+
+  public constructor(args: MemberLoaderArgs) {
+    this.parameterLoader = args.parameterLoader;
+  }
+
+  /**
+   * Create a class index containing all member data from the classes in the given index.
+   * @param classIndex An index of loaded classes.
+   */
+  public getMembers(
+    classIndex: ClassIndex<ClassReferenceLoaded>,
+  ): ClassIndex<MemberData<ParameterRangeUnresolved>> {
+    const membersIndex: ClassIndex<MemberData<ParameterRangeUnresolved>> = {};
+    for (const [ className, classLoadedRoot ] of Object.entries(classIndex)) {
+      if (classLoadedRoot.type === 'class' || classLoadedRoot.type === 'interface') {
+        membersIndex[className] = {
+          members: this.collectClassFields(classLoadedRoot),
+          classLoaded: classLoadedRoot,
+        };
+      }
+    }
+    return membersIndex;
+  }
+
+  /**
+   * Obtain the class member fields.
+   * This should correspond to the keys that are available within the `keyof` range of this class
+   * @param classLoaded A class or interface
+   */
+  public collectClassFields(
+    classLoaded: ClassReferenceLoadedClassOrInterface,
+  ): MemberParameterData<ParameterRangeUnresolved>[] {
+    const members: MemberParameterData<ParameterRangeUnresolved>[] = [];
+    for (const element of classLoaded.declaration.body.body) {
+      // eslint-disable-next-line @typescript-eslint/switch-exhaustiveness-check
+      switch (element.type) {
+        case AST_NODE_TYPES.ClassProperty:
+        case AST_NODE_TYPES.TSAbstractClassProperty:
+        case AST_NODE_TYPES.MethodDefinition:
+        case AST_NODE_TYPES.TSAbstractMethodDefinition:
+        case AST_NODE_TYPES.TSPropertySignature:
+        case AST_NODE_TYPES.TSMethodSignature:
+          if (element.key.type === 'Identifier') {
+            const typeNode = 'typeAnnotation' in element ? element.typeAnnotation!.typeAnnotation : undefined;
+            members.push({
+              name: element.key.name,
+              range: typeNode ?
+                this.parameterLoader.getRangeFromTypeNode(classLoaded, typeNode, `field ${element.key.name}`) :
+                undefined,
+            });
+          }
+          break;
+      }
+    }
+    return members;
+  }
+}
+
+/**
+ * Member parameter information
+ */
+export interface MemberData<R> {
+  members: MemberParameterData<R>[];
+  classLoaded: ClassReferenceLoaded;
+}
+
+export interface MemberLoaderArgs {
+  parameterLoader: ParameterLoader;
+}

lib/parse/ParameterLoader.ts

@@ -742,6 +742,21 @@ export interface GenericTypeParameterData<R> {
   comment?: string;
 }
 
+export interface MemberParameterData<R> {
+  /**
+   * The member name.
+   */
+  name: string;
+  /**
+   * The range of the member parameter.
+   */
+  range?: R;
+  /**
+   * The human-readable description of this member.
+   */
+  comment?: string;
+}
+
 /**
  * Extension information
  */

lib/parse/ParameterResolver.ts

@@ -11,13 +11,14 @@ import type {
 import type { ClassLoader } from './ClassLoader';
 import type { ConstructorData } from './ConstructorLoader';
 import type { GenericsData } from './GenericsLoader';
+import type { MemberData } from './MemberLoader';
 import type { ExtensionData,
   GenericTypeParameterData,
   ParameterData,
   ParameterDataField,
   ParameterRangeResolved,
   ParameterRangeUnresolved,
-  ParameterLoader } from './ParameterLoader';
+  ParameterLoader, MemberParameterData } from './ParameterLoader';
 
 export class ParameterResolver {
   private readonly classLoader: ClassLoader;
@@ -115,6 +116,47 @@ export class ParameterResolver {
       })));
   }
 
+  /**
+   * Resolve all member parameters of a given constructor index.
+   * @param unresolvedParametersIndex An index of unresolved constructor data.
+   */
+  public async resolveAllMemberParameterData(
+    unresolvedParametersIndex: ClassIndex<MemberData<ParameterRangeUnresolved>>,
+  ): Promise<ClassIndex<MemberData<ParameterRangeResolved>>> {
+    const resolvedIndex: ClassIndex<MemberData<ParameterRangeResolved>> = {};
+
+    // Resolve parameters for the different constructors in parallel
+    await Promise.all(Object.entries(unresolvedParametersIndex)
+      .map(async([ className, unresolvedData ]) => {
+        resolvedIndex[className] = {
+          members: await this.resolveMemberParameterData(unresolvedData.members, unresolvedData.classLoaded, {}),
+          classLoaded: unresolvedData.classLoaded,
+        };
+      }));
+
+    return resolvedIndex;
+  }
+
+  /**
+   * Resolve the given array of member parameter data in parallel.
+   * @param members An array of unresolved members.
+   * @param owningClass The class in which the given generic type parameters are declared.
+   * @param genericTypeRemappings A remapping of generic type names.
+   */
+  public async resolveMemberParameterData(
+    members: MemberParameterData<ParameterRangeUnresolved>[],
+    owningClass: ClassReferenceLoaded,
+    genericTypeRemappings: Record<string, ParameterRangeUnresolved>,
+  ): Promise<GenericTypeParameterData<ParameterRangeResolved>[]> {
+    return await Promise.all(members
+      .map(async member => ({
+        ...member,
+        range: member.range ?
+          await this.resolveRange(member.range, owningClass, genericTypeRemappings, false, new Set()) :
+          undefined,
+      })));
+  }
+
   /**
    * Resolve the given array of parameter data in parallel.
    * @param parameters An array of unresolved parameters.