@teambit/aspect-loader 1.0.107 → 1.0.108

package/constants.ts

@@ -0,0 +1,16 @@
+import chalk from 'chalk';
+
+export const UNABLE_TO_LOAD_EXTENSION = (id: string, errMsg?: string) =>
+  `error: Bit received an error loading "${id}", due to the error "${
+    errMsg || '<unknown-error>'
+  }", please use the '--log=error' flag for the full error.`;
+export const UNABLE_TO_LOAD_EXTENSION_FROM_LIST = (ids: string[], errMsg?: string, neededFor?: string) => {
+  // const installOutput = err?.code === 'MODULE_NOT_FOUND' ? `try running "bit install" to install the missing dependencies` : '';
+  const installOutput = `try running ${chalk.cyan('"bit install"')} to fix this issue`;
+  return `Bit received an error loading ${chalk.cyan(ids.join(', '))}, due to the error:
+"${errMsg || '<unknown-error>'}".
+This is required for the component: ${chalk.cyan(neededFor || 'unknown')}
+Please use the ${chalk.cyan("'--log=error'")} flag for the full error.
+${installOutput}
+`;
+};

package/core-aspects.spec.ts

@@ -0,0 +1,10 @@
+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

@@ -0,0 +1,153 @@
+import { BitError } from '@teambit/bit-error';
+import { existsSync, readdir } from 'fs-extra';
+import { join, resolve } from 'path';
+import { Config } from '@teambit/bvm.config';
+import { findCurrentBvmDir } from '@teambit/bvm.path';
+
+let _bvmConfig;
+
+export function getBvmDir(): string {
+  if (!_bvmConfig) {
+    _bvmConfig = Config.load(false, ['env', 'file']);
+  }
+
+  const bvmConfig = _bvmConfig;
+  return bvmConfig.getBvmDirectory();
+}
+
+function isRunFromBvm() {
+  return __dirname.includes('.bvm') || __dirname.includes(getBvmDir());
+}
+
+function resolveFromPaths(packageName: string, aspectName: string, pathsToResolveAspects: string[]): string {
+  const moduleDirectory = require.resolve(packageName, { paths: pathsToResolveAspects });
+  const dirPath = join(moduleDirectory, '../..'); // to remove the "index.js" at the end
+  if (!existsSync(dirPath)) {
+    throw new Error(`unable to find ${aspectName} in ${dirPath}`);
+  }
+  return dirPath;
+}
+
+function resolveFromCurrDir(packageName: string, aspectName: string): string | undefined {
+  try {
+    const moduleDirectory = require.resolve(packageName);
+    const dirPath = join(moduleDirectory, '../..'); // to remove the "index.js" at the end
+    if (!existsSync(dirPath)) {
+      throw new Error(`unable to find ${aspectName} in ${dirPath}`);
+    }
+    return dirPath;
+  } catch (err) {
+    return undefined;
+  }
+}
+function resolveFromBvmDir(packageName: string): string | undefined {
+  const currentBitDir = findCurrentBvmDir();
+  if (currentBitDir) {
+    return resolve(currentBitDir, 'node_modules', packageName);
+  }
+  return undefined;
+}
+
+function getAspectDirFromPath(id: string, pathsToResolveAspects?: string[]): string {
+  const aspectName = getCoreAspectName(id);
+  const packageName = getCoreAspectPackageName(id);
+
+  if (pathsToResolveAspects && pathsToResolveAspects.length) {
+    const fromPaths = resolveFromPaths(packageName, aspectName, pathsToResolveAspects);
+    return fromPaths;
+  }
+  const isRunFromBvmDir = isRunFromBvm();
+  const resolvers = isRunFromBvmDir ? [resolveFromBvmDir, resolveFromCurrDir] : [resolveFromCurrDir, resolveFromBvmDir];
+  for (const resolver of resolvers) {
+    const currResolved = resolver(packageName, aspectName);
+    if (currResolved) return currResolved;
+  }
+  throw new Error(`unable to find ${aspectName}`);
+}
+
+export function getAspectDir(id: string): string {
+  const aspectName = getCoreAspectName(id);
+  let dirPath;
+
+  try {
+    dirPath = getAspectDirFromPath(id);
+  } catch (err: any) {
+    dirPath = resolve(__dirname, '../..', aspectName, 'dist');
+  }
+  if (!existsSync(dirPath)) {
+    throw new Error(`unable to find ${aspectName} in ${dirPath}`);
+  }
+  return dirPath;
+}
+
+type BvmDirOptions = {
+  version?: string;
+  linkName?: string;
+};
+
+export function getAspectDirFromBvm(id: string, bvmDirOptions?: BvmDirOptions): string {
+  // Resolve from default link
+  if (!bvmDirOptions) {
+    const packageName = getCoreAspectPackageName(id);
+    const resolved = resolveFromBvmDir(packageName);
+    if (resolved) return resolved;
+  }
+
+  if (!_bvmConfig) {
+    _bvmConfig = Config.load(false, ['env', 'file']);
+  }
+
+  const bvmConfig = _bvmConfig;
+  let version;
+  if (bvmDirOptions?.version) {
+    version = bvmDirOptions?.version;
+  } else {
+    const link = bvmDirOptions?.linkName || bvmConfig.getDefaultLinkName();
+    if (!link) {
+      throw new BitError(`can't find link in bvm config. most likely bvm is not installed`);
+    }
+    const links = bvmConfig.getLinks();
+    version = links[link];
+    if (!version) {
+      throw new BitError(`can't find link named ${bvmDirOptions?.linkName} in bvm config`);
+    }
+  }
+  const { versionDir, exists } = bvmConfig.getSpecificVersionDir(version, true);
+  if (!exists) {
+    throw new BitError(`can't find version ${version} in bvm folder`);
+  }
+  return getAspectDirFromPath(id, [versionDir]);
+}
+
+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;
+  }
+  const aspectFile = files.find((file) => file.includes(`.aspect.js`)) || null;
+
+  return {
+    id: aspectName,
+    aspectPath: join(dirPath, '..'),
+    aspectFilePath: aspectFile ? resolve(`${dirPath}/${aspectFile}`) : null,
+    runtimePath: runtimeFile ? resolve(`${dirPath}/${runtimeFile}`) : null,
+  };
+}

