@teambit/config-merger 0.0.1

package/dist/component-config-merger.d.ts

@@ -0,0 +1,63 @@
+import { ComponentID } from '@teambit/component-id';
+import { Logger } from '@teambit/logger';
+import { Lane } from '@teambit/legacy/dist/scope/models';
+import { ExtensionDataList } from '@teambit/legacy/dist/consumer/config/extension-data';
+import { ConfigMergeResult } from './config-merge-result';
+export declare type GenericConfigOrRemoved = Record<string, any> | '-';
+export declare const conflictIndicator = "CONFLICT::";
+export declare type MergeStrategyResult = {
+    id: string;
+    mergedConfig?: GenericConfigOrRemoved;
+    conflict?: Record<string, any>;
+};
+/**
+ * perform 3-way merge of component configuration (aspects).
+ * normally this is needed when merging one lane into another. the component may have different aspects config in each lane.
+ * the baseAspects are the aspects of the component in the diversion point (the common ancestor of the two lanes).
+ * the currentAspects are the aspects of the component in the current lane.
+ * the otherAspects are the aspects of the component in the other lane. this is the lane we merge into the current lane.
+ *
+ * the basic merging strategy is a simple comparison between the aspect-configs, if they're different, we have a conflict.
+ * we have two special cases:
+ *
+ * 1. dependency-resolver: we do a deeper check for the policy, we compare each dependency separately. also, we take
+ * into account not only the config, but also the data. this is needed because some dependencies are automatically
+ * added by Bit (from the import statements in the code) and they're not in the config. the final config has the deps
+ * from both sources, the config and the data. The way we know to differentiate between them is by the "force" prop.
+ * the config has always force: true.
+ *
+ * 2. envs: if we don't treat it specially, the user will need to make the change not only in the envs aspect, but also
+ * in the deps-resolver (because the env is added as a devDependency) and also in the aspect itself (because
+ * teambit.envs/env has only the id and not the version). to make it simpler, we ignore the envs in the deps-resolver
+ * we ignore the individual aspect that is the env itself. we only show teambit.envs/env and we put the env id and
+ * version. later, when the component is loaded, we split the id and the version and put them in the correct places.
+ * see workspace.componentExtension / adjustEnvsOnConfigMerge for more details.
+ */
+export declare class ComponentConfigMerger {
+    private compIdStr;
+    private workspaceIds;
+    private currentAspects;
+    private baseAspects;
+    private otherAspects;
+    private currentLabel;
+    private otherLabel;
+    private logger;
+    private currentEnv;
+    private otherEnv;
+    private baseEnv?;
+    private handledExtIds;
+    private otherLaneIdsStr;
+    constructor(compIdStr: string, workspaceIds: ComponentID[], otherLane: Lane | undefined, currentAspects: ExtensionDataList, baseAspects: ExtensionDataList, otherAspects: ExtensionDataList, currentLabel: string, otherLabel: string, logger: Logger);
+    merge(): ConfigMergeResult;
+    private populateEnvs;
+    private envStrategy;
+    private areConfigsEqual;
+    private mergePerStrategy;
+    private basicConfigMerge;
+    private depResolverStrategy;
+    private isIdInWorkspaceOrOtherLane;
+    private getIdFromWorkspace;
+    private isEnv;
+    private getConfig;
+    private getPolicy;
+}

package/dist/component-config-merger.js

