@teambit/snapping 1.0.1235 → 1.0.1237

package/dist/snapping.main.runtime.js

@@ -194,12 +194,19 @@ function _dependencyResolver() {
   return data;
 }
 function _legacy6() {
-  const data = require("@teambit/legacy.extension-data");
+  const data = require("@teambit/legacy.consumer-config");
   _legacy6 = function () {
     return data;
   };
   return data;
 }
+function _legacy7() {
+  const data = require("@teambit/legacy.extension-data");
+  _legacy7 = function () {
+    return data;
+  };
+  return data;
+}
 function _builder() {
   const data = require("@teambit/builder");
   _builder = function () {
@@ -312,9 +319,9 @@ function _application() {
   };
   return data;
 }
-function _legacy7() {
+function _legacy8() {
   const data = require("@teambit/legacy.scope-api");
-  _legacy7 = function () {
+  _legacy8 = function () {
     return data;
   };
   return data;
@@ -501,10 +508,10 @@ class SnappingMain {
   }
   async addAspectsFromConfigObject(component, configObject) {
     if (!configObject) return;
-    _legacy6().ExtensionDataList.adjustEnvsOnConfigObject(configObject);
-    const extensionsFromConfigObject = _legacy6().ExtensionDataList.fromConfigObject(configObject);
+    _legacy7().ExtensionDataList.adjustEnvsOnConfigObject(configObject);
+    const extensionsFromConfigObject = _legacy7().ExtensionDataList.fromConfigObject(configObject);
     const consumerComponent = component.state._consumer;
-    const extensionDataList = _legacy6().ExtensionDataList.mergeConfigs([extensionsFromConfigObject, consumerComponent.extensions]).filterRemovedExtensions();
+    const extensionDataList = _legacy7().ExtensionDataList.mergeConfigs([extensionsFromConfigObject, consumerComponent.extensions]).filterRemovedExtensions();
 
     // Restore data fields from the original extensions after merging configs.
     // configObject contains only config (from the merged config result), it has no data.
@@ -525,6 +532,49 @@ class SnappingMain {
     const autoDeps = extensionsFromConfigObject.extractAutoDepsFromConfig();
     return autoDeps;
   }
+
+  /**
+   * re-calculate the dependencies policy of the component and its overrides from its config and env, the same way a
+   * workspace calculates them when it loads a component, rather than keeping the ones of the version it was loaded from.
+   * returns the policy and the overrides of the auto-detected dependencies (versions only, see
+   * ApplyOverrides.autoDetectOverrides), which include the deps of the merge-config, same as
+   * workspace.getAutoDetectOverrides().
+   */
+  async recalcDependenciesPolicy(component, componentsInSnap, mergeConfigAutoDeps) {
+    const legacyComponent = component.state._consumer;
+    const {
+      extensions
+    } = legacyComponent;
+    const depResolverExt = extensions.findCoreExtension(_dependencyResolver().DependencyResolverAspect.id);
+    // an env that defines its policy in code is loaded only when it changed: a changed env is a changed (or missing)
+    // extension, which mergeExtensionsData() reports as a data conflict (see loadAspectOnlyForIds). when it's not
+    // loaded, it didn't change, so the env part of the stored policy is still valid. (the other parts, such as the
+    // policies of aspects and the config, are calculated by mergeVariantPolicies() from the current config)
+    const storedPolicy = _dependencyResolver().VariantPolicy.parse(depResolverExt?.data.policy || []);
+    const storedEnvPolicy = storedPolicy.filter(entry => entry.source === 'env');
+    // an env.jsonc env that is snapped along (e.g. merged as well) has its policy in its new files, like a workspace
+    // that loads the env from its files. otherwise, the policy is read from the stored version of the env.
+    const envPolicy = (await this.dependencyResolver.getEnvPolicyFromComponents(extensions, componentsInSnap)) ?? (await this.dependencyResolver.getComponentEnvPolicyFromExtension(extensions, storedEnvPolicy));
+    // when the component is an env, its own policy (its own peers) is calculated from its env.jsonc or from the loaded
+    // env. same as above, an env that defines it in code and is not loaded didn't change, so the stored one is valid.
+    const envExtendsDeps = legacyComponent.dependencies.get();
+    const storedEnvOwnPolicy = storedPolicy.filter(entry => entry.source === 'env-own');
+    const isEnvOwnPolicyMissing = storedEnvOwnPolicy.length > 0 && !(await this.dependencyResolver.getPoliciesFromEnvForItself(component.id, legacyComponent.files, envExtendsDeps));
+    const policy = await this.dependencyResolver.mergeVariantPolicies(extensions, component.id, legacyComponent.files, envExtendsDeps,
+    // merged right after the env policy, same as mergeVariantPolicies() merges a calculated own policy
+    isEnvOwnPolicyMissing ? _dependencyResolver().VariantPolicy.mergePolices([envPolicy, storedEnvOwnPolicy]) : envPolicy);
+    // the "source" of each dependency in the dependency-resolver data is determined by this policy
+    if (depResolverExt) depResolverExt.data.policy = policy.serialize();
+    legacyComponent.overrides = new (_legacy6().ComponentOverrides)((0, _lodash().pickBy)(policy.toLegacyDepsOverrides(), val => !(0, _lodash().isEmpty)(val)));
+    const mergeConfigPolicy = _dependencyResolver().VariantPolicy.fromConfigObject(mergeConfigAutoDeps || {}, {
+      source: 'auto'
+    });
+    const autoDetectOverrides = _dependencyResolver().VariantPolicy.mergePolices([policy, mergeConfigPolicy]).toLegacyAutoDetectOverrides();
+    return {
+      policy,
+      autoDetectOverrides
+    };
+  }
   async snapFromScope(snapDataPerCompRaw, params) {
     if (this.workspace) {
       throw new (_bitError().BitError)(`unable to run this command from a workspace, please create a new bare-scope and run it from there`);
@@ -536,7 +586,7 @@ class SnappingMain {
       try {
         lane = await this.importer.importLaneObject(laneId);
       } catch (err) {
-        if (err.constructor.name !== _legacy7().LaneNotFound.name) throw err;
+        if (err.constructor.name !== _legacy8().LaneNotFound.name) throw err;
         // if the lane is not found, it's probably because it's new. create a new lane.
         lane = await (0, _lanesModules().createLaneInScope)(laneId.name, this.scope, laneId.scope);
         // it's important to set the lane as new in scope.json. otherwise, later, when importing and the lane is loaded
@@ -628,13 +678,20 @@ class SnappingMain {
       });
     }
     const components = [...existingComponents, ...newComponents];
-
+    const autoDepsPerComp = new Map();
+    const addDepsToComp = (component, autoDetectOverrides) => (0, _generateCompFromScope().addDeps)(component, getSnapData(component.id), this.scope, this.deps, this.dependencyResolver, this, autoDepsPerComp.get(component), autoDetectOverrides);
     // this must be done before we load component aspects later on, because this updated deps may update aspects.
     await (0, _pMapSeries().default)(components, async component => {
       const snapData = getSnapData(component.id);
-      const autoDeps = await this.addAspectsFromConfigObject(component, snapData.aspects);
+      autoDepsPerComp.set(component, await this.addAspectsFromConfigObject(component, snapData.aspects));
+      if (params.recalcDependencies) {
+        // the dependencies are added once the aspects are loaded, see below. only update the versions of aspects that
+        // are part of the snap (e.g. an env merged into the lane), so the correct versions get loaded.
+        await this.updateAspectsVersions(component, snapData.dependencies);
+        return;
+      }
       // adds explicitly defined dependencies and dependencies from envs/aspects (overrides)
-      await (0, _generateCompFromScope().addDeps)(component, snapData, this.scope, this.deps, this.dependencyResolver, this, autoDeps);
+      await addDepsToComp(component);
     });
 
     // for new components these are not needed. coz when generating them we already add the aspects and the files.
@@ -670,9 +727,22 @@ class SnappingMain {
     } = params;
     const compsToLoadAspects = loadAspectOnlyForIds ? components.filter(c => loadAspectOnlyForIds.hasWithoutVersion(c.id)) : components;
     await this.scope.loadManyCompsAspects(compsToLoadAspects);
+    const policyPerComp = new Map();
+    if (params.recalcDependencies) {
+      // the config (and with it, the env) may differ from the one stored in the version the components were loaded
+      // from. now that the env is loaded, the dependencies are calculated according to it.
+      await (0, _pMapSeries().default)(components, async component => {
+        const {
+          policy,
+          autoDetectOverrides
+        } = await this.recalcDependenciesPolicy(component, components, autoDepsPerComp.get(component));
+        policyPerComp.set(component, policy);
+        await addDepsToComp(component, autoDetectOverrides);
+      });
+    }
 
     // this is similar to what happens in the workspace. the "onLoad" is running and populating the "data" of the aspects.
-    await (0, _pMapSeries().default)(compsToLoadAspects, async comp => this.scope.executeOnCompAspectReCalcSlot(comp));
+    await (0, _pMapSeries().default)(compsToLoadAspects, async comp => this.scope.executeOnCompAspectReCalcSlot(comp, policyPerComp.get(comp)));
     const ids = _componentId().ComponentIdList.fromArray(allCompIds);
     const shouldTag = Boolean(params.tag);
     const makeVersionParams = _objectSpread(_objectSpread({}, params), {}, {
@@ -1460,8 +1530,11 @@ another option, in case this dependency is not in main yet is to remove all refe
     const updatedIds = _componentId().ComponentIdList.fromArray([...currentBitIds, ...dependencies]);
     const componentIdStr = component.id.toString();
     const legacyComponent = component.state._consumer;
-    const deps = [...legacyComponent.dependencies.get(), ...legacyComponent.devDependencies.get()];
-    const dependenciesList = this.dependencyResolver.getDependencies(component);
+    const deps = [...legacyComponent.dependencies.get(), ...legacyComponent.devDependencies.get(), ...legacyComponent.peerDependencies.get()];
+    // peers can be hidden, and they're part of the legacy peers
+    const dependenciesList = this.dependencyResolver.getDependencies(component, {
+      includeHidden: true
+    });
     deps.forEach(dep => {
       const updatedBitId = updatedIds.searchWithoutVersion(dep.id);
       if (updatedBitId) {
@@ -1484,6 +1557,22 @@ another option, in case this dependency is not in main yet is to remove all refe
    * 2. save all dependencies data from the legacy into DependencyResolver aspect.
    */
   async UpdateDepsAspectsSaveIntoDepsResolver(component, updatedIds) {
+    await this.updateAspectsVersions(component, updatedIds);
+    const dependenciesListSerialized = (await this.dependencyResolver.extractDepsFromLegacy(component)).serialize();
+    const extId = _dependencyResolver().DependencyResolverAspect.id;
+    const data = {
+      dependencies: dependenciesListSerialized
+    };
+    const existingExtension = component.config.extensions.findExtension(extId);
+    if (existingExtension) {
+      // Only merge top level of extension data
+      Object.assign(existingExtension.data, data);
+      return;
+    }
+    const extension = new (_legacy7().ExtensionDataEntry)(undefined, undefined, extId, undefined, data);
+    component.config.extensions.push(extension);
+  }
+  async updateAspectsVersions(component, updatedIds) {
     const legacyComponent = component.state._consumer;
     legacyComponent.extensions.forEach(ext => {
       const extId = ext.extensionId;
@@ -1497,19 +1586,6 @@ another option, in case this dependency is not in main yet is to remove all refe
       }
     });
     component.state.aspects = await this.scope.createAspectListFromExtensionDataList(legacyComponent.extensions);
-    const dependenciesListSerialized = (await this.dependencyResolver.extractDepsFromLegacy(component)).serialize();
-    const extId = _dependencyResolver().DependencyResolverAspect.id;
-    const data = {
-      dependencies: dependenciesListSerialized
-    };
-    const existingExtension = component.config.extensions.findExtension(extId);
-    if (existingExtension) {
-      // Only merge top level of extension data
-      Object.assign(existingExtension.data, data);
-      return;
-    }
-    const extension = new (_legacy6().ExtensionDataEntry)(undefined, undefined, extId, undefined, data);
-    component.config.extensions.push(extension);
   }
 
   /**