@teambit/aspect-loader 1.0.106 → 1.0.108

package/plugin.ts

@@ -0,0 +1,27 @@
+import { Aspect } from '@teambit/harmony';
+import { PluginDefinition } from './plugin-definition';
+
+export class Plugin {
+  constructor(readonly def: PluginDefinition, readonly path: string) {}
+
+  // consider adding a more abstract type here to allow users to ask for dependencies.
+  private _instance: undefined | unknown;
+
+  /**
+   * determines whether the plugin supports a certain runtime.
+   */
+  supportsRuntime(runtime: string) {
+    return this.def.runtimes.includes(runtime);
+  }
+
+  register(sourceAspect: Aspect, module?: unknown) {
+    const object = module || this.require();
+    this.def.register<unknown>(object, sourceAspect);
+  }
+
+  require() {
+    // eslint-disable-next-line global-require, import/no-dynamic-require
+    this._instance = require(this.path).default;
+    return this._instance;
+  }
+}

package/plugins.ts

@@ -0,0 +1,150 @@
+import { Component } from '@teambit/component';
+import esmLoader from '@teambit/node.utils.esm-loader';
+import { NativeCompileCache } from '@teambit/toolbox.performance.v8-cache';
+import { Logger } from '@teambit/logger';
+import { Aspect } from '@teambit/harmony';
+import { PluginDefinition } from './plugin-definition';
+import { isEsmModule } from './is-esm-module';
+import { Plugin } from './plugin';
+import { OnAspectLoadErrorHandler } from './aspect-loader.main.runtime';
+
+export type PluginMap = { [filePath: string]: PluginDefinition };
+
+export class Plugins {
+  constructor(
+    readonly component: Component,
+    readonly plugins: Plugin[],
+    private triggerOnAspectLoadError: OnAspectLoadErrorHandler,
+    private logger: Logger
+  ) {}
+
+  // computeDependencies(runtime: string): Aspect[] {
+  //   const inRuntime = this.getByRuntime(runtime);
+  //   return inRuntime.flatMap((plugin) => {
+  //     return plugin.def.dependencies;
+  //   });
+  // }
+
+  getByRuntime(runtime: string) {
+    return this.plugins.filter((plugin) => {
+      return plugin.supportsRuntime(runtime);
+    });
+  }
+
+  async load(runtime: string) {
+    const plugins = this.getByRuntime(runtime);
+    const aspect = Aspect.create({
+      id: this.component.id.toString(),
+    });
+
+    aspect.addRuntime({
+      provider: async () => {
+        await Promise.all(
+          plugins.map(async (plugin) => {
+            return this.registerPluginWithTryCatch(plugin, aspect);
+          })
+        );
+        // Return an empty object so haromny will have something in the extension instance
+        // otherwise it will throw an error when trying to access the extension instance (harmony.get)
+        return {};
+      },
+      runtime,
+      // dependencies: this.computeDependencies(runtime)
+      dependencies: [],
+    });
+
+    return aspect;
+  }
+
+  async loadModule(path: string) {
+    NativeCompileCache.uninstall();
+    const module = await esmLoader(path);
+    return module.default;
+  }
+
+  async registerPluginWithTryCatch(plugin: Plugin, aspect: Aspect) {
+    const isModule = isEsmModule(plugin.path);
+    const module = isModule ? await this.loadModule(plugin.path) : undefined;
+
+    try {
+      if (isModule && !module) {
+        this.logger.consoleFailure(
+          `failed to load plugin ${plugin.path}, make sure to use 'export default' to expose your plugin`
+        );
+        return undefined;
+      }
+      return plugin.register(aspect, module);
+    } catch (firstErr: any) {
+      this.logger.warn(
+        `failed loading plugin with pattern "${
+          plugin.def.pattern
+        }", in component ${this.component.id.toString()}, will try to fix and reload`,
+        firstErr
+      );
+      const isFixed = await this.triggerOnAspectLoadError(firstErr, this.component);
+      let errAfterReLoad;
+      if (isFixed) {
+        this.logger.info(
+          `the loading issue might be fixed now, re-loading plugin with pattern "${
+            plugin.def.pattern
+          }", in component ${this.component.id.toString()}`
+        );
+        try {
+          return plugin.register(aspect, module);
+        } catch (err: any) {
+          this.logger.warn(
+            `re-load of the plugin with pattern "${
+              plugin.def.pattern
+            }", in component ${this.component.id.toString()} failed as well`,
+            err
+          );
+          errAfterReLoad = err;
+        }
+      }
+      const error = errAfterReLoad || firstErr;
+      throw error;
+    }
+  }
+
+  has() {
+    return Boolean(this.plugins.length);
+  }
+
+  static from(
+    component: Component,
+    defs: PluginDefinition[],
+    triggerOnAspectLoadError: OnAspectLoadErrorHandler,
+    logger: Logger,
+    resolvePath?: (path: string) => string
+  ) {
+    const plugins = defs.flatMap((pluginDef) => {
+      const files =
+        typeof pluginDef.pattern === 'string'
+          ? component.filesystem.byGlob([pluginDef.pattern])
+          : component.filesystem.byRegex(pluginDef.pattern);
+
+      return files.map((file) => {
+        return new Plugin(pluginDef, resolvePath ? resolvePath(file.relative) : file.path);
+      });
+    });
+
+    return new Plugins(component, plugins, triggerOnAspectLoadError, logger);
+  }
+
+  /**
+   * Get the plugin files from the component.
+   */
+  static files(component: Component, defs: PluginDefinition[], resolvePath?: (path: string) => string): string[] {
+    const files = defs.flatMap((pluginDef) => {
+      const matches =
+        typeof pluginDef.pattern === 'string'
+          ? component.filesystem.byGlob([pluginDef.pattern])
+          : component.filesystem.byRegex(pluginDef.pattern);
+
+      return matches.map((file) => {
+        return resolvePath ? resolvePath(file.relative) : file.path;
+      });
+    });
+    return files;
+  }
+}

