Allow components from dependencies to be used, Closes #39

Author: rubensworks

lib/generate/Generator.ts

@@ -8,6 +8,7 @@ import { ClassLoader } from '../parse/ClassLoader';
 import { ConstructorLoader } from '../parse/ConstructorLoader';
 import { PackageMetadataLoader } from '../parse/PackageMetadataLoader';
 import { ParameterResolver } from '../parse/ParameterResolver';
+import { ExternalModulesLoader } from '../resolution/ExternalModulesLoader';
 import type { ResolutionContext } from '../resolution/ResolutionContext';
 import type { PathDestinationDefinition } from '../serialize/ComponentConstructor';
 import { ComponentConstructor } from '../serialize/ComponentConstructor';
@@ -44,14 +45,24 @@ export class Generator {
     const classIndexer = new ClassIndexer({ classLoader, classFinder, ignoreClasses: this.ignoreClasses });
 
     // Find all relevant classes
-    const packageExports = await classFinder.getPackageExports(packageMetadata.typesPath);
+    const packageExports = await classFinder.getPackageExports(packageMetadata.name, packageMetadata.typesPath);
     const classIndex = await classIndexer.createIndex(packageExports);
 
     // Load constructor data
     const constructorsUnresolved = new ConstructorLoader().getConstructors(classIndex);
     const constructors = await new ParameterResolver({ classLoader, ignoreClasses: this.ignoreClasses })
       .resolveAllConstructorParameters(constructorsUnresolved, classIndex);
 
+    // Load external components
+    const logger = ComponentsManagerBuilder.createLogger(this.logLevel);
+    const externalModulesLoader = new ExternalModulesLoader({
+      pathDestination: this.pathDestination,
+      packageMetadata,
+      logger,
+    });
+    const externalPackages = externalModulesLoader.findExternalPackages(classIndex, constructors);
+    const externalComponents = await externalModulesLoader.loadExternalComponents(require, externalPackages);
+
     // Create components
     const contextConstructor = new ContextConstructor({
       packageMetadata,
@@ -63,11 +74,13 @@ export class Generator {
       pathDestination: this.pathDestination,
       classReferences: classIndex,
       classConstructors: constructors,
+      externalComponents,
       contextParser: new ContextParser({
         documentLoader: new PrefetchedDocumentLoader({
-          contexts: {},
-          logger: ComponentsManagerBuilder.createLogger(this.logLevel),
+          contexts: externalComponents.moduleState.contexts,
+          logger,
         }),
+        skipValidation: true,
       }),
     });
     const components = await componentConstructor.constructComponents();

lib/parse/ClassFinder.ts

@@ -14,18 +14,19 @@ export class ClassFinder {
 
   /**
    * From a given types index, find all named exports.
+   * @param packageName Package we are checking.
    * @param typesPath The path to the index typings file.
    */
-  public async getPackageExports(typesPath: string): Promise<ClassIndex<ClassReference>> {
+  public async getPackageExports(packageName: string, typesPath: string): Promise<ClassIndex<ClassReference>> {
     let exports: ClassIndex<ClassReference> = {};
 
     // Start from the package index, and collect all named exports.
     const paths = [ typesPath ];
     for (const path of paths) {
-      const { named, unnamed } = await this.getFileExports(path);
+      const { named, unnamed } = await this.getFileExports(packageName, path);
       exports = { ...exports, ...named };
       for (const additionalPath of unnamed) {
-        paths.push(additionalPath);
+        paths.push(additionalPath.fileName);
       }
     }
 
@@ -34,10 +35,11 @@ export class ClassFinder {
 
   /**
    * Get all named and unnamed exports from the given file.
+   * @param packageName Package we are checking.
    * @param fileName The path to a typescript file.
    */
-  public async getFileExports(fileName: string):
-  Promise<{ named: ClassIndex<ClassReference>; unnamed: string[] }> {
+  public async getFileExports(packageName: string, fileName: string):
+  Promise<{ named: ClassIndex<ClassReference>; unnamed: { packageName: string; fileName: string }[] }> {
     // Load the elements of the class
     const {
       exportedClasses,
@@ -46,12 +48,15 @@ export class ClassFinder {
       exportedUnknowns,
       declaredClasses,
       importedElements,
-    } = await this.classLoader.loadClassElements(fileName);
-    const exportDefinitions: { named: ClassIndex<ClassReference>; unnamed: string[] } = { named: {}, unnamed: []};
+    } = await this.classLoader.loadClassElements(packageName, fileName);
+    const exportDefinitions:
+    { named: ClassIndex<ClassReference>; unnamed: { packageName: string; fileName: string }[] } =
+      { named: {}, unnamed: []};
 
     // Get all named exports
     for (const localName in exportedClasses) {
       exportDefinitions.named[localName] = {
+        packageName,
         localName,
         fileName,
       };
@@ -60,6 +65,7 @@ export class ClassFinder {
     // Get all named exports from other files
     for (const [ exportedName, { localName, fileName: importedFileName }] of Object.entries(exportedImportedElements)) {
       exportDefinitions.named[exportedName] = {
+        packageName,
         localName,
         fileName: importedFileName,
       };
@@ -72,6 +78,7 @@ export class ClassFinder {
         // First check declared classes
         if (localName in declaredClasses) {
           exportDefinitions.named[exportedName] = {
+            packageName,
             localName,
             fileName,
           };

lib/parse/ClassIndex.ts

@@ -10,6 +10,8 @@ export type ClassIndex<T> = Record<string, T>;
  * The name and location of a class.
  */
 export interface ClassReference {
+  // Name of the package this class is part of.
+  packageName: string;
   // The name of the class within the file.
   localName: string;
   // The name of the file the class is defined in.

lib/parse/ClassIndexer.ts

@@ -47,6 +47,7 @@ export class ClassIndexer {
     if (superClassName && !(superClassName in this.ignoreClasses)) {
       try {
         classReferenceLoaded.superClass = await this.loadClassChain({
+          packageName: classReferenceLoaded.packageName,
           localName: superClassName,
           fileName: classReferenceLoaded.fileName,
         });

lib/parse/ClassLoader.ts

@@ -81,7 +81,7 @@ export class ClassLoader {
       importedElements,
       exportedImportedAll,
       exportedImportedElements,
-    } = this.getClassElements(classReference.fileName, ast);
+    } = this.getClassElements(classReference.packageName, classReference.fileName, ast);
 
     // If the class has been exported in this file, return directly
     if (classReference.localName in exportedClasses) {
@@ -149,7 +149,7 @@ export class ClassLoader {
     // If we still haven't found the class, iterate over all export all's
     for (const subFile of exportedImportedAll) {
       try {
-        return await this.loadClassDeclaration({ localName: classReference.localName, fileName: subFile },
+        return await this.loadClassDeclaration({ localName: classReference.localName, ...subFile },
           considerInterfaces);
       } catch {
         // Ignore class not found errors
@@ -188,37 +188,88 @@ export class ClassLoader {
 
   /**
    * Load a class, and get all class elements from it.
+   * @param packageName Package name we are importing from.
    * @param fileName A file path.
    */
-  public async loadClassElements(fileName: string): Promise<ClassElements> {
+  public async loadClassElements(packageName: string, fileName: string): Promise<ClassElements> {
     const ast = await this.resolutionContext.parseTypescriptFile(fileName);
-    return this.getClassElements(fileName, ast);
+    return this.getClassElements(packageName, fileName, ast);
   }
 
   /**
-   * Convert the given import path to an absolute file path.
+   * Convert the given import path to an absolute file path, coupled with the module it is part of.
+   * @param currentPackageName Package name we are importing from.
    * @param currentFilePath Absolute path to a file in which the import path occurs.
    * @param importPath Possibly relative path that is being imported.
    */
-  public importTargetToAbsolutePath(currentFilePath: string, importPath: string): string {
-    // TODO: Add support for imports from other packages (#39)
-    return Path.join(Path.dirname(currentFilePath), importPath);
+  public importTargetToAbsolutePath(
+    currentPackageName: string,
+    currentFilePath: string,
+    importPath: string,
+  ): { packageName: string; fileName: string } {
+    // Handle import paths within the current package
+    if (importPath.startsWith('.')) {
+      return {
+        packageName: currentPackageName,
+        fileName: Path.join(Path.dirname(currentFilePath), importPath),
+      };
+    }
+
+    // Handle import paths to other packages
+    let packageName: string;
+    let packagePath: string | undefined;
+    if (importPath.startsWith('@')) {
+      const slashIndexFirst = importPath.indexOf('/');
+      if (slashIndexFirst < 0) {
+        throw new Error(`Invalid scoped package name for import path '${importPath}' in '${currentFilePath}'`);
+      }
+      const slashIndexSecond = importPath.indexOf('/', slashIndexFirst + 1);
+      if (slashIndexSecond < 0) {
+        // Import form: "@scope/package"
+        packageName = importPath;
+      } else {
+        // Import form: "@scope/package/path"
+        packageName = importPath.slice(0, Math.max(0, slashIndexSecond));
+        packagePath = importPath.slice(slashIndexSecond + 1);
+      }
+    } else {
+      const slashIndex = importPath.indexOf('/');
+      if (slashIndex < 0) {
+        // Import form: "package"
+        packageName = importPath;
+      } else {
+        // Import form: "package/path"
+        packageName = importPath.slice(0, Math.max(0, slashIndex));
+        packagePath = importPath.slice(slashIndex + 1);
+      }
+    }
+
+    // Resolve paths
+    const packageRoot = this.resolutionContext.resolvePackageIndex(packageName, currentFilePath);
+    const remoteFilePath = packagePath ?
+      Path.resolve(Path.dirname(packageRoot), packagePath) :
+      packageRoot.slice(0, packageRoot.lastIndexOf('.'));
+    return {
+      packageName,
+      fileName: remoteFilePath,
+    };
   }
 
   /**
    * Get all class elements in a file.
+   * @param packageName Package name we are importing from.
    * @param fileName A file path.
    * @param ast The parsed file.
    */
-  public getClassElements(fileName: string, ast: AST<TSESTreeOptions>): ClassElements {
+  public getClassElements(packageName: string, fileName: string, ast: AST<TSESTreeOptions>): ClassElements {
     const exportedClasses: Record<string, ClassDeclaration> = {};
     const exportedInterfaces: Record<string, TSInterfaceDeclaration> = {};
-    const exportedImportedElements: Record<string, { localName: string; fileName: string }> = {};
-    const exportedImportedAll: string[] = [];
+    const exportedImportedElements: Record<string, ClassReference> = {};
+    const exportedImportedAll: { packageName: string; fileName: string }[] = [];
     const exportedUnknowns: Record<string, string> = {};
     const declaredClasses: Record<string, ClassDeclaration> = {};
     const declaredInterfaces: Record<string, TSInterfaceDeclaration> = {};
-    const importedElements: Record<string, { localName: string; fileName: string }> = {};
+    const importedElements: Record<string, ClassReference> = {};
 
     for (const statement of ast.body) {
       if (statement.type === AST_NODE_TYPES.ExportNamedDeclaration) {
@@ -240,7 +291,7 @@ export class ClassLoader {
           for (const specifier of statement.specifiers) {
             exportedImportedElements[specifier.exported.name] = {
               localName: specifier.local.name,
-              fileName: this.importTargetToAbsolutePath(fileName, statement.source.value),
+              ...this.importTargetToAbsolutePath(packageName, fileName, statement.source.value),
             };
           }
         } else {
@@ -254,7 +305,7 @@ export class ClassLoader {
         if (statement.source &&
           statement.source.type === AST_NODE_TYPES.Literal &&
           typeof statement.source.value === 'string') {
-          exportedImportedAll.push(this.importTargetToAbsolutePath(fileName, statement.source.value));
+          exportedImportedAll.push(this.importTargetToAbsolutePath(packageName, fileName, statement.source.value));
         }
       } else if (statement.type === AST_NODE_TYPES.ClassDeclaration && statement.id) {
         // Form: `declare class A {}`
@@ -270,7 +321,7 @@ export class ClassLoader {
           if (specifier.type === AST_NODE_TYPES.ImportSpecifier) {
             importedElements[specifier.local.name] = {
               localName: specifier.imported.name,
-              fileName: this.importTargetToAbsolutePath(fileName, statement.source.value),
+              ...this.importTargetToAbsolutePath(packageName, fileName, statement.source.value),
             };
           }
         }
@@ -303,15 +354,15 @@ export interface ClassElements {
   // Interfaces that have been declared in a file via `export interface A`
   exportedInterfaces: Record<string, TSInterfaceDeclaration>;
   // Elements that have been exported via `export { A as B } from "b"`
-  exportedImportedElements: Record<string, { localName: string; fileName: string }>;
+  exportedImportedElements: Record<string, ClassReference>;
   // Exports via `export * from "b"`
-  exportedImportedAll: string[];
+  exportedImportedAll: { packageName: string; fileName: string }[];
   // Things that have been exported via `export {A as B}`, where the target is not known
   exportedUnknowns: Record<string, string>;
   // Classes that have been declared in a file via `declare class A`
   declaredClasses: Record<string, ClassDeclaration>;
   // Interfaces that have been declared in a file via `declare interface A`
   declaredInterfaces: Record<string, TSInterfaceDeclaration>;
   // Elements that are imported from elsewhere via `import {A} from ''`
-  importedElements: Record<string, { localName: string; fileName: string }>;
+  importedElements: Record<string, ClassReference>;
 }

lib/parse/ParameterLoader.ts

@@ -9,7 +9,7 @@ import type {
   TSTypeReference,
 } from '@typescript-eslint/types/dist/ts-estree';
 import { AST_NODE_TYPES } from '@typescript-eslint/typescript-estree';
-import type { ClassReference, ClassReferenceLoaded, InterfaceLoaded } from './ClassIndex';
+import type { ClassReferenceLoaded, InterfaceLoaded } from './ClassIndex';
 import type { CommentData } from './CommentLoader';
 import { CommentLoader } from './CommentLoader';
 import type { ConstructorData } from './ConstructorLoader';
@@ -417,7 +417,7 @@ export type ParameterRangeResolved = {
   value: string;
 } | {
   type: 'class';
-  value: ClassReference;
+  value: ClassReferenceLoaded;
 } | {
   type: 'nested';
   value: ParameterData<ParameterRangeResolved>[];

lib/parse/ParameterResolver.ts

@@ -100,9 +100,10 @@ export class ParameterResolver {
    */
   public async resolveRangeInterface(
     interfaceName: string,
-    owningClass: ClassReference,
+    owningClass: ClassReferenceLoaded,
   ): Promise<ParameterRangeResolved> {
     const classOrInterface = await this.loadClassOrInterfacesChain({
+      packageName: owningClass.packageName,
       localName: interfaceName,
       fileName: owningClass.fileName,
     });
@@ -160,6 +161,7 @@ export class ParameterResolver {
         .filter(interfaceName => !(interfaceName in this.ignoreClasses))
         .map(async interfaceName => {
           const superInterface = await this.loadClassOrInterfacesChain({
+            packageName: classOrInterface.packageName,
             localName: interfaceName,
             fileName: classOrInterface.fileName,
           });