@teambit/workspace 0.0.881 → 0.0.883

package/dist/workspace.js

@@ -1,448 +1,312 @@
 "use strict";
 
 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.iterator.js");
-
 require("core-js/modules/es.array.unscopables.flat.js");
-
 require("core-js/modules/es.promise.js");
-
 require("core-js/modules/es.regexp.exec.js");
-
 Object.defineProperty(exports, "__esModule", {
   value: true
 });
 exports.default = exports.Workspace = exports.ComponentRemoved = exports.ComponentChanged = exports.ComponentAdded = exports.AspectSpecificField = void 0;
-
 function _defineProperty2() {
   const data = _interopRequireDefault(require("@babel/runtime/helpers/defineProperty"));
-
   _defineProperty2 = function () {
     return data;
   };
-
   return data;
 }
-
 function _memoizee() {
   const data = _interopRequireDefault(require("memoizee"));
-
   _memoizee = function () {
     return data;
   };
-
   return data;
 }
-
 function _pMapSeries() {
   const data = _interopRequireDefault(require("p-map-series"));
-
   _pMapSeries = 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 _scopeGraph() {
   const data = _interopRequireDefault(require("@teambit/legacy/dist/scope/graph/scope-graph"));
-
   _scopeGraph = 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 _config() {
   const data = require("@teambit/legacy/dist/consumer/config");
-
   _config = function () {
     return data;
   };
-
   return data;
 }
-
 function _envs() {
   const data = require("@teambit/envs");
-
   _envs = function () {
     return data;
   };
-
   return data;
 }
-
 function _workspaceModules() {
   const data = require("@teambit/workspace.modules.match-pattern");
-
   _workspaceModules = function () {
     return data;
   };
-
   return data;
 }
-
 function _harmonyModules() {
   const data = require("@teambit/harmony.modules.requireable-component");
-
   _harmonyModules = function () {
     return data;
   };
-
   return data;
 }
-
 function _consumer() {
   const data = require("@teambit/legacy/dist/api/consumer");
-
   _consumer = function () {
     return data;
   };
-
   return data;
 }
-
 function _bitId() {
   const data = require("@teambit/legacy/dist/bit-id");
-
   _bitId = function () {
     return data;
   };
-
   return data;
 }
-
 function _legacyBitId() {
   const data = require("@teambit/legacy-bit-id");
-
   _legacyBitId = function () {
     return data;
   };
-
   return data;
 }
-
 function _consumer2() {
   const data = require("@teambit/legacy/dist/consumer");
-
   _consumer2 = function () {
     return data;
   };
-
   return data;
 }
-
 function _addComponents() {
   const data = _interopRequireDefault(require("@teambit/legacy/dist/consumer/component-ops/add-components"));
-
   _addComponents = function () {
     return data;
   };
-
   return data;
 }
-
 function _inMemoryCache() {
   const data = require("@teambit/legacy/dist/cache/in-memory-cache");
-
   _inMemoryCache = function () {
     return data;
   };
-
   return data;
 }
-
 function _cacheFactory() {
   const data = require("@teambit/legacy/dist/cache/cache-factory");
-
   _cacheFactory = function () {
     return data;
   };
-
   return data;
 }
-
 function _exceptions() {
   const data = require("@teambit/legacy/dist/scope/exceptions");
-
   _exceptions = function () {
     return data;
   };
-
   return data;
 }
-
 function _componentsList() {
   const data = _interopRequireDefault(require("@teambit/legacy/dist/consumer/component/components-list"));
-
   _componentsList = function () {
     return data;
   };
-
   return data;
 }
-
 function _noComponentDir() {
   const data = require("@teambit/legacy/dist/consumer/component/exceptions/no-component-dir");
-
   _noComponentDir = function () {
     return data;
   };
-
   return data;
 }
-
 function _extensionData() {
   const data = require("@teambit/legacy/dist/consumer/config/extension-data");
-
   _extensionData = function () {
     return data;
   };
-
   return data;
 }
-
 function _utils() {
   const data = require("@teambit/legacy/dist/utils");
-
   _utils = function () {
     return data;
   };
-
   return data;
 }
-
 function _componentIdToPackageName() {
   const data = _interopRequireDefault(require("@teambit/legacy/dist/utils/bit/component-id-to-package-name"));
-
   _componentIdToPackageName = function () {
     return data;
   };
-
   return data;
 }
-
 function _path() {
   const data = require("@teambit/legacy/dist/utils/path");
-
   _path = function () {
     return data;
   };
-
   return data;
 }
-
 function _fsExtra() {
   const data = _interopRequireDefault(require("fs-extra"));
-
   _fsExtra = function () {
     return data;
   };
-
   return data;
 }
-
 function _lodash() {
   const data = require("lodash");
-
   _lodash = function () {
     return data;
   };
-
   return data;
 }
-
 function _path2() {
   const data = _interopRequireDefault(require("path"));
-
   _path2 = function () {
     return data;
   };
-
   return data;
 }
-
 function _scopeComponentsImporter() {
   const data = _interopRequireDefault(require("@teambit/legacy/dist/scope/component-ops/scope-components-importer"));
-
   _scopeComponentsImporter = function () {
     return data;
   };
-
   return data;
 }
-
 function _exceptions2() {
   const data = require("@teambit/legacy/dist/consumer/bit-map/exceptions");
-
   _exceptions2 = function () {
     return data;
   };
-
   return data;
 }
-
 function _loader() {
   const data = _interopRequireDefault(require("@teambit/legacy/dist/cli/loader"));
-
   _loader = function () {
     return data;
   };
-
   return data;
 }
-
 function _laneNotFound() {
   const data = require("@teambit/legacy/dist/api/scope/lib/exceptions/lane-not-found");
-
   _laneNotFound = function () {
     return data;
   };
-
   return data;
 }
-
 function _scopeNotFoundOrDenied() {
   const data = require("@teambit/legacy/dist/remotes/exceptions/scope-not-found-or-denied");
-
   _scopeNotFoundOrDenied = function () {
     return data;
   };
-
   return data;
 }
-
 function _componentConfigFile() {
   const data = require("./component-config-file");
-
   _componentConfigFile = function () {
     return data;
   };
-
   return data;
 }
-
 function _watcher() {
   const data = require("./watch/watcher");
-
   _watcher = function () {
     return data;
   };
-
   return data;
 }
-
 function _componentStatus() {
   const data = require("./workspace-component/component-status");
-
   _componentStatus = function () {
     return data;
   };
-
   return data;
 }
-
 function _workspaceComponentLoader() {
   const data = require("./workspace-component/workspace-component-loader");
-
   _workspaceComponentLoader = function () {
     return data;
   };
-
   return data;
 }
-
 function _incorrectEnvAspect() {
   const data = require("./exceptions/incorrect-env-aspect");
-
   _incorrectEnvAspect = function () {
     return data;
   };
-
   return data;
 }
-
 function _buildGraphFromFs() {
   const data = require("./build-graph-from-fs");
-
   _buildGraphFromFs = function () {
     return data;
   };
-
   return data;
 }
-
 function _bitMap() {
   const data = require("./bit-map");
-
   _bitMap = function () {
     return data;
   };
-
   return data;
 }
-
 function _workspace() {
   const data = require("./workspace.aspect");
-
   _workspace = 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; }
-
 const AspectSpecificField = '__specific';
 exports.AspectSpecificField = AspectSpecificField;
 const ComponentAdded = 'componentAdded';
@@ -452,10 +316,10 @@ exports.ComponentChanged = ComponentChanged;
 const ComponentRemoved = 'componentRemoved';
 exports.ComponentRemoved = ComponentRemoved;
 const DEFAULT_VENDOR_DIR = 'vendor';
+
 /**
  * API of the Bit Workspace
  */
-
 class Workspace {
   // cache loaded components
   // cache env-ids that have been errored about not having "env" type
@@ -493,7 +357,6 @@ class Workspace {
    */
   onComponentAddSlot, onComponentRemoveSlot, onPreWatchSlot, graphql) {
     var _this$config;
-
     this.pubsub = pubsub;
     this.config = config;
     this.consumer = consumer;
@@ -523,18 +386,18 @@ class Workspace {
     (0, _defineProperty2().default)(this, "watcher", new (_watcher().Watcher)(this, this.pubsub));
     this.componentLoadedSelfAsAspects = (0, _cacheFactory().createInMemoryCache)({
       maxSize: (0, _inMemoryCache().getMaxSizeForComponents)()
-    }); // TODO: refactor - prefer to avoid code inside the constructor.
+    });
 
+    // TODO: refactor - prefer to avoid code inside the constructor.
     this.owner = (_this$config = this.config) === null || _this$config === void 0 ? void 0 : _this$config.defaultOwner;
     this.componentLoader = new (_workspaceComponentLoader().WorkspaceComponentLoader)(this, logger, dependencyResolver, envs);
     this.validateConfig();
-    this.bitMap = new (_bitMap().BitMap)(this.consumer.bitMap, this.consumer); // memoize this method to improve performance.
-
+    this.bitMap = new (_bitMap().BitMap)(this.consumer.bitMap, this.consumer);
+    // memoize this method to improve performance.
     this.componentDefaultScopeFromComponentDirAndNameWithoutConfigFile = (0, _memoizee().default)(this.componentDefaultScopeFromComponentDirAndNameWithoutConfigFile.bind(this), {
       primitive: true,
       promise: true,
       maxAge: 60 * 1000 // 1 min
-
     });
   }
 
@@ -545,68 +408,58 @@ class Workspace {
     if (!defaultScope) throw new (_bitError().BitError)('defaultScope is missing');
     if (!(0, _legacyBitId().isValidScopeName)(defaultScope)) throw new (_legacyBitId().InvalidScopeName)(defaultScope);
   }
+
   /**
    * watcher api.
    */
 
-
   /**
    * root path of the Workspace.
    */
   get path() {
     return this.consumer.getPath();
   }
-  /** get the `node_modules` folder of this workspace */
-
 
+  /** get the `node_modules` folder of this workspace */
   get modulesPath() {
     return _path2().default.join(this.path, 'node_modules');
   }
-
   get isLegacy() {
     return this.consumer.isLegacy;
   }
-
   onComponentLoad(loadFn) {
     this.onComponentLoadSlot.register(loadFn);
     return this;
   }
-
   registerOnComponentChange(onComponentChangeFunc) {
     this.onComponentChangeSlot.register(onComponentChangeFunc);
     return this;
   }
-
   registerOnComponentAdd(onComponentAddFunc) {
     this.onComponentAddSlot.register(onComponentAddFunc);
     return this;
   }
-
   registerOnComponentRemove(onComponentRemoveFunc) {
     this.onComponentRemoveSlot.register(onComponentRemoveFunc);
     return this;
   }
-
   registerOnPreWatch(onPreWatchFunc) {
     this.onPreWatchSlot.register(onPreWatchFunc);
     return this;
   }
+
   /**
    * name of the workspace as configured in either `workspace.json`.
    * defaults to workspace root directory name.
    */
-
-
   get name() {
     if (this.config.name) return this.config.name;
     const tokenizedPath = this.path.split('/');
     return tokenizedPath[tokenizedPath.length - 1];
   }
-
   get icon() {
     return this.config.icon;
   }
-
   async hasModifiedDependencies(component) {
     const componentsList = new (_componentsList().default)(this.consumer);
     const listAutoTagPendingComponents = await componentsList.listAutoTagPendingComponents();
@@ -614,68 +467,60 @@ class Workspace {
     if (isAutoTag) return true;
     return false;
   }
+
   /**
    * get Component issues
    */
-
-
   getComponentIssues(component) {
     return component.state._consumer.issues || null;
   }
+
   /**
    * provides status of all components in the workspace.
    */
-
-
   async getComponentStatus(component) {
     const status = await this.consumer.getComponentStatusById(component.id._legacy);
     const hasModifiedDependencies = await this.hasModifiedDependencies(component);
     return _componentStatus().ComponentStatus.fromLegacy(status, hasModifiedDependencies, component.isOutdated());
   }
+
   /**
    * list all workspace components.
    */
-
-
   async list(filter, loadOpts) {
     const legacyIds = this.consumer.bitMap.getAllIdsAvailableOnLane();
     const ids = await this.resolveMultipleComponentIds(legacyIds);
     const idsToGet = filter && filter.limit ? (0, _lodash().slice)(ids, filter.offset, filter.offset + filter.limit) : ids;
     return this.getMany(idsToGet, loadOpts);
   }
+
   /**
    * list all invalid components.
    * (see the invalid criteria in ConsumerComponent.isComponentInvalidByErrorType())
    */
-
-
   async listInvalid() {
     const legacyIds = this.consumer.bitMap.getAllIdsAvailableOnLane();
     const ids = await this.resolveMultipleComponentIds(legacyIds);
     return this.componentLoader.getInvalid(ids);
   }
+
   /**
    * get ids of all workspace components.
    */
-
-
   async listIds() {
     if (this._cachedListIds && this.bitMap.hasChanged()) {
       delete this._cachedListIds;
     }
-
     if (!this._cachedListIds) {
       this._cachedListIds = await this.resolveMultipleComponentIds(this.consumer.bitmapIdsFromCurrentLane);
     }
-
     return this._cachedListIds;
   }
+
   /**
    * Check if a specific id exist in the workspace
    * @param componentId
    */
-
-
   async hasId(componentId) {
     const ids = await this.listIds();
     const found = ids.find(id => {
@@ -683,125 +528,113 @@ class Workspace {
     });
     return !!found;
   }
+
   /**
    * whether or not a workspace has a component with the given name
    */
-
-
   async hasName(name) {
     const ids = await this.listIds();
     return Boolean(ids.find(id => id.fullName === name));
   }
+
   /**
    * Check if a specific id exist in the workspace or in the scope
    * @param componentId
    */
-
-
   async hasIdNested(componentId, includeCache = true) {
     const found = await this.hasId(componentId);
     if (found) return found;
     return this.scope.hasIdNested(componentId, includeCache);
   }
+
   /**
    * list all modified components in the workspace.
    */
-
-
   async modified() {
     const ids = await this.componentList.listModifiedComponents(false);
     const componentIds = ids.map(_component().ComponentID.fromLegacy);
     return this.getMany(componentIds);
   }
+
   /**
    * list all new components in the workspace.
    */
-
-
   async newComponents() {
     const ids = await this.componentList.listNewComponents(false);
     const componentIds = ids.map(_component().ComponentID.fromLegacy);
     return this.getMany(componentIds);
   }
+
   /**
    * get all workspace component-ids, include vendor components.
    * (exclude nested dependencies in case dependencies are saved as components and not packages)
    */
-
-
   getAllComponentIds() {
     const bitIds = this.consumer.bitMap.getAllBitIds();
     return this.resolveMultipleComponentIds(bitIds);
   }
-
   async getNewAndModifiedIds() {
     const ids = await this.componentList.listTagPendingComponents();
     return this.resolveMultipleComponentIds(ids);
   }
-
   async newAndModified() {
     const ids = await this.getNewAndModifiedIds();
     return this.getMany(ids);
   }
-
   async getLogs(id, shortHash = false, startsFrom) {
     return this.scope.getLogs(id, shortHash, startsFrom);
   }
-
   async getLegacyGraph(ids, shouldThrowOnMissingDep = true) {
     if (!ids || ids.length < 1) ids = await this.listIds();
     const legacyIds = ids.map(id => id._legacy);
     const legacyGraph = await this.buildOneGraphForComponents(legacyIds, undefined, undefined, shouldThrowOnMissingDep);
     return legacyGraph;
   }
+
   /**
    * given component ids, find their dependents in the workspace
    */
-
-
   async getDependentsIds(ids) {
     const workspaceGraph = await _scopeGraph().default.buildGraphFromWorkspace(this.consumer, true);
     const workspaceDependencyGraph = new (_scopeGraph().default)(workspaceGraph);
     const workspaceDependents = ids.map(id => workspaceDependencyGraph.getDependentsInfo(id._legacy));
     const dependentsLegacyIds = workspaceDependents.flat().map(_ => _.id);
-
     const dependentsLegacyNoDup = _bitId().BitIds.uniqFromArray(dependentsLegacyIds);
-
     const dependentsIds = await this.resolveMultipleComponentIds(dependentsLegacyNoDup);
     return dependentsIds;
   }
-
   async createAspectList(extensionDataList) {
     const entiresP = extensionDataList.map(entry => this.extensionDataEntryToAspectEntry(entry));
     const entries = await Promise.all(entiresP);
     return this.componentAspect.createAspectListFromEntries(entries);
   }
-
   async extensionDataEntryToAspectEntry(dataEntry) {
     return new (_component().AspectEntry)(await this.resolveComponentId(dataEntry.id), dataEntry);
   }
+
   /**
    * get a component from workspace
    * @param id component ID
    */
-
-
   async get(componentId, legacyComponent, useCache = true, storeInCache = true, loadOpts) {
     this.logger.debug(`get ${componentId.toString()}`);
-    const component = await this.componentLoader.get(componentId, legacyComponent, useCache, storeInCache, loadOpts); // When loading a component if it's an env make sure to load it as aspect as well
+    const component = await this.componentLoader.get(componentId, legacyComponent, useCache, storeInCache, loadOpts);
+    // When loading a component if it's an env make sure to load it as aspect as well
     // We only want to try load it as aspect if it's the first time we load the component
+    const tryLoadAsAspect = this.componentLoadedSelfAsAspects.get(component.id.toString()) === undefined;
+    // const config = this.harmony.get<ConfigMain>('teambit.harmony/config');
 
-    const tryLoadAsAspect = this.componentLoadedSelfAsAspects.get(component.id.toString()) === undefined; // const config = this.harmony.get<ConfigMain>('teambit.harmony/config');
     // We are loading the component as aspect if it's an env, in order to be able to run the env-preview-template task which run only on envs.
     // Without this loading we will have a problem in case the env is the only component in the workspace. in that case we will load it as component
     // then we don't run it's provider so it doesn't register to the env slot, so we don't know it's an env.
-
-    if (tryLoadAsAspect && this.envs.isUsingEnvEnv(component) && !this.aspectLoader.isCoreAspect(component.id.toStringWithoutVersion()) && !this.aspectLoader.isAspectLoaded(component.id.toString()) && (await this.hasId(component.id)) // !config.extension(component.id.toStringWithoutVersion(), true)
+    if (tryLoadAsAspect && this.envs.isUsingEnvEnv(component) && !this.aspectLoader.isCoreAspect(component.id.toStringWithoutVersion()) && !this.aspectLoader.isAspectLoaded(component.id.toString()) && (await this.hasId(component.id))
+    // !config.extension(component.id.toStringWithoutVersion(), true)
     ) {
       try {
         this.componentLoadedSelfAsAspects.set(component.id.toString(), true);
         this.logger.debug(`trying to load self as aspect with id ${component.id.toString()}`);
-        await this.loadAspects([component.id.toString()], undefined, component.id.toString()); // In most cases if the load self as aspect failed we don't care about it.
+        await this.loadAspects([component.id.toString()], undefined, component.id.toString());
+        // In most cases if the load self as aspect failed we don't care about it.
         // we only need it in specific cases to work, but this workspace.get runs on different
         // cases where it might fail (like when importing aspect, after the import objects
         // when we write the package.json we run the applyTransformers which get to pkg which call
@@ -812,20 +645,17 @@ class Workspace {
         return component;
       }
     }
-
     this.componentLoadedSelfAsAspects.set(component.id.toString(), false);
     return component;
-  } // TODO: @gilad we should refactor this asap into to the envs aspect.
-
+  }
 
+  // TODO: @gilad we should refactor this asap into to the envs aspect.
   async getEnvSystemDescriptor(component) {
     const env = this.envs.calculateEnv(component);
-
     if (env.env.__getDescriptor && typeof env.env.__getDescriptor === 'function') {
       var _services;
-
-      const systemDescriptor = await env.env.__getDescriptor(); // !important persist services only on the env itself.
-
+      const systemDescriptor = await env.env.__getDescriptor();
+      // !important persist services only on the env itself.
       let services;
       if (this.envs.isEnvRegistered(component.id.toString())) services = this.envs.getServices(env);
       const icon = this.aspectLoader.getDescriptor(env.id).icon || env.env.icon;
@@ -840,10 +670,8 @@ class Workspace {
         services: (_services = services) === null || _services === void 0 ? void 0 : _services.toObject()
       };
     }
-
     return {};
   }
-
   clearCache() {
     this.aspectLoader.resetFailedLoadAspects();
     this.logger.debug('clearing the workspace and scope caches');
@@ -852,21 +680,18 @@ class Workspace {
     this.scope.clearCache();
     this.componentList = new (_componentsList().default)(this.consumer);
   }
-
   clearComponentCache(id) {
     this.componentLoader.clearComponentCache(id);
     this.consumer.componentLoader.clearOneComponentCache(id._legacy);
     this.componentList = new (_componentsList().default)(this.consumer);
   }
-
   async triggerOnComponentChange(id, files, initiator) {
-    const component = await this.get(id); // if a new file was added, upon component-load, its .bitmap entry is updated to include the
+    const component = await this.get(id);
+    // if a new file was added, upon component-load, its .bitmap entry is updated to include the
     // new file. write these changes to the .bitmap file so then other processes have access to
     // this new file. If the .bitmap wasn't change, it won't do anything.
-
     await this.bitMap.write();
     const onChangeEntries = this.onComponentChangeSlot.toArray(); // e.g. [ [ 'teambit.bit/compiler', [Function: bound onComponentChange] ] ]
-
     const results = [];
     await (0, _pMapSeries().default)(onChangeEntries, async ([extension, onChangeFunc]) => {
       const onChangeResult = await onChangeFunc(component, files, initiator);
@@ -874,8 +699,9 @@ class Workspace {
         extensionId: extension,
         results: onChangeResult
       });
-    }); // TODO: find way to standardize event names.
+    });
 
+    // TODO: find way to standardize event names.
     await this.graphql.pubsub.publish(ComponentChanged, {
       componentChanged: {
         component
@@ -883,11 +709,9 @@ class Workspace {
     });
     return results;
   }
-
   async triggerOnComponentAdd(id) {
     const component = await this.get(id);
     const onAddEntries = this.onComponentAddSlot.toArray(); // e.g. [ [ 'teambit.bit/compiler', [Function: bound onComponentChange] ] ]
-
     const results = [];
     const files = component.state.filesystem.files.map(file => file.path);
     await (0, _pMapSeries().default)(onAddEntries, async ([extension, onAddFunc]) => {
@@ -904,10 +728,8 @@ class Workspace {
     });
     return results;
   }
-
   async triggerOnComponentRemove(id) {
     const onRemoveEntries = this.onComponentRemoveSlot.toArray(); // e.g. [ [ 'teambit.bit/compiler', [Function: bound onComponentChange] ] ]
-
     const results = [];
     await (0, _pMapSeries().default)(onRemoveEntries, async ([extension, onRemoveFunc]) => {
       const onRemoveResult = await onRemoveFunc(id);
@@ -923,67 +745,52 @@ class Workspace {
     });
     return results;
   }
-
   getState(id, hash) {
     return this.scope.getState(id, hash);
   }
-
   getSnap(id, hash) {
     return this.scope.getSnap(id, hash);
   }
-
   getCurrentLaneId() {
     return this.consumer.getCurrentLaneId();
   }
+
   /**
    * if checked out to a lane and the lane exists in the remote,
    * return the remote lane id (name+scope). otherwise, return null.
    */
-
-
   async getCurrentRemoteLane() {
     const currentLaneId = this.getCurrentLaneId();
-
     if (currentLaneId.isDefault()) {
       return null;
     }
-
     const scopeComponentImporter = _scopeComponentsImporter().default.getInstance(this.consumer.scope);
-
     try {
       const lanes = await scopeComponentImporter.importLanes([currentLaneId]);
       return lanes[0];
     } catch (err) {
       if (err instanceof _legacyBitId().InvalidScopeName || err instanceof _scopeNotFoundOrDenied().ScopeNotFoundOrDenied || err instanceof _laneNotFound().LaneNotFound || err instanceof _legacyBitId().InvalidScopeNameFromRemote) {
         const bitMapLaneId = this.bitMap.getExportedLaneId();
-
         if (bitMapLaneId !== null && bitMapLaneId !== void 0 && bitMapLaneId.isEqual(currentLaneId)) {
           throw err; // we know the lane is not new, so the error is legit
-        } // the lane could be a local lane so no need to throw an error in such case
-
-
+        }
+        // the lane could be a local lane so no need to throw an error in such case
         _loader().default.stop();
-
         this.logger.warn(`unable to get lane's data from a remote due to an error:\n${err.message}`);
         return null;
       }
-
       throw err;
     }
   }
-
   getDefaultExtensions() {
     if (!this.config.extensions) {
       return new (_extensionData().ExtensionDataList)();
     }
-
     return _extensionData().ExtensionDataList.fromConfigObject(this.config.extensions);
   }
-
   async ejectMultipleConfigs(ids, options) {
     return Promise.all(ids.map(id => this.ejectConfig(id, options)));
   }
-
   async ejectConfig(id, options) {
     const componentId = await this.resolveComponentId(id);
     const component = await this.get(componentId);
@@ -998,31 +805,30 @@ class Workspace {
     const componentConfigFile = new (_componentConfigFile().ComponentConfigFile)(componentId, aspects, componentDir, options.propagate);
     await componentConfigFile.write({
       override: options.override
-    }); // remove config from the .bitmap as it's not needed anymore. it is replaced by the component.json
-
+    });
+    // remove config from the .bitmap as it's not needed anymore. it is replaced by the component.json
     this.bitMap.removeEntireConfig(id);
     await this.bitMap.write();
     return {
       configPath: _componentConfigFile().ComponentConfigFile.composePath(componentDir)
     };
   }
+
   /**
    * see component-aspect, createAspectListFromLegacy() method for a context why this is needed.
    */
-
-
   async resolveScopeAspectListIds(aspectListFromScope) {
     const resolvedList = await aspectListFromScope.pmap(async entry => {
       if (entry.id.scope !== this.scope.name) {
         return entry;
       }
-
       const newId = await this.resolveComponentId(entry.id.fullName);
       const newEntry = new (_component().AspectEntry)(newId, entry.legacy);
       return newEntry;
     });
     return resolvedList;
   }
+
   /**
    * @deprecated use `this.idsByPattern` instead for consistency. also, it supports negation and list of patterns.
    *
@@ -1030,8 +836,6 @@ class Workspace {
    * @param pattern variants.
    * @param scope scope name.
    */
-
-
   async byPattern(pattern, scope = '**') {
     const ids = await this.listIds();
     const finalPattern = `${scope}/${pattern || '**'}`;
@@ -1042,12 +846,11 @@ class Workspace {
     const components = await this.getMany(targetIds);
     return components;
   }
+
   /**
    * get component-ids matching the given pattern. a pattern can have multiple patterns separated by a comma.
    * it supports negate (!) character to exclude ids.
    */
-
-
   async idsByPattern(pattern, throwForNoMatch = true) {
     if (!pattern.includes('*') && !pattern.includes(',')) {
       // if it's not a pattern but just id, resolve it without multimatch to support specifying id without scope-name
@@ -1056,30 +859,25 @@ class Workspace {
       if (throwForNoMatch) throw new (_exceptions2().MissingBitMapComponent)(pattern);
       return [];
     }
-
     const ids = await this.listIds();
     return this.scope.filterIdsFromPoolIdsByPattern(pattern, ids, throwForNoMatch);
   }
+
   /**
    * useful for workspace commands, such as `bit build`, `bit compile`.
    * by default, it should be running on new and modified components.
    * a user can specify `--all` to run on all components or specify a pattern to limit to specific components.
    * some commands such as build/test needs to run also on the dependents.
    */
-
-
   async getComponentsByUserInput(all, pattern, includeDependents = false) {
     if (all) {
       return this.list();
     }
-
     if (pattern) {
       const ids = await this.idsByPattern(pattern);
       return this.getMany(ids);
     }
-
     const newAndModified = await this.newAndModified();
-
     if (includeDependents) {
       const newAndModifiedIds = newAndModified.map(comp => comp.id);
       const dependentsIds = await this.getDependentsIds(newAndModifiedIds);
@@ -1087,10 +885,8 @@ class Workspace {
       const dependents = await this.getMany(dependentsIdsFiltered);
       newAndModified.push(...dependents);
     }
-
     return newAndModified;
   }
-
   async getComponentsUsingEnv(env, ignoreVersion = true, throwIfNotFound = false) {
     const allComps = await this.list();
     const allEnvs = await this.envs.createEnvironment(allComps);
@@ -1100,42 +896,37 @@ class Workspace {
       const envWithoutVersion = runtimeEnv.id.split('@')[0];
       return env === envWithoutVersion;
     });
-
     if (!foundEnv && throwIfNotFound) {
       const availableEnvs = allEnvs.runtimeEnvs.map(runtimeEnv => runtimeEnv.id);
       throw new (_bitError().BitError)(`unable to find components that using "${env}" env.
 the following envs are used in this workspace: ${availableEnvs.join(', ')}`);
     }
-
     return (foundEnv === null || foundEnv === void 0 ? void 0 : foundEnv.components) || [];
   }
-
   async getMany(ids, loadOpts) {
     return this.componentLoader.getMany(ids, loadOpts);
   }
-
   getManyByLegacy(components, loadOpts) {
     return (0, _pMapSeries().default)(components, async component => {
       const id = await this.resolveComponentId(component.id);
       return this.get(id, component, true, true, loadOpts);
     });
   }
+
   /**
    * don't throw an error if the component was not found, simply return undefined.
    */
-
-
   async getIfExist(componentId) {
     return this.componentLoader.getIfExist(componentId);
   }
+
   /**
    * whether a component exists in the workspace
    */
-
-
   exists(componentId) {
     return Boolean(this.consumer.bitmapIdsFromCurrentLane.find(_ => _.isEqualWithoutVersion(componentId._legacy)));
   }
+
   /**
    * This will make sure to fetch the objects prior to load them
    * do not use it if you are not sure you need it.
@@ -1143,8 +934,6 @@ the following envs are used in this workspace: ${availableEnvs.join(', ')}`);
    * currently it used only for get many of aspects
    * @param ids
    */
-
-
   async importAndGetMany(ids) {
     await this.importCurrentLaneIfMissing();
     await this.scope.import(ids, {
@@ -1152,34 +941,27 @@ the following envs are used in this workspace: ${availableEnvs.join(', ')}`);
     });
     return this.componentLoader.getMany(ids);
   }
-
   async importCurrentLaneIfMissing() {
     const laneId = this.getCurrentLaneId();
     const laneObj = await this.scope.legacyScope.getCurrentLaneObject();
-
     if (laneId.isDefault() || laneObj) {
       return;
     }
-
     const lane = await this.getCurrentRemoteLane();
-
     if (!lane) {
       return;
     }
-
     this.logger.info(`current lane ${laneId.toString()} is missing, importing it`);
     await this.scope.legacyScope.objects.writeObjectsToTheFS([lane]);
-
     const scopeComponentsImporter = _scopeComponentsImporter().default.getInstance(this.scope.legacyScope);
-
     const ids = _bitId().BitIds.fromArray(lane.toBitIds().filter(id => id.hasScope()));
-
     await scopeComponentsImporter.importManyDeltaWithoutDeps(ids, true, lane);
     await scopeComponentsImporter.importMany({
       ids,
       lanes: [lane]
     });
   }
+
   /**
    * @deprecated use this.track() instead
    * track a new component. (practically, add it to .bitmap).
@@ -1189,8 +971,6 @@ the following envs are used in this workspace: ${availableEnvs.join(', ')}`);
    * @param main if not set, will try to guess according to some strategies and throws if failed
    * @param override whether add details to an existing component or re-define it
    */
-
-
   async add(componentPaths, id, main, override = false) {
     const addComponent = new (_addComponents().default)({
       consumer: this.consumer
@@ -1200,28 +980,23 @@ the following envs are used in this workspace: ${availableEnvs.join(', ')}`);
       main,
       override
     });
-    const addResults = await addComponent.add(); // @todo: the legacy commands have `consumer.onDestroy()` on command completion, it writes the
+    const addResults = await addComponent.add();
+    // @todo: the legacy commands have `consumer.onDestroy()` on command completion, it writes the
     //  .bitmap file. workspace needs a similar mechanism. once done, remove the next line.
-
     await this.bitMap.write();
     return addResults;
   }
-
   async use(aspectIdStr) {
     const aspectId = await this.resolveComponentId(aspectIdStr);
     let aspectIdToAdd = aspectId.toStringWithoutVersion();
-
     if (!(await this.hasId(aspectId))) {
       const loadedIds = await this.scope.loadAspects([aspectIdStr], true, 'bit use command');
       if (loadedIds[0]) aspectIdToAdd = loadedIds[0];
     }
-
     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
@@ -1229,13 +1004,12 @@ the following envs are used in this workspace: ${availableEnvs.join(', ')}`);
     await config.write();
     return aspectIdToAdd;
   }
+
   /**
    * add a new component to the .bitmap file.
    * this method only adds the records in memory but doesn't persist to the filesystem.
    * to write the .bitmap file once completed, run "await this.bitMap.write();"
    */
-
-
   async track(trackData) {
     const defaultScope = trackData.defaultScope ? await this.addOwnerToScopeName(trackData.defaultScope) : undefined;
     const addComponent = new (_addComponents().default)({
@@ -1258,6 +1032,7 @@ the following envs are used in this workspace: ${availableEnvs.join(', ')}`);
       warnings: result.warnings
     };
   }
+
   /**
    * scopes in bit.dev are "owner.collection".
    * we might have the scope-name only without the owner and we need to retrieve it from the defaultScope in the
@@ -1266,80 +1041,64 @@ the following envs are used in this workspace: ${availableEnvs.join(', ')}`);
    * @param scopeName scopeName that might not have the owner part.
    * @returns full scope name
    */
-
-
   async addOwnerToScopeName(scopeName) {
     if (scopeName.includes('.')) return scopeName; // it has owner.
-
     const isSelfHosted = !(await this.isHostedByBit(scopeName));
     if (isSelfHosted) return scopeName;
     const wsDefaultScope = this.defaultScope;
-
     if (!wsDefaultScope.includes('.')) {
       throw new Error(`the entered scope has no owner nor the defaultScope in workspace.jsonc`);
     }
-
     const [owner] = wsDefaultScope.split('.');
     return `${owner}.${scopeName}`;
   }
-
   async write(component, rootPath) {
     await Promise.all(component.filesystem.files.map(async file => {
       const pathToWrite = rootPath ? _path2().default.join(this.path, rootPath, file.relative) : file.path;
       await _fsExtra().default.outputFile(pathToWrite, file.contents);
     }));
   }
+
   /**
    * Get the component root dir in the file system (relative to workspace or full) in Linux format
    * @param componentId
    * @param relative return the path relative to the workspace or full path
    */
-
-
   componentDir(componentId, bitMapOptions, options = {
     relative: false
   }) {
     return this.componentDirFromLegacyId(componentId._legacy, bitMapOptions, options);
   }
+
   /**
    * component's files in the workspace are symlinked to the node_modules, and a package.json file is generated on that
    * package directory to simulate a valid node package.
    * @returns the package directory inside the node_module.
    * by default the absolute path, unless `options.relative` was set
    */
-
-
   componentPackageDir(component, options = {
     relative: false
   }) {
     const packageName = (0, _componentIdToPackageName().default)(component.state._consumer);
-
     const packageDir = _path2().default.join('node_modules', packageName);
-
     return options.relative ? packageDir : this.consumer.toAbsolutePath(packageDir);
   }
-
   componentDirFromLegacyId(bitId, bitMapOptions, options = {
     relative: false
   }) {
     const componentMap = this.consumer.bitMap.getComponent(bitId, bitMapOptions);
     const relativeComponentDir = componentMap.getComponentDir();
-
     if (!relativeComponentDir) {
       throw new (_noComponentDir().NoComponentDir)(bitId.toString());
     }
-
     if (options.relative) {
       return relativeComponentDir;
     }
-
     return _path2().default.join(this.path, relativeComponentDir);
   }
-
   componentDirToAbsolute(relativeComponentDir) {
     return _path2().default.join(this.path, relativeComponentDir);
   }
-
   async componentDefaultScope(componentId) {
     const relativeComponentDir = this.componentDir(componentId, {
       ignoreVersion: true
@@ -1348,43 +1107,33 @@ the following envs are used in this workspace: ${availableEnvs.join(', ')}`);
     });
     return this.componentDefaultScopeFromComponentDirAndName(relativeComponentDir, componentId.fullName);
   }
-
   async componentDefaultScopeFromComponentDirAndName(relativeComponentDir, name) {
     const componentConfigFile = await this.componentConfigFileFromComponentDirAndName(relativeComponentDir, name);
-
     if (componentConfigFile && componentConfigFile.defaultScope) {
       return componentConfigFile.defaultScope;
     }
-
     const bitMapId = this.consumer.bitMap.getExistingBitId(name);
     const bitMapEntry = bitMapId ? this.consumer.bitMap.getComponent(bitMapId) : undefined;
-
     if (bitMapEntry && bitMapEntry.defaultScope) {
       return bitMapEntry.defaultScope;
     }
-
     return this.componentDefaultScopeFromComponentDirAndNameWithoutConfigFile(relativeComponentDir, name);
   }
-
   get defaultScope() {
     return this.config.defaultScope;
   }
-
   async componentDefaultScopeFromComponentDirAndNameWithoutConfigFile(relativeComponentDir, name) {
     const variantConfig = this.variants.byRootDirAndName(relativeComponentDir, name);
-
     if (variantConfig && variantConfig.defaultScope) {
       return variantConfig.defaultScope;
     }
-
     const isVendor = this.isVendorComponentByComponentDir(relativeComponentDir);
-
     if (!isVendor) {
       return this.config.defaultScope;
     }
-
     return undefined;
   }
+
   /**
    * Calculate the component config based on:
    * the config property in the .bitmap file
@@ -1394,11 +1143,8 @@ the following envs are used in this workspace: ${availableEnvs.join(', ')}`);
    * extensions from the model.
    */
   // eslint-disable-next-line complexity
-
-
   async componentExtensions(componentId, componentFromScope, excludeOrigins = []) {
     var _componentFromScope$c, _componentConfigFile$, _variantConfig$propag, _wsDefaultExtensions;
-
     // TODO: consider caching this result
     let configFileExtensions;
     let variantsExtensions;
@@ -1410,7 +1156,6 @@ the following envs are used in this workspace: ${availableEnvs.join(', ')}`);
     let unmergedExtensions;
     let unmergedExtensionsSpecific;
     let unmergedExtensionsNonSpecific;
-
     if (unmergedHead) {
       const versionInstance = await this.scope.legacyScope.getVersionInstance(componentId._legacy.changeVersion(unmergedHead.toString()));
       unmergedExtensions = versionInstance.extensions;
@@ -1418,58 +1163,48 @@ the following envs are used in this workspace: ${availableEnvs.join(', ')}`);
       unmergedExtensionsSpecific = new (_extensionData().ExtensionDataList)(...specific);
       unmergedExtensionsNonSpecific = new (_extensionData().ExtensionDataList)(...nonSpecific);
     }
-
     const scopeExtensions = (componentFromScope === null || componentFromScope === void 0 ? void 0 : (_componentFromScope$c = componentFromScope.config) === null || _componentFromScope$c === void 0 ? void 0 : _componentFromScope$c.extensions) || new (_extensionData().ExtensionDataList)();
     const [specific, nonSpecific] = (0, _lodash().partition)(scopeExtensions, entry => entry.config[AspectSpecificField] === true);
     const scopeExtensionsNonSpecific = new (_extensionData().ExtensionDataList)(...nonSpecific);
     const scopeExtensionsSpecific = new (_extensionData().ExtensionDataList)(...specific);
     const componentConfigFile = await this.componentConfigFile(componentId);
-
     if (componentConfigFile) {
       configFileExtensions = componentConfigFile.aspects.toLegacy();
     }
-
     const relativeComponentDir = this.componentDir(componentId, {
       ignoreVersion: true
     }, {
       relative: true
     });
     const variantConfig = this.variants.byRootDirAndName(relativeComponentDir, componentId.fullName);
-
     if (variantConfig) {
-      variantsExtensions = variantConfig.extensions.clone(); // Do not merge from scope when there is specific variant (which is not *) that match the component
+      variantsExtensions = variantConfig.extensions.clone();
+      // Do not merge from scope when there is specific variant (which is not *) that match the component
       // if (variantConfig.maxSpecificity > 0) {
       //   mergeFromScope = false;
       // }
     }
 
     const isVendor = this.isVendorComponentByComponentDir(relativeComponentDir);
-
     if (!isVendor) {
       wsDefaultExtensions = this.getDefaultExtensions();
-    } // We don't stop on each step because we want to merge the default scope even if propagate=false but the default scope is not defined
+    }
+    // We don't stop on each step because we want to merge the default scope even if propagate=false but the default scope is not defined
     // in the case the same extension pushed twice, the former takes precedence (opposite of Object.assign)
-
-
     const extensionsToMerge = [];
     let envWasFoundPreviously = false;
     const loadedExtensionIds = [];
     const removedExtensionIds = [];
-
     const addAndLoadExtensions = async (extensions, origin, extraData) => {
       if (!extensions.length) {
         return;
       }
-
       removedExtensionIds.push(...extensions.filter(extData => extData.isRemoved).map(extData => extData.stringId));
       const extsWithoutRemoved = extensions.filterRemovedExtensions();
-
       const extsWithoutLoaded = _extensionData().ExtensionDataList.fromArray(extsWithoutRemoved.filter(ext => {
         var _ext$extensionId;
-
         return !loadedExtensionIds.includes(((_ext$extensionId = ext.extensionId) === null || _ext$extensionId === void 0 ? void 0 : _ext$extensionId.toStringWithoutVersion()) || '');
       }));
-
       const selfInMergedExtensions = extsWithoutLoaded.findExtension(componentId._legacy.toStringWithoutScopeAndVersion(), true, true);
       const extsWithoutSelf = selfInMergedExtensions !== null && selfInMergedExtensions !== void 0 && selfInMergedExtensions.extensionId ? extsWithoutLoaded.remove(selfInMergedExtensions.extensionId) : extsWithoutLoaded;
       await this.loadExtensions(extsWithoutSelf, componentId);
@@ -1477,12 +1212,10 @@ the following envs are used in this workspace: ${availableEnvs.join(', ')}`);
         extensionDataListFiltered,
         envIsCurrentlySet
       } = this.filterEnvsFromExtensionsIfNeeded(extsWithoutSelf, envWasFoundPreviously);
-
       if (envIsCurrentlySet) {
         await this.warnAboutMisconfiguredEnv(componentId, extensions);
         envWasFoundPreviously = true;
       }
-
       extensionsToMerge.push({
         origin,
         extensions: extensionDataListFiltered,
@@ -1490,37 +1223,28 @@ the following envs are used in this workspace: ${availableEnvs.join(', ')}`);
       });
       loadedExtensionIds.push(...(0, _lodash().compact)(extensionDataListFiltered.map(e => {
         var _e$extensionId;
-
         return (_e$extensionId = e.extensionId) === null || _e$extensionId === void 0 ? void 0 : _e$extensionId.toStringWithoutVersion();
       })));
     };
-
     const setDataListAsSpecific = extensions => {
       extensions.forEach(dataEntry => dataEntry.config[AspectSpecificField] = true);
     };
-
     if (bitMapExtensions && !excludeOrigins.includes('BitmapFile')) {
       const extensionDataList = _extensionData().ExtensionDataList.fromConfigObject(bitMapExtensions);
-
       setDataListAsSpecific(extensionDataList);
       await addAndLoadExtensions(extensionDataList, 'BitmapFile');
     }
-
     if (configFileExtensions && !excludeOrigins.includes('ComponentJsonFile')) {
       setDataListAsSpecific(configFileExtensions);
       await addAndLoadExtensions(configFileExtensions, 'ComponentJsonFile');
     }
-
     if (unmergedExtensionsSpecific && !excludeOrigins.includes('UnmergedSpecific')) {
       await addAndLoadExtensions(_extensionData().ExtensionDataList.fromArray(unmergedExtensionsSpecific), 'UnmergedSpecific');
     }
-
     if (!excludeOrigins.includes('ModelSpecific')) {
       await addAndLoadExtensions(_extensionData().ExtensionDataList.fromArray(scopeExtensionsSpecific), 'ModelSpecific');
     }
-
     let continuePropagating = (_componentConfigFile$ = componentConfigFile === null || componentConfigFile === void 0 ? void 0 : componentConfigFile.propagate) !== null && _componentConfigFile$ !== void 0 ? _componentConfigFile$ : true;
-
     if (variantsExtensions && continuePropagating && !excludeOrigins.includes('WorkspaceVariants')) {
       const appliedRules = variantConfig === null || variantConfig === void 0 ? void 0 : variantConfig.sortedMatches.map(({
         pattern,
@@ -1533,57 +1257,52 @@ the following envs are used in this workspace: ${availableEnvs.join(', ')}`);
         appliedRules
       });
     }
-
-    continuePropagating = continuePropagating && ((_variantConfig$propag = variantConfig === null || variantConfig === void 0 ? void 0 : variantConfig.propagate) !== null && _variantConfig$propag !== void 0 ? _variantConfig$propag : true); // Do not apply default extensions on the default extensions (it will create infinite loop when loading them)
-
+    continuePropagating = continuePropagating && ((_variantConfig$propag = variantConfig === null || variantConfig === void 0 ? void 0 : variantConfig.propagate) !== null && _variantConfig$propag !== void 0 ? _variantConfig$propag : true);
+    // Do not apply default extensions on the default extensions (it will create infinite loop when loading them)
     const isDefaultExtension = (_wsDefaultExtensions = wsDefaultExtensions) === null || _wsDefaultExtensions === void 0 ? void 0 : _wsDefaultExtensions.findExtension(componentId.toString(), true, true);
-
     if (wsDefaultExtensions && continuePropagating && !isDefaultExtension && !excludeOrigins.includes('WorkspaceDefault')) {
       await addAndLoadExtensions(wsDefaultExtensions, 'WorkspaceDefault');
     }
-
     if (unmergedExtensionsNonSpecific && mergeFromScope && continuePropagating && !excludeOrigins.includes('UnmergedNonSpecific')) {
       await addAndLoadExtensions(unmergedExtensionsNonSpecific, 'UnmergedNonSpecific');
     }
-
     if (mergeFromScope && continuePropagating && !excludeOrigins.includes('ModelNonSpecific')) {
       await addAndLoadExtensions(scopeExtensionsNonSpecific, 'ModelNonSpecific');
-    } // It's important to do this resolution before the merge, otherwise we have issues with extensions
-    // coming from scope with local scope name, as opposed to the same extension comes from the workspace with default scope name
-
+    }
 
+    // It's important to do this resolution before the merge, otherwise we have issues with extensions
+    // coming from scope with local scope name, as opposed to the same extension comes from the workspace with default scope name
     await Promise.all(extensionsToMerge.map(list => this.resolveExtensionListIds(list.extensions)));
-
     const afterMerge = _extensionData().ExtensionDataList.mergeConfigs(extensionsToMerge.map(ext => ext.extensions));
-
     const withoutRemoved = afterMerge.filter(extData => !removedExtensionIds.includes(extData.stringId));
-
     const extensions = _extensionData().ExtensionDataList.fromArray(withoutRemoved);
-
     return {
       extensions,
       beforeMerge: extensionsToMerge
     };
   }
-
   getUnmergedHead(componentId) {
     const unmerged = this.scope.legacyScope.objects.unmergedComponents.getEntry(componentId._legacy.name);
     return unmerged === null || unmerged === void 0 ? void 0 : unmerged.head;
   }
-
+  async getUnmergedComponent(componentId) {
+    const unmerged = this.scope.legacyScope.objects.unmergedComponents.getEntry(componentId._legacy.name);
+    if (unmerged !== null && unmerged !== void 0 && unmerged.head) {
+      return this.scope.get(componentId.changeVersion(unmerged === null || unmerged === void 0 ? void 0 : unmerged.head.toString()));
+    }
+    return undefined;
+  }
   async warnAboutMisconfiguredEnv(componentId, extensionDataList) {
     if (!(await this.hasId(componentId))) {
       // if this is a dependency and not belong to the workspace, don't show the warning
       return;
     }
-
     const envAspect = extensionDataList.findExtension(_envs().EnvsAspect.id);
     const envFromEnvsAspect = envAspect === null || envAspect === void 0 ? void 0 : envAspect.config.env;
     if (!envFromEnvsAspect) return;
     if (this.envs.getCoreEnvsIds().includes(envFromEnvsAspect)) return;
     if (this.warnedAboutMisconfiguredEnvs.includes(envFromEnvsAspect)) return;
     let env;
-
     try {
       const envId = await this.resolveComponentId(envFromEnvsAspect);
       env = await this.get(envId);
@@ -1596,10 +1315,8 @@ the following envs are used in this workspace: ${availableEnvs.join(', ')}`);
       this.logger.consoleWarning(`env "${envFromEnvsAspect}" is not of type env. (correct the env's type, or component config with "bit env set ${envFromEnvsAspect} teambit.envs/env")`);
     }
   }
-
   async isModified(component) {
     const head = component.head;
-
     if (!head) {
       return true; // it's a new component
     }
@@ -1609,7 +1326,6 @@ the following envs are used in this workspace: ${availableEnvs.join(', ')}`);
     const componentStatus = await this.consumer.getComponentStatusById(component.id._legacy);
     return componentStatus.modified === true;
   }
-
   filterEnvsFromExtensionsIfNeeded(extensionDataList, envWasFoundPreviously) {
     const envAspect = extensionDataList.findExtension(_envs().EnvsAspect.id);
     const envFromEnvsAspect = envAspect === null || envAspect === void 0 ? void 0 : envAspect.config.env;
@@ -1617,7 +1333,6 @@ the following envs are used in this workspace: ${availableEnvs.join(', ')}`);
     const extensionDataListFiltered = new (_extensionData().ExtensionDataList)(...nonEnvs);
     const envIsCurrentlySet = envFromEnvsAspect || envsNotFromEnvsAspect.length;
     const shouldIgnoreCurrentEnv = envIsCurrentlySet && envWasFoundPreviously;
-
     if (shouldIgnoreCurrentEnv) {
       // still, aspect env may have other data other then config.env.
       if (envAspect) {
@@ -1629,13 +1344,11 @@ the following envs are used in this workspace: ${availableEnvs.join(', ')}`);
       if (envAspect) extensionDataListFiltered.push(envAspect);
       extensionDataListFiltered.push(...envsNotFromEnvsAspect);
     }
-
     return {
       extensionDataListFiltered,
       envIsCurrentlySet
     };
   }
-
   async triggerOnPreWatch(componentIds, watchOpts) {
     const components = await this.getMany(componentIds);
     const preWatchFunctions = this.onPreWatchSlot.values();
@@ -1643,36 +1356,29 @@ the following envs are used in this workspace: ${availableEnvs.join(', ')}`);
       await func(components, watchOpts);
     });
   }
+
   /**
    * filter the given component-ids and set default-scope only to the new ones.
    * returns the affected components.
    */
-
-
   async setDefaultScopeToComponents(componentIds, scopeName) {
     if (!(0, _legacyBitId().isValidScopeName)(scopeName)) {
       throw new (_legacyBitId().InvalidScopeName)(scopeName);
     }
-
     const newComponentIds = componentIds.filter(id => !id.hasVersion());
-
     if (!newComponentIds.length) {
       const compIdsStr = componentIds.map(compId => compId.toString()).join(', ');
       throw new (_bitError().BitError)(`unable to set default-scope for the following components, as they are not new:\n${compIdsStr}`);
     }
-
     newComponentIds.map(comp => this.bitMap.setDefaultScope(comp, scopeName));
     await this.bitMap.write();
     return newComponentIds;
   }
-
   async setDefaultScope(scopeName) {
     var _config$workspaceConf, _config$workspaceConf2;
-
     if (this.defaultScope === scopeName) {
       throw new Error(`the default-scope is already set as "${scopeName}", nothing to change`);
     }
-
     const config = this.harmony.get('teambit.harmony/config');
     (_config$workspaceConf = config.workspaceConfig) === null || _config$workspaceConf === void 0 ? void 0 : _config$workspaceConf.setExtension(_workspace().WorkspaceAspect.id, {
       defaultScope: scopeName
@@ -1684,10 +1390,8 @@ the following envs are used in this workspace: ${availableEnvs.join(', ')}`);
       dir: _path2().default.dirname(config.workspaceConfig.path)
     }));
   }
-
   async addSpecificComponentConfig(id, aspectId, config = {}, shouldMergeWithExisting = false) {
     const componentConfigFile = await this.componentConfigFile(id);
-
     if (componentConfigFile) {
       await componentConfigFile.addAspect(aspectId, config, this.resolveComponentId.bind(this), shouldMergeWithExisting);
       await componentConfigFile.write({
@@ -1697,10 +1401,8 @@ the following envs are used in this workspace: ${availableEnvs.join(', ')}`);
       this.bitMap.addComponentConfig(id, aspectId, config, shouldMergeWithExisting);
     }
   }
-
   async removeSpecificComponentConfig(id, aspectId, markWithMinusIfNotExist) {
     const componentConfigFile = await this.componentConfigFile(id);
-
     if (componentConfigFile) {
       await componentConfigFile.removeAspect(aspectId, markWithMinusIfNotExist, this.resolveComponentId.bind(this));
       await componentConfigFile.write({
@@ -1710,72 +1412,57 @@ the following envs are used in this workspace: ${availableEnvs.join(', ')}`);
       this.bitMap.removeComponentConfig(id, aspectId, markWithMinusIfNotExist);
     }
   }
-
   async getAspectIdFromConfig(componentId, aspectIdStr, ignoreAspectVersion = false) {
     const aspectId = await this.resolveComponentId(aspectIdStr);
     const componentConfigFile = await this.componentConfigFile(componentId);
-
     if (componentConfigFile) {
       const aspectEntry = componentConfigFile.aspects.find(aspectId, ignoreAspectVersion);
       return aspectEntry === null || aspectEntry === void 0 ? void 0 : aspectEntry.id.toString();
     }
-
     return this.bitMap.getAspectIdFromConfig(componentId, aspectId, ignoreAspectVersion);
   }
-
   async getSpecificComponentConfig(id, aspectId) {
     var _this$bitMap$getBitma;
-
     const componentConfigFile = await this.componentConfigFile(id);
-
     if (componentConfigFile) {
       var _componentConfigFile$2;
-
       return (_componentConfigFile$2 = componentConfigFile.aspects.get(aspectId)) === null || _componentConfigFile$2 === void 0 ? void 0 : _componentConfigFile$2.config;
     }
-
     return (_this$bitMap$getBitma = this.bitMap.getBitmapEntry(id, {
       ignoreVersion: true
     }).config) === null || _this$bitMap$getBitma === void 0 ? void 0 : _this$bitMap$getBitma[aspectId];
   }
+
   /**
    * This will mutate the entries with extensionId prop to have resolved legacy id
    * This should be worked on the extension data list not the new aspect list
    * @param extensionList
    */
-
-
   async resolveExtensionListIds(extensionList) {
     const promises = extensionList.map(async entry => {
       if (entry.extensionId) {
         const id = await this.resolveComponentId(entry.extensionId);
         entry.extensionId = id._legacy;
       }
-
       return entry;
     });
     await Promise.all(promises);
     return extensionList;
   }
-
   isVendorComponentByComponentDir(relativeComponentDir) {
     var _this$config$vendor;
-
     const vendorDir = ((_this$config$vendor = this.config.vendor) === null || _this$config$vendor === void 0 ? void 0 : _this$config$vendor.directory) || DEFAULT_VENDOR_DIR;
-
     if ((0, _utils().pathIsInside)(relativeComponentDir, vendorDir)) {
       return true;
-    } // TODO: implement
-
-
+    }
+    // TODO: implement
     return false;
   }
+
   /**
    * return the component config from its folder (component.json)
    * @param componentId
    */
-
-
   async componentConfigFile(id) {
     const relativeComponentDir = this.componentDir(id, {
       ignoreVersion: true
@@ -1784,41 +1471,34 @@ the following envs are used in this workspace: ${availableEnvs.join(', ')}`);
     });
     return this.componentConfigFileFromComponentDirAndName(relativeComponentDir, id.fullName);
   }
+
   /**
    * @param componentPath can be relative or absolute. supports Linux and Windows
    */
-
-
   async getComponentIdByPath(componentPath) {
     const relativePath = _path2().default.isAbsolute(componentPath) ? _path2().default.relative(this.path, componentPath) : componentPath;
     const linuxPath = (0, _path().pathNormalizeToLinux)(relativePath);
     const bitId = this.consumer.bitMap.getComponentIdByPath(linuxPath);
-
     if (bitId) {
       return this.resolveComponentId(bitId);
     }
-
     return undefined;
   }
-
   async componentConfigFileFromComponentDirAndName(relativeComponentDir, name) {
     let componentConfigFile;
-
     if (relativeComponentDir) {
       const absComponentDir = this.componentDirToAbsolute(relativeComponentDir);
       const defaultScopeFromVariantsOrWs = await this.componentDefaultScopeFromComponentDirAndNameWithoutConfigFile(relativeComponentDir, name);
       componentConfigFile = await _componentConfigFile().ComponentConfigFile.load(absComponentDir, this.createAspectList.bind(this), defaultScopeFromVariantsOrWs);
     }
-
     return componentConfigFile;
   }
-
   async getAspectsGraphWithoutCore(components, isAspect) {
     const ids = components.map(component => component.id._legacy);
     const coreAspectsStringIds = this.aspectLoader.getCoreAspectIds();
     const coreAspectsComponentIds = coreAspectsStringIds.map(id => _legacyBitId().BitId.parse(id, true));
-
-    const coreAspectsBitIds = _bitId().BitIds.fromArray(coreAspectsComponentIds.map(id => id.changeScope(null))); // const aspectsIds = components.reduce((acc, curr) => {
+    const coreAspectsBitIds = _bitId().BitIds.fromArray(coreAspectsComponentIds.map(id => id.changeScope(null)));
+    // const aspectsIds = components.reduce((acc, curr) => {
     //   const currIds = curr.state.aspects.ids;
     //   acc = acc.concat(currIds);
     //   return acc;
@@ -1829,22 +1509,20 @@ the following envs are used in this workspace: ${availableEnvs.join(', ')}`);
     //   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
     // TODO: @gilad it causes many issues we need to find a better solution. removed for now.
-
-
     const ignoredIds = coreAspectsBitIds.concat([]);
     return this.buildOneGraphForComponents(ids, _bitId().BitIds.fromArray(ignoredIds), isAspect);
   }
+
   /**
    * load aspects from the workspace and if not exists in the workspace, load from the scope.
    * keep in mind that the graph may have circles.
    */
-
-
   async loadAspects(ids = [], throwOnError = false, neededFor) {
     // generate a random callId to be able to identify the call from the logs
     const callId = Math.floor(Math.random() * 1000);
@@ -1858,7 +1536,6 @@ needed-for: ${neededFor || '<unknown>'}`);
     const idsWithoutCore = (0, _lodash().difference)(notLoadedIds, coreAspectsStringIds);
     const componentIds = await this.resolveMultipleComponentIds(idsWithoutCore);
     const components = await this.importAndGetAspects(componentIds);
-
     const isAspect = async bitId => {
       const id = await this.resolveComponentId(bitId);
       const component = await this.get(id);
@@ -1866,10 +1543,8 @@ needed-for: ${neededFor || '<unknown>'}`);
       const isUsingAspectEnv = this.envs.isUsingAspectEnv(component);
       const isUsingEnvEnv = this.envs.isUsingEnvEnv(component);
       const isValidAspect = isUsingAspectEnv || isUsingEnvEnv;
-
       if (!isValidAspect && idsWithoutCore.includes(component.id.toString())) {
         const err = new (_incorrectEnvAspect().IncorrectEnvAspect)(component.id.toString(), data.type, data.id);
-
         if (data.id === _envs().DEFAULT_ENV) {
           // when cloning a project, or when the node-modules dir is deleted, nothing works and all
           // components are default to the DEFAULT_ENV, which is node-env. we must allow "bit
@@ -1879,10 +1554,8 @@ needed-for: ${neededFor || '<unknown>'}`);
           throw err;
         }
       }
-
       return isValidAspect;
     };
-
     const graph = await this.getAspectsGraphWithoutCore(components, isAspect);
     const idsStr = graph.nodes();
     this.logger.debug(`${loggerPrefix} found ${idsStr.length} aspects in the aspects-graph`);
@@ -1901,10 +1574,10 @@ needed-for: ${neededFor || '<unknown>'}`);
       if (this.aspectLoader.isValidAspect(manifest)) return undefined;
       return index;
     }));
-    const workspaceManifestsIds = (0, _lodash().compact)(workspaceManifests.map(m => m.id)); // We are grouping the scope aspects by whether they are envs of something of the list or not
+    const workspaceManifestsIds = (0, _lodash().compact)(workspaceManifests.map(m => m.id));
+    // We are grouping the scope aspects by whether they are envs of something of the list or not
     // if yes, we want to load them first
     // the rest we will load together with the workspace aspects
-
     const scopeIdsGrouped = await this.scope.groupAspectIdsByEnvOfTheList(scopeIds);
     const scopeEnvsManifestsIds = scopeIdsGrouped.envs && scopeIdsGrouped.envs.length ? await this.scope.loadAspects(scopeIdsGrouped.envs, throwOnError, 'workspace.loadAspects loading scope aspects') : [];
     const {
@@ -1915,39 +1588,35 @@ needed-for: ${neededFor || '<unknown>'}`);
       manifests: []
     };
     const scopeOtherManifestsIds = (0, _lodash().compact)(scopeOtherManifests.map(m => m.id));
-    await this.aspectLoader.loadExtensionsByManifests([...scopeOtherManifests, ...workspaceManifests], throwOnError); // Try require components for potential plugins
-
+    await this.aspectLoader.loadExtensionsByManifests([...scopeOtherManifests, ...workspaceManifests], throwOnError);
+    // Try require components for potential plugins
     const pluginsWorkspaceComps = potentialPluginsIndexes.map(index => {
       return workspaceComps[index];
-    }); // Do the require again now that the plugins defs already registered
-
+    });
+    // Do the require again now that the plugins defs already registered
     const pluginsWorkspaceAspects = await this.requireComponents(pluginsWorkspaceComps);
     const pluginsWorkspaceManifests = await this.aspectLoader.getManifestsFromRequireableExtensions(pluginsWorkspaceAspects, throwOnError);
     await this.aspectLoader.loadExtensionsByManifests(pluginsWorkspaceManifests, throwOnError);
     this.logger.debug(`${loggerPrefix} finish loading aspects`);
     return (0, _lodash().compact)(scopeEnvsManifestsIds.concat(scopeOtherManifestsIds).concat(workspaceManifestsIds));
   }