package/tsconfig.json

@@ -1,38 +1,33 @@
 {
   "compilerOptions": {
     "lib": [
-      "es2019",
-      "DOM",
-      "ES6",
-      "DOM.Iterable",
-      "ScriptHost"
+      "esnext",
+      "dom",
+      "dom.Iterable"
     ],
-    "target": "es2015",
-    "module": "CommonJS",
-    "jsx": "react",
-    "allowJs": true,
-    "composite": true,
+    "target": "es2020",
+    "module": "es2020",
+    "jsx": "react-jsx",
     "declaration": true,
     "sourceMap": true,
-    "skipLibCheck": true,
     "experimentalDecorators": true,
-    "outDir": "dist",
+    "skipLibCheck": true,
     "moduleResolution": "node",
     "esModuleInterop": true,
-    "rootDir": ".",
     "resolveJsonModule": true,
-    "emitDeclarationOnly": true,
-    "emitDecoratorMetadata": true,
-    "allowSyntheticDefaultImports": true,
-    "strictPropertyInitialization": false,
-    "strict": true,
-    "noImplicitAny": false,
-    "preserveConstEnums": true
+    "allowJs": true,
+    "outDir": "dist",
+    "emitDeclarationOnly": true
   },
   "exclude": [
+    "artifacts",
+    "public",
     "dist",
+    "node_modules",
+    "package.json",
     "esm.mjs",
-    "package.json"
+    "**/*.cjs",
+    "./dist"
   ],
   "include": [
     "**/*",

package/types/asset.d.ts

@@ -5,12 +5,12 @@ declare module '*.png' {
 declare module '*.svg' {
   import type { FunctionComponent, SVGProps } from 'react';
 
-  export const ReactComponent: FunctionComponent<SVGProps<SVGSVGElement> & { title?: string }>;
+  export const ReactComponent: FunctionComponent<
+    SVGProps<SVGSVGElement> & { title?: string }
+  >;
   const src: string;
   export default src;
 }
-
-// @TODO Gilad
 declare module '*.jpg' {
   const value: any;
   export = value;
@@ -27,3 +27,15 @@ declare module '*.bmp' {
   const value: any;
   export = value;
 }
+declare module '*.otf' {
+  const value: any;
+  export = value;
+}
+declare module '*.woff' {
+  const value: any;
+  export = value;
+}
+declare module '*.woff2' {
+  const value: any;
+  export = value;
+}