Allow param range to be undefined when its class range is ignored

Author: rubensworks

lib/generate/Generator.ts

@@ -42,7 +42,7 @@ export class Generator {
 
     // Load constructor data
     const constructorsUnresolved = new ConstructorLoader().getConstructors(classIndex);
-    const constructors = await new ParameterResolver({ classLoader })
+    const constructors = await new ParameterResolver({ classLoader, ignoreClasses: this.ignoreClasses })
       .resolveAllConstructorParameters(constructorsUnresolved, classIndex);
 
     // Create components

lib/parse/ParameterLoader.ts

@@ -421,4 +421,6 @@ export type ParameterRangeResolved = {
 } | {
   type: 'nested';
   value: ParameterData<ParameterRangeResolved>[];
+} | {
+  type: 'undefined';
 };

lib/parse/ParameterResolver.ts

@@ -13,9 +13,11 @@ import {
 
 export class ParameterResolver {
   private readonly classLoader: ClassLoader;
+  private readonly ignoreClasses: Record<string, boolean>;
 
   public constructor(args: ParameterResolverArgs) {
     this.classLoader = args.classLoader;
+    this.ignoreClasses = args.ignoreClasses;
   }
 
   /**
@@ -77,6 +79,11 @@ export class ParameterResolver {
       case 'override':
         return range;
       case 'interface':
+        if (range.value in this.ignoreClasses) {
+          return {
+            type: 'undefined',
+          };
+        }
         return await this.resolveRangeInterface(range.value, owningClass);
       case 'hash':
         return {
@@ -150,6 +157,7 @@ export class ParameterResolver {
     if (classOrInterface.type === 'interface') {
       classOrInterface.superInterfaces = await Promise.all(this.classLoader
         .getSuperInterfaceNames(classOrInterface.declaration, classOrInterface.fileName)
+        .filter(interfaceName => !(interfaceName in this.ignoreClasses))
         .map(async interfaceName => {
           const superInterface = await this.loadClassOrInterfacesChain({
             localName: interfaceName,
@@ -189,4 +197,5 @@ export class ParameterResolver {
 
 export interface ParameterResolverArgs {
   classLoader: ClassLoader;
+  ignoreClasses: Record<string, boolean>;
 }

lib/serialize/ComponentConstructor.ts

@@ -272,9 +272,25 @@ export class ComponentConstructor {
     }
 
     // For all other range types, create a parameter and return its parameter id.
-    const param: ParameterDefinition = parameterData.range.type === 'raw' || parameterData.range.type === 'override' ?
-      this.constructParameterRaw(context, classReference, parameterData, parameterData.range.value, fieldId) :
-      this.constructParameterClass(context, classReference, parameterData, parameterData.range.value, fieldId);
+    let param: ParameterDefinition;
+    switch (parameterData.range.type) {
+      case 'raw':
+      case 'override':
+        param = this.constructParameterRaw(context, classReference, parameterData, parameterData.range.value, fieldId);
+        break;
+      case 'undefined':
+        param = this.constructParameterRangeUndefined(context, classReference, parameterData, fieldId);
+        break;
+      case 'class':
+        param = this.constructParameterClass(
+          context,
+          classReference,
+          parameterData,
+          parameterData.range.value,
+          fieldId,
+        );
+        break;
+    }
     parameters.push(param);
     return { '@id': fieldId };
   }
@@ -399,6 +415,30 @@ export class ComponentConstructor {
     return definition;
   }
 
+  /**
+   * Construct a parameter definition from the given parameter data with an undefined range.
+   * @param context A parsed JSON-LD context.
+   * @param classReference Class reference of the class component owning this parameter.
+   * @param parameterData Parameter data.
+   * @param fieldId The @id of the field.
+   */
+  public constructParameterRangeUndefined(
+    context: JsonLdContextNormalized,
+    classReference: ClassLoaded,
+    parameterData: ParameterData<ParameterRangeResolved>,
+    fieldId: string,
+  ): ParameterDefinition {
+    // Fill in required fields
+    const definition: ParameterDefinition = {
+      '@id': fieldId,
+    };
+
+    // Fill in optional fields
+    this.populateOptionalParameterFields(definition, parameterData);
+
+    return definition;
+  }
+
   /**
    * Construct a parameter definition from the given parameter data with class reference range.
    * @param context A parsed JSON-LD context.

test/parse/ParameterResolver.test.ts

@@ -8,11 +8,13 @@ import { ResolutionContextMocked } from '../ResolutionContextMocked';
 describe('ParameterResolver', () => {
   const resolutionContext = new ResolutionContextMocked({});
   let classLoader: ClassLoader;
+  let ignoreClasses: Record<string, boolean>;
   let loader: ParameterResolver;
 
   beforeEach(() => {
     classLoader = new ClassLoader({ resolutionContext });
-    loader = new ParameterResolver({ classLoader });
+    ignoreClasses = {};
+    loader = new ParameterResolver({ classLoader, ignoreClasses });
   });
 
   describe('resolveAllConstructorParameters', () => {
@@ -263,6 +265,20 @@ describe('ParameterResolver', () => {
       });
     });
 
+    it('should handle an ignored interface range pointing to a class', async() => {
+      ignoreClasses.MyClass = true;
+      resolutionContext.contentsOverrides = {
+        'A.d.ts': `export * from 'MyClass'`,
+        'MyClass.d.ts': `export class MyClass{}`,
+      };
+      expect(await loader.resolveRange({
+        type: 'interface',
+        value: 'MyClass',
+      }, classReference)).toMatchObject({
+        type: 'undefined',
+      });
+    });
+
     it('should handle an interface range pointing to an implicit class', async() => {
       resolutionContext.contentsOverrides = {
         'A.d.ts': `export * from 'MyClass'`,
@@ -300,8 +316,23 @@ describe('ParameterResolver', () => {
           },
         ],
       });
+    });
 
-      // TODO: hash
+    it('should handle an interface range pointing to a extended interface that is ignored', async() => {
+      ignoreClasses.IgnoredInterface = true;
+      resolutionContext.contentsOverrides = {
+        'A.d.ts': `export * from 'MyInterface'`,
+        'MyInterface.d.ts': `
+export interface MyInterface extends IgnoredInterface{};
+`,
+      };
+      expect(await loader.resolveRange({
+        type: 'interface',
+        value: 'MyInterface',
+      }, classReference)).toMatchObject({
+        type: 'nested',
+        value: [],
+      });
     });
   });
 
@@ -562,6 +593,30 @@ declare interface C{}
         });
     });
 
+    it('should load an interface with supers and consider ignored classes', async() => {
+      ignoreClasses.C = true;
+      resolutionContext.contentsOverrides = {
+        'A.d.ts': `
+export interface A extends B, C{}
+export interface B{}
+declare interface C{}
+`,
+      };
+      expect(await loader.loadClassOrInterfacesChain(classReference))
+        .toMatchObject({
+          fileName: 'A',
+          localName: 'A',
+          type: 'interface',
+          superInterfaces: [
+            {
+              fileName: 'A',
+              localName: 'B',
+              type: 'interface',
+            },
+          ],
+        });
+    });
+
     it('should load an interface with supers over different files', async() => {
       resolutionContext.contentsOverrides = {
         'A.d.ts': `

test/serialize/ComponentConstructor.test.ts

@@ -780,6 +780,26 @@ describe('ComponentConstructor', () => {
       ]);
     });
 
+    it('should handle an undefined parameter definition', () => {
+      const parameters: ParameterDefinition[] = [];
+      expect(ctor.parameterDataToConstructorArgument(context, classReference, {
+        type: 'field',
+        name: 'field',
+        range: { type: 'undefined' },
+        required: true,
+        unique: true,
+        comment: 'Hi',
+      }, parameters, 'mp:a/b/file-param#MyClass_field', scope)).toEqual({ '@id': 'mp:a/b/file-param#MyClass_field' });
+      expect(parameters).toEqual([
+        {
+          '@id': 'mp:a/b/file-param#MyClass_field',
+          comment: 'Hi',
+          required: true,
+          unique: true,
+        },
+      ]);
+    });
+
     it('should handle an empty nested parameter definition', () => {
       const parameters: ParameterDefinition[] = [];
       expect(ctor.parameterDataToConstructorArgument(context, classReference, {