+
   /**
    * Note - this gets called from Harmony only.
    * returns one graph that includes all dependencies types. each edge has a label of the dependency
    * type. the nodes content is the Component object.
    */
-
-
   async buildOneGraphForComponents(ids, ignoreIds, shouldLoadFunc, shouldThrowOnMissingDep = true) {
     const graphFromFsBuilder = new (_buildGraphFromFs().GraphFromFsBuilder)(this, this.logger, ignoreIds, shouldLoadFunc, shouldThrowOnMissingDep);
     return graphFromFsBuilder.buildGraph(ids);
   }
-
   async resolveAspects(runtimeName, componentIds, opts) {
     this.logger.debug(`workspace resolveAspects, runtimeName: ${runtimeName}, componentIds: ${componentIds}`);
     const defaultOpts = {
       excludeCore: false,
       requestedOnly: false
     };
-
     const mergedOpts = _objectSpread(_objectSpread({}, defaultOpts), opts);
-
     let missingPaths = false;
     const stringIds = [];
     const idsToResolve = componentIds ? componentIds.map(id => id.toString()) : this.harmony.extensionsIds;
@@ -1961,15 +1630,12 @@ needed-for: ${neededFor || '<unknown>'}`);
     const wsComponents = await this.getMany(workspaceIds);
     const aspectDefs = await this.aspectLoader.resolveAspects(wsComponents, async component => {
       const compStringId = component.id._legacy.toString();
-
       stringIds.push(compStringId);
       const localPath = this.getComponentPackagePath(component);
       const isExist = await _fsExtra().default.pathExists(localPath);
-
       if (!isExist) {
         missingPaths = true;
       }
-
       const runtimePath = runtimeName ? await this.aspectLoader.getRuntimePath(component, localPath, runtimeName) : null;
       this.logger.debug(`workspace resolveAspects, resolving id: ${compStringId}, localPath: ${localPath}, runtimePath: ${runtimePath}`);
       return {
@@ -1978,56 +1644,46 @@ needed-for: ${neededFor || '<unknown>'}`);
       };
     });
     let scopeAspectDefs = [];
