@teambit/aspect-loader 0.0.554 → 0.0.558

package/dist/aspect-definition.d.ts

@@ -6,12 +6,47 @@ export declare type AspectDefinitionProps = {
     runtimePath: string | null;
 };
 export declare class AspectDefinition {
+    /**
+     * path the the root directory of the aspect module.
+     */
     readonly aspectPath: string;
+    /**
+     * path to the runtime entry
+     */
     readonly runtimePath: string | null;
+    /**
+     * aspect component
+     */
     readonly component?: Component | undefined;
+    /**
+     * id of the component (used instead of component in the case of core aspect)
+     */
     readonly id?: string | undefined;
+    /**
+     * aspect defined using 'file://' protocol
+     */
     readonly local?: boolean | undefined;
-    constructor(aspectPath: string, runtimePath: string | null, component?: Component | undefined, id?: string | undefined, local?: boolean | undefined);
+    constructor(
+    /**
+     * path the the root directory of the aspect module.
+     */
+    aspectPath: string, 
+    /**
+     * path to the runtime entry
+     */
+    runtimePath: string | null, 
+    /**
+     * aspect component
+     */
+    component?: Component | undefined, 
+    /**
+     * id of the component (used instead of component in the case of core aspect)
+     */
+    id?: string | undefined, 
+    /**
+     * aspect defined using 'file://' protocol
+     */
+    local?: boolean | undefined);
     get getId(): string | null;
     static from({ component, aspectPath, runtimePath, id }: AspectDefinitionProps): AspectDefinition;
 }

package/dist/aspect-loader.main.runtime.d.ts

@@ -9,7 +9,13 @@ import { PluginDefinition } from './plugin-definition';
 import { Plugins } from './plugins';
 export declare type PluginDefinitionSlot = SlotRegistry<PluginDefinition[]>;
 export declare type AspectDescriptor = {
+    /**
+     * name of the extension.
+     */
     id: string;
+    /**
+     * icon of the extension.
+     */
     icon?: string;
 };
 export declare type AspectResolver = (component: Component) => Promise<ResolvedAspect>;
