@teambit/workspace 0.0.1002 → 0.0.1004

package/dist/workspace-aspects-loader.js

@@ -0,0 +1,588 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+require("core-js/modules/es.array.iterator.js");
+require("core-js/modules/es.promise.js");
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.WorkspaceAspectsLoader = void 0;
+function _defineProperty2() {
+  const data = _interopRequireDefault(require("@babel/runtime/helpers/defineProperty"));
+  _defineProperty2 = function () {
+    return data;
+  };
+  return data;
+}
+function _findRoot() {
+  const data = _interopRequireDefault(require("find-root"));
+  _findRoot = function () {
+    return data;
+  };
+  return data;
+}
+function _toolboxModules() {
+  const data = require("@teambit/toolbox.modules.module-resolver");
+  _toolboxModules = function () {
+    return data;
+  };
+  return data;
+}
+function _aspectLoader() {
+  const data = require("@teambit/aspect-loader");
+  _aspectLoader = function () {
+    return data;
+  };
+  return data;
+}
+function _cli() {
+  const data = require("@teambit/cli");
+  _cli = function () {
+    return data;
+  };
+  return data;
+}
+function _fsExtra() {
+  const data = _interopRequireDefault(require("fs-extra"));
+  _fsExtra = function () {
+    return data;
+  };
+  return data;
+}
+function _harmonyModules() {
+  const data = require("@teambit/harmony.modules.requireable-component");
+  _harmonyModules = function () {
+    return data;
+  };
+  return data;
+}
+function _workspaceModules() {
+  const data = require("@teambit/workspace.modules.node-modules-linker");
+  _workspaceModules = function () {
+    return data;
+  };
+  return data;
+}
+function _exceptions() {
+  const data = require("@teambit/legacy/dist/scope/exceptions");
+  _exceptions = function () {
+    return data;
+  };
+  return data;
+}
+function _pMapSeries() {
+  const data = _interopRequireDefault(require("p-map-series"));
+  _pMapSeries = function () {
+    return data;
+  };
+  return data;
+}
+function _lodash() {
+  const data = require("lodash");
+  _lodash = function () {
+    return data;
+  };
+  return data;
+}
+function _component() {
+  const data = require("@teambit/component");
+  _component = function () {
+    return data;
+  };
+  return data;
+}
+function _bitError() {
+  const data = require("@teambit/bit-error");
+  _bitError = function () {
+    return data;
+  };
+  return data;
+}
+function ownKeys(object, enumerableOnly) { var keys = Object.keys(object); if (Object.getOwnPropertySymbols) { var symbols = Object.getOwnPropertySymbols(object); enumerableOnly && (symbols = symbols.filter(function (sym) { return Object.getOwnPropertyDescriptor(object, sym).enumerable; })), keys.push.apply(keys, symbols); } return keys; }
+function _objectSpread(target) { for (var i = 1; i < arguments.length; i++) { var source = null != arguments[i] ? arguments[i] : {}; i % 2 ? ownKeys(Object(source), !0).forEach(function (key) { (0, _defineProperty2().default)(target, key, source[key]); }) : Object.getOwnPropertyDescriptors ? Object.defineProperties(target, Object.getOwnPropertyDescriptors(source)) : ownKeys(Object(source)).forEach(function (key) { Object.defineProperty(target, key, Object.getOwnPropertyDescriptor(source, key)); }); } return target; }
+class WorkspaceAspectsLoader {
+  constructor(workspace, scope, aspectLoader, envs, dependencyResolver, logger, harmony, onAspectsResolveSlot, onRootAspectAddedSlot) {
+    this.workspace = workspace;
+    this.scope = scope;
+    this.aspectLoader = aspectLoader;
+    this.envs = envs;
+    this.dependencyResolver = dependencyResolver;
+    this.logger = logger;
+    this.harmony = harmony;
+    this.onAspectsResolveSlot = onAspectsResolveSlot;
+    this.onRootAspectAddedSlot = onRootAspectAddedSlot;
+    (0, _defineProperty2().default)(this, "consumer", void 0);
+    (0, _defineProperty2().default)(this, "resolvedInstalledAspects", void 0);
+    this.consumer = this.workspace.consumer;
+    this.resolvedInstalledAspects = new Map();
+  }
+
+  /**
+   * load aspects from the workspace and if not exists in the workspace, load from the node_modules.
+   * keep in mind that the graph may have circles.
+   */
+  async loadAspects(ids = [], throwOnError = false, neededFor, opts = {}) {
+    const defaultOpts = {
+      useScopeAspectsCapsule: false
+    };
+    const mergedOpts = _objectSpread(_objectSpread({}, defaultOpts), opts);
+
+    // generate a random callId to be able to identify the call from the logs
+    const callId = Math.floor(Math.random() * 1000);
+    const loggerPrefix = `[${callId}] loadAspects,`;
+    this.logger.info(`${loggerPrefix} loading ${ids.length} aspects.
+ids: ${ids.join(', ')}
+needed-for: ${neededFor || '<unknown>'}. using opts: ${JSON.stringify(mergedOpts, null, 2)}`);
+    const notLoadedIds = ids.filter(id => !this.aspectLoader.isAspectLoaded(id));
+    if (!notLoadedIds.length) return [];
+    const coreAspectsStringIds = this.aspectLoader.getCoreAspectIds();
+    const idsWithoutCore = (0, _lodash().difference)(notLoadedIds, coreAspectsStringIds);
+    const componentIds = await this.workspace.resolveMultipleComponentIds(idsWithoutCore);
+    const {
+      workspaceIds,
+      nonWorkspaceIds
+    } = await this.groupIdsByWorkspaceExistence(componentIds);
+    let idsToLoadFromWs = componentIds;
+    let scopeAspectIds = [];
+    if (mergedOpts.useScopeAspectsCapsule) {
+      idsToLoadFromWs = workspaceIds;
+      const currentLane = await this.consumer.getCurrentLaneObject();
+      const nonWorkspaceIdsString = nonWorkspaceIds.map(id => id.toString());
+      try {
+        scopeAspectIds = await this.scope.loadAspects(nonWorkspaceIdsString, throwOnError, neededFor, currentLane || undefined, {
+          packageManagerConfigRootDir: this.workspace.path
+        });
+      } catch (err) {
+        if (err instanceof _exceptions().ComponentNotFound) {
+          var _config$workspaceConf;
+          const config = this.harmony.get('teambit.harmony/config');
+          const configStr = JSON.stringify(((_config$workspaceConf = config.workspaceConfig) === null || _config$workspaceConf === void 0 ? void 0 : _config$workspaceConf.raw) || {});
+          if (configStr.includes(err.id)) {
+            throw new (_bitError().BitError)(`error: a component "${err.id}" was not found
+  your workspace.jsonc has this component-id set. you might want to remove/change it.`);
+          }
+        }
+        throw err;
+      }
+    }
+    const aspectsDefs = await this.resolveAspects(undefined, idsToLoadFromWs, _objectSpread({
+      excludeCore: true,
+      requestedOnly: false,
+      throwOnError
+    }, mergedOpts));
+    const requireableComponents = this.aspectDefsToRequireableComponents(aspectsDefs);
+    const manifests = await this.aspectLoader.getManifestsFromRequireableExtensions(requireableComponents, throwOnError);
+    const potentialPluginsIndexes = (0, _lodash().compact)(manifests.map((manifest, index) => {
+      if (this.aspectLoader.isValidAspect(manifest)) return undefined;
+      return index;
+    }));
+    await this.aspectLoader.loadExtensionsByManifests(manifests, throwOnError, idsWithoutCore);
+
+    // Try require components for potential plugins
+    const pluginsRequireableComponents = potentialPluginsIndexes.map(index => {
+      return requireableComponents[index];
+    });
+    // Do the require again now that the plugins defs already registered
+    const pluginsManifests = await this.aspectLoader.getManifestsFromRequireableExtensions(pluginsRequireableComponents, throwOnError);
+    await this.aspectLoader.loadExtensionsByManifests(pluginsManifests, throwOnError);
+    this.logger.debug(`${loggerPrefix} finish loading aspects`);
+    const manifestIds = manifests.map(manifest => manifest.id);
+    return (0, _lodash().compact)(manifestIds.concat(scopeAspectIds));
+  }
+  async resolveAspects(runtimeName, componentIds, opts) {
+    var _opts$throwOnError;
+    const callId = Math.floor(Math.random() * 1000);
+    const loggerPrefix = `[${callId}] workspace resolveAspects,`;
+    this.logger.debug(`${loggerPrefix}, resolving aspects for - runtimeName: ${runtimeName}, componentIds: ${componentIds}`);
+    const defaultOpts = {
+      excludeCore: false,
+      requestedOnly: false,
+      filterByRuntime: true,
+      useScopeAspectsCapsule: false
+    };
+    const mergedOpts = _objectSpread(_objectSpread({}, defaultOpts), opts);
+    const idsToResolve = componentIds ? componentIds.map(id => id.toString()) : this.harmony.extensionsIds;
+    const coreAspectsIds = this.aspectLoader.getCoreAspectIds();
+    const configuredAspects = this.aspectLoader.getConfiguredAspects();
+    const userAspectsIds = (0, _lodash().difference)(idsToResolve, coreAspectsIds);
+    const rootAspectsIds = (0, _lodash().difference)(configuredAspects, coreAspectsIds);
+    const componentIdsToResolve = await this.workspace.resolveMultipleComponentIds(userAspectsIds);
+    const components = await this.importAndGetAspects(componentIdsToResolve);
+
+    // Run the on load slot
+    await this.runOnAspectsResolveFunctions(components);
+    const graph = await this.getAspectsGraphWithoutCore(components, this.isAspect.bind(this));
+    const aspects = graph.nodes.map(node => node.attr);
+    this.logger.debug(`${loggerPrefix} found ${aspects.length} aspects in the aspects-graph`);
+    const {
+      workspaceComps,
+      nonWorkspaceComps
+    } = await this.groupComponentsByWorkspaceExistence(aspects);
+    const workspaceCompsIds = workspaceComps.map(c => c.id);
+    this.logger.debug(`${loggerPrefix} found ${workspaceComps.length} components in the workspace:\n${workspaceComps.map(c => c.id.toString()).join('\n')}`);
+    this.logger.debug(`${loggerPrefix} ${nonWorkspaceComps.length} components are not in the workspace and are loaded from the scope capsules or from the node_modules:\n${nonWorkspaceComps.map(c => c.id.toString()).join('\n')}`);
+    const stringIds = [];
+    const wsAspectDefs = await this.aspectLoader.resolveAspects(workspaceComps, this.getWorkspaceAspectResolver(stringIds, runtimeName));
+    await this.linkIfMissingWorkspaceAspects(wsAspectDefs, workspaceCompsIds);
+
+    // TODO: hard coded use the old approach and loading from the scope capsules
+    // This is because right now loading from the ws node_modules causes issues in some cases
+    // like for the cloud app
+    // it should be removed once we fix the issues
+    mergedOpts.useScopeAspectsCapsule = true;
+    let componentsToResolveFromScope = nonWorkspaceComps;
+    let componentsToResolveFromInstalled = [];
+    if (!mergedOpts.useScopeAspectsCapsule) {
+      const nonWorkspaceCompsGroups = (0, _lodash().groupBy)(nonWorkspaceComps, component => this.envs.isEnv(component));
+      componentsToResolveFromScope = nonWorkspaceCompsGroups.true || [];
+      componentsToResolveFromInstalled = nonWorkspaceCompsGroups.false || [];
+    }
+    const scopeIds = componentsToResolveFromScope.map(c => c.id);
+    this.logger.debug(`${loggerPrefix} ${scopeIds.length} components are not in the workspace and are loaded from the scope capsules:\n${scopeIds.map(id => id.toString()).join('\n')}`);
+    const scopeAspectsDefs = scopeIds.length ? await this.scope.resolveAspects(runtimeName, scopeIds, mergedOpts) : [];
+    this.logger.debug(`${loggerPrefix} ${componentsToResolveFromInstalled.length} components are not in the workspace and are loaded from the node_modules:\n${componentsToResolveFromInstalled.map(c => c.id.toString()).join('\n')}`);
+    const installedAspectsDefs = componentsToResolveFromInstalled.length ? await this.aspectLoader.resolveAspects(componentsToResolveFromInstalled, this.getInstalledAspectResolver(graph, rootAspectsIds, runtimeName, {
+      throwOnError: (_opts$throwOnError = opts === null || opts === void 0 ? void 0 : opts.throwOnError) !== null && _opts$throwOnError !== void 0 ? _opts$throwOnError : false
+    })) : [];
+    let coreAspectDefs = await Promise.all(coreAspectsIds.map(async coreId => {
+      const rawDef = await (0, _aspectLoader().getAspectDef)(coreId, runtimeName);
+      return this.aspectLoader.loadDefinition(rawDef);
+    }));
+
+    // due to lack of workspace and scope runtimes. TODO: fix after adding them.
+    if (runtimeName && mergedOpts.filterByRuntime) {
+      coreAspectDefs = coreAspectDefs.filter(coreAspect => {
+        return coreAspect.runtimePath;
+      });
+    }
+    const allDefs = wsAspectDefs.concat(coreAspectDefs).concat(scopeAspectsDefs).concat(installedAspectsDefs);
+    const idsToFilter = idsToResolve.map(idStr => _component().ComponentID.fromString(idStr));
+    const filteredDefs = this.aspectLoader.filterAspectDefs(allDefs, idsToFilter, runtimeName, mergedOpts);
+    return filteredDefs;
+  }
+  async use(aspectIdStr) {
+    let aspectId = await this.workspace.resolveComponentId(aspectIdStr);
+    const inWs = await this.workspace.hasId(aspectId);
+    let aspectIdToAdd = aspectId.toStringWithoutVersion();
+    let aspectsComponent;
+    // let aspectPackage;
+    if (!inWs) {
+      const aspectsComponents = await this.importAndGetAspects([aspectId]);
+      if (aspectsComponents[0]) {
+        aspectsComponent = aspectsComponents[0];
+        aspectId = aspectsComponent.id;
+        aspectIdToAdd = aspectId.toString();
+      }
+    }
+    const config = this.harmony.get('teambit.harmony/config').workspaceConfig;
+    if (!config) {
+      throw new Error(`use() unable to get the workspace config`);
+    }
+    config.setExtension(aspectIdToAdd, {}, {
+      overrideExisting: false,
+      ignoreVersion: false
+    });
+    await config.write();
+    this.aspectLoader.addInMemoryConfiguredAspect(aspectIdToAdd);
+    await this.runOnRootAspectAddedFunctions(aspectId, inWs);
+    return aspectIdToAdd;
+  }
+  async getConfiguredUserAspectsPackages(options = {}) {
+    const configuredAspects = this.aspectLoader.getConfiguredAspects();
+    const coreAspectsIds = this.aspectLoader.getCoreAspectIds();
+    const userAspectsIds = (0, _lodash().difference)(configuredAspects, coreAspectsIds);
+    const componentIdsToResolve = await this.workspace.resolveMultipleComponentIds(userAspectsIds);
+    const aspectsComponents = await this.importAndGetAspects(componentIdsToResolve);
+    let componentsToGetPackages = aspectsComponents;
+    if (options.externalsOnly) {
+      const {
+        nonWorkspaceComps
+      } = await this.groupComponentsByWorkspaceExistence(aspectsComponents);
+      componentsToGetPackages = nonWorkspaceComps;
+    }
+    const packages = componentsToGetPackages.map(aspectComponent => {
+      const packageName = this.dependencyResolver.getPackageName(aspectComponent);
+      const version = aspectComponent.id.version || '*';
+      return {
+        packageName,
+        version
+      };
+    });
+    return packages;
+  }
+  aspectDefsToRequireableComponents(aspectDefs) {
+    const requireableComponents = aspectDefs.map(aspectDef => {
+      const localPath = aspectDef.aspectPath;
+      const component = aspectDef.component;
+      if (!component) return undefined;
+      const requireFunc = async () => {
+        const plugins = this.aspectLoader.getPlugins(component, localPath);
+        if (plugins.has()) {
+          return plugins.load(_cli().MainRuntime.name);
+        }
+
+        // eslint-disable-next-line global-require, import/no-dynamic-require
+        const aspect = require(localPath);
+        // require aspect runtimes
+        const runtimePath = await this.aspectLoader.getRuntimePath(component, localPath, _cli().MainRuntime.name);
+        // eslint-disable-next-line global-require, import/no-dynamic-require
+        if (runtimePath) require(runtimePath);
+        return aspect;
+      };
+      return new (_harmonyModules().RequireableComponent)(component, requireFunc);
+    });
+    return (0, _lodash().compact)(requireableComponents);
+  }
+  async linkIfMissingWorkspaceAspects(aspects, ids) {
+    let missingPaths = false;
+    const existsP = aspects.map(async aspect => {
+      const exist = await _fsExtra().default.pathExists(aspect.aspectPath);
+      if (!exist) {
+        missingPaths = true;
+      }
+    });
+    await Promise.all(existsP);
+    // TODO: this should be done properly by the install aspect by slot
+    if (missingPaths) {
+      const bitIds = ids.map(id => id._legacy);
+      return (0, _workspaceModules().linkToNodeModulesByIds)(this.workspace, bitIds);
+    }
+    return Promise.resolve();
+  }
+
+  /**
+   * This will return a resolver that knows to resolve aspects which are part of the workspace.
+   * means aspects exist in the bitmap file
+   * @param stringIds
+   * @param runtimeName
+   * @returns
+   */
+  getWorkspaceAspectResolver(stringIds, runtimeName) {
+    const workspaceAspectResolver = async component => {
+      const compStringId = component.id._legacy.toString();
+      stringIds.push(compStringId);
+      const localPath = this.workspace.getComponentPackagePath(component);
+      const runtimePath = runtimeName ? await this.aspectLoader.getRuntimePath(component, localPath, runtimeName) : null;
+      const aspectFilePath = await this.aspectLoader.getAspectFilePath(component, localPath);
+      this.logger.debug(`workspace resolveAspects, resolving id: ${compStringId}, localPath: ${localPath}, runtimePath: ${runtimePath}`);
+      return {
+        aspectPath: localPath,
+        aspectFilePath,
+        runtimePath
+      };
+    };
+    return workspaceAspectResolver;
+  }
+  async runOnAspectsResolveFunctions(aspectsComponents) {
+    const funcs = this.getOnAspectsResolveFunctions();
+    await (0, _pMapSeries().default)(funcs, async func => {
+      try {
+        await func(aspectsComponents);
+      } catch (err) {
+        this.logger.error('failed running onAspectsResolve function', err);
+      }
+    });
+  }
+  getOnAspectsResolveFunctions() {
+    const aspectsResolveFunctions = this.onAspectsResolveSlot.values();
+    return aspectsResolveFunctions;
+  }
+  async runOnRootAspectAddedFunctions(aspectsId, inWs) {
+    const funcs = this.getOnRootAspectAddedFunctions();
+    await (0, _pMapSeries().default)(funcs, async func => {
+      try {
+        await func(aspectsId, inWs);
+      } catch (err) {
+        this.logger.error('failed running onRootAspectAdded function', err);
+      }
+    });
+  }
+  getOnRootAspectAddedFunctions() {
+    const RootAspectAddedFunctions = this.onRootAspectAddedSlot.values();
+    return RootAspectAddedFunctions;
+  }
+
+  /**
+   * This will return a resolver that knows to resolve aspects which are not part of the workspace.
+   * means aspects that does not exist in the bitmap file
+   * instead it will resolve them from the node_modules recursively
+   * @param graph
+   * @param rootIds
+   * @param runtimeName
+   * @returns
+   */
+  getInstalledAspectResolver(graph, rootIds, runtimeName, opts = {
+    throwOnError: false
+  }) {
+    const installedAspectsResolver = async component => {
+      const compStringId = component.id._legacy.toString();
+      // stringIds.push(compStringId);
+      const localPath = this.resolveInstalledAspectRecursively(component, rootIds, graph, opts);
+      if (!localPath) return undefined;
+      const runtimePath = runtimeName ? await this.aspectLoader.getRuntimePath(component, localPath, runtimeName) : null;
+      const aspectFilePath = await this.aspectLoader.getAspectFilePath(component, localPath);
+      this.logger.debug(`workspace resolveInstalledAspects, resolving id: ${compStringId}, localPath: ${localPath}, runtimePath: ${runtimePath}`);
+      return {
+        aspectPath: localPath,
+        aspectFilePath,
+        runtimePath
+      };
+    };
+    return installedAspectsResolver;
+  }
+  resolveInstalledAspectRecursively(aspectComponent, rootIds, graph, opts = {
+    throwOnError: false
+  }) {
+    const aspectStringId = aspectComponent.id._legacy.toString();
+    if (this.resolvedInstalledAspects.has(aspectStringId)) {
+      const resolvedPath = this.resolvedInstalledAspects.get(aspectStringId);
+      return resolvedPath;
+    }
+    if (rootIds.includes(aspectStringId)) {
+      const localPath = this.workspace.getComponentPackagePath(aspectComponent);
+      this.resolvedInstalledAspects.set(aspectStringId, localPath);
+      return localPath;
+    }
+    const parent = graph.predecessors(aspectStringId)[0];
+    const parentPath = this.resolveInstalledAspectRecursively(parent.attr, rootIds, graph);
+    if (!parentPath) {
+      this.resolvedInstalledAspects.set(aspectStringId, null);
+      return undefined;
+    }
+    const packageName = this.dependencyResolver.getPackageName(aspectComponent);
+    try {
+      const resolvedPath = (0, _toolboxModules().resolveFrom)(parentPath, [packageName]);
+      const localPath = (0, _findRoot().default)(resolvedPath);
+      this.resolvedInstalledAspects.set(aspectStringId, localPath);
+      return localPath;
+    } catch (error) {
+      this.resolvedInstalledAspects.set(aspectStringId, null);
+      if (opts.throwOnError) {
+        throw error;
+      }
+      this.logger.consoleWarning(`failed resolving aspect ${aspectStringId} from ${parentPath}, error: ${error.message}`);
+      return undefined;
+    }
+  }
+
+  /**
+   * Create a graph of aspects without the core aspects.
+   * @param components
+   * @param isAspect
+   * @returns
+   */
+  async getAspectsGraphWithoutCore(components, isAspect) {
+    const ids = components.map(component => component.id);
+    const coreAspectsStringIds = this.aspectLoader.getCoreAspectIds();
+    // TODO: @gilad it causes many issues we need to find a better solution. removed for now.
+    // const coreAspectsComponentIds = coreAspectsStringIds.map((id) => BitId.parse(id, true));
+    // const aspectsIds = components.reduce((acc, curr) => {
+    //   const currIds = curr.state.aspects.ids;
+    //   acc = acc.concat(currIds);
+    //   return acc;
+    // }, [] as any);
+    // const otherDependenciesMap = components.reduce((acc, curr) => {
+    //   // const currIds = curr.state.dependencies.dependencies.map(dep => dep.id.toString());
+    //   const currMap = curr.state.dependencies.getIdsMap();
+    //   Object.assign(acc, currMap);
+    //   return acc;
+    // }, {});
+
+    // const depsWhichAreNotAspects = difference(Object.keys(otherDependenciesMap), aspectsIds);
+    // const depsWhichAreNotAspectsBitIds = depsWhichAreNotAspects.map((strId) => otherDependenciesMap[strId]);
+    // We only want to load into the graph components which are aspects and not regular dependencies
+    // This come to solve a circular loop when an env aspect use an aspect (as regular dep) and the aspect use the env aspect as its env
+    return this.workspace.buildOneGraphForComponents(ids, coreAspectsStringIds, isAspect);
+  }
+
+  /**
+   * Load all unloaded extensions from an extension list
+   * this will resolve the extensions from the scope aspects capsules if they are not in the ws
+   * Only use it for component extensions
+   * for workspace/scope root aspect use the load aspects directly
+   *
+   * The reason we are loading component extensions with "scope aspects capsules" is becasuse for component extensions
+   * we might have the same extension in multiple versions
+   * (for example I might have 2 components using different versions of the same env)
+   * in such case, I can't install both version into the root of the node_modules so I need to place it somewhere else (capsules)
+   * @param extensions list of extensions with config to load
+   */
+  async loadComponentsExtensions(extensions, originatedFrom, throwOnError = false) {
+    const extensionsIdsP = extensions.map(async extensionEntry => {
+      // Core extension
+      if (!extensionEntry.extensionId) {
+        return extensionEntry.stringId;
+      }
+      const id = await this.workspace.resolveComponentId(extensionEntry.extensionId);
+      // return this.resolveComponentId(extensionEntry.extensionId);
+      return id.toString();
+    });
+    const extensionsIds = await Promise.all(extensionsIdsP);
+    const loadedExtensions = this.harmony.extensionsIds;
+    const extensionsToLoad = (0, _lodash().difference)(extensionsIds, loadedExtensions);
+    if (!extensionsToLoad.length) return;
+    await this.loadAspects(extensionsToLoad, throwOnError, originatedFrom === null || originatedFrom === void 0 ? void 0 : originatedFrom.toString(), {
+      useScopeAspectsCapsule: true
+    });
+  }
+  async isAspect(id) {
+    const component = await this.workspace.get(id);
+    const isUsingAspectEnv = this.envs.isUsingAspectEnv(component);
+    const isUsingEnvEnv = this.envs.isUsingEnvEnv(component);
+    const isValidAspect = isUsingAspectEnv || isUsingEnvEnv;
+    return isValidAspect;
+  }
+
+  /**
+   * same as `this.importAndGetMany()` with a specific error handling of ComponentNotFound
+   */
+  async importAndGetAspects(componentIds) {
+    try {
+      return await this.workspace.importAndGetMany(componentIds);
+    } catch (err) {
+      if (err instanceof _exceptions().ComponentNotFound) {
+        var _config$workspaceConf2;
+        const config = this.harmony.get('teambit.harmony/config');
+        const configStr = JSON.stringify(((_config$workspaceConf2 = config.workspaceConfig) === null || _config$workspaceConf2 === void 0 ? void 0 : _config$workspaceConf2.raw) || {});
+        if (configStr.includes(err.id)) {
+          throw new (_bitError().BitError)(`error: a component "${err.id}" was not found
+your workspace.jsonc has this component-id set. you might want to remove/change it.`);
+        }
+      }
+      throw err;
+    }
+  }
+
+  /**
+   * split the provided components into 2 groups, one which are workspace components and the other which are not.
+   * @param components
+   * @returns
+   */
+  async groupComponentsByWorkspaceExistence(components) {
+    const workspaceComps = [];
+    const nonWorkspaceComps = [];
+    await Promise.all(components.map(async component => {
+      const existOnWorkspace = await this.workspace.hasId(component.id);
+      existOnWorkspace ? workspaceComps.push(component) : nonWorkspaceComps.push(component);
+    }));
+    return {
+      workspaceComps,
+      nonWorkspaceComps
+    };
+  }
+  async groupIdsByWorkspaceExistence(ids) {
+    const workspaceIds = [];
+    const nonWorkspaceIds = [];
+    await Promise.all(ids.map(async id => {
+      const existOnWorkspace = await this.workspace.hasId(id);
+      existOnWorkspace ? workspaceIds.push(id) : nonWorkspaceIds.push(id);
+    }));
+    return {
+      workspaceIds,
+      nonWorkspaceIds
+    };
+  }
+}
+exports.WorkspaceAspectsLoader = WorkspaceAspectsLoader;
+
+//# sourceMappingURL=workspace-aspects-loader.js.map