-
     if (scopeIds.length) {
       scopeAspectDefs = await this.scope.resolveAspects(runtimeName, scopeIds, mergedOpts);
     }
-
     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.
+    }));
 
+    // due to lack of workspace and scope runtimes. TODO: fix after adding them.
     if (runtimeName) {
       coreAspectDefs = coreAspectDefs.filter(coreAspect => {
         return coreAspect.runtimePath;
       });
     }
-
     if (missingPaths) {
       await (0, _consumer().link)(stringIds, false);
     }
-
     const allDefs = aspectDefs.concat(coreAspectDefs).concat(scopeAspectDefs);
     const ids = idsToResolve.map(idStr => _component().ComponentID.fromString(idStr).toStringWithoutVersion());
     const afterExclusion = mergedOpts.excludeCore ? allDefs.filter(def => {
       const isCore = coreAspectDefs.find(coreId => def.getId === coreId.getId);
-
       const id = _component().ComponentID.fromString(def.getId || '');
-
       const isTarget = ids.includes(id.toStringWithoutVersion());
       if (isTarget) return true;
       return !isCore;
     }) : allDefs;
     const uniqDefs = (0, _lodash().uniqBy)(afterExclusion, def => `${def.aspectPath}-${def.runtimePath}`);
     let defs = uniqDefs;