package/dist/aspect-definition.d.ts

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

package/dist/aspect-loader.composition.d.ts

@@ -1,2 +1,2 @@
-import React from 'react';
-export declare const Logo: () => React.JSX.Element;
+/// <reference types="react" />
+export declare const Logo: () => JSX.Element;

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

@@ -8,8 +8,8 @@ import { EnvsMain } from '@teambit/envs';
 import { AspectDefinition, AspectDefinitionProps } from './aspect-definition';
 import { PluginDefinition } from './plugin-definition';
 import { Plugins } from './plugins';
-export declare type PluginDefinitionSlot = SlotRegistry<PluginDefinition[]>;
-export declare type AspectDescriptor = {
+export type PluginDefinitionSlot = SlotRegistry<PluginDefinition[]>;
+export type AspectDescriptor = {
     /**
      * name of the extension.
      */
@@ -19,17 +19,17 @@ export declare type AspectDescriptor = {
      */
     icon?: string;
 };
-export declare type AspectResolver = (component: Component) => Promise<ResolvedAspect | undefined>;
-export declare type ResolvedAspect = {
+export type AspectResolver = (component: Component) => Promise<ResolvedAspect | undefined>;
+export type ResolvedAspect = {
     aspectPath: string;
     runtimePath: string | null;
     aspectFilePath: string | null;
 };
-export declare type LoadExtByManifestContext = {
+export type LoadExtByManifestContext = {
     seeders?: string[];
     neededFor?: string;
 };
-export declare type LoadExtByManifestOptions = {
+export type LoadExtByManifestOptions = {
     throwOnError?: boolean;
     hideMissingModuleError?: boolean;
     ignoreErrors?: boolean;
@@ -39,15 +39,15 @@ export declare type LoadExtByManifestOptions = {
      */
     unifyErrorsByExtId?: boolean;
 };
-declare type OnAspectLoadError = (err: Error, id: ComponentID) => Promise<boolean>;
-export declare type OnAspectLoadErrorSlot = SlotRegistry<OnAspectLoadError>;
-export declare type OnAspectLoadErrorHandler = (err: Error, component: Component) => Promise<boolean>;
-export declare type OnLoadRequireableExtension = (requireableExtension: RequireableComponent, manifest: ExtensionManifest | Aspect) => Promise<ExtensionManifest | Aspect>;
+type OnAspectLoadError = (err: Error, id: ComponentID) => Promise<boolean>;
+export type OnAspectLoadErrorSlot = SlotRegistry<OnAspectLoadError>;
+export type OnAspectLoadErrorHandler = (err: Error, component: Component) => Promise<boolean>;
+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 declare type OnLoadRequireableExtensionSlot = SlotRegistry<OnLoadRequireableExtension>;
-export declare type MainAspect = {
+export type OnLoadRequireableExtensionSlot = SlotRegistry<OnLoadRequireableExtension>;
+export type MainAspect = {
     /**
      * path to the main aspect.
      */

package/dist/aspect-loader.main.runtime.js

@@ -206,9 +206,8 @@ class AspectLoaderMain {
     _defineProperty(this, "failedLoadAspect", []);
   }
   getCompiler(component) {
-    var _this$envs$getEnv;
-    const env = (_this$envs$getEnv = this.envs.getEnv(component)) === null || _this$envs$getEnv === void 0 ? void 0 : _this$envs$getEnv.env;
-    return env === null || env === void 0 ? void 0 : env.getCompiler();
+    const env = this.envs.getEnv(component)?.env;
+    return env?.getCompiler();
   }
   registerOnAspectLoadErrorSlot(onAspectLoadError) {
     this.onAspectLoadErrorSlot.register(onAspectLoadError);
@@ -323,8 +322,7 @@ class AspectLoaderMain {
     const configuredAspects = this.getConfiguredAspects();
     const harmonyExtensions = this.harmony.extensionsIds;
     const loadedExtensions = harmonyExtensions.filter(extId => {
-      var _this$harmony$extensi;
-      return (_this$harmony$extensi = this.harmony.extensions.get(extId)) === null || _this$harmony$extensi === void 0 ? void 0 : _this$harmony$extensi.loaded;
+      return this.harmony.extensions.get(extId)?.loaded;
     });
     const extensionsToLoad = (0, _lodash().difference)(configuredAspects, loadedExtensions);
     return extensionsToLoad;
@@ -583,8 +581,7 @@ class AspectLoaderMain {
     try {
       await aspectLoader.loadRequireableExtensions(resolvedAspects, true);
     } catch (err) {
-      var _err$error;
-      if ((err === null || err === void 0 || (_err$error = err.error) === null || _err$error === void 0 ? void 0 : _err$error.code) === 'MODULE_NOT_FOUND') {
+      if (err?.error?.code === 'MODULE_NOT_FOUND') {
         const resolvedAspectsAgain = await scope.getResolvedAspects(components, {
           skipIfExists: false,
           workspaceName: 'global-scope'
@@ -617,8 +614,7 @@ class AspectLoaderMain {
     if (componentIds && componentIds.length && filterOpts.requestedOnly) {
       const componentIdsString = componentIds.map(id => id.toString());
       defs = defs.filter(def => {
-        var _def$component;
-        return def.id && componentIdsString.includes(def.id) || def.component && componentIdsString.includes((_def$component = def.component) === null || _def$component === void 0 ? void 0 : _def$component.id.toString());
+        return def.id && componentIdsString.includes(def.id) || def.component && componentIdsString.includes(def.component?.id.toString());
       });
     }
     return defs;
@@ -748,9 +744,8 @@ class AspectLoaderMain {
     const graph = new (_graph().Graph)();
     manifests.forEach(manifest => graph.setNode(new (_graph().Node)(manifest.id, manifest)));
     manifests.forEach(manifest => {
-      var _manifest$getRuntime;
-      const deps = (_manifest$getRuntime = manifest.getRuntime(_cli().MainRuntime)) === null || _manifest$getRuntime === void 0 || (_manifest$getRuntime = _manifest$getRuntime.dependencies) === null || _manifest$getRuntime === void 0 ? void 0 : _manifest$getRuntime.map(dep => dep.id);
-      deps === null || deps === void 0 || deps.forEach(dep => {
+      const deps = manifest.getRuntime(_cli().MainRuntime)?.dependencies?.map(dep => dep.id);
+      deps?.forEach(dep => {
         if (graph.node(dep)) {
           graph.setEdge(new (_graph().Edge)(manifest.id, dep, 'dep'));
         }