@teambit/workspace 1.0.105 → 1.0.106

package/dist/workspace-component/workspace-component-loader.js

@@ -4,6 +4,20 @@ Object.defineProperty(exports, "__esModule", {
   value: true
 });
 exports.WorkspaceComponentLoader = void 0;
+function _pMap() {
+  const data = _interopRequireDefault(require("p-map"));
+  _pMap = function () {
+    return data;
+  };
+  return data;
+}
+function _concurrency() {
+  const data = require("@teambit/legacy/dist/utils/concurrency");
+  _concurrency = function () {
+    return data;
+  };
+  return data;
+}
 function _component() {
   const data = require("@teambit/component");
   _component = function () {
@@ -124,29 +138,389 @@ function _mergeConfigConflict() {
   return data;
 }
 function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+function ownKeys(e, r) { var t = Object.keys(e); if (Object.getOwnPropertySymbols) { var o = Object.getOwnPropertySymbols(e); r && (o = o.filter(function (r) { return Object.getOwnPropertyDescriptor(e, r).enumerable; })), t.push.apply(t, o); } return t; }
+function _objectSpread(e) { for (var r = 1; r < arguments.length; r++) { var t = null != arguments[r] ? arguments[r] : {}; r % 2 ? ownKeys(Object(t), !0).forEach(function (r) { _defineProperty(e, r, t[r]); }) : Object.getOwnPropertyDescriptors ? Object.defineProperties(e, Object.getOwnPropertyDescriptors(t)) : ownKeys(Object(t)).forEach(function (r) { Object.defineProperty(e, r, Object.getOwnPropertyDescriptor(t, r)); }); } return e; }
 function _defineProperty(obj, key, value) { key = _toPropertyKey(key); if (key in obj) { Object.defineProperty(obj, key, { value: value, enumerable: true, configurable: true, writable: true }); } else { obj[key] = value; } return obj; }
 function _toPropertyKey(t) { var i = _toPrimitive(t, "string"); return "symbol" == typeof i ? i : String(i); }
 function _toPrimitive(t, r) { if ("object" != typeof t || !t) return t; var e = t[Symbol.toPrimitive]; if (void 0 !== e) { var i = e.call(t, r || "default"); if ("object" != typeof i) return i; throw new TypeError("@@toPrimitive must return a primitive value."); } return ("string" === r ? String : Number)(t); }
 class WorkspaceComponentLoader {
   // cache loaded components
-  constructor(workspace, logger, dependencyResolver, envs) {
+  constructor(workspace, logger, dependencyResolver, envs, aspectLoader) {
     this.workspace = workspace;
     this.logger = logger;
     this.dependencyResolver = dependencyResolver;
     this.envs = envs;
+    this.aspectLoader = aspectLoader;
     _defineProperty(this, "componentsCache", void 0);
+    // cache loaded components
+    /**
+     * Cache components that loaded from scope (especially for get many for perf improvements)
+     */
+    _defineProperty(this, "scopeComponentsCache", void 0);
+    /**
+     * Cache extension list for components. used by get many for perf improvements.
+     * And to make sure we load extensions first.
+     */
+    _defineProperty(this, "componentsExtensionsCache", void 0);
+    _defineProperty(this, "componentLoadedSelfAsAspects", void 0);
     this.componentsCache = (0, _cacheFactory().createInMemoryCache)({
       maxSize: (0, _inMemoryCache().getMaxSizeForComponents)()
     });
+    this.scopeComponentsCache = (0, _cacheFactory().createInMemoryCache)({
+      maxSize: (0, _inMemoryCache().getMaxSizeForComponents)()
+    });
+    this.componentsExtensionsCache = (0, _cacheFactory().createInMemoryCache)({
+      maxSize: (0, _inMemoryCache().getMaxSizeForComponents)()
+    });
+    this.componentLoadedSelfAsAspects = (0, _cacheFactory().createInMemoryCache)({
+      maxSize: (0, _inMemoryCache().getMaxSizeForComponents)()
+    });
   }
   async getMany(ids, loadOpts, throwOnFailure = true) {
     const idsWithoutEmpty = (0, _lodash().compact)(ids);
-    const errors = [];
+    this.logger.setStatusLine(`loading ${ids.length} component(s)`);
+    const loadOptsWithDefaults = Object.assign(
+    // We don't want to load extension or execute the load slot at this step
+    // we will do it later
+    // this important for better performance
+    // We don't want to resolveExtensionsVersions as with get many we call aspect merger merge before update dependencies
+    // so we will have the correct versions for extensions already and update them after will resolve wrong versions
+    // in some cases
+    {
+      loadExtensions: false,
+      executeLoadSlot: false,
+      loadSeedersAsAspects: true,
+      resolveExtensionsVersions: false
+    }, loadOpts || {});
+    const loadOrCached = {
+      idsToLoad: [],
+      fromCache: []
+    };
+    idsWithoutEmpty.forEach(id => {
+      const componentFromCache = this.getFromCache(id, loadOptsWithDefaults);
+      if (componentFromCache) {
+        loadOrCached.fromCache.push(componentFromCache);
+      } else {
+        loadOrCached.idsToLoad.push(id);
+      }
+    }, loadOrCached);
+    const {
+      components: loadedComponents,
+      invalidComponents
+    } = await this.getAndLoadSlotOrdered(loadOrCached.idsToLoad || [], loadOptsWithDefaults, throwOnFailure);
+    const components = [...loadedComponents, ...loadOrCached.fromCache];
+
+    // this.logger.clearStatusLine();
+    return {
+      components,
+      invalidComponents
+    };
+  }
+  async getAndLoadSlotOrdered(ids, loadOpts, throwOnFailure = true) {
+    if (!(ids !== null && ids !== void 0 && ids.length)) return {
+      components: [],
+      invalidComponents: []
+    };
+    const workspaceScopeIdsMap = await this.groupAndUpdateIds(ids);
+    const groupsToHandle = await this.buildLoadGroups(workspaceScopeIdsMap);
+    const groupsRes = (0, _lodash().compact)(await (0, _pMapSeries().default)(groupsToHandle, async group => {
+      const {
+        scopeIds,
+        workspaceIds,
+        aspects,
+        core,
+        seeders
+      } = group;
+      if (!workspaceIds.length && !scopeIds.length) return undefined;
+      const res = await this.getAndLoadSlot(workspaceIds, scopeIds, _objectSpread(_objectSpread({}, loadOpts), {}, {
+        core,
+        seeders,
+        aspects
+      }), throwOnFailure);
+      // We don't want to return components that were not asked originally (we do want to load them)
+      if (!group.seeders) return undefined;
+      return res;
+    }));
+    const finalRes = groupsRes.reduce((acc, curr) => {
+      return {
+        components: [...acc.components, ...curr.components],
+        invalidComponents: [...acc.invalidComponents, ...curr.invalidComponents]
+      };
+    }, {
+      components: [],
+      invalidComponents: []
+    });
+    return finalRes;
+  }
+  async buildLoadGroups(workspaceScopeIdsMap) {
+    const allIds = [...workspaceScopeIdsMap.workspaceIds.values(), ...workspaceScopeIdsMap.scopeIds.values()];
+    const groupedByIsCoreEnvs = (0, _lodash().groupBy)(allIds, id => {
+      return this.envs.isCoreEnv(id.toStringWithoutVersion());
+    });
+    await this.populateScopeAndExtensionsCache(groupedByIsCoreEnvs.false || [], workspaceScopeIdsMap);
+    const allExtIds = new Map();
+    groupedByIsCoreEnvs.false.forEach(id => {
+      const idStr = id.toString();
+      const fromCache = this.componentsExtensionsCache.get(idStr);
+      if (!fromCache || !fromCache.extensions) {
+        return;
+      }
+      fromCache.extensions.forEach(ext => {
+        if (!allExtIds.has(ext.stringId) && ext.newExtensionId) {
+          allExtIds.set(ext.stringId, ext.newExtensionId);
+        }
+      });
+    });
+    const allExtCompIds = Array.from(allExtIds.values());
+    await this.populateScopeAndExtensionsCache(allExtCompIds || [], workspaceScopeIdsMap);
+    const allExtIdsStr = allExtCompIds.map(id => id.toString());
+    const groupedByIsExtOfAnother = (0, _lodash().groupBy)(groupedByIsCoreEnvs.false, id => {
+      return allExtIdsStr.includes(id.toString());
+    });
+    const extIdsFromTheList = (groupedByIsExtOfAnother.true || []).map(id => id.toString());
+    const extsNotFromTheList = [];
+    for (const [, id] of allExtIds.entries()) {
+      if (!extIdsFromTheList.includes(id.toString())) {
+        extsNotFromTheList.push(id);
+      }
+    }
+    await this.groupAndUpdateIds(extsNotFromTheList, workspaceScopeIdsMap);
+    const layerdExtFromTheList = this.regroupExtIdsFromTheList(groupedByIsExtOfAnother.true);
+    const layerdExtGroups = layerdExtFromTheList.map(ids => {
+      return {
+        ids,
+        core: false,
+        aspects: true,
+        seeders: true
+      };
+    });
+    const groupsToHandle = [
+    // Always load first core envs
+    {
+      ids: groupedByIsCoreEnvs.true || [],
+      core: true,
+      aspects: true,
+      seeders: false
+    }, {
+      ids: extsNotFromTheList || [],
+      core: false,
+      aspects: true,
+      seeders: false
+    }, ...layerdExtGroups, {
+      ids: groupedByIsExtOfAnother.false || [],
+      core: false,
+      aspects: false,
+      seeders: true
+    }];
+    const groupsByWsScope = groupsToHandle.map(group => {
+      const groupedByWsScope = (0, _lodash().groupBy)(group.ids, id => {
+        return workspaceScopeIdsMap.workspaceIds.has(id.toString());
+      });
+      return {
+        workspaceIds: groupedByWsScope.true || [],
+        scopeIds: groupedByWsScope.false || [],
+        core: group.core,
+        aspects: group.aspects,
+        seeders: group.seeders
+      };
+    });
+    return groupsByWsScope;
+  }
+  regroupExtIdsFromTheList(ids) {
+    // TODO: implement this function
+    // this should handle a case when you have:
+    // compA that has extA and that extA has extB
+    // in that case we now get the following group:
+    // ids: [extA, extB]
+    // while we need extB to be in a different group before extA
+    return [ids];
+  }
+  async getAndLoadSlot(workspaceIds, scopeIds, loadOpts, throwOnFailure = true) {
+    const {
+      workspaceComponents,
+      scopeComponents,
+      invalidComponents
+    } = await this.getComponentsWithoutLoadExtensions(workspaceIds, scopeIds, loadOpts, throwOnFailure);
+    const components = workspaceComponents.concat(scopeComponents);
+    const allExtensions = components.map(component => {
+      return component.state._consumer.extensions;
+    });
+
+    // Ensure we won't load the same extension many times
+    // We don't want to ignore version here, as we do want to load different extensions with same id but different versions here
+    const mergedExtensions = _config().ExtensionDataList.mergeConfigs(allExtensions, false);
+    await this.workspace.loadComponentsExtensions(mergedExtensions);
+    const withAspects = await (0, _pMap().default)(components, component => this.executeLoadSlot(component), {
+      concurrency: (0, _concurrency().concurrentComponentsLimit)()
+    });
+
+    // const withAspects = await Promise.all(
+    //   components.map((component) => {
+    //     return this.executeLoadSlot(component);
+    //   })
+    // );
+    await this.warnAboutMisconfiguredEnvs(withAspects);
+    // It's important to load the workspace components as aspects here
+    // otherwise the envs from the workspace won't be loaded at time
+    // so we will get wrong dependencies from component who uses envs from the workspace
+    if (loadOpts.loadSeedersAsAspects) {
+      await this.loadCompsAsAspects(workspaceComponents.concat(scopeComponents), {
+        loadApps: true,
+        loadEnvs: true,
+        loadAspects: loadOpts.aspects,
+        core: loadOpts.core,
+        seeders: loadOpts.seeders,
+        idsToNotLoadAsAspects: loadOpts.idsToNotLoadAsAspects
+      });
+    }
+    return {
+      components: withAspects,
+      invalidComponents
+    };
+  }
+
+  // TODO: this is similar to scope.main.runtime loadCompAspects func, we should merge them.
+  async loadCompsAsAspects(components, opts = {
+    loadApps: true,
+    loadEnvs: true,
+    loadAspects: true
+  }) {
+    const aspectIds = [];
+    components.forEach(component => {
+      var _opts$idsToNotLoadAsA, _appData$data, _envsData$data, _envsData$data2, _envsData$data3, _envsData$data4;
+      const firstTimeToLoad = this.componentLoadedSelfAsAspects.get(component.id.toString()) === undefined;
+      const excluded = (_opts$idsToNotLoadAsA = opts.idsToNotLoadAsAspects) === null || _opts$idsToNotLoadAsA === void 0 ? void 0 : _opts$idsToNotLoadAsA.includes(component.id.toString());
+      const isCore = this.aspectLoader.isCoreAspect(component.id.toStringWithoutVersion());
+      const alreadyLoaded = this.aspectLoader.isAspectLoaded(component.id.toString());
+      const skipLoading = excluded || isCore || alreadyLoaded || !firstTimeToLoad;
+      if (skipLoading) {
+        return;
+      }
+      const idStr = component.id.toString();
+      const appData = component.state.aspects.get('teambit.harmony/application');
+      if (opts.loadApps && appData !== null && appData !== void 0 && (_appData$data = appData.data) !== null && _appData$data !== void 0 && _appData$data.appName) {
+        aspectIds.push(idStr);
+        this.componentLoadedSelfAsAspects.set(idStr, true);
+      }
+      const envsData = component.state.aspects.get(_envs().EnvsAspect.id);
+      if (opts.loadEnvs && (envsData !== null && envsData !== void 0 && (_envsData$data = envsData.data) !== null && _envsData$data !== void 0 && _envsData$data.services || envsData !== null && envsData !== void 0 && (_envsData$data2 = envsData.data) !== null && _envsData$data2 !== void 0 && _envsData$data2.self || (envsData === null || envsData === void 0 || (_envsData$data3 = envsData.data) === null || _envsData$data3 === void 0 ? void 0 : _envsData$data3.type) === 'env')) {
+        aspectIds.push(idStr);
+        this.componentLoadedSelfAsAspects.set(idStr, true);
+      }
+      if (opts.loadAspects && (envsData === null || envsData === void 0 || (_envsData$data4 = envsData.data) === null || _envsData$data4 === void 0 ? void 0 : _envsData$data4.type) === 'aspect') {
+        aspectIds.push(idStr);
+        this.componentLoadedSelfAsAspects.set(idStr, true);
+      }
+    });
+    if (!aspectIds.length) return;
+    try {
+      await this.workspace.loadAspects(aspectIds, true, 'self loading aspects', {});
+    } catch (err) {
+      this.logger.warn(`failed loading components as aspects for components ${aspectIds.join(', ')}`, err);
+      // we ignore that errors at the moment
+    }
+  }
+  async populateScopeAndExtensionsCache(ids, workspaceScopeIdsMap) {
+    return (0, _pMapSeries().default)(ids, async id => {
+      const idStr = id.toString();
+      let componentFromScope;
+      if (!this.scopeComponentsCache.has(idStr)) {
+        try {
+          // Do not import automatically if it's missing, it will throw an error later
+          componentFromScope = await this.workspace.scope.get(id, undefined, false);
+          if (componentFromScope) {
+            this.scopeComponentsCache.set(idStr, componentFromScope);
+          }
+          // This is fine here, as it will be handled later in the process
+        } catch (err) {
+          const wsAspectLoader = this.workspace.getWorkspaceAspectsLoader();
+          wsAspectLoader.throwWsJsoncAspectNotFoundError(err);
+          this.logger.warn(`populateScopeAndExtensionsCache - failed loading component ${idStr} from scope`, err);
+        }
+      }
+      if (!this.componentsExtensionsCache.has(idStr) && workspaceScopeIdsMap.workspaceIds.has(idStr)) {
+        componentFromScope = componentFromScope || this.scopeComponentsCache.get(idStr);
+        const {
+          extensions,
+          errors
+        } = await this.workspace.componentExtensions(id, componentFromScope, undefined, {
+          loadExtensions: false
+        });
+        this.componentsExtensionsCache.set(idStr, {
+          extensions,
+          errors
+        });
+      }
+    });
+  }
+  async warnAboutMisconfiguredEnvs(components) {
+    const allIds = (0, _lodash().uniq)(components.map(component => this.envs.getEnvId(component)));
+    return Promise.all(allIds.map(envId => this.workspace.warnAboutMisconfiguredEnv(envId)));
+  }
+  async groupAndUpdateIds(ids, existingGroups) {
+    const result = existingGroups || {
+      scopeIds: new Map(),
+      workspaceIds: new Map()
+    };
+    await Promise.all(ids.map(async componentId => {
+      const inWs = await this.isInWsIncludeDeleted(componentId);
+      if (!inWs) {
+        result.scopeIds.set(componentId.toString(), componentId);
+        return undefined;
+      }
+      const resolvedVersions = this.resolveVersion(componentId);
+      result.workspaceIds.set(resolvedVersions.toString(), resolvedVersions);
+      return undefined;
+    }));
+    return result;
+  }
+  async isInWsIncludeDeleted(componentId) {
+    const nonDeletedWsIds = await this.workspace.listIds();
+    const deletedWsIds = await this.workspace.locallyDeletedIds();
+    const allWsIds = nonDeletedWsIds.concat(deletedWsIds);
+    const inWs = allWsIds.find(id => id.isEqual(componentId, {
+      ignoreVersion: !componentId.hasVersion()
+    }));
+    return !!inWs;
+  }
+  async getComponentsWithoutLoadExtensions(workspaceIds, scopeIds, loadOpts, throwOnFailure = true) {
     const invalidComponents = [];
-    const longProcessLogger = this.logger.createLongProcessLogger('loading components', ids.length);
-    const componentsP = (0, _pMapSeries().default)(idsWithoutEmpty, async id => {
-      longProcessLogger.logProgress(id.toString());
-      return this.get(id, undefined, undefined, undefined, loadOpts).catch(err => {
+    const errors = [];
+    const loadOptsWithDefaults = Object.assign(
+    // We don't want to load extension or execute the load slot at this step
+    // we will do it later
+    // this important for better performance
+    // We don't want to store deps in fs cache, as at this point extensions are not loaded yet
+    // so it might save a wrong deps into the cache
+    {
+      loadExtensions: false,
+      executeLoadSlot: false
+    }, loadOpts || {});
+    const idsIndex = {};
+    workspaceIds.forEach(id => {
+      idsIndex[id.toString()] = id;
+    });
+    const {
+      components: legacyComponents,
+      invalidComponents: legacyInvalidComponents,
+      removedComponents
+    } = await this.workspace.consumer.loadComponents(_componentId().ComponentIdList.fromArray(workspaceIds), false, loadOptsWithDefaults);
+    const allLegacyComponents = legacyComponents.concat(removedComponents);
+    legacyInvalidComponents.forEach(invalidComponent => {
+      const entry = {
+        id: idsIndex[invalidComponent.id.toString()],
+        err: invalidComponent.error
+      };
+      if (_component2().default.isComponentInvalidByErrorType(invalidComponent.error)) {
+        if (throwOnFailure) throw invalidComponent.error;
+        invalidComponents.push(entry);
+      }
+      if (this.isComponentNotExistsError(invalidComponent.error) || invalidComponent.error instanceof _componentNotFoundInPath().default) {
+        errors.push(entry);
+      }
+    });
+    const getWithCatch = (id, legacyComponent) => {
+      return this.get(id, legacyComponent, undefined, undefined, loadOptsWithDefaults).catch(err => {
         if (_component2().default.isComponentInvalidByErrorType(err) && !throwOnFailure) {
           invalidComponents.push({
             id,
@@ -163,19 +537,49 @@ class WorkspaceComponentLoader {
         }
         throw err;
       });
+    };
+
+    // await this.getConsumerComponent(id, loadOpts)
+    const componentsP = (0, _pMap().default)(allLegacyComponents, legacyComponent => {
+      // const componentsP = Promise.all(
+      //   allLegacyComponents.map(async (legacyComponent) => {
+      let id = idsIndex[legacyComponent.id.toString()];
+      if (!id) {
+        const withoutVersion = idsIndex[legacyComponent.id.toStringWithoutVersion()] || legacyComponent.id;
+        if (withoutVersion) {
+          id = withoutVersion.changeVersion(legacyComponent.id.version);
+          idsIndex[legacyComponent.id.toString()] = id;
+        }
+      }
+      return getWithCatch(id, legacyComponent);
+    }, {
+      concurrency: (0, _concurrency().concurrentComponentsLimit)()
     });
-    const components = await componentsP;
     errors.forEach(err => {
       this.logger.console(`failed loading component ${err.id.toString()}, see full error in debug.log file`);
       this.logger.warn(`failed loading component ${err.id.toString()}`, err.err);
     });
-    // remove errored components
-    const filteredComponents = (0, _lodash().compact)(components);
-    longProcessLogger.end();
-    return {
-      components: filteredComponents,
-      invalidComponents
-    };
+    const components = (0, _lodash().compact)(await componentsP);
+
+    // Here we need to load many, otherwise we will get wrong overrides dependencies data
+    // as when loading the next batch of components (next group) we won't have the envs loaded
+
+    try {
+      // We don't want to load envs as part of this step, they will be loaded later
+      const scopeComponents = await this.workspace.scope.loadMany(scopeIds, undefined, {
+        loadApps: false,
+        loadEnvs: false
+      });
+      return {
+        workspaceComponents: components,
+        scopeComponents,
+        invalidComponents
+      };
+    } catch (err) {
+      const wsAspectLoader = this.workspace.getWorkspaceAspectsLoader();
+      wsAspectLoader.throwWsJsoncAspectNotFoundError(err);
+      throw err;
+    }
   }
   async getInvalid(ids) {
     const idsWithoutEmpty = (0, _lodash().compact)(ids);
@@ -198,20 +602,30 @@ class WorkspaceComponentLoader {
     });
     return errors;
   }
-  async get(componentId, legacyComponent, useCache = true, storeInCache = true, loadOpts) {
-    const bitIdWithVersion = (0, _utils().getLatestVersionNumber)(this.workspace.consumer.bitmapIdsFromCurrentLaneIncludeRemoved, componentId);
-    const id = bitIdWithVersion.version ? componentId.changeVersion(bitIdWithVersion.version) : componentId;
-    const fromCache = this.getFromCache(id, loadOpts);
+  async get(componentId, legacyComponent, useCache = true, storeInCache = true, loadOpts, getOpts = {
+    resolveIdVersion: true
+  }) {
+    const loadOptsWithDefaults = Object.assign({
+      loadExtensions: true,
+      executeLoadSlot: true
+    }, loadOpts || {});
+    const id = getOpts !== null && getOpts !== void 0 && getOpts.resolveIdVersion ? this.resolveVersion(componentId) : componentId;
+    const fromCache = this.getFromCache(componentId, loadOptsWithDefaults);
     if (fromCache && useCache) {
       return fromCache;
     }
-    const consumerComponent = legacyComponent || (await this.getConsumerComponent(id, loadOpts));
+    let consumerComponent = legacyComponent;
+    const inWs = await this.isInWsIncludeDeleted(componentId);
+    if (inWs && !consumerComponent) {
+      consumerComponent = await this.getConsumerComponent(id, loadOptsWithDefaults);
+    }
+
     // in case of out-of-sync, the id may changed during the load process
     const updatedId = consumerComponent ? consumerComponent.id : id;
-    const component = await this.loadOne(updatedId, consumerComponent, loadOpts);
+    const component = await this.loadOne(updatedId, consumerComponent, loadOptsWithDefaults);
     if (storeInCache) {
       this.addMultipleEnvsIssueIfNeeded(component); // it's in storeInCache block, otherwise, it wasn't fully loaded
-      this.saveInCache(component, loadOpts);
+      this.saveInCache(component, loadOptsWithDefaults);
     }
     return component;
   }
@@ -225,6 +639,11 @@ class WorkspaceComponentLoader {
       throw err;
     }
   }
+  resolveVersion(componentId) {
+    const bitIdWithVersion = (0, _utils().getLatestVersionNumber)(this.workspace.consumer.bitmapIdsFromCurrentLaneIncludeRemoved, componentId);
+    const id = bitIdWithVersion.version ? componentId.changeVersion(bitIdWithVersion.version) : componentId;
+    return id;
+  }
   addMultipleEnvsIssueIfNeeded(component) {
     const envs = this.envs.getAllEnvsConfiguredOnComponent(component);
     const envIds = (0, _lodash().uniq)(envs.map(env => env.id));
@@ -235,6 +654,9 @@ class WorkspaceComponentLoader {
   }
   clearCache() {
     this.componentsCache.deleteAll();
+    this.scopeComponentsCache.deleteAll();
+    this.componentsExtensionsCache.deleteAll();
+    this.componentLoadedSelfAsAspects.deleteAll();
   }
   clearComponentCache(id) {
     const idStr = id.toString();
@@ -245,15 +667,19 @@ class WorkspaceComponentLoader {
     }
   }
   async loadOne(id, consumerComponent, loadOpts) {
-    const componentFromScope = await this.workspace.scope.get(id);
+    const idStr = id.toString();
+    const componentFromScope = this.scopeComponentsCache.has(idStr) ? this.scopeComponentsCache.get(idStr) : await this.workspace.scope.get(id);
     if (!consumerComponent) {
       if (!componentFromScope) throw new (_exceptions().MissingBitMapComponent)(id.toString());
       return componentFromScope;
     }
+    const extErrorsFromCache = this.componentsExtensionsCache.has(idStr) ? this.componentsExtensionsCache.get(idStr) : undefined;
     const {
       extensions,
       errors
-    } = await this.workspace.componentExtensions(id, componentFromScope);
+    } = extErrorsFromCache || (await this.workspace.componentExtensions(id, componentFromScope, undefined, {
+      loadExtensions: loadOpts === null || loadOpts === void 0 ? void 0 : loadOpts.loadExtensions
+    }));
     if (errors !== null && errors !== void 0 && errors.some(err => err instanceof _mergeConfigConflict().MergeConfigConflict)) {
       consumerComponent.issues.getOrCreate(_componentIssues().IssuesClasses.MergeConfigHasConflict).data = true;
     }
@@ -267,10 +693,17 @@ class WorkspaceComponentLoader {
       // componentFromScope.state = state;
       // const workspaceComponent = WorkspaceComponent.fromComponent(componentFromScope, this.workspace);
       const workspaceComponent = new (_workspaceComponent().WorkspaceComponent)(componentFromScope.id, componentFromScope.head, state, componentFromScope.tags, this.workspace);
-      const updatedComp = await this.executeLoadSlot(workspaceComponent, loadOpts);
-      return updatedComp;
+      if (loadOpts !== null && loadOpts !== void 0 && loadOpts.executeLoadSlot) {
+        return this.executeLoadSlot(workspaceComponent, loadOpts);
+      }
+      // const updatedComp = await this.executeLoadSlot(workspaceComponent, loadOpts);
+      return workspaceComponent;
     }
-    return this.executeLoadSlot(this.newComponentFromState(id, state), loadOpts);
+    const newComponent = this.newComponentFromState(id, state);
+    if (!(loadOpts !== null && loadOpts !== void 0 && loadOpts.executeLoadSlot)) {
+      return newComponent;
+    }
+    return this.executeLoadSlot(newComponent, loadOpts);
   }
   saveInCache(component, loadOpts) {
     const cacheKey = createComponentCacheKey(component.id, loadOpts);
@@ -284,9 +717,19 @@ class WorkspaceComponentLoader {
    * as a result, when out-of-sync is happening and the id is changed to include scope-name in the
    * legacy-id, the component is the cache has the old id.
    */
-  getFromCache(id, loadOpts) {
+  getFromCache(componentId, loadOpts) {
+    const bitIdWithVersion = this.resolveVersion(componentId);
+    const id = bitIdWithVersion.version ? componentId.changeVersion(bitIdWithVersion.version) : componentId;
     const cacheKey = createComponentCacheKey(id, loadOpts);
-    const fromCache = this.componentsCache.get(cacheKey);
+    // If we try to look for the cache without load extensions/ without execute load slot
+    // but there is an entry after the load, we want to use it as well.
+    // as we want the component, so if we already loaded it with everything, it's fine.
+    // this sometime relevant for cases with tiny cache size (during tag)
+    const cacheKeyWithTrueLoadOpts = createComponentCacheKey(id, {
+      loadExtensions: true,
+      executeLoadSlot: true
+    });
+    const fromCache = this.componentsCache.get(cacheKey) || this.componentsCache.get(cacheKeyWithTrueLoadOpts);
     if (fromCache && fromCache.id.isEqual(id)) {
       return fromCache;
     }
@@ -372,7 +815,8 @@ class WorkspaceComponentLoader {
 }
 exports.WorkspaceComponentLoader = WorkspaceComponentLoader;
 function createComponentCacheKey(id, loadOpts) {
-  return `${id.toString()}:${JSON.stringify(sortKeys(loadOpts ?? {}))}`;
+  const relevantOpts = (0, _lodash().pick)(loadOpts, ['loadExtensions', 'executeLoadSlot']);
+  return `${id.toString()}:${JSON.stringify(sortKeys(relevantOpts ?? {}))}`;
 }
 function sortKeys(obj) {
   return (0, _lodash().fromPairs)(Object.entries(obj).sort(([k1], [k2]) => k1.localeCompare(k2)));