-
     if (runtimeName) {
       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 groupIdsByWorkspaceAndScope(ids) {
     const workspaceIds = [];
     const scopeIds = [];
@@ -2040,7 +1696,6 @@ needed-for: ${neededFor || '<unknown>'}`);
       scopeIds
     };
   }
-
   async groupComponentsByWorkspaceAndScope(components) {
     const workspaceComps = [];
     const scopeComps = [];
@@ -2053,21 +1708,19 @@ needed-for: ${neededFor || '<unknown>'}`);
       scopeComps
     };
   }
+
   /**
    * Load all unloaded extensions from a list
    * @param extensions list of extensions with config to load
    */
-
-
   async loadExtensions(extensions, originatedFrom, throwOnError = false) {
     const extensionsIdsP = extensions.map(async extensionEntry => {
       // Core extension
       if (!extensionEntry.extensionId) {
         return extensionEntry.stringId;
       }
-
-      const id = await this.resolveComponentId(extensionEntry.extensionId); // return this.resolveComponentId(extensionEntry.extensionId);
-
+      const id = await this.resolveComponentId(extensionEntry.extensionId);
+      // return this.resolveComponentId(extensionEntry.extensionId);
       return id.toString();
     });
     const extensionsIds = await Promise.all(extensionsIdsP);
@@ -2076,31 +1729,27 @@ needed-for: ${neededFor || '<unknown>'}`);
     if (!extensionsToLoad.length) return;
     await this.loadAspects(extensionsToLoad, throwOnError, originatedFrom === null || originatedFrom === void 0 ? void 0 : originatedFrom.toString());
   }
+
   /**
    * Provides a cache folder, unique per key.
    * Return value may be undefined, if workspace folder is unconventional (bare-scope, no node_modules, etc)
    */
-
-
   getTempDir(
   /*
    * unique key, i.e. aspect or component id
    */
   id) {
     const PREFIX = 'bit';
+    const cacheDir = _path2().default.join(this.modulesPath, '.cache', PREFIX, id);
 
-    const cacheDir = _path2().default.join(this.modulesPath, '.cache', PREFIX, id); // maybe should also check it's a folder and has write permissions
-
-
+    // maybe should also check it's a folder and has write permissions
     if (!_fsExtra().default.existsSync(cacheDir)) {
       _fsExtra().default.mkdirSync(cacheDir, {
         recursive: true
       });
     }
-
     return cacheDir;
   }
-
   async requireComponents(components) {
     let missingPaths = false;
     const stringIds = [];
@@ -2108,101 +1757,87 @@ needed-for: ${neededFor || '<unknown>'}`);
       stringIds.push(component.id._legacy.toString());
       const localPath = this.getComponentPackagePath(component);
       const isExist = await _fsExtra().default.pathExists(localPath);