@@ -0,0 +1,601 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.conflictIndicator = exports.ComponentConfigMerger = void 0;
+function _semver() {
+  const data = _interopRequireDefault(require("semver"));
+  _semver = function () {
+    return data;
+  };
+  return data;
+}
+function _builder() {
+  const data = _interopRequireDefault(require("@teambit/builder"));
+  _builder = function () {
+    return data;
+  };
+  return data;
+}
+function _componentVersion() {
+  const data = require("@teambit/component-version");
+  _componentVersion = function () {
+    return data;
+  };
+  return data;
+}
+function _dependencyResolver() {
+  const data = require("@teambit/dependency-resolver");
+  _dependencyResolver = function () {
+    return data;
+  };
+  return data;
+}
+function _envs() {
+  const data = require("@teambit/envs");
+  _envs = function () {
+    return data;
+  };
+  return data;
+}
+function _lodash() {
+  const data = require("lodash");
+  _lodash = function () {
+    return data;
+  };
+  return data;
+}
+function _configMergeResult() {
+  const data = require("./config-merge-result");
+  _configMergeResult = function () {
+    return data;
+  };
+  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); }
+const conflictIndicator = exports.conflictIndicator = 'CONFLICT::';
+/**
+ * perform 3-way merge of component configuration (aspects).
+ * normally this is needed when merging one lane into another. the component may have different aspects config in each lane.
+ * the baseAspects are the aspects of the component in the diversion point (the common ancestor of the two lanes).
+ * the currentAspects are the aspects of the component in the current lane.
+ * the otherAspects are the aspects of the component in the other lane. this is the lane we merge into the current lane.
+ *
+ * the basic merging strategy is a simple comparison between the aspect-configs, if they're different, we have a conflict.
+ * we have two special cases:
+ *
+ * 1. dependency-resolver: we do a deeper check for the policy, we compare each dependency separately. also, we take
+ * into account not only the config, but also the data. this is needed because some dependencies are automatically
+ * added by Bit (from the import statements in the code) and they're not in the config. the final config has the deps
+ * from both sources, the config and the data. The way we know to differentiate between them is by the "force" prop.
+ * the config has always force: true.
+ *
+ * 2. envs: if we don't treat it specially, the user will need to make the change not only in the envs aspect, but also
+ * in the deps-resolver (because the env is added as a devDependency) and also in the aspect itself (because
+ * teambit.envs/env has only the id and not the version). to make it simpler, we ignore the envs in the deps-resolver
+ * we ignore the individual aspect that is the env itself. we only show teambit.envs/env and we put the env id and
+ * version. later, when the component is loaded, we split the id and the version and put them in the correct places.
+ * see workspace.componentExtension / adjustEnvsOnConfigMerge for more details.
+ */
+class ComponentConfigMerger {
+  constructor(compIdStr, workspaceIds, otherLane, currentAspects, baseAspects, otherAspects, currentLabel, otherLabel, logger) {
+    this.compIdStr = compIdStr;
+    this.workspaceIds = workspaceIds;
+    this.currentAspects = currentAspects;
+    this.baseAspects = baseAspects;
+    this.otherAspects = otherAspects;
+    this.currentLabel = currentLabel;
+    this.otherLabel = otherLabel;
+    this.logger = logger;
+    _defineProperty(this, "currentEnv", void 0);
+    _defineProperty(this, "otherEnv", void 0);
+    _defineProperty(this, "baseEnv", void 0);
+    _defineProperty(this, "handledExtIds", [_builder().default.id]);
+    // don't try to merge builder, it's possible that at one end it wasn't built yet, so it's empty
+    _defineProperty(this, "otherLaneIdsStr", void 0);
+    this.otherLaneIdsStr = (otherLane === null || otherLane === void 0 ? void 0 : otherLane.toBitIds().map(id => id.toString())) || [];
+  }
+  merge() {
+    this.logger.debug(`\n************** start config-merger for ${this.compIdStr} **************`);
+    this.logger.debug(`currentLabel: ${this.currentLabel}`);
+    this.logger.debug(`otherLabel: ${this.otherLabel}`);
+    this.populateEnvs();
+    const results = this.currentAspects.map(currentExt => {
+      const id = currentExt.stringId;
+      if (this.handledExtIds.includes(id)) return null;
+      this.handledExtIds.push(id);
+      const baseExt = this.baseAspects.findExtension(id, true);
+      const otherExt = this.otherAspects.findExtension(id, true);
+      if (otherExt) {
+        // try to 3-way-merge
+        return this.mergePerStrategy({
+          id,
+          currentExt,
+          otherExt,
+          baseExt
+        });
+      }
+      // exist in current but not in other
+      if (baseExt) {
+        // was removed on other
+        return {
+          id,
+          conflict: {
+            currentConfig: this.getConfig(currentExt),
+            otherConfig: '-'
+          }
+        };
+      }
+      // exist in current but not in other and base, so it got created on current. nothing to do.
+      return null;
+    });
+    const otherAspectsNotHandledResults = this.otherAspects.map(otherExt => {
+      let id = otherExt.stringId;
+      if (this.handledExtIds.includes(id)) return null;
+      this.handledExtIds.push(id);
+      if (otherExt.extensionId && otherExt.extensionId.hasVersion()) {
+        // avoid using the id from the other lane if it exits in the workspace. prefer the id from the workspace.
+        const idFromWorkspace = this.getIdFromWorkspace(otherExt.extensionId.toStringWithoutVersion());
+        if (idFromWorkspace) {
+          const existingExt = this.currentAspects.findExtension(otherExt.extensionId.toStringWithoutVersion(), true);
+          if (existingExt) return null; // the aspect is set currently, no need to add it again.
+          id = idFromWorkspace._legacy.toString();
+        }
+      }
+      const baseExt = this.baseAspects.findExtension(id, true);
+      if (baseExt) {
+        // was removed on current
+        return {
+          id,
+          conflict: {
+            currentConfig: '-',
+            otherConfig: this.getConfig(otherExt)
+          }
+        };
+      }
+      // exist in other but not in current and base, so it got created on other.
+      return {
+        id,
+        mergedConfig: this.getConfig(otherExt)
+      };
+    });
+    const envResult = [this.envStrategy()] || [];
+    this.logger.debug(`*** end config-merger for ${this.compIdStr} ***\n`);
+    return new (_configMergeResult().ConfigMergeResult)(this.compIdStr, this.currentLabel, this.otherLabel, (0, _lodash().compact)([...results, ...otherAspectsNotHandledResults, ...envResult]));
+  }
+  populateEnvs() {
+    // populate ids
+    const getEnvId = ext => {
+      const envsAspect = ext.findCoreExtension(_envs().EnvsAspect.id);
+      if (!envsAspect) throw new Error(`unable to find ${_envs().EnvsAspect.id} aspect for ${this.compIdStr}`);
+      const env = envsAspect.config.env || envsAspect.data.id;
+      if (!env) throw new Error(`unable to find env for ${this.compIdStr}, the config and data of ${_envs().EnvsAspect.id} are empty}`);
+      return env;
+    };
+    const currentEnv = getEnvId(this.currentAspects);
+    this.currentEnv = {
+      id: currentEnv
+    };
+    const otherEnv = getEnvId(this.otherAspects);
+    this.otherEnv = {
+      id: otherEnv
+    };
+    const baseEnv = this.baseAspects ? getEnvId(this.baseAspects) : undefined;
+    if (baseEnv) this.baseEnv = {
+      id: baseEnv
+    };
+
+    // populate version
+    const currentEnvAspect = this.currentAspects.findExtension(currentEnv, true);
+    if (currentEnvAspect) {
+      var _currentEnvAspect$ext;
+      this.handledExtIds.push(currentEnvAspect.stringId);
+      this.currentEnv.version = (_currentEnvAspect$ext = currentEnvAspect.extensionId) === null || _currentEnvAspect$ext === void 0 ? void 0 : _currentEnvAspect$ext.version;
+      this.currentEnv.config = this.getConfig(currentEnvAspect);
+    }
+    const otherEnvAspect = this.otherAspects.findExtension(otherEnv, true);
+    if (otherEnvAspect) {
+      var _otherEnvAspect$exten;
+      this.handledExtIds.push(otherEnvAspect.stringId);
+      this.otherEnv.version = (_otherEnvAspect$exten = otherEnvAspect.extensionId) === null || _otherEnvAspect$exten === void 0 ? void 0 : _otherEnvAspect$exten.version;
+      this.otherEnv.config = this.getConfig(otherEnvAspect);
+    }
+    if (this.baseEnv) {
+      const baseEnvAspect = this.baseAspects.findExtension(baseEnv, true);
+      if (baseEnvAspect) {
+        var _baseEnvAspect$extens;
+        this.baseEnv.version = (_baseEnvAspect$extens = baseEnvAspect.extensionId) === null || _baseEnvAspect$extens === void 0 ? void 0 : _baseEnvAspect$extens.version;
+        this.baseEnv.config = this.getConfig(baseEnvAspect);
+      }
+    }
+  }
+  envStrategy() {
+    const mergeStrategyParams = {
+      id: _envs().EnvsAspect.id,
+      currentConfig: {
+        env: this.currentEnv.version ? `${this.currentEnv.id}@${this.currentEnv.version}` : this.currentEnv.id
+      },
+      otherConfig: {
+        env: this.otherEnv.version ? `${this.otherEnv.id}@${this.otherEnv.version}` : this.otherEnv.id
+      }
+    };
+    if (this.baseEnv) {
+      var _this$baseEnv, _this$baseEnv2;
+      mergeStrategyParams.baseConfig = {
+        env: (_this$baseEnv = this.baseEnv) !== null && _this$baseEnv !== void 0 && _this$baseEnv.version ? `${this.baseEnv.id}@${this.baseEnv.version}` : (_this$baseEnv2 = this.baseEnv) === null || _this$baseEnv2 === void 0 ? void 0 : _this$baseEnv2.id
+      };
+    }
+    if (this.currentEnv.id === this.otherEnv.id && this.currentEnv.version === this.otherEnv.version) {
+      return null;
+    }
+    if (this.isIdInWorkspaceOrOtherLane(this.currentEnv.id, this.otherEnv.version)) {
+      // the env currently used is part of the workspace, that's what the user needs. don't try to resolve anything.
+      return null;
+    }
+    return this.basicConfigMerge(mergeStrategyParams);
+  }
+  areConfigsEqual(configA, configB) {
+    return JSON.stringify(configA) === JSON.stringify(configB);
+  }
+  mergePerStrategy(mergeStrategyParams) {
+    const {
+      id,
+      currentExt,
+      otherExt,
+      baseExt
+    } = mergeStrategyParams;
+    const depResolverResult = this.depResolverStrategy(mergeStrategyParams);
+    if (depResolverResult) {
+      // if (depResolverResult.mergedConfig || depResolverResult?.conflict) console.log("\n\nDepResolverResult", this.compIdStr, '\n', JSON.stringify(depResolverResult, undefined, 2))
+      return depResolverResult;
+    }
+    const currentConfig = this.getConfig(currentExt);
+    const otherConfig = this.getConfig(otherExt);
+    const baseConfig = baseExt ? this.getConfig(baseExt) : undefined;
+    return this.basicConfigMerge({
+      id,
+      currentConfig,
+      otherConfig,
+      baseConfig
+    });
+  }
+  basicConfigMerge(mergeStrategyParams) {
+    const {
+      id,
+      currentConfig,
+      otherConfig,
+      baseConfig
+    } = mergeStrategyParams;
+    if (this.areConfigsEqual(currentConfig, otherConfig)) {
+      return null;
+    }
+    if (baseConfig && this.areConfigsEqual(baseConfig, otherConfig)) {
+      // was changed on current
+      return null;
+    }
+    if (baseConfig && this.areConfigsEqual(baseConfig, currentConfig)) {
+      // was changed on other
+      return {
+        id,
+        mergedConfig: otherConfig
+      };
+    }
+    // either no baseConfig, or baseConfig is also different from both: other and local. that's a conflict.
+    return {
+      id,
+      conflict: {
+        currentConfig,
+        otherConfig,
+        baseConfig
+      }
+    };
+  }
+  depResolverStrategy(params) {
+    if (params.id !== _dependencyResolver().DependencyResolverAspect.id) return undefined;
+    this.logger.trace(`start depResolverStrategy for ${this.compIdStr}`);
+    const {
+      currentExt,
+      otherExt,
+      baseExt
+    } = params;
+    const currentConfig = this.getConfig(currentExt);
+    const currentConfigPolicy = this.getPolicy(currentConfig);
+    const otherConfig = this.getConfig(otherExt);
+    const otherConfigPolicy = this.getPolicy(otherConfig);
+    const baseConfig = baseExt ? this.getConfig(baseExt) : undefined;
+    const baseConfigPolicy = baseConfig ? this.getPolicy(baseConfig) : undefined;
+    this.logger.debug(`currentConfig, ${JSON.stringify(currentConfig, undefined, 2)}`);
+    this.logger.debug(`otherConfig, ${JSON.stringify(otherConfig, undefined, 2)}`);
+    this.logger.debug(`baseConfig, ${JSON.stringify(baseConfig, undefined, 2)}`);
+    const getAllDeps = ext => {
+      var _ext$findCoreExtensio, _ext$findCoreExtensio2;
+      const data = (_ext$findCoreExtensio = ext.findCoreExtension(_dependencyResolver().DependencyResolverAspect.id)) === null || _ext$findCoreExtensio === void 0 ? void 0 : _ext$findCoreExtensio.data.dependencies;
+      if (!data) return [];
+      const policy = ((_ext$findCoreExtensio2 = ext.findCoreExtension(_dependencyResolver().DependencyResolverAspect.id)) === null || _ext$findCoreExtensio2 === void 0 ? void 0 : _ext$findCoreExtensio2.data.policy) || [];
+      return data.map(d => {
+        const idWithoutVersion = d.__type === 'package' ? d.id : d.id.split('@')[0];
+        const existingPolicy = policy.find(p => p.dependencyId === idWithoutVersion);
+        const getPolicyVer = () => {
+          if (d.__type === 'package') return undefined; // for packages, the policy is already the version
+          if (existingPolicy) return existingPolicy.value.version; // currently it's missing, will be implemented by @Gilad
+          return d.version;
+          // if (!semver.valid(d.version)) return d.version; // could be a hash
+          // // default to `^` or ~ if starts with zero, until we save the policy from the workspace during tag/snap.
+          // return d.version.startsWith('0.') ? `~${d.version}` : `^${d.version}`;
+        };
+        return _objectSpread(_objectSpread({}, d), {}, {
+          id: idWithoutVersion,
+          policy: getPolicyVer()
+        });
+      });
+    };
+    const getDataPolicy = ext => {
+      var _ext$findCoreExtensio3;
+      return ((_ext$findCoreExtensio3 = ext.findCoreExtension(_dependencyResolver().DependencyResolverAspect.id)) === null || _ext$findCoreExtensio3 === void 0 ? void 0 : _ext$findCoreExtensio3.data.policy) || [];
+    };
+    const getAutoDeps = ext => {
+      const allDeps = getAllDeps(ext);
+      return allDeps.filter(d => d.source === 'auto');
+    };
+    const currentAutoData = getAutoDeps(this.currentAspects);
+    const currentAllData = getAllDeps(this.currentAspects);
+    const currentDataPolicy = getDataPolicy(this.currentAspects);
+    const otherData = getAutoDeps(this.otherAspects);
+    const currentAndOtherData = (0, _lodash().uniqBy)(currentAutoData.concat(otherData), d => d.id);
+    const currentAndOtherComponentsData = currentAndOtherData.filter(c => c.__type === 'component');
+    const baseData = getAutoDeps(this.baseAspects);
+    const getCompIdStrByPkgNameFromData = pkgName => {
+      const found = currentAndOtherComponentsData.find(d => d.packageName === pkgName);
+      return found === null || found === void 0 ? void 0 : found.id;
+    };
+    const getFromCurrentDataByPackageName = pkgName => {
+      return currentAllData.find(d => {
+        if (d.__type === 'package') return d.id === pkgName;
+        return d.packageName === pkgName;
+      });
+    };
+    const getFromCurrentDataPolicyByPackageName = pkgName => {
+      return currentDataPolicy.find(d => d.dependencyId === pkgName);
+    };
+    const mergedPolicy = {
+      dependencies: [],
+      devDependencies: [],
+      peerDependencies: []
+    };
+    const conflictedPolicy = {
+      dependencies: [],
+      devDependencies: [],
+      peerDependencies: []
+    };
+    let hasConflict = false;
+    const lifecycleToDepType = {
+      runtime: 'dependencies',
+      dev: 'devDependencies',
+      peer: 'peerDependencies'
+    };
+    const handleConfigMerge = () => {
+      const addVariantPolicyEntryToPolicy = dep => {
+        const compIdStr = getCompIdStrByPkgNameFromData(dep.dependencyId);
+        if (compIdStr && this.isIdInWorkspaceOrOtherLane(compIdStr, dep.value.version)) {
+          // no need to add if the id exists in the workspace (regardless the version)
+          return;
+        }
+        const fromCurrentData = getFromCurrentDataByPackageName(dep.dependencyId);
+        if (fromCurrentData && !dep.force) {
+          if (fromCurrentData.version === dep.value.version) return;
+          if (!(0, _componentVersion().isHash)(fromCurrentData.version) && !(0, _componentVersion().isHash)(dep.value.version) && _semver().default.satisfies(fromCurrentData.version, dep.value.version)) {
+            return;
+          }
+        }
+        const fromCurrentDataPolicy = getFromCurrentDataPolicyByPackageName(dep.dependencyId);
+        if (fromCurrentDataPolicy && fromCurrentDataPolicy.value.version === dep.value.version) {
+          // -- updated comment --
+          // not sure why this block is needed. this gets called also from this if: `if (baseConfig && this.areConfigsEqual(baseConfig, currentConfig)) {`
+          // and in this case, it's possible that current/base has 5 deps, and other just added one and it has 6.
+          // in which case, we do need to add all these 5 in additional to the new one. otherwise, only the new one appears in the final
+          // merged object, and all the 5 deps are lost.
+          // --- previous comment ---
+          // that's a bug. if it's in the data.policy, it should be in data.dependencies.
+          // return;
+        }
+        const depType = lifecycleToDepType[dep.lifecycleType];
+        mergedPolicy[depType].push({
+          name: dep.dependencyId,
+          version: dep.value.version,
+          force: dep.force
+        });
+      };
+      if (this.areConfigsEqual(currentConfig, otherConfig)) {
+        return;
+      }
+      if (baseConfig && this.areConfigsEqual(baseConfig, otherConfig)) {
+        // was changed on current
+        return;
+      }
+      if (currentConfig === '-' || otherConfig === '-') {
+        throw new Error('not implemented. Is it possible to have it as minus?');
+      }
+      if (baseConfig && this.areConfigsEqual(baseConfig, currentConfig)) {
+        // was changed on other
+        if (otherConfigPolicy.length) {
+          otherConfigPolicy.forEach(dep => {
+            addVariantPolicyEntryToPolicy(dep);
+          });
+        }
+        return;
+      }
+
+      // either no baseConfig, or baseConfig is also different from both: other and local. that's a conflict.
+      if (!currentConfig.policy && !otherConfig.policy) return;
+      const currentAndOtherConfig = (0, _lodash().uniqBy)(currentConfigPolicy.concat(otherConfigPolicy), d => d.dependencyId);
+      currentAndOtherConfig.forEach(dep => {
+        const depType = lifecycleToDepType[dep.lifecycleType];
+        const currentDep = currentConfigPolicy.find(d => d.dependencyId === dep.dependencyId);
+        const otherDep = otherConfigPolicy.find(d => d.dependencyId === dep.dependencyId);
+        const baseDep = baseConfigPolicy === null || baseConfigPolicy === void 0 ? void 0 : baseConfigPolicy.find(d => d.dependencyId === dep.dependencyId);
+        if (!otherDep) {
+          return;
+        }
+        if (!currentDep) {
+          // only on other
+          addVariantPolicyEntryToPolicy(otherDep);
+          return;
+        }
+        const currentVer = currentDep.value.version;
+        const otherVer = otherDep.value.version;
+        if (currentVer === otherVer) {
+          return;
+        }
+        const baseVer = baseDep === null || baseDep === void 0 ? void 0 : baseDep.value.version;
+        if (baseVer && baseVer === otherVer) {
+          return;
+        }
+        if (baseVer && baseVer === currentVer) {
+          addVariantPolicyEntryToPolicy(otherDep);
+          return;
+        }
+        const compIdStr = getCompIdStrByPkgNameFromData(dep.dependencyId);
+        if (compIdStr && this.isIdInWorkspaceOrOtherLane(compIdStr, otherVer)) {
+          // no need to add if the id exists in the workspace (regardless the version)
+          return;
+        }
+        hasConflict = true;
+        conflictedPolicy[depType].push({
+          name: currentDep.dependencyId,
+          version: `${conflictIndicator}${currentVer}::${otherVer}::`,
+          force: currentDep.force
+        });
+      });
+    };
+    handleConfigMerge();
+    const hasConfigForDep = (depType, depName) => mergedPolicy[depType].find(d => d.name === depName);
+    const getDepIdAsPkgName = dep => {
+      if (dep.__type !== 'component') {
+        return dep.id;
+      }
+      // @ts-ignore
+      return dep.packageName;
+    };
+    const addSerializedDepToPolicy = dep => {
+      const depType = lifecycleToDepType[dep.lifecycle];
+      if (dep.__type === 'component' && this.isIdInWorkspaceOrOtherLane(dep.id, dep.version)) {
+        return;
+      }
+      if (hasConfigForDep(depType, dep.id)) {
+        return; // there is already config for it.
+      }
+      mergedPolicy[depType].push({
+        name: getDepIdAsPkgName(dep),
+        version: dep.policy || dep.version,
+        force: false
+      });
+    };
+    this.logger.debug(`currentData, ${currentAllData.length}\n${currentAllData.map(d => `${d.__type} ${d.id} ${d.version}`).join('\n')}`);
+    this.logger.debug(`otherData, ${otherData.length}\n${otherData.map(d => `${d.__type} ${d.id} ${d.version}`).join('\n')}`);
+    this.logger.debug(`baseData, ${baseData.length}\n${baseData.map(d => `${d.__type} ${d.id} ${d.version}`).join('\n')}`);
+
+    // eslint-disable-next-line complexity
+    currentAndOtherData.forEach(depData => {
+      this.logger.trace(`depData.id, ${depData.id}`);
+      if (this.isEnv(depData.id)) {
+        // ignore the envs
+        return;
+      }
+      const currentDep = currentAllData.find(d => d.id === depData.id);
+      const otherDep = otherData.find(d => d.id === depData.id);
+      const baseDep = baseData.find(d => d.id === depData.id);
+      this.logger.trace(`currentDep`, currentDep);
+      this.logger.trace(`otherDep`, otherDep);
+      this.logger.trace(`baseDep`, baseDep);
+      if (!otherDep) {
+        return;
+      }
+      if (!currentDep) {
+        if (baseDep) {
+          // exists in other and base, so it was removed from current
+          return;
+        }
+        // only on other
+        addSerializedDepToPolicy(otherDep);
+        return;
+      }
+      if (currentDep.policy && otherDep.policy) {
+        if (_semver().default.satisfies(currentDep.version, otherDep.policy)) {
+          return;
+        }
+        if (_semver().default.satisfies(otherDep.version, currentDep.policy)) {
+          return;
+        }
+      }
+      const currentVer = currentDep.policy || currentDep.version;
+      const otherVer = otherDep.policy || otherDep.version;
+      if (currentVer === otherVer) {
+        return;
+      }
+      const baseVer = (baseDep === null || baseDep === void 0 ? void 0 : baseDep.policy) || (baseDep === null || baseDep === void 0 ? void 0 : baseDep.version);
+      if (baseVer && baseVer === otherVer) {
+        return;
+      }
+      const currentId = currentDep.id;
+      if (currentDep.__type === 'component' && this.isIdInWorkspaceOrOtherLane(currentId, otherDep.version)) {
+        // dependencies that exist in the workspace, should be ignored. they'll be resolved later to the version in the ws.
+        return;
+      }
+      const depType = lifecycleToDepType[currentDep.lifecycle];
+      if (hasConfigForDep(depType, currentDep.id)) {
+        return; // there is already config for it.
+      }
+      if (baseVer && baseVer === currentVer) {
+        addSerializedDepToPolicy(otherDep);
+        return;
+      }
+      hasConflict = true;
+      conflictedPolicy[depType].push({
+        name: getDepIdAsPkgName(currentDep),
+        version: `${conflictIndicator}${currentVer}::${otherVer}::`,
+        force: false
+      });
+    });
+    ['dependencies', 'devDependencies', 'peerDependencies'].forEach(depType => {
+      if (!mergedPolicy[depType].length) delete mergedPolicy[depType];
+      if (!conflictedPolicy[depType].length) delete conflictedPolicy[depType];
+    });
+    const config = Object.keys(mergedPolicy).length ? {
+      policy: mergedPolicy
+    } : undefined;
+    const conflict = hasConflict ? conflictedPolicy : undefined;
+    this.logger.debug('final mergedConfig', config);
+    this.logger.debug('final conflict', conflict);
+    return {
+      id: params.id,
+      mergedConfig: config,
+      conflict
+    };
+  }
+  isIdInWorkspaceOrOtherLane(id, versionOnOtherLane) {
+    return Boolean(this.getIdFromWorkspace(id)) || this.otherLaneIdsStr.includes(`${id}@${versionOnOtherLane}`);
+  }
+  getIdFromWorkspace(id) {
+    return this.workspaceIds.find(c => c.toStringWithoutVersion() === id);
+  }
+  isEnv(id) {
+    return id === this.currentEnv.id || id === this.otherEnv.id;
+  }
+  getConfig(ext) {
+    if (ext.rawConfig === '-') return ext.rawConfig;
+    return (0, _lodash().omit)(ext.rawConfig, ['__specific']);
+  }
+  getPolicy(config) {
+    if (!config.policy) return [];
+    return _dependencyResolver().VariantPolicy.fromConfigObject(config.policy).entries;
+  }
+}
+exports.ComponentConfigMerger = ComponentConfigMerger;
+
+//# sourceMappingURL=component-config-merger.js.map