Output the default values of generic types

Author: rubensworks

lib/parse/ClassIndex.ts

@@ -59,7 +59,7 @@ export interface ClassLoaded extends ClassReference {
 /**
  * A hash of generic type name to its properties.
  */
-export type GenericTypes = Record<string, { type?: TSESTree.TypeNode }>;
+export type GenericTypes = Record<string, { type?: TSESTree.TypeNode; default?: TSESTree.TypeNode }>;
 
 /**
  * Something (like a class or interface) that may have generic types assigned to it as instantiation.

lib/parse/ClassLoader.ts

@@ -444,7 +444,7 @@ export class ClassLoader {
     const genericTypes: GenericTypes = {};
     if (classDeclaration.typeParameters) {
       for (const param of classDeclaration.typeParameters.params) {
-        genericTypes[param.name.name] = { type: param.constraint };
+        genericTypes[param.name.name] = { type: param.constraint, default: param.default };
       }
     }
     return genericTypes;

lib/parse/ParameterLoader.ts

@@ -128,6 +128,7 @@ export class ParameterLoader {
         genericTypeParameters,
         genericName,
         genericType.type,
+        genericType.default,
       );
     }
 
@@ -143,12 +144,14 @@ export class ParameterLoader {
    * @param genericTypeParameters The array of generic type parameters that will be appended to.
    * @param genericName The generic type name.
    * @param genericType The optional generic type range.
+   * @param genericDefault The optional generic default value.
    */
   public loadClassGeneric(
     classLoaded: ClassReferenceLoaded,
     genericTypeParameters: GenericTypeParameterData<ParameterRangeUnresolved>[],
     genericName: string,
     genericType: TSESTree.TypeNode | undefined,
+    genericDefault: TSESTree.TypeNode | undefined,
   ): void {
     genericTypeParameters.push({
       name: genericName,
@@ -159,6 +162,13 @@ export class ParameterLoader {
             this.getErrorIdentifierGeneric(classLoaded, genericName),
           ) } :
           {},
+      ...genericDefault ?
+          { default: this.getRangeFromTypeNode(
+            classLoaded,
+            genericDefault,
+            this.getErrorIdentifierGeneric(classLoaded, genericName),
+          ) } :
+          {},
     });
   }
 
@@ -753,6 +763,10 @@ export interface GenericTypeParameterData<R> {
    * The range of the generic type parameter.
    */
   range?: R;
+  /**
+   * The default value.
+   */
+  default?: R;
   /**
    * The human-readable description of this parameter.
    */

lib/parse/ParameterResolver.ts

@@ -115,6 +115,9 @@ export class ParameterResolver {
         range: generic.range ?
           await this.resolveRange(generic.range, owningClass, genericTypeRemappings, false, new Set()) :
           undefined,
+        default: generic.default ?
+          await this.resolveRange(generic.default, owningClass, genericTypeRemappings, false, new Set()) :
+          undefined,
       })));
   }
 

lib/serialize/ComponentConstructor.ts

@@ -472,6 +472,11 @@ export class ComponentConstructor {
         ...genericType.range ?
             { range: await this.constructParameterRange(genericType.range, context, externalContextsCallback, id) } :
             {},
+        ...genericType.default ?
+            {
+              default: await this.constructParameterRange(genericType.default, context, externalContextsCallback, id),
+            } :
+            {},
       });
     }
     return definitions;

lib/serialize/ComponentDefinitions.ts

@@ -36,6 +36,7 @@ export type ExtensionDefinition = string | {
 export interface GenericTypeParameterDefinition {
   '@id': string;
   range?: ParameterDefinitionRange;
+  default?: ParameterDefinitionRange;
 }
 
 export interface ParameterDefinition {

test/parse/GenericsLoader.test.ts

@@ -119,5 +119,42 @@ describe('GenericsLoader', () => {
         },
       });
     });
+
+    it('should return for a single class with default generic types', async() => {
+      resolutionContext.contentsOverrides = {
+        'file.d.ts': `export class A<A, B extends number = 3>{
+  constructor(){}
+}`,
+      };
+      const A = await classIndexer.loadClassChain({
+        packageName: 'p',
+        localName: 'A',
+        fileName: 'file',
+        fileNameReferenced: 'fileReferenced',
+      });
+      expect(parser.getGenerics({
+        A,
+      })).toEqual({
+        A: {
+          genericTypeParameters: [
+            {
+              name: 'A',
+            },
+            {
+              name: 'B',
+              range: {
+                type: 'raw',
+                value: 'number',
+              },
+              default: {
+                type: 'literal',
+                value: 3,
+              },
+            },
+          ],
+          classLoaded: A,
+        },
+      });
+    });
   });
 });

test/parse/ParameterResolver.test.ts

@@ -184,6 +184,13 @@ describe('ParameterResolver', () => {
             value: 'number',
           },
         },
+        {
+          name: 'C',
+          default: {
+            type: 'literal',
+            value: 3,
+          },
+        },
       ], classReference, {})).resolves.toEqual([
         {
           name: 'A',
@@ -195,6 +202,13 @@ describe('ParameterResolver', () => {
             value: 'number',
           },
         },
+        {
+          name: 'C',
+          default: {
+            type: 'literal',
+            value: 3,
+          },
+        },
       ]);
     });
 

test/serialize/ComponentConstructor.test.ts

@@ -1137,6 +1137,26 @@ describe('ComponentConstructor', () => {
       ]);
     });
 
+    it('should handle a constructor with a single generic with default', async() => {
+      await expect(ctor.constructGenericTypeParameters(context, externalContextsCallback, classReference, [
+        {
+          name: 'T',
+          default: {
+            type: 'literal',
+            value: 3,
+          },
+        },
+      ])).resolves.toEqual([
+        {
+          '@id': 'mp:components/a/b/file-param.jsonld#MyClass__generic_T',
+          default: {
+            '@type': 'ParameterRangeLiteral',
+            parameterRangeValueLiteral: 3,
+          },
+        },
+      ]);
+    });
+
     it('should handle a constructor with a multiple generics', async() => {
       await expect(ctor.constructGenericTypeParameters(context, externalContextsCallback, classReference, [
         {