-
       if (!isExist) {
         missingPaths = true;
       }
-
       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
+        }
 
+        // 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);
     });
-    const resolved = await Promise.all(resolveP); // Make sure to link missing components
-
+    const resolved = await Promise.all(resolveP);
+    // Make sure to link missing components
     if (missingPaths) {
       await (0, _consumer().link)(stringIds, false);
     }
-
     return resolved;
   }
+
   /**
    * whether a scope is hosted by Bit cloud.
    * otherwise, it is self-hosted
    */
-
-
   async isHostedByBit(scopeName) {
     // TODO: once scope create a new API for this, replace it with the new one
     const remotes = await this.scope._legacyRemotes();
     return remotes.isHub(scopeName);
   }
+
   /**
    * same as `this.importAndGetMany()` with a specific error handling of ComponentNotFound
    */
-
-
   async importAndGetAspects(componentIds) {
     try {
       return await this.importAndGetMany(componentIds);
     } catch (err) {
       if (err instanceof _exceptions().ComponentNotFound) {
         var _config$workspaceConf3;
-
         const config = this.harmony.get('teambit.harmony/config');
         const configStr = JSON.stringify(((_config$workspaceConf3 = config.workspaceConfig) === null || _config$workspaceConf3 === void 0 ? void 0 : _config$workspaceConf3.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;
     }
   }
+
   /**
    * this should be rarely in-use.
    * it's currently used by watch extension as a quick workaround to load .bitmap and the components
    */
-
-
   async _reloadConsumer() {
     this.consumer = await (0, _consumer2().loadConsumer)(this.path, true);
     this.clearCache();
   }
-
   getComponentPackagePath(component) {
     const relativePath = this.dependencyResolver.getRuntimeModulePath(component);
     return _path2().default.join(this.path, relativePath);
-  } // TODO: should we return here the dir as it defined (aka components) or with /{name} prefix (as it used in legacy)
-
+  }
 
+  // TODO: should we return here the dir as it defined (aka components) or with /{name} prefix (as it used in legacy)
   get defaultDirectory() {
     return this.config.defaultDirectory;
   }
-
   get legacyDefaultDirectory() {
     if (this.defaultDirectory && !this.defaultDirectory.includes('{name}')) {
       return `${this.defaultDirectory}/{name}`;
     }
-
     return this.defaultDirectory;
   }
+
   /**
    * Transform the id to ComponentId and get the exact id as appear in bitmap
    *
@@ -2210,51 +1845,44 @@ your workspace.jsonc has this component-id set. you might want to remove/change
    * @returns {Promise<ComponentID>}
    * @memberof Workspace
    */
-
-
   async resolveComponentId(id) {
     const getDefaultScope = async (bitId, bitMapOptions) => {
       if (bitId.scope) {
         return bitId.scope;
       }
-
       const relativeComponentDir = this.componentDirFromLegacyId(bitId, bitMapOptions, {
         relative: true
       });
       const defaultScope = await this.componentDefaultScopeFromComponentDirAndName(relativeComponentDir, bitId.toStringWithoutScopeAndVersion());
       return defaultScope;
-    }; // This is required in case where you have in your workspace a component with the same name as a core aspect
+    };
+
+    // This is required in case where you have in your workspace a component with the same name as a core aspect
     // let's say you have component called react-native (which is eventually my-org.my-scope/react-native)
     // and you set teambit.react/react-native as your env
     // bit will get here with the string teambit.react/react-native and will try to resolve it from the workspace
     // during this it will find the my-org.my-scope/react-native which is incorrect as the core one doesn't exist in the
     // workspace
-
-
     if (this.aspectLoader.isCoreAspect(id.toString())) {
       return _component().ComponentID.fromString(id.toString());
     }
-
     let legacyId = this.consumer.getParsedIdIfExist(id.toString(), true, true);
-
     if (legacyId) {
-      const defaultScope = await getDefaultScope(legacyId); // only reason to strip the scopeName from the given id is when this id has the defaultScope, because .bitmap
+      const defaultScope = await getDefaultScope(legacyId);
+      // only reason to strip the scopeName from the given id is when this id has the defaultScope, because .bitmap
       // doesn't have the defaultScope. if the given id doesn't have scope or has scope different than the default,
       // then don't ignore it. search with the scope-name.
-
       const shouldSearchWithoutScopeInProvidedId = id.toString().startsWith(`${defaultScope}/`);
       legacyId = this.consumer.getParsedIdIfExist(id.toString(), true, shouldSearchWithoutScopeInProvidedId);
-
       if (legacyId) {
         return _component().ComponentID.fromLegacy(legacyId, defaultScope);
       }
     }
-
     try {
       const idWithVersion = id.toString();
       const [idWithoutVersion, version] = id.toString().split('@');
-
-      const _bitMapId = this.consumer.getParsedIdIfExist(idWithoutVersion, false, true); // This logic is very specific, and very sensitive for changes please do not touch this without consulting with @ran or @gilad
+      const _bitMapId = this.consumer.getParsedIdIfExist(idWithoutVersion, false, true);
+      // This logic is very specific, and very sensitive for changes please do not touch this without consulting with @ran or @gilad
       // example (partial list) cases which should be handled are:
       // use case 1 - ws component provided with the local scope name:
       // source id        : my-scope1/my-name1
@@ -2280,55 +1908,43 @@ your workspace.jsonc has this component-id set. you might want to remove/change
       // local scope name : my-scope1
       // scope content    : my-scope2/my-name1
       // expected result  : my-scope2/my-name1 (get the name from the bitmap)
-      // No entry in bitmap at all, search for the original input id
-
 
+      // No entry in bitmap at all, search for the original input id
       if (!_bitMapId) {
         return await this.scope.resolveComponentId(id.toString());
       }
-
       const _bitMapIdWithoutVersion = _bitMapId.toStringWithoutVersion();
-
-      const _bitMapIdWithVersion = _bitMapId.changeVersion(version).toString(); // The id in the bitmap has prefix which is not in the source id - the bitmap entry has scope name
+      const _bitMapIdWithVersion = _bitMapId.changeVersion(version).toString();
+      // The id in the bitmap has prefix which is not in the source id - the bitmap entry has scope name
       // Handle use case 4
-
-
       if (_bitMapIdWithoutVersion.endsWith(idWithoutVersion) && _bitMapIdWithoutVersion !== idWithoutVersion) {
         return await this.scope.resolveComponentId(_bitMapIdWithVersion);
-      } // Handle case when I tagged the component locally with a default scope which is not the local scope
+      }
+      // Handle case when I tagged the component locally with a default scope which is not the local scope
       // but not exported it yet
       // now i'm trying to load it with source id contain the default scope prefix
       // we want to get it from the local first before assuming it's something coming from outside
-
-
       if (!_bitMapId.scope) {
         const defaultScopeForBitmapId = await getDefaultScope(_bitMapId, {
           ignoreVersion: true
         });
-
         const getFromBitmapAddDefaultScope = () => {
           let _bitmapIdWithVersionForSource = _bitMapId;
-
           if (version) {
             _bitmapIdWithVersionForSource = _bitMapId.changeVersion(version);
           }
-
           return _component().ComponentID.fromLegacy(_bitmapIdWithVersionForSource, defaultScopeForBitmapId);
-        }; // a case when the given id contains the default scope
-
-
+        };
+        // a case when the given id contains the default scope
         if (idWithVersion.startsWith(`${defaultScopeForBitmapId}/${_bitMapIdWithoutVersion}`)) {
           return getFromBitmapAddDefaultScope();
-        } // a case when the given id does not contain the default scope
-
-
+        }
+        // a case when the given id does not contain the default scope
         const fromScope = await this.scope.resolveComponentId(idWithVersion);
-
         if (!fromScope._legacy.hasScope()) {
           return getFromBitmapAddDefaultScope();
         }
       }
