@teambit/scope 0.0.1002 → 0.0.1006

package/dist/scope.main.runtime.d.ts

@@ -6,12 +6,11 @@ import { CLIMain } from '@teambit/cli';
 import type { ComponentMain, ComponentMap, ResolveAspectsOptions } from '@teambit/component';
 import { Component, ComponentFactory, ComponentID, Snap, State } from '@teambit/component';
 import type { GraphqlMain } from '@teambit/graphql';
-import { Harmony, SlotRegistry, ExtensionManifest, Aspect } from '@teambit/harmony';
+import { Harmony, SlotRegistry } from '@teambit/harmony';
 import { IsolatorMain } from '@teambit/isolator';
 import { LoggerMain, Logger } from '@teambit/logger';
 import { ExpressMain } from '@teambit/express';
 import type { UiMain } from '@teambit/ui';
-import { RequireableComponent } from '@teambit/harmony.modules.requireable-component';
 import { BitId } from '@teambit/legacy-bit-id';
 import { BitIds as ComponentsIds } from '@teambit/legacy/dist/bit-id';
 import { ModelComponent, Lane } from '@teambit/legacy/dist/scope/models';
@@ -24,13 +23,14 @@ import { CompIdGraph } from '@teambit/graph';
 import { Types } from '@teambit/legacy/dist/scope/object-registrar';
 import { FETCH_OPTIONS } from '@teambit/legacy/dist/api/scope/lib/fetch';
 import { ObjectList } from '@teambit/legacy/dist/scope/objects/object-list';
+import { RequireableComponent } from '@teambit/harmony.modules.requireable-component';
 import { AuthData } from '@teambit/legacy/dist/scope/network/http/http';
 import ConsumerComponent from '@teambit/legacy/dist/consumer/component';
 import { ExtensionDataList } from '@teambit/legacy/dist/consumer/config';
 import { EnvsMain } from '@teambit/envs';
 import { ScopeComponentLoader } from './scope-component-loader';
 import { StagedConfig } from './staged-config';