@@ -20,13 +26,34 @@ export declare type ResolvedAspect = {
 declare type OnAspectLoadError = (err: Error, id: ComponentID) => Promise<boolean>;
 export declare type OnAspectLoadErrorSlot = SlotRegistry<OnAspectLoadError>;
 export declare type OnLoadRequireableExtension = (requireableExtension: RequireableComponent, manifest: ExtensionManifest | Aspect) => Promise<ExtensionManifest | Aspect>;
+/**
+ * A slot which run during loading the requirable extension (after first manifest calculation)
+ */
 export declare type OnLoadRequireableExtensionSlot = SlotRegistry<OnLoadRequireableExtension>;
 export declare type MainAspect = {
+    /**
+     * path to the main aspect.
+     */
     path: string;
+    /**
+     * version of the aspect.
+     */
     version: string | undefined;
+    /**
+     * package name of the aspect
+     */
     packageName: string | undefined;
+    /**
+     * reference to aspect manifest.
+     */
     aspect: Aspect;
+    /**
+     * The name of the aspect (without the scope prefix)
+     */
     name: string;
+    /**
+     * The name of the aspect
+     */
     id: string;
 };
 export declare class AspectLoaderMain {
@@ -40,6 +67,9 @@ export declare class AspectLoaderMain {
     private getCompiler;
     registerOnAspectLoadErrorSlot(onAspectLoadError: OnAspectLoadError): void;
     registerOnLoadRequireableExtensionSlot(onLoadRequireableExtension: OnLoadRequireableExtension): void;
+    /**
+     * returns whether the aspect-load issue has been fixed.
+     */
     triggerOnAspectLoadError(err: Error, component: Component): Promise<boolean>;
     getRuntimePath(component: Component, modulePath: string, runtime: string): Promise<string | null>;
     isAspectLoaded(id: string): unknown;
@@ -61,7 +91,30 @@ export declare class AspectLoaderMain {
     private failedLoadAspect;
     get failedAspects(): string[];
     private addFailure;
+    /**
+     * run "require" of the component code to get the manifest
+     */
     doRequire(requireableExtension: RequireableComponent): Promise<ExtensionManifest | Aspect>;
+    /**
+     * in case the extension failed to load, prefer to throw an error, unless `throwOnError` param
+     * passed as `false`.
+     * there are cases when throwing an error blocks the user from doing anything else. for example,
+     * when a user develops an extension and deletes the node-modules, the extension on the workspace
+     * cannot be loaded anymore until "bit compile" is running. however, if this function throws an
+     * error, it'll throw for "bit compile" as well, which blocks the user.
+     * for the CI, it is important to throw an error because errors on console can be ignored.
+     * for now, when loading the extension from the workspace the throwOnError is passed as false.
+     * when loading from the scope (CI) it should be true.
+     *
+     * the console printing here is done directly by "console.error" and not by the logger. the reason
+     * is that the logger.console only prints when the loader started (which, btw, happens after
+     * entering this function, so it can't work) and here we want it to be printed regardless of the
+     * rules of starting the loader. e.g. if by mistake the CI got it as throwOnError=false, it's ok
+     * to break the output by the console.error.
+     *
+     * @todo: this is not the final word however about throwing/non throwing errors here.
+     * in some cases, such as "bit tag", it's better not to tag if an extension changes the model.
+     */
     loadRequireableExtensions(requireableExtensions: RequireableComponent[], throwOnError?: boolean): Promise<void>;
     getManifestsFromRequireableExtensions(requireableExtensions: RequireableComponent[], throwOnError?: boolean): Promise<Array<ExtensionManifest | Aspect>>;
     handleExtensionLoadingError(error: Error, idStr: string, throwOnError: boolean): void;
@@ -70,8 +123,15 @@ export declare class AspectLoaderMain {
     getPlugins(component: Component, componentPath: string): Plugins;
     isAspect(manifest: any): boolean;
     isAspectComponent(component: Component): boolean;
+    /**
+     * get or create a global scope, import the non-core aspects, load bit from that scope, create
+     * capsules for the aspects and load them from the capsules.
+     */
     loadAspectsFromGlobalScope(aspectIds: string[]): Promise<Component[]>;
     private prepareManifests;
+    /**
+     * register a plugin.
+     */
     registerPlugins(pluginDefs: PluginDefinition[]): this;
     loadExtensionsByManifests(extensionsManifests: Array<ExtensionManifest | Aspect>, throwOnError?: boolean): Promise<void>;
     static runtime: import("@teambit/harmony").RuntimeDefinition;

package/dist/plugin-definition.d.ts

@@ -1,5 +1,14 @@
 export interface PluginDefinition {
+    /**
+     * regex pattern for detecting the definition file within a component.
+     */
     pattern: string | RegExp;
+    /**
+     * runtimes for the plugin to apply.
+     */
     runtimes: string[];
+    /**
+     * register the plugin to its slot registry.
+     */
     register<T>(object: T): void;
 }

package/dist/plugin.d.ts

@@ -4,6 +4,9 @@ export declare class Plugin {
     readonly path: string;
     constructor(def: PluginDefinition, path: string);
     private _instance;
+    /**
+     * determines whether the plugin supports a certain runtime.
+     */
     supportsRuntime(runtime: string): boolean;
     register(): void;
     require(): unknown;

package/package.json

@@ -1,12 +1,12 @@
 {
   "name": "@teambit/aspect-loader",
-  "version": "0.0.554",
+  "version": "0.0.558",
   "homepage": "https://bit.dev/teambit/harmony/aspect-loader",
   "main": "dist/index.js",
   "componentId": {
     "scope": "teambit.harmony",
     "name": "aspect-loader",
-    "version": "0.0.554"
+    "version": "0.0.558"
   },
   "dependencies": {
     "@teambit/harmony": "0.2.11",
@@ -15,15 +15,15 @@
     "fs-extra": "10.0.0",
     "@babel/runtime": "7.12.18",
     "core-js": "^3.0.0",
-    "@teambit/component": "0.0.554",
-    "@teambit/bit": "0.0.556",
-    "@teambit/cli": "0.0.385",
-    "@teambit/envs": "0.0.554",
-    "@teambit/harmony.modules.requireable-component": "0.0.460",
-    "@teambit/legacy-bit-id": "0.0.374",
-    "@teambit/logger": "0.0.470",
-    "@teambit/scope": "0.0.554",
-    "@teambit/bit-error": "0.0.371"
+    "@teambit/component": "0.0.558",
+    "@teambit/bit": "0.0.560",
+    "@teambit/cli": "0.0.388",
+    "@teambit/envs": "0.0.558",
+    "@teambit/harmony.modules.requireable-component": "0.0.463",
+    "@teambit/legacy-bit-id": "0.0.377",
+    "@teambit/logger": "0.0.473",
+    "@teambit/scope": "0.0.558",
+    "@teambit/bit-error": "0.0.374"
   },
   "devDependencies": {
     "@types/lodash": "4.14.165",
@@ -36,7 +36,7 @@
     "@types/node": "12.20.4"
   },
   "peerDependencies": {
-    "@teambit/legacy": "1.0.171",
+    "@teambit/legacy": "1.0.174",
     "react-dom": "^16.8.0 || ^17.0.0",
     "react": "^16.8.0 || ^17.0.0"
   },
@@ -64,12 +64,20 @@
         "react": "-"
       },
       "peerDependencies": {
-        "@teambit/legacy": "1.0.171",
+        "@teambit/legacy": "1.0.174",
         "react-dom": "^16.8.0 || ^17.0.0",
         "react": "^16.8.0 || ^17.0.0"
       }
     }
   },
+  "files": [
+    "dist",
+    "!dist/tsconfig.tsbuildinfo",
+    "README.md",
+    "README.mdx",
+    "*.js",
+    "*.json"
+  ],
   "private": false,
   "engines": {
     "node": ">=12.22.0"

package/tsconfig.json

@@ -15,9 +15,9 @@
     "skipLibCheck": true,
     "moduleResolution": "node",
     "esModuleInterop": true,
-    "outDir": "dist",
     "composite": true,
     "emitDeclarationOnly": true,
+    "outDir": "dist",
     "experimentalDecorators": true,
     "emitDecoratorMetadata": true,
     "allowSyntheticDefaultImports": true,
@@ -25,7 +25,6 @@
     "strict": true,
     "noImplicitAny": false,
     "rootDir": ".",
-    "removeComments": true,
     "preserveConstEnums": true,
     "resolveJsonModule": true
   },

package/aspect-definition.ts

@@ -1,44 +0,0 @@
-import { Component } from '@teambit/component';
-
-export type AspectDefinitionProps = {
-  id?: string;
-  component?: Component;
-  aspectPath: string;
-  runtimePath: string | null;
-};
-
-export class AspectDefinition {
-  constructor(
-    /**
-     * path the the root directory of the aspect module.
-     */
-    readonly aspectPath: string,
-
-    /**
-     * path to the runtime entry
-     */
-    readonly runtimePath: string | null,
-    /**
-     * aspect component
-     */
-    readonly component?: Component,
-    /**
-     * id of the component (used instead of component in the case of core aspect)
-     */
-    readonly id?: string,
-    /**
-     * aspect defined using 'file://' protocol
-     */
-    readonly local?: boolean
-  ) {}
-
-  get getId() {
-    if (this.id) return this.id;
-    if (this.component) return this.component.id.toString();
-    return null;
-  }
-
-  static from({ component, aspectPath, runtimePath, id }: AspectDefinitionProps) {
-    return new AspectDefinition(aspectPath, runtimePath, component, id);
-  }
-}

package/aspect-loader.aspect.ts

@@ -1,8 +0,0 @@
-import { Aspect } from '@teambit/harmony';
-
-export const AspectLoaderAspect = Aspect.create({
-  id: 'teambit.harmony/aspect-loader',
-  dependencies: [],
-});
-
-export default AspectLoaderAspect;

package/aspect-loader.main.runtime.ts

@@ -1,490 +0,0 @@
-import { join } from 'path';
-import { BitId } from '@teambit/legacy-bit-id';
-import LegacyScope from '@teambit/legacy/dist/scope/scope';
-import { GLOBAL_SCOPE } from '@teambit/legacy/dist/constants';
-import { MainRuntime } from '@teambit/cli';
-import { ExtensionManifest, Harmony, Aspect, SlotRegistry, Slot } from '@teambit/harmony';
-import type { LoggerMain } from '@teambit/logger';
-import { ComponentID, Component } from '@teambit/component';
-import { Logger, LoggerAspect } from '@teambit/logger';
-import { RequireableComponent } from '@teambit/harmony.modules.requireable-component';
-import { EnvsAspect, EnvsMain } from '@teambit/envs';
-import { loadBit } from '@teambit/bit';
-import { ScopeAspect, ScopeMain } from '@teambit/scope';
-import mapSeries from 'p-map-series';
-import { difference, compact, flatten } from 'lodash';
-import { AspectDefinition, AspectDefinitionProps } from './aspect-definition';
-import { PluginDefinition } from './plugin-definition';
-import { AspectLoaderAspect } from './aspect-loader.aspect';
-import { UNABLE_TO_LOAD_EXTENSION, UNABLE_TO_LOAD_EXTENSION_FROM_LIST } from './constants';
-import { CannotLoadExtension } from './exceptions';
-import { getAspectDef } from './core-aspects';
-import { Plugins } from './plugins';
-
-export type PluginDefinitionSlot = SlotRegistry<PluginDefinition[]>;
-
-export type AspectDescriptor = {
-  /**
-   * name of the extension.
-   */
-  id: string;
-
-  /**
-   * icon of the extension.
-   */
-  icon?: string;
-};
-
-export type AspectResolver = (component: Component) => Promise<ResolvedAspect>;
-
-export type ResolvedAspect = {
-  aspectPath: string;
-  runtimePath: string | null;
-};
-
-type OnAspectLoadError = (err: Error, id: ComponentID) => Promise<boolean>;
-export type OnAspectLoadErrorSlot = SlotRegistry<OnAspectLoadError>;
-
-export type OnLoadRequireableExtension = (
-  requireableExtension: RequireableComponent,
-  manifest: ExtensionManifest | Aspect
-) => Promise<ExtensionManifest | Aspect>;
-/**
- * A slot which run during loading the requirable extension (after first manifest calculation)
- */
-export type OnLoadRequireableExtensionSlot = SlotRegistry<OnLoadRequireableExtension>;
-
-export type MainAspect = {
-  /**
-   * path to the main aspect.
-   */
-  path: string;
-
-  /**
-   * version of the aspect.
-   */
-  version: string | undefined;
-
-  /**
-   * package name of the aspect
-   */
-  packageName: string | undefined;
-
-  /**
-   * reference to aspect manifest.
-   */
-  aspect: Aspect;
-
-  /**
-   * The name of the aspect (without the scope prefix)
-   */
-  name: string;
-
-  /**
-   * The name of the aspect
-   */
-  id: string;
-};
-
-export class AspectLoaderMain {
-  constructor(
-    private logger: Logger,
-    private envs: EnvsMain,
-    private harmony: Harmony,
-    private onAspectLoadErrorSlot: OnAspectLoadErrorSlot,
-    private onLoadRequireableExtensionSlot: OnLoadRequireableExtensionSlot,
-    private pluginSlot: PluginDefinitionSlot
-  ) {}
-
-  private getCompiler(component: Component) {
-    const env = this.envs.getEnv(component)?.env;
-    return env?.getCompiler();
-  }
-
-  registerOnAspectLoadErrorSlot(onAspectLoadError: OnAspectLoadError) {
-    this.onAspectLoadErrorSlot.register(onAspectLoadError);
-  }
-
-  registerOnLoadRequireableExtensionSlot(onLoadRequireableExtension: OnLoadRequireableExtension) {
-    this.onLoadRequireableExtensionSlot.register(onLoadRequireableExtension);
-  }
-
-  /**
-   * returns whether the aspect-load issue has been fixed.
-   */
-  async triggerOnAspectLoadError(err: Error, component: Component): Promise<boolean> {
-    const entries = this.onAspectLoadErrorSlot.toArray(); // e.g. [ [ 'teambit.bit/compiler', [Function: bound onAspectLoadError] ] ]
-    let isFixed = false;
-    await mapSeries(entries, async ([, onAspectFailFunc]) => {
-      const result = await onAspectFailFunc(err, component.id);
-      if (result) isFixed = true;
-    });
-
-    return isFixed;
-  }
-
-  async getRuntimePath(component: Component, modulePath: string, runtime: string): Promise<string | null> {
-    const runtimeFile = component.filesystem.files.find((file: any) => {
-      return file.relative.includes(`.${runtime}.runtime`);
-    });
-
-    // @david we should add a compiler api for this.
-    if (!runtimeFile) return null;
-
-    const compiler = this.getCompiler(component);
-
-    if (!compiler) {
-      return join(modulePath, runtimeFile.relative);
-    }
-
-    const dist = compiler.getDistPathBySrcPath(runtimeFile.relative);
-    return join(modulePath, dist);
-  }
-
-  isAspectLoaded(id: string) {
-    if (this.failedAspects.includes(id)) return true;
-    try {
-      return this.harmony.get(id);
-    } catch (err: any) {
-      return false;
-    }
-  }
-
-  getDescriptor(id: string): AspectDescriptor {
-    const instance = this.harmony.get<any>(id);
-    const iconFn = instance.icon;
-
-    const icon = iconFn ? iconFn.apply(instance) : undefined;
-
-    return {
-      id,
-      icon,
-    };
-  }
-
-  getNotLoadedConfiguredExtensions() {
-    const configuredAspects = Array.from(this.harmony.config.raw.keys());
-    const loadedExtensions = this.harmony.extensionsIds;
-    const extensionsToLoad = difference(configuredAspects, loadedExtensions);
-    return extensionsToLoad;
-  }
-
-  loadDefinition(props: AspectDefinitionProps): AspectDefinition {
-    return AspectDefinition.from(props);
-  }
-
-  private _coreAspects: Aspect[] = [];
-
-  get coreAspects() {
-    return this._coreAspects;
-  }
-
-  isCoreAspect(id: string) {
-    const ids = this.getCoreAspectIds();
-    return ids.includes(id);
-  }
-
-  setCoreAspects(aspects: Aspect[]) {
-    this._coreAspects = aspects;
-    return this;
-  }
-
-  getCoreAspectIds() {
-    const ids = this.coreAspects.map((aspect) => aspect.id);
-    return ids.concat(this._reserved);
-  }
-
-  private _reserved = ['teambit.harmony/bit', 'teambit.harmony/config'];
-
-  getUserAspects(): string[] {
-    const coreAspectIds = this.getCoreAspectIds();
-    return difference(this.harmony.extensionsIds, coreAspectIds);
-  }
-
-  async getCoreAspectDefs(runtimeName?: string) {
-    const defs = await Promise.all(
-      this.coreAspects.map(async (aspect) => {
-        const id = aspect.id;
-        const rawDef = await getAspectDef(id, runtimeName);
-        return this.loadDefinition(rawDef);
-      })
-    );
-
-    return defs.filter((def) => def.runtimePath);
-  }
-
-  async resolveAspects(components: Component[], resolver: AspectResolver): Promise<AspectDefinition[]> {
-    const promises = components.map(async (component) => {
-      const resolvedAspect = await resolver(component);
-      return new AspectDefinition(resolvedAspect.aspectPath, resolvedAspect.runtimePath, component);
-    });
-
-    const aspectDefs = await Promise.all(promises);
-    // return aspectDefs.filter((def) => def.runtimePath);
-    return aspectDefs;
-  }
-
-  private _mainAspect: MainAspect;
-
-  get mainAspect() {
-    return this._mainAspect;
-  }
-
-  setMainAspect(mainAspect: MainAspect) {
-    this._mainAspect = mainAspect;
-    return this;
-  }
-
-  private failedLoadAspect: string[] = [];
-
-  get failedAspects() {
-    return this.failedLoadAspect;
-  }
-
-  private addFailure(id: string): void {
-    if (this.failedAspects.includes(id)) return;
-    this.failedLoadAspect.push(id);
-  }
-
-  /**
-   * run "require" of the component code to get the manifest
-   */
-  async doRequire(requireableExtension: RequireableComponent): Promise<ExtensionManifest | Aspect> {
-    const idStr = requireableExtension.component.id.toString();
-    const aspect = await requireableExtension.require();
-    const manifest = aspect.default || aspect;
-    manifest.id = idStr;
-    const newManifest = await this.runOnLoadRequireableExtensionSubscribers(requireableExtension, manifest);
-    return newManifest;
-  }
-
-  /**
-   * in case the extension failed to load, prefer to throw an error, unless `throwOnError` param
-   * passed as `false`.
-   * there are cases when throwing an error blocks the user from doing anything else. for example,
-   * when a user develops an extension and deletes the node-modules, the extension on the workspace
-   * cannot be loaded anymore until "bit compile" is running. however, if this function throws an
-   * error, it'll throw for "bit compile" as well, which blocks the user.
-   * for the CI, it is important to throw an error because errors on console can be ignored.
-   * for now, when loading the extension from the workspace the throwOnError is passed as false.
-   * when loading from the scope (CI) it should be true.
-   *
-   * the console printing here is done directly by "console.error" and not by the logger. the reason
-   * is that the logger.console only prints when the loader started (which, btw, happens after
-   * entering this function, so it can't work) and here we want it to be printed regardless of the
-   * rules of starting the loader. e.g. if by mistake the CI got it as throwOnError=false, it's ok
-   * to break the output by the console.error.
-   *
-   * @todo: this is not the final word however about throwing/non throwing errors here.
-   * in some cases, such as "bit tag", it's better not to tag if an extension changes the model.
-   */
-  async loadRequireableExtensions(requireableExtensions: RequireableComponent[], throwOnError = false): Promise<void> {
-    const manifests = await this.getManifestsFromRequireableExtensions(requireableExtensions, throwOnError);
-    return this.loadExtensionsByManifests(manifests, throwOnError);
-  }
-
-  async getManifestsFromRequireableExtensions(
-    requireableExtensions: RequireableComponent[],
-    throwOnError = false
-  ): Promise<Array<ExtensionManifest | Aspect>> {
-    const manifestsP = mapSeries(requireableExtensions, async (requireableExtension) => {
-      if (!requireableExtensions) return undefined;
-      const idStr = requireableExtension.component.id.toString();
-      try {
-        return await this.doRequire(requireableExtension);
-      } catch (e: any) {
-        this.addFailure(idStr);
-        const errorMsg = UNABLE_TO_LOAD_EXTENSION(idStr);
-        this.logger.error(errorMsg, e);
-        const isFixed = await this.triggerOnAspectLoadError(e, requireableExtension.component);
-        let errAfterReLoad;
-        if (isFixed) {
-          this.logger.info(`the loading issue has been fixed, re-loading ${idStr}`);
-          try {
-            return await this.doRequire(requireableExtension);
-          } catch (err: any) {
-            this.logger.error('re-load of the aspect failed as well', err);
-            errAfterReLoad = err;
-          }
-        }
-        const error = errAfterReLoad || e;
-        this.handleExtensionLoadingError(error, idStr, throwOnError);
-      }
-      return undefined;
-    });
-    const manifests = await manifestsP;
-
-    // Remove empty manifests as a result of loading issue
-    return compact(manifests);
-  }
-
-  handleExtensionLoadingError(error: Error, idStr: string, throwOnError: boolean) {
-    const errorMsg = UNABLE_TO_LOAD_EXTENSION(idStr);
-    if (throwOnError) {
-      // @ts-ignore
-      this.logger.console(error);
-      throw new CannotLoadExtension(idStr, error);
-    }
-    if (this.logger.isLoaderStarted) {
-      this.logger.consoleFailure(errorMsg);
-    } else {
-      this.logger.console(errorMsg);
-      this.logger.console(error.message);
-    }
-  }
-
-  async runOnLoadRequireableExtensionSubscribers(
-    requireableExtension: RequireableComponent,
-    manifest: ExtensionManifest | Aspect
-  ): Promise<ExtensionManifest | Aspect> {
-    let updatedManifest = manifest;
-    const entries = this.onLoadRequireableExtensionSlot.toArray();
-    await mapSeries(entries, async ([, onLoadRequireableExtensionFunc]) => {
-      updatedManifest = await onLoadRequireableExtensionFunc(requireableExtension, updatedManifest);
-    });
-    return updatedManifest;
-  }
-
-  getPluginDefs() {
-    return flatten(this.pluginSlot.values());
-  }
-
-  getPlugins(component: Component, componentPath: string): Plugins {
-    const defs = this.getPluginDefs();
-    return Plugins.from(component, defs, (relativePath) => {
-      const compiler = this.getCompiler(component);
-      if (!compiler) {
-        return join(componentPath, relativePath);
-      }
-
-      const dist = compiler.getDistPathBySrcPath(relativePath);
-      return join(componentPath, dist);
-    });
-  }
-
-  isAspect(manifest: any) {
-    return !!(manifest.addRuntime && manifest.getRuntime);
-  }
-
-  isAspectComponent(component: Component): boolean {
-    const data = component.config.extensions.findExtension(EnvsAspect.id)?.data;
-    return Boolean(data && data.type === 'aspect');
-  }
-
-  /**
-   * get or create a global scope, import the non-core aspects, load bit from that scope, create
-   * capsules for the aspects and load them from the capsules.
-   */
-  async loadAspectsFromGlobalScope(aspectIds: string[]): Promise<Component[]> {
-    const globalScope = await LegacyScope.ensure(GLOBAL_SCOPE, 'global-scope');
-    await globalScope.ensureDir();
-    const globalScopeHarmony = await loadBit(globalScope.path);
-    const scope = globalScopeHarmony.get<ScopeMain>(ScopeAspect.id);
-    // @todo: Gilad make this work
-    // const ids = await scope.resolveMultipleComponentIds(aspectIds);
-    const ids = aspectIds.map((id) => ComponentID.fromLegacy(BitId.parse(id, true)));
-    const hasVersions = ids.every((id) => id.hasVersion());
-    const useCache = hasVersions; // if all components has versions, try to use the cached aspects
-    const components = await scope.import(ids, { useCache, throwIfNotExist: true });
-
-    // don't use `await scope.loadAspectsFromCapsules(components, true);`
-    // it won't work for globalScope because `this !== scope.aspectLoader` (this instance
-    // is not the same as the aspectLoader instance Scope has)
-    const resolvedAspects = await scope.getResolvedAspects(components);
-    try {
-      await this.loadRequireableExtensions(resolvedAspects, true);
-    } catch (err: any) {
-      if (err?.error.code === 'MODULE_NOT_FOUND') {
-        const resolvedAspectsAgain = await scope.getResolvedAspects(components, { skipIfExists: false });
-        await this.loadRequireableExtensions(resolvedAspectsAgain, true);
-      } else {
-        throw err;
-      }
-    }
-
-    return components;
-  }
-
-  private prepareManifests(manifests: Array<ExtensionManifest | Aspect>): Aspect[] {
-    return manifests.map((manifest: any) => {
-      if (this.isAspect(manifest)) return manifest as Aspect;
-      manifest.runtime = MainRuntime;
-      if (!manifest.id) throw new Error('manifest must have static id');
-      const aspect = Aspect.create({
-        id: manifest.id,
-      });
-      aspect.addRuntime(manifest);
-      return aspect;
-    });
-  }
-
-  /**
-   * register a plugin.
-   */
-  registerPlugins(pluginDefs: PluginDefinition[]) {
-    this.pluginSlot.register(pluginDefs);
-    return this;
-  }
-
-  // TODO: change to use the new logger, see more info at loadExtensions function in the workspace
-  async loadExtensionsByManifests(extensionsManifests: Array<ExtensionManifest | Aspect>, throwOnError = true) {
-    try {
-      const manifests = extensionsManifests.filter((manifest) => {
-        // @ts-ignore TODO: fix this
-        const isValid = this.isAspect(manifest) || manifest.provider;
-        if (!isValid) this.logger.warn(`${manifest.id} is invalid. please make sure the extension is valid.`);
-        return isValid;
-      });
-      const preparedManifests = this.prepareManifests(manifests);
-      // @ts-ignore TODO: fix this
-      await this.harmony.load(preparedManifests);
-    } catch (e: any) {
-      const ids = extensionsManifests.map((manifest) => manifest.id || 'unknown');
-      // TODO: improve texts
-      const warning = UNABLE_TO_LOAD_EXTENSION_FROM_LIST(ids);
-      this.logger.warn(warning, e);
-      if (this.logger.isLoaderStarted) {
-        this.logger.consoleFailure(warning);
-      } else {
-        this.logger.console(warning);
-        this.logger.console(e);
-      }
-      if (throwOnError) {
-        throw e;
-      }
-    }
-  }
-
-  static runtime = MainRuntime;
-  static dependencies = [LoggerAspect, EnvsAspect];
-  static slots = [
-    Slot.withType<OnAspectLoadError>(),
-    Slot.withType<OnLoadRequireableExtension>(),
-    Slot.withType<PluginDefinition[]>(),
-  ];
-
-  static async provider(
-    [loggerExt, envs]: [LoggerMain, EnvsMain],
-    config,
-    [onAspectLoadErrorSlot, onLoadRequireableExtensionSlot, pluginSlot]: [
-      OnAspectLoadErrorSlot,
-      OnLoadRequireableExtensionSlot,
-      PluginDefinitionSlot
-    ],
-    harmony: Harmony
-  ) {
-    const logger = loggerExt.createLogger(AspectLoaderAspect.id);
-    const aspectLoader = new AspectLoaderMain(
-      logger,
-      envs,
-      harmony,
-      onAspectLoadErrorSlot,
-      onLoadRequireableExtensionSlot,
-      pluginSlot
-    );
-
-    return aspectLoader;
-  }
-}
-
-AspectLoaderAspect.addRuntime(AspectLoaderMain);

package/constants.ts

@@ -1,5 +0,0 @@
-// Warnings
-export const UNABLE_TO_LOAD_EXTENSION = (id: string) =>
-  `error: unable to load the extension "${id}", please use the '--log' flag for the full error.`;
-export const UNABLE_TO_LOAD_EXTENSION_FROM_LIST = (ids: string[]) =>
-  `couldn't load one of the following extensions ${ids.join(', ')}, please use the '--log' flag for the full error.`;

package/core-aspects.spec.ts

@@ -1,10 +0,0 @@
-import { getCoreAspectName } from './core-aspects';
-
-describe('core-aspects', () => {
-  describe('getCoreAspectName', () => {
-    it('should include the namespace in the aspect name', () => {
-      const aspectName = getCoreAspectName('teambit.workspace/e2e/workspace');
-      expect(aspectName).toEqual('e2e.workspace');
-    });
-  });
-});

package/core-aspects.ts

@@ -1,49 +0,0 @@
-import { existsSync, readdir } from 'fs-extra';
-import { join, resolve } from 'path';
-
-export function getAspectDir(id: string): string {
-  const aspectName = getCoreAspectName(id);
-  const packageName = getCoreAspectPackageName(id);
-  let dirPath: string;
-  try {
-    const moduleDirectory = require.resolve(packageName);
-    dirPath = join(moduleDirectory, '../..'); // to remove the "index.js" at the end
-  } catch (err: any) {
-    dirPath = resolve(__dirname, '../..', aspectName, 'dist');
-  }
-  if (!existsSync(dirPath)) {
-    throw new Error(`unable to find ${aspectName} in ${dirPath}`);
-  }
-  return dirPath;
-}
-
-export function getAspectDistDir(id: string) {
-  return resolve(`${getAspectDir(id)}/dist`);
-}
-
-export function getCoreAspectName(id: string): string {
-  const [, ...name] = id.split('/');
-  const aspectName = name.join('.');
-  return aspectName;
-}
-
-export function getCoreAspectPackageName(id: string): string {
-  const aspectName = getCoreAspectName(id);
-  return `@teambit/${aspectName}`;
-}
-
-export async function getAspectDef(aspectName: string, runtime?: string) {
-  const dirPath = getAspectDistDir(aspectName);
-
-  const files = await readdir(dirPath);
-  let runtimeFile;
-  if (runtime) {
-    runtimeFile = files.find((file) => file.includes(`.${runtime}.runtime.js`)) || null;
-  }
-
-  return {
-    id: aspectName,
-    aspectPath: join(dirPath, '..'),
-    runtimePath: runtimeFile ? resolve(`${dirPath}/${runtimeFile}`) : null,
-  };
-}

package/exceptions/cannot-load-extension.ts

@@ -1,14 +0,0 @@
-import { BitError } from '@teambit/bit-error';
-
-export class CannotLoadExtension extends BitError {
-  constructor(private extensionName: string, private error: Error) {
-    super(`could not load extension: ${extensionName} with error: ${error}`);
-  }
-
-  report(verbose?: boolean) {
-    if (verbose) return `could not load extension: ${this.extensionName}. ${this.error} `;
-    return this.message;
-  }
-
-  toJson() {}
-}

package/exceptions/index.ts

@@ -1 +0,0 @@
-export { CannotLoadExtension } from './cannot-load-extension';

package/index.ts

@@ -1,19 +0,0 @@
-import { AspectLoaderAspect } from './aspect-loader.aspect';
-
-export type {
-  AspectLoaderMain,
-  AspectDescriptor,
-  MainAspect,
-  OnLoadRequireableExtension,
-} from './aspect-loader.main.runtime';
-export {
-  getAspectDef,
-  getAspectDir,
-  getAspectDistDir,
-  getCoreAspectPackageName,
-  getCoreAspectName,
-} from './core-aspects';
-export { PluginDefinition } from './plugin-definition';
-export { AspectDefinition } from './aspect-definition';
-export { AspectLoaderAspect };
-export default AspectLoaderAspect;

package/plugin-definition.ts

@@ -1,16 +0,0 @@
-export interface PluginDefinition {
-  /**
-   * regex pattern for detecting the definition file within a component.
-   */
-  pattern: string | RegExp;
-
-  /**
-   * runtimes for the plugin to apply.
-   */
-  runtimes: string[];
-
-  /**
-   * register the plugin to its slot registry.
-   */
-  register<T>(object: T): void;
-}

package/plugin.ts

@@ -1,26 +0,0 @@
-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() {
-    const object = this.require();
-    this.def.register<unknown>(object);
-  }
-
-  require() {
-    // eslint-disable-next-line global-require, import/no-dynamic-require
-    this._instance = require(this.path).default;
-    return this._instance;
-  }
-}

package/plugins.ts

@@ -1,62 +0,0 @@
-import { Component } from '@teambit/component';
-import { Aspect } from '@teambit/harmony';
-import { PluginDefinition } from './plugin-definition';
-import { Plugin } from './plugin';
-
-export type PluginMap = { [filePath: string]: PluginDefinition };
-
-export class Plugins {
-  constructor(readonly component: Component, readonly plugins: Plugin[]) {}
-
-  // 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);
-    });
-  }
-
-  load(runtime: string) {
-    const plugins = this.getByRuntime(runtime);
-    const aspect = Aspect.create({
-      id: this.component.id.toString(),
-    });
-
-    aspect.addRuntime({
-      provider: async () => {
-        plugins.forEach((plugin) => {
-          plugin.register();
-        });
-      },
-      runtime,
-      // dependencies: this.computeDependencies(runtime)
-      dependencies: [],
-    });
-
-    return aspect;
-  }
-
-  has() {
-    return Boolean(this.plugins.length);
-  }
-
-  static from(component: Component, defs: PluginDefinition[], 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);
-  }
-}

package/types/asset.d.ts

@@ -1,29 +0,0 @@
-declare module '*.png' {
-  const value: any;
-  export = value;
-}
-declare module '*.svg' {
-  import type { FunctionComponent, SVGProps } from 'react';
-
-  export const ReactComponent: FunctionComponent<SVGProps<SVGSVGElement> & { title?: string }>;
-  const src: string;
-  export default src;
-}
-
-// @TODO Gilad
-declare module '*.jpg' {
-  const value: any;
-  export = value;
-}
-declare module '*.jpeg' {
-  const value: any;
-  export = value;
-}
-declare module '*.gif' {
-  const value: any;
-  export = value;
-}
-declare module '*.bmp' {
-  const value: any;
-  export = value;
-}

package/types/style.d.ts

@@ -1,42 +0,0 @@
-declare module '*.module.css' {
-  const classes: { readonly [key: string]: string };
-  export default classes;
-}
-declare module '*.module.scss' {
-  const classes: { readonly [key: string]: string };
-  export default classes;
-}
-declare module '*.module.sass' {
-  const classes: { readonly [key: string]: string };
-  export default classes;
-}
-
-declare module '*.module.less' {
-  const classes: { readonly [key: string]: string };
-  export default classes;
-}
-
-declare module '*.less' {
-  const classes: { readonly [key: string]: string };
-  export default classes;
-}
-
-declare module '*.css' {
-  const classes: { readonly [key: string]: string };
-  export default classes;
-}
-
-declare module '*.sass' {
-  const classes: { readonly [key: string]: string };
-  export default classes;
-}
-
-declare module '*.scss' {
-  const classes: { readonly [key: string]: string };
-  export default classes;
-}
-
-declare module '*.mdx' {
-  const component: any;
-  export default component;
-}