-
       if (idWithoutVersion.endsWith(_bitMapIdWithoutVersion) && _bitMapIdWithoutVersion !== idWithoutVersion) {
         // The id in the bitmap doesn't have scope, the source id has scope
         // Handle use case 2 and use case 1
@@ -2336,24 +1952,22 @@ your workspace.jsonc has this component-id set. you might want to remove/change
           // Handle use case 1 - the provided id has scope name same as the local scope name
           // we want to send it as it appear in the bitmap
           return await this.scope.resolveComponentId(_bitMapIdWithVersion);
-        } // Handle use case 2 - the provided id has scope which is not the local scope
+        }
+        // Handle use case 2 - the provided id has scope which is not the local scope
         // we want to search by the source id
-
-
         return await this.scope.resolveComponentId(idWithVersion);
-      } // Handle use case 3
-
-
+      }
+      // Handle use case 3
       return await this.scope.resolveComponentId(idWithVersion);
     } catch (error) {
       legacyId = _legacyBitId().BitId.parse(id.toString(), true);
       return _component().ComponentID.fromLegacy(legacyId);
     }
   }
-
   async resolveMultipleComponentIds(ids) {
     return Promise.all(ids.map(async id => this.resolveComponentId(id)));
   }
+
   /**
    * This will mutate the original extensions list and resolve it's ids
    *
@@ -2361,14 +1975,13 @@ your workspace.jsonc has this component-id set. you might want to remove/change
    * @returns {Promise<void[]>}
    * @memberof Workspace
    */
-
-
   resolveExtensionsList(extensions) {
     const resolveMergedExtensionsP = extensions.map(async extensionEntry => {
       if (extensionEntry.extensionId) {
         // const hasVersion = extensionEntry.extensionId.hasVersion();
         // const useBitmapVersion = !hasVersion;
         // const resolvedId = await this.resolveComponentId(extensionEntry.extensionId, true, useBitmapVersion);
+
         // Assuming extensionId always has scope - do not allow extension id without scope
         const resolvedId = await this.resolveComponentId(extensionEntry.extensionId);
         extensionEntry.extensionId = resolvedId._legacy;
@@ -2376,6 +1989,7 @@ your workspace.jsonc has this component-id set. you might want to remove/change
     });
     return Promise.all(resolveMergedExtensionsP);
   }
+
   /**
    * This will mutate the original extensions list and make sure all extensions has the ids with the scope / default scope
    *
@@ -2383,25 +1997,21 @@ your workspace.jsonc has this component-id set. you might want to remove/change
    * @returns {Promise<void[]>}
    * @memberof Workspace
    */
-
-
   addDefaultScopeToExtensionsList(extensions) {
     const resolveMergedExtensionsP = extensions.map(async extensionEntry => {
       if (extensionEntry.extensionId && !extensionEntry.extensionId.hasScope()) {
         const componentId = _component().ComponentID.fromLegacy(extensionEntry.extensionId);
-
         const defaultScope = await this.componentDefaultScope(componentId);
         extensionEntry.extensionId = extensionEntry.extensionId.changeScope(defaultScope);
       }
     });
     return Promise.all(resolveMergedExtensionsP);
   }
+
   /**
    * configure an environment to the given components in the .bitmap file, this configuration overrides other, such as
    * overrides in workspace.jsonc.
    */
-
-
   async setEnvToComponents(envId, componentIds) {
     const envStrWithPossiblyVersion = await this.resolveEnvIdWithPotentialVersionForConfig(envId);
     const envIdStrNoVersion = envId.toStringWithoutVersion();
@@ -2414,56 +2024,46 @@ your workspace.jsonc has this component-id set. you might want to remove/change
     }));
     await this.bitMap.write();
   }
+
   /**
    * helpful when a user provides an env-string to be set and this env has no version.
    * in the workspace config, a custom-env needs to be set with a version unless it's part of the workspace.
    * (inside envs/envs it's set without a version).
    */
-
-
   async resolveEnvIdWithPotentialVersionForConfig(envId) {
     var _found$extensionId;
-
     const isCore = this.aspectLoader.isCoreAspect(envId.toStringWithoutVersion());
     const existsOnWorkspace = await this.hasId(envId);
-
     if (isCore || existsOnWorkspace) {
       // the env needs to be without version
       return envId.toStringWithoutVersion();
-    } // the env must include a version
-
-
+    }
+    // the env must include a version
     if (envId.hasVersion()) {
       return envId.toString();
     }
-
     const extensions = this.harmony.get('teambit.harmony/config').extensions;
     const found = extensions === null || extensions === void 0 ? void 0 : extensions.findExtension(envId.toString(), true);
-
     if (found && (_found$extensionId = found.extensionId) !== null && _found$extensionId !== void 0 && _found$extensionId.version) {
       return found.extensionId.toString();
     }
-
     const comps = await this.importAndGetMany([envId]);
     return comps[0].id.toString();
   }
+
   /**
    * remove env configuration from the .bitmap file, so then other configuration, such as "variants" will take place
    */
-
-
   async unsetEnvFromComponents(ids) {
     const changed = [];
     const unchanged = [];
     await Promise.all(ids.map(async id => {
       const envsAspect = await this.getSpecificComponentConfig(id, _envs().EnvsAspect.id);
       const currentEnv = envsAspect && envsAspect !== _config().REMOVE_EXTENSION_SPECIAL_SIGN ? envsAspect.env : null;
-
       if (!currentEnv) {
         unchanged.push(id);
         return;
       }
-
       const currentEnvWithPotentialVersion = await this.getAspectIdFromConfig(id, currentEnv, true);
       await this.removeSpecificComponentConfig(id, currentEnvWithPotentialVersion || currentEnv, false);
       await this.removeSpecificComponentConfig(id, _envs().EnvsAspect.id, false);
@@ -2475,8 +2075,8 @@ your workspace.jsonc has this component-id set. you might want to remove/change
       unchanged
     };
   }
-
 }
+
 /**
  * this is a super hacky way to do it. problem is that loadAspect is running as onStart hook, where we don't
  * have the CLI fully loaded yet, so we can't get the command from the CLI aspect, we have to retrieve it from
@@ -2485,15 +2085,11 @@ your workspace.jsonc has this component-id set. you might want to remove/change
  * Bit loads (even bit --help), it'll fetch them and slow down everything.
  * instead, long-running commands and those that need the artifacts from the Version objects, should try to re-fetch.
  */
-
-
 exports.Workspace = Workspace;
-
 function shouldReFetchUnBuiltVersion() {
   const commandsToReFetch = ['import'];
   return commandsToReFetch.includes(process.argv[2]);
 }
-
 var _default = Workspace;
 exports.default = _default;