-declare type ManifestOrAspect = ExtensionManifest | Aspect;
+import { ScopeAspectsLoader, ScopeLoadAspectsOptions } from './scope-aspects-loader';
 declare type RemoteEventMetadata = {
     auth?: AuthData;
     headers?: {};
@@ -108,6 +108,7 @@ export declare class ScopeMain implements ComponentFactory {
      * slot registry for subscribing to build
      */
     config: ScopeConfig, postPutSlot: OnPostPutSlot, postDeleteSlot: OnPostDeleteSlot, postExportSlot: OnPostExportSlot, postObjectsPersist: OnPostObjectsPersistSlot, preFetchObjects: OnPreFetchObjectsSlot, isolator: IsolatorMain, aspectLoader: AspectLoaderMain, logger: Logger, envs: EnvsMain, dependencyResolver: DependencyResolverMain);
+    priority?: boolean | undefined;
     /**
      * name of the scope
      */
@@ -118,7 +119,15 @@ export declare class ScopeMain implements ComponentFactory {
     get path(): string;
     get isLegacy(): boolean;
     reloadAspectsWithNewVersion(components: ConsumerComponent[]): Promise<void>;
+    loadAspects(ids: string[], throwOnError?: boolean | undefined, neededFor?: string | undefined, lane?: Lane, opts?: ScopeLoadAspectsOptions): Promise<string[]>;
+    resolveAspects(runtimeName?: string | undefined, componentIds?: ComponentID[] | undefined, opts?: ResolveAspectsOptions | undefined): Promise<AspectDefinition[]>;
+    getResolvedAspects(components: Component[], opts?: {
+        skipIfExists?: boolean;
+        packageManagerConfigRootDir?: string;
+    }): Promise<RequireableComponent[]>;
+    getAspectCapsulePath(): string;
     getManyByLegacy(components: ConsumerComponent[]): Promise<Component[]>;
+    getScopeAspectsLoader(): ScopeAspectsLoader;
     clearCache(): void;
     builderDataMapToLegacyOnTagResults(builderDataComponentMap: ComponentMap<RawBuilderData>): LegacyOnTagResult[];
     /**
@@ -156,41 +165,6 @@ export declare class ScopeMain implements ComponentFactory {
     }, headers?: Record<string, any>): Promise<import("@teambit/legacy/dist/scope/removed-components").RemovedObjectSerialized>;
     toObjectList(types: Types): Promise<ObjectList>;
     private toJs;
-    private parseLocalAspect;
-    private findRuntime;
-    private findAspectFile;
-    private loadAspectFromPath;
-    private localAspects;
-    loadAspects(ids: string[], throwOnError?: boolean, neededFor?: string, lane?: Lane): Promise<string[]>;
-    /**
-     * This function get's a list of aspect ids and return them grouped by whether any of them is the env of other from the list
-     * @param ids
-     */
-    groupAspectIdsByEnvOfTheList(ids: string[], lane?: Lane): Promise<{
-        envs?: string[];
-        other?: string[];
-    }>;
-    private getManifestsAndLoadAspects;
-    getManifestsGraphRecursively(ids: string[], visited?: string[], throwOnError?: boolean, lane?: Lane, opts?: {
-        packageManagerConfigRootDir?: string;
-    }): Promise<{
-        manifests: ManifestOrAspect[];
-        potentialPluginsIds: string[];
-    }>;
-    private getNonLoadedAspects;
-    private resolveLocalAspects;
-    getResolvedAspects(components: Component[], opts?: {
-        skipIfExists?: boolean;
-        packageManagerConfigRootDir?: string;
-    }): Promise<RequireableComponent[]>;
-    private compileIfNoDist;
-    private tryCompile;
-    requireAspects(components: Component[], throwOnError?: boolean, opts?: {
-        packageManagerConfigRootDir?: string;
-    }): Promise<Array<ExtensionManifest | Aspect>>;
-    getAspectCapsulePath(): string;
-    private resolveUserAspects;
-    resolveAspects(runtimeName?: string, componentIds?: ComponentID[], opts?: ResolveAspectsOptions): Promise<AspectDefinition[]>;
     getGraph(ids?: ComponentID[]): Promise<Graph<Component, string>>;
     getGraphIds(ids?: ComponentID[]): Promise<CompIdGraph>;
     private getSavedGraphOfComponentIfExist;
@@ -325,7 +299,7 @@ export declare class ScopeMain implements ComponentFactory {
      */
     static slots: (((registerFn: () => string) => SlotRegistry<OnPostPut>) | ((registerFn: () => string) => SlotRegistry<OnPostObjectsPersist>) | ((registerFn: () => string) => SlotRegistry<OnPreFetchObjects>))[];
     static runtime: import("@teambit/harmony").RuntimeDefinition;
-    static dependencies: Aspect[];
+    static dependencies: import("@teambit/harmony").Aspect[];
     static defaultConfig: ScopeConfig;
     static provider([componentExt, ui, graphql, cli, isolator, aspectLoader, express, loggerMain, envs, depsResolver]: [
         ComponentMain,

package/dist/scope.main.runtime.js

@@ -3,10 +3,8 @@
 var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
 require("core-js/modules/es.symbol.description.js");
 require("core-js/modules/es.array.flat.js");
-require("core-js/modules/es.array.flat-map.js");
 require("core-js/modules/es.array.iterator.js");
 require("core-js/modules/es.array.unscopables.flat.js");
-require("core-js/modules/es.array.unscopables.flat-map.js");
 require("core-js/modules/es.promise.js");
 require("core-js/modules/es.regexp.exec.js");
 require("core-js/modules/es.string.replace.js");
@@ -57,20 +55,6 @@ function _builder() {
   };
   return data;
 }
-function _fsExtra() {
-  const data = require("fs-extra");
-  _fsExtra = function () {
-    return data;
-  };
-  return data;
-}
-function _path() {
-  const data = require("path");
-  _path = function () {
-    return data;
-  };
-  return data;
-}
 function _aspectLoader() {
   const data = require("@teambit/aspect-loader");
   _aspectLoader = function () {
@@ -134,13 +118,6 @@ function _ui() {
   };
   return data;
 }
-function _harmonyModules() {
-  const data = require("@teambit/harmony.modules.requireable-component");
-  _harmonyModules = function () {
-    return data;
-  };
-  return data;
-}
 function _legacyBitId() {
   const data = require("@teambit/legacy-bit-id");
   _legacyBitId = function () {
@@ -169,13 +146,6 @@ function _scopeLoader() {
   };
   return data;
 }
-function _constants() {
-  const data = require("@teambit/legacy/dist/constants");
-  _constants = function () {
-    return data;
-  };
-  return data;
-}
 function _actions() {
   const data = require("@teambit/legacy/dist/scope/actions");
   _actions = function () {
@@ -330,6 +300,13 @@ function _noIdMatchPattern() {
   };
   return data;
 }
+function _scopeAspectsLoader() {
+  const data = require("./scope-aspects-loader");
+  _scopeAspectsLoader = 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 ScopeMain {
@@ -366,10 +343,9 @@ class ScopeMain {
     this.envs = envs;
     this.dependencyResolver = dependencyResolver;
     (0, _defineProperty2().default)(this, "componentLoader", void 0);
-    (0, _defineProperty2().default)(this, "localAspects", []);
+    (0, _defineProperty2().default)(this, "priority", void 0);
     this.componentLoader = new (_scopeComponentLoader().ScopeComponentLoader)(this, this.logger);
   }
-
   /**
    * name of the scope
    */
@@ -429,9 +405,29 @@ class ScopeMain {
     const idsToLoad = await getAspectsByPreviouslyUsedVersion();
     await host.loadAspects(idsToLoad, false, 'scope.reloadAspectsWithNewVersion');
   }
+  loadAspects(ids, throwOnError, neededFor, lane, opts) {
+    const scopeAspectsLoader = this.getScopeAspectsLoader();
+    return scopeAspectsLoader.loadAspects(ids, throwOnError, neededFor, lane, opts);
+  }
+  resolveAspects(runtimeName, componentIds, opts) {
+    const scopeAspectsLoader = this.getScopeAspectsLoader();
+    return scopeAspectsLoader.resolveAspects(runtimeName, componentIds, opts);
+  }
+  async getResolvedAspects(components, opts) {
+    const scopeAspectsLoader = this.getScopeAspectsLoader();
+    return scopeAspectsLoader.getResolvedAspects(components, opts);
+  }
+  getAspectCapsulePath() {
+    const scopeAspectsLoader = this.getScopeAspectsLoader();
+    return scopeAspectsLoader.getAspectCapsulePath();
+  }
   getManyByLegacy(components) {
     return (0, _pMapSeries().default)(components, async component => this.getFromConsumerComponent(component));
   }
+  getScopeAspectsLoader() {
+    const scopeAspectsLoader = new (_scopeAspectsLoader().ScopeAspectsLoader)(this, this.aspectLoader, this.envs, this.isolator, this.logger);
+    return scopeAspectsLoader;
+  }
   clearCache() {
     this.logger.debug('clearing the components and the legacy cache');
     this.componentLoader.clearCache();
@@ -538,363 +534,6 @@ class ScopeMain {
     if (str.endsWith('.ts')) return str.replace('.ts', '.js');
     return str;
   }
-  parseLocalAspect(localAspects) {
-    const dirPaths = localAspects.map(localAspect => (0, _path().resolve)(localAspect.replace('file://', '')));
-    const nonExistsDirPaths = dirPaths.filter(path => !(0, _fsExtra().existsSync)(path));
-    nonExistsDirPaths.forEach(path => this.logger.warn(`no such file or directory: ${path}`));
-    const existsDirPaths = dirPaths.filter(path => (0, _fsExtra().existsSync)(path));
-    return existsDirPaths;
-  }
-  findRuntime(dirPath, runtime) {
-    const files = (0, _fsExtra().readdirSync)((0, _path().join)(dirPath, 'dist'));
-    return files.find(path => path.includes(`${runtime}.runtime.js`));
-  }
-  findAspectFile(dirPath) {
-    const files = (0, _fsExtra().readdirSync)((0, _path().join)(dirPath, 'dist'));
-    return files.find(path => path.includes(`.aspect.js`));
-  }
-  async loadAspectFromPath(localAspects) {
-    const dirPaths = this.parseLocalAspect(localAspects);
-    const manifests = dirPaths.map(dirPath => {
-      const scopeRuntime = this.findRuntime(dirPath, 'scope');
-      if (scopeRuntime) {
-        // eslint-disable-next-line global-require, import/no-dynamic-require
-        const module = require((0, _path().join)(dirPath, 'dist', scopeRuntime));
-        return module.default || module;
-      }
-      // eslint-disable-next-line global-require, import/no-dynamic-require
-      const module = require(dirPath);
-      return module.default || module;
-    });
-    await this.aspectLoader.loadExtensionsByManifests(manifests, true);
-  }
-  async loadAspects(ids, throwOnError = false, neededFor, lane) {
-    var _grouped$envs, _grouped$other;
-    if (!ids.length) return [];
-    // 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>'}`);
-    const grouped = await this.groupAspectIdsByEnvOfTheList(ids, lane);
-    this.logger.info(`${loggerPrefix} getManifestsAndLoadAspects for grouped.envs, total ${((_grouped$envs = grouped.envs) === null || _grouped$envs === void 0 ? void 0 : _grouped$envs.length) || 0}`);
-    const envsManifestsIds = await this.getManifestsAndLoadAspects(grouped.envs, throwOnError, lane);
-    this.logger.info(`${loggerPrefix} getManifestsAndLoadAspects for grouped.other, total ${((_grouped$other = grouped.other) === null || _grouped$other === void 0 ? void 0 : _grouped$other.length) || 0}`);
-    const otherManifestsIds = await this.getManifestsAndLoadAspects(grouped.other, throwOnError, lane);
-    this.logger.debug(`${loggerPrefix} finish loading aspects`);
-    return envsManifestsIds.concat(otherManifestsIds);
-  }
-
-  /**
-   * This function get's a list of aspect ids and return them grouped by whether any of them is the env of other from the list
-   * @param ids
-   */
-  async groupAspectIdsByEnvOfTheList(ids, lane) {
-    const components = await this.getNonLoadedAspects(ids, lane);
-    const envsIds = (0, _lodash().uniq)(components.map(component => this.envs.getEnvId(component)).filter(envId => !this.aspectLoader.isCoreEnv(envId)));
-    const grouped = (0, _lodash().groupBy)(ids, id => {
-      if (envsIds.includes(id)) return 'envs';
-      return 'other';
-    });
-    return grouped;
-  }
-  async getManifestsAndLoadAspects(ids = [], throwOnError = false, lane) {
-    const {
-      manifests: scopeManifests,
-      potentialPluginsIds
-    } = await this.getManifestsGraphRecursively(ids, [], throwOnError, lane);
-    await this.aspectLoader.loadExtensionsByManifests(scopeManifests);
-    const {
-      manifests: scopePluginsManifests
-    } = await this.getManifestsGraphRecursively(potentialPluginsIds, [], throwOnError, lane);
-    await this.aspectLoader.loadExtensionsByManifests(scopePluginsManifests);
-    const allManifests = scopeManifests.concat(scopePluginsManifests);
-    return (0, _lodash().compact)(allManifests.map(manifest => manifest.id));
-  }
-  async getManifestsGraphRecursively(ids, visited = [], throwOnError = false, lane, opts = {}) {
-    ids = (0, _lodash().uniq)(ids);
-    this.logger.debug(`getManifestsGraphRecursively, ids:\n${ids.join('\n')}`);
-    const nonVisitedId = ids.filter(id => !visited.includes(id));
-    if (!nonVisitedId.length) {
-      return {
-        manifests: [],
-        potentialPluginsIds: []
-      };
-    }
-    const components = await this.getNonLoadedAspects(nonVisitedId, lane);
-    // Adding all the envs ids to the array to support case when one (or more) of the aspects has custom aspect env
-    const customEnvsIds = components.map(component => this.envs.getEnvId(component)).filter(envId => !this.aspectLoader.isCoreEnv(envId));
-    // In case there is custom env we need to load it right away, otherwise we will fail during the require aspects
-    await this.getManifestsAndLoadAspects(customEnvsIds, undefined, lane);
-    visited.push(...nonVisitedId);
-    const manifests = await this.requireAspects(components, throwOnError, opts);
-    const potentialPluginsIds = (0, _lodash().compact)(manifests.map((manifest, index) => {
-      if (this.aspectLoader.isValidAspect(manifest)) return undefined;
-      // return index;
-      return components[index].id.toString();
-    }));
-    const depsToLoad = [];
-    await (0, _pMapSeries().default)(manifests, async manifest => {
-      depsToLoad.push(...(manifest.dependencies || []));
-      // @ts-ignore
-      (manifest._runtimes || []).forEach(runtime => {
-        depsToLoad.push(...(runtime.dependencies || []));
-      });
-      const depIds = depsToLoad.map(d => d.id).filter(id => id);
-      this.logger.debug(`getManifestsGraphRecursively, id: ${manifest.id || '<unknown>'}, found ${depIds.length}: ${depIds.join(', ')}`);
-      const {
-        manifests: loaded
-      } = await this.getManifestsGraphRecursively(depIds, visited, throwOnError, lane);
-      manifests.push(...loaded);
-    });
-    return {
-      manifests,
-      potentialPluginsIds
-    };
-  }
-  async getNonLoadedAspects(ids, lane) {
-    const notLoadedIds = ids.filter(id => !this.aspectLoader.isAspectLoaded(id));
-    if (!notLoadedIds.length) return [];
-    const coreAspectsStringIds = this.aspectLoader.getCoreAspectIds();
-    const idsWithoutCore = (0, _lodash().difference)(ids, coreAspectsStringIds);
-    const aspectIds = idsWithoutCore.filter(id => !id.startsWith('file://'));
-    // TODO: use diff instead of filter twice
-    const localAspects = ids.filter(id => id.startsWith('file://'));
-    this.localAspects = this.localAspects.concat(localAspects);
-    // load local aspects for debugging purposes.
-    await this.loadAspectFromPath(localAspects);
-    const componentIds = await this.resolveMultipleComponentIds(aspectIds);
-    if (!componentIds || !componentIds.length) return [];
-    const components = await this.import(componentIds, {
-      reFetchUnBuiltVersion: false,
-      preferDependencyGraph: true,
-      lane
-    });
-    return components;
-  }
-  async resolveLocalAspects(ids, runtime) {
-    const dirs = this.parseLocalAspect(ids);
-    return dirs.map(dir => {
-      const runtimeManifest = runtime ? this.findRuntime(dir, runtime) : undefined;
-      const aspectFilePath = runtime ? this.findAspectFile(dir) : undefined;
-      return new (_aspectLoader().AspectDefinition)(dir, aspectFilePath ? (0, _path().join)(dir, 'dist', aspectFilePath) : null, runtimeManifest ? (0, _path().join)(dir, 'dist', runtimeManifest) : null, undefined, undefined, true);
-    });
-  }
-  async getResolvedAspects(components, opts) {
-    var _opts$skipIfExists;
-    if (!components || !components.length) return [];
-    const network = await this.isolator.isolateComponents(components.map(c => c.id),
-    // includeFromNestedHosts - to support case when you are in a workspace, trying to load aspect defined in the workspace.jsonc but not part of the workspace
-    {
-      baseDir: this.getAspectCapsulePath(),
-      skipIfExists: (_opts$skipIfExists = opts === null || opts === void 0 ? void 0 : opts.skipIfExists) !== null && _opts$skipIfExists !== void 0 ? _opts$skipIfExists : true,
-      seedersOnly: true,
-      includeFromNestedHosts: true,
-      installOptions: {
-        copyPeerToRuntimeOnRoot: true,
-        packageManagerConfigRootDir: opts === null || opts === void 0 ? void 0 : opts.packageManagerConfigRootDir,
-        useNesting: true,
-        copyPeerToRuntimeOnComponents: true,
-        installPeersFromEnvs: true
-      }
-    }, this.legacyScope);
-    const capsules = network.seedersCapsules;
-    return capsules.map(capsule => {
-      return new (_harmonyModules().RequireableComponent)(capsule.component, async () => {
-        // eslint-disable-next-line global-require, import/no-dynamic-require
-        const plugins = this.aspectLoader.getPlugins(capsule.component, capsule.path);
-        if (plugins.has()) {
-          await this.compileIfNoDist(capsule, capsule.component);
-          return plugins.load(_cli().MainRuntime.name);
-        }
-        // eslint-disable-next-line global-require, import/no-dynamic-require
-        const aspect = require(capsule.path);
-        const scopeRuntime = await this.aspectLoader.getRuntimePath(capsule.component, capsule.path, 'scope');
-        const mainRuntime = await this.aspectLoader.getRuntimePath(capsule.component, capsule.path, _cli().MainRuntime.name);
-        const runtimePath = scopeRuntime || mainRuntime;
-        // eslint-disable-next-line global-require, import/no-dynamic-require
-        if (runtimePath) require(runtimePath);
-        // eslint-disable-next-line global-require, import/no-dynamic-require
-        return aspect;
-      }, capsule);
-    });
-  }
-  async compileIfNoDist(capsule, component) {
-    const env = this.envs.getEnv(component);
-    const compiler = env.env.getCompiler();
-    const distDir = (compiler === null || compiler === void 0 ? void 0 : compiler.distDir) || _constants().DEFAULT_DIST_DIRNAME;
-    const distExists = (0, _fsExtra().existsSync)((0, _path().join)(capsule.path, distDir));
-    if (distExists) return;
-    const compiledCode = component.filesystem.files.flatMap(file => {
-      if (!compiler.isFileSupported(file.path)) {
-        return [{
-          outputText: file.contents.toString('utf8'),
-          outputPath: file.path
-        }];
-      }
-      if (compiler.transpileFile) {
-        return compiler.transpileFile(file.contents.toString('utf8'), {
-          filePath: file.path,
-          componentDir: capsule.path
-        });
-      }
-      return [];
-    });
-    await Promise.all((0, _lodash().compact)(compiledCode).map(compiledFile => {
-      const path = compiler.getDistPathBySrcPath(compiledFile.outputPath);
-      return capsule === null || capsule === void 0 ? void 0 : capsule.outputFile(path, compiledFile.outputText);
-    }));
-  }
-  async tryCompile(requirableAspect) {
-    if (requirableAspect.capsule) return this.compileIfNoDist(requirableAspect.capsule, requirableAspect.component);
-    return undefined;
-  }
-  async requireAspects(components, throwOnError = false, opts = {}) {
-    const requireableExtensions = await this.getResolvedAspects(components, opts);
-    if (!requireableExtensions) {
-      return [];
-    }
-    let error;
-    let erroredId = '';
-    const requireWithCatch = async requireableAspects => {
-      error = undefined;
-      try {
-        const manifests = await (0, _pMapSeries().default)(requireableAspects, async requireableExtension => {
-          try {
-            return await this.aspectLoader.doRequire(requireableExtension);
-          } catch (err) {
-            erroredId = requireableExtension.component.id.toString();
-            if (err.code === 'MODULE_NOT_FOUND') {
-              try {
-                await this.tryCompile(requireableExtension);
-                return await this.aspectLoader.doRequire(requireableExtension);
-              } catch (newErr) {
-                error = newErr;
-                throw newErr;
-              }
-            }
-            error = err;
-            throw err;
-          }
-        });
-        return manifests;
-      } catch (err) {
-        return null;
-      }
-    };
-    const manifests = await requireWithCatch(requireableExtensions);
-    if (!error) {
-      return (0, _lodash().compact)(manifests);
-    }
-    if (error.code === 'MODULE_NOT_FOUND') {
-      this.logger.warn(`failed loading aspects from capsules due to MODULE_NOT_FOUND error, re-creating the capsules and trying again`);
-      const resolvedAspectsAgain = await this.getResolvedAspects(components, _objectSpread(_objectSpread({}, opts), {}, {
-        skipIfExists: false
-      }));
-      const manifestAgain = await requireWithCatch(resolvedAspectsAgain);
-      if (!error) {
-        return (0, _lodash().compact)(manifestAgain);
-      }
-    }
-    this.aspectLoader.handleExtensionLoadingError(error, erroredId, throwOnError);
-    return [];
-  }
-  getAspectCapsulePath() {
-    return `${this.path}-aspects`;
-  }
-  async resolveUserAspects(runtimeName, userAspectsIds) {
-    if (!userAspectsIds || !userAspectsIds.length) return [];
-    const components = await this.getMany(userAspectsIds);
-    const network = await this.isolator.isolateComponents(userAspectsIds, {
-      baseDir: this.getAspectCapsulePath(),
-      skipIfExists: true,
-      // for some reason this needs to be false, otherwise tagging components in some workspaces
-      // result in error during Preview task:
-      // "No matching version found for <some-component-on-the-workspace>"
-      seedersOnly: true,
-      includeFromNestedHosts: true,
-      installOptions: {
-        copyPeerToRuntimeOnRoot: true,
-        useNesting: true,
-        copyPeerToRuntimeOnComponents: true,
-        installPeersFromEnvs: true
-      },
-      host: this
-    }, this.legacyScope);
-    const capsules = network.seedersCapsules;
-    const aspectDefs = await this.aspectLoader.resolveAspects(components, async component => {
-      const capsule = capsules.getCapsule(component.id);
-      if (!capsule) throw new Error(`failed loading aspect: ${component.id.toString()}`);
-      const localPath = capsule.path;
-      const runtimePath = runtimeName ? await this.aspectLoader.getRuntimePath(component, localPath, runtimeName) : null;
-      const aspectFilePath = await this.aspectLoader.getAspectFilePath(component, localPath);
-      this.logger.debug(`scope resolveUserAspects, resolving id: ${component.id.toString()}, localPath: ${localPath}, runtimePath: ${runtimePath}`);
-      return {
-        id: capsule.component.id,
-        aspectPath: localPath,
-        aspectFilePath,
-        runtimePath
-      };
-    });
-    return aspectDefs;
-  }
-  async resolveAspects(runtimeName, componentIds, opts) {
-    const originalStringIds = componentIds === null || componentIds === void 0 ? void 0 : componentIds.map(id => id.toString());
-    this.logger.debug(`scope resolveAspects, runtimeName: ${runtimeName}, componentIds: ${originalStringIds}`);
-    const defaultOpts = {
-      excludeCore: false,
-      requestedOnly: false,
-      filterByRuntime: true
-    };
-    const mergedOpts = _objectSpread(_objectSpread({}, defaultOpts), opts);
-    const coreAspectsIds = this.aspectLoader.getCoreAspectIds();
-    let userAspectsIds;
-    let requestedCoreStringIds;
-    if (componentIds && componentIds.length) {
-      var _groupedByIsCore$true;
-      const groupedByIsCore = (0, _lodash().groupBy)(componentIds, id => coreAspectsIds.includes(id.toString()));
-      userAspectsIds = groupedByIsCore.false || [];
-      requestedCoreStringIds = ((_groupedByIsCore$true = groupedByIsCore.true) === null || _groupedByIsCore$true === void 0 ? void 0 : _groupedByIsCore$true.map(id => id.toStringWithoutVersion())) || [];
-    } else {
-      userAspectsIds = await this.resolveMultipleComponentIds(this.aspectLoader.getUserAspects());
-    }
-    const withoutLocalAspects = userAspectsIds.filter(aspectId => {
-      return !this.localAspects.find(localAspect => {
-        return localAspect.includes(aspectId.fullName.replace('/', '.'));
-      });
-    });
-    const userAspectsDefs = await this.resolveUserAspects(runtimeName, withoutLocalAspects);
-    const localResolved = await this.resolveLocalAspects(this.localAspects, runtimeName);
-    const coreAspectsDefs = await this.aspectLoader.getCoreAspectDefs(runtimeName);
-    const allDefs = userAspectsDefs.concat(coreAspectsDefs).concat(localResolved);
-    let afterExclusion = allDefs;
-    if (mergedOpts.excludeCore) {
-      const userAspectsIdsWithoutVersion = userAspectsIds.map(aspectId => aspectId.toStringWithoutVersion());
-      const userAspectsIdsWithoutVersionAndCoreRequested = userAspectsIdsWithoutVersion.concat(requestedCoreStringIds);
-      afterExclusion = allDefs.filter(def => {
-        const id = _component().ComponentID.fromString(def.getId || '');
-        const isTarget = userAspectsIdsWithoutVersionAndCoreRequested.includes(id.toStringWithoutVersion());
-        // If it's core, but requested explicitly, keep it
-        if (isTarget) return true;
-        const isCore = coreAspectsDefs.find(coreId => def.getId === coreId.getId);
-        return !isCore;
-      });
-    }
-    const uniqDefs = (0, _lodash().uniqBy)(afterExclusion, def => `${def.aspectPath}-${def.runtimePath}`);
-    let defs = uniqDefs;
-    if (runtimeName && mergedOpts.filterByRuntime) {
-      defs = defs.filter(def => def.runtimePath);
-    }
-    if (componentIds && componentIds.length && mergedOpts.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 defs;
-  }
   async getGraph(ids) {
     if (!ids || !ids.length) ids = (await this.list()).map(comp => comp.id) || [];
     const components = await this.getMany(ids);
@@ -1085,7 +724,6 @@ needed-for: ${neededFor || '<unknown>'}`);
   async hasId(componentId, includeCache = false) {
     if (!includeCache && componentId.scope !== this.name) return false;
     const opts = {
-      includeOrphaned: true,
       includeVersion: true
     };
     return this.legacyScope.hasId(componentId._legacy, opts);