@teambit/workspace 0.0.598 → 0.0.605

package/dist/workspace.js

@@ -1017,6 +1017,14 @@ class Workspace {
   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.
@@ -1218,19 +1226,15 @@ class Workspace {
   }
   /**
    * Calculate the component config based on:
+   * the config property in the .bitmap file
    * the component.json file in the component folder
    * matching pattern in the variants config
    * defaults extensions from workspace config
-   *
-   * @param {ComponentID} componentId
-   * @param {Component} [componentFromScope]
-   * @returns {Promise<ExtensionDataList>}
-   * @memberof Workspace
    */
 
 
   async componentExtensions(componentId, componentFromScope) {
-    var _componentFromScope$c, _componentConfigFile$, _variantConfig$propag;
+    var _componentFromScope$c, _componentConfigFile$, _variantConfig$propag, _wsDefaultExtensions;
 
     // TODO: consider caching this result
     let configFileExtensions;
@@ -1270,54 +1274,83 @@ class Workspace {
 
 
     const extensionsToMerge = [];
+    let envWasFoundPreviously = false;
+
+    const addAndLoadExtensions = async extensions => {
+      const extsWithoutRemoved = extensions.filterRemovedExtensions();
+      const selfInMergedExtensions = extsWithoutRemoved.findExtension(componentId._legacy.toStringWithoutScopeAndVersion(), true, true);
+      const extsWithoutSelf = selfInMergedExtensions !== null && selfInMergedExtensions !== void 0 && selfInMergedExtensions.extensionId ? extsWithoutRemoved.remove(selfInMergedExtensions.extensionId) : extsWithoutRemoved;
+      await this.loadExtensions(extsWithoutSelf);
+      const {
+        extensionDataListFiltered,
+        envIsCurrentlySet
+      } = this.filterEnvsFromExtensionsIfNeeded(extsWithoutSelf, envWasFoundPreviously);
+      if (envIsCurrentlySet) envWasFoundPreviously = true;
+      extensionsToMerge.push(extensionDataListFiltered);
+    };
 
     if (bitMapExtensions) {
       const extensionsDataEntries = Object.keys(bitMapExtensions).map(aspectId => new (_extensionData().ExtensionDataEntry)(aspectId, undefined, aspectId, bitMapExtensions[aspectId]));
       const extensionDataList = new (_extensionData().ExtensionDataList)(...extensionsDataEntries);
-      extensionsToMerge.push(extensionDataList);
+      await addAndLoadExtensions(extensionDataList);
     }
 
     if (configFileExtensions) {
-      extensionsToMerge.push(configFileExtensions);
+      await addAndLoadExtensions(configFileExtensions);
     }
 
     let continuePropagating = (_componentConfigFile$ = componentConfigFile === null || componentConfigFile === void 0 ? void 0 : componentConfigFile.propagate) !== null && _componentConfigFile$ !== void 0 ? _componentConfigFile$ : true;
 
     if (variantsExtensions && continuePropagating) {
       // Put it in the start to make sure the config file is stronger
-      extensionsToMerge.push(variantsExtensions);
+      await addAndLoadExtensions(variantsExtensions);
     }
 
     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.findExtension(componentId.toString(), true, true);
+    const isDefaultExtension = (_wsDefaultExtensions = wsDefaultExtensions) === null || _wsDefaultExtensions === void 0 ? void 0 : _wsDefaultExtensions.findExtension(componentId.toString(), true, true);
 
     if (wsDefaultExtensions && continuePropagating && !isDefaultExtension) {
       // Put it in the start to make sure the config file is stronger
-      extensionsToMerge.push(wsDefaultExtensions);
+      await addAndLoadExtensions(wsDefaultExtensions);
     } // It's before the scope extensions, since there is no need to resolve extensions from scope they are already resolved
     // await Promise.all(extensionsToMerge.map((extensions) => this.resolveExtensionsList(extensions)));
 
 
     if (mergeFromScope && continuePropagating) {
-      extensionsToMerge.push(scopeExtensions);
+      await addAndLoadExtensions(scopeExtensions);
     } // 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
 
 
-    const promises = extensionsToMerge.map(list => this.resolveExtensionListIds(list));
-    await Promise.all(promises);
-
-    let mergedExtensions = _extensionData().ExtensionDataList.mergeConfigs(extensionsToMerge).filterRemovedExtensions(); // remove self from merged extensions
-
+    await Promise.all(extensionsToMerge.map(list => this.resolveExtensionListIds(list)));
+    return _extensionData().ExtensionDataList.mergeConfigs(extensionsToMerge);
+  }
 
-    const selfInMergedExtensions = mergedExtensions.findExtension(componentId._legacy.toStringWithoutScopeAndVersion(), true, true);
+  filterEnvsFromExtensionsIfNeeded(extensionDataList, envWasFoundPreviously) {
+    const envAspect = extensionDataList.findExtension(_envs().EnvsAspect.id);
+    const envFromEnvsAspect = envAspect === null || envAspect === void 0 ? void 0 : envAspect.config.env;
+    const [envsNotFromEnvsAspect, nonEnvs] = (0, _lodash().partition)(extensionDataList, ext => this.envs.isEnvRegistered(ext.stringId));
+    const extensionDataListFiltered = new (_extensionData().ExtensionDataList)(...nonEnvs);
+    const envIsCurrentlySet = envFromEnvsAspect || envsNotFromEnvsAspect.length;
+    const shouldIgnoreCurrentEnv = envIsCurrentlySet && envWasFoundPreviously;
 
-    if (selfInMergedExtensions && selfInMergedExtensions.extensionId) {
-      mergedExtensions = mergedExtensions.remove(selfInMergedExtensions.extensionId);
+    if (shouldIgnoreCurrentEnv) {
+      // still, aspect env may have other data other then config.env.
+      if (envAspect) {
+        delete envAspect.config.env;
+        extensionDataListFiltered.push(envAspect);
+      }
+    } else {
+      // add the envs
+      if (envAspect) extensionDataListFiltered.push(envAspect);
+      extensionDataListFiltered.push(...envsNotFromEnvsAspect);
     }
 
-    return mergedExtensions;
+    return {
+      extensionDataListFiltered,
+      envIsCurrentlySet
+    };
   }
 
   async triggerOnPreWatch(componentIds, watchOpts) {
@@ -2191,6 +2224,51 @@ your workspace.jsonc has this component-id set. you might want to remove/change
       dedupe: true
     });
   }
+  /**
+   * configure an environment to the given components in the .bitmap file, this configuration overrides other, such as
+   * overrides in workspace.jsonc.
+   */
+
+
+  async setEnvToComponents(envId, components) {
+    const envIdStr = envId.toString();
+    components.forEach(component => {
+      this.bitMap.addComponentConfig(component.id, envIdStr);
+      this.bitMap.addComponentConfig(component.id, _envs().EnvsAspect.id, {
+        env: envIdStr
+      });
+    });
+    await this.bitMap.write();
+  }
+  /**
+   * remove env configuration from the .bitmap file, so then other configuration, such as "variants" will take place
+   */
+
+
+  async unsetEnvFromComponents(components) {
+    const changed = [];
+    const unchanged = [];
+    components.forEach(comp => {
+      var _bitMapEntry$config, _bitMapEntry$config$E;
+
+      const bitMapEntry = this.bitMap.getBitmapEntry(comp.id);
+      const currentEnv = (_bitMapEntry$config = bitMapEntry.config) === null || _bitMapEntry$config === void 0 ? void 0 : (_bitMapEntry$config$E = _bitMapEntry$config[_envs().EnvsAspect.id]) === null || _bitMapEntry$config$E === void 0 ? void 0 : _bitMapEntry$config$E.env;
+
+      if (!currentEnv) {
+        unchanged.push(comp.id);
+        return;
+      }
+
+      this.bitMap.removeComponentConfig(comp.id, currentEnv);
+      this.bitMap.removeComponentConfig(comp.id, _envs().EnvsAspect.id);
+      changed.push(comp.id);
+    });
+    await this.bitMap.write();
+    return {
+      changed,
+      unchanged
+    };
+  }
 
 }
 /**