@teambit/merging 0.0.252 → 0.0.253

package/dist/config-merger.js

@@ -0,0 +1,588 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+require("core-js/modules/es.array.iterator.js");
+require("core-js/modules/es.regexp.exec.js");
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.ConfigMerger = void 0;
+function _defineProperty2() {
+  const data = _interopRequireDefault(require("@babel/runtime/helpers/defineProperty"));
+  _defineProperty2 = function () {
+    return data;
+  };
+  return data;
+}
+function _semver() {
+  const data = _interopRequireDefault(require("semver"));
+  _semver = 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 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; }
+/**
+ * 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 ConfigMerger {
+  constructor(compIdStr, workspaceIds, currentAspects, baseAspects, otherAspects, currentLabel, otherLabel) {
+    this.compIdStr = compIdStr;
+    this.workspaceIds = workspaceIds;
+    this.currentAspects = currentAspects;
+    this.baseAspects = baseAspects;
+    this.otherAspects = otherAspects;
+    this.currentLabel = currentLabel;
+    this.otherLabel = otherLabel;
+    (0, _defineProperty2().default)(this, "currentEnv", void 0);
+    (0, _defineProperty2().default)(this, "otherEnv", void 0);
+    (0, _defineProperty2().default)(this, "baseEnv", void 0);
+    (0, _defineProperty2().default)(this, "handledExtIds", []);
+  }
+  merge() {
+    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 this.basicConflictGenerator({
+          id,
+          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 => {
+      const id = otherExt.stringId;
+      if (this.handledExtIds.includes(id)) return null;
+      this.handledExtIds.push(id);
+      const baseExt = this.baseAspects.findExtension(id, true);
+      if (baseExt) {
+        // was removed on current
+        return this.basicConflictGenerator({
+          id,
+          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();
+    return new (_configMergeResult().ConfigMergeResult)(this.compIdStr, (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 = currentEnvAspect.rawConfig;
+    }
+    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 = otherEnvAspect.rawConfig;
+    }
+    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 = baseEnvAspect.rawConfig;
+      }
+    }
+  }
+  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.isIdInWorkspace(this.currentEnv.id)) {
+      // 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) {
+      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.
+    const mergeStrategyConfigParams = {
+      id,
+      currentConfig,
+      otherConfig,
+      baseConfig
+    };
+    return this.basicConflictGenerator(mergeStrategyConfigParams);
+  }
+  basicConflictGenerator({
+    id,
+    currentConfig,
+    otherConfig
+  }) {
+    // uncomment to debug
+    // console.log('basicConflictGenerator', this.compIdStr, id, 'currentConfig', currentConfig, 'otherConfig', otherConfig);
+    let conflict;
+    if (currentConfig === '-') {
+      conflict = `${'<'.repeat(7)} ${this.currentLabel}
+=======
+"${id}": ${JSON.stringify(otherConfig, undefined, 2)}
+${'>'.repeat(7)} ${this.otherLabel}`;
+    } else if (otherConfig === '-') {
+      conflict = `${'<'.repeat(7)} ${this.currentLabel}
+"${id}": ${JSON.stringify(otherConfig, undefined, 2)}
+=======
+${'>'.repeat(7)} ${this.otherLabel}`;
+    } else {
+      const formatConfig = conf => {
+        const confStr = JSON.stringify(conf, undefined, 2);
+        const confStrSplit = confStr.split('\n');
+        confStrSplit.shift(); // remove first {
+        confStrSplit.pop(); // remove last }
+        return confStrSplit.join('\n');
+      };
+      conflict = `"${id}": {
+${'<'.repeat(7)} ${this.currentLabel}
+${formatConfig(currentConfig)}
+=======
+${formatConfig(otherConfig)}
+${'>'.repeat(7)} ${this.otherLabel}
+}`;
+    }
+    return {
+      id,
+      conflict
+    };
+  }
+  depResolverStrategy(params) {
+    if (params.id !== _dependencyResolver().DependencyResolverAspect.id) return undefined;
+    const {
+      currentExt,
+      otherExt,
+      baseExt
+    } = params;
+    const currentConfig = this.getConfig(currentExt);
+    const otherConfig = this.getConfig(otherExt);
+    const baseConfig = baseExt ? this.getConfig(baseExt) : undefined;
+    // const mergeStrategyConfigParams = { id, currentConfig, otherConfig, baseConfig };
+
+    const mergedPolicy = {
+      dependencies: [],
+      devDependencies: [],
+      peerDependencies: []
+    };
+    const conflictedPolicy = {
+      dependencies: [],
+      devDependencies: [],
+      peerDependencies: []
+    };
+    let isMerged = false;
+    let hasConflict = false;
+    const conflictIndicator = 'CONFLICT::';
+    const nonPolicyConfigToMerged = {};
+    const nonPolicyConfigConflict = {};
+    const handleConfigMerge = () => {
+      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?');
+      }
+      const allKeys = (0, _lodash().uniq)([...Object.keys(currentConfig), ...Object.keys(otherConfig)]);
+      const otherKeys = allKeys.filter(key => key !== 'policy');
+      if (baseConfig && this.areConfigsEqual(baseConfig, currentConfig)) {
+        // was changed on other
+        otherKeys.forEach(key => {
+          if (otherConfig[key]) {
+            nonPolicyConfigToMerged[key] = otherConfig[key];
+          }
+        });
+        if (otherConfig.policy) {
+          ['dependencies', 'devDependencies', 'peerDependencies'].forEach(depType => {
+            if (!otherConfig.policy[depType]) return;
+            Object.keys(otherConfig.policy[depType]).forEach(depName => {
+              mergedPolicy[depType].push({
+                name: depName,
+                version: otherConfig.policy[depType][depName],
+                force: true
+              });
+            });
+          });
+        }
+        isMerged = true;
+        return;
+      }
+
+      // either no baseConfig, or baseConfig is also different from both: other and local. that's a conflict.
+      // we have to differentiate between a conflict in the policy, which might be merged with conflict with dependencies data.
+      // and a conflict with other fields of config.
+      otherKeys.forEach(key => {
+        if (JSON.stringify(currentConfig[key]) === JSON.stringify(otherConfig[key])) {
+          return;
+        }
+        if (baseConfig && JSON.stringify(baseConfig[key]) === JSON.stringify(otherConfig[key])) {
+          // was changed on current
+          return;
+        }
+        if (baseConfig && JSON.stringify(baseConfig[key]) === JSON.stringify(currentConfig[key])) {
+          // was changed on other
+          nonPolicyConfigToMerged[key] = otherConfig[key];
+          return;
+        }
+        // conflict
+        nonPolicyConfigConflict[key] = {
+          current: currentConfig[key],
+          other: otherConfig[key]
+        };
+      });
+      if (!currentConfig.policy && !otherConfig.policy) return;
+      ['dependencies', 'devDependencies', 'peerDependencies'].forEach(depType => {
+        var _currentConfig$policy, _otherConfig$policy;
+        const currentPolicy = (_currentConfig$policy = currentConfig.policy) === null || _currentConfig$policy === void 0 ? void 0 : _currentConfig$policy[depType];
+        const otherPolicy = (_otherConfig$policy = otherConfig.policy) === null || _otherConfig$policy === void 0 ? void 0 : _otherConfig$policy[depType];
+        const allPolicyKeys = (0, _lodash().uniq)(Object.keys(currentPolicy || {}).concat(Object.keys(otherPolicy || {})));
+        if (!allPolicyKeys.length) return;
+        allPolicyKeys.forEach(pkgName => {
+          var _baseConfig$policy, _baseConfig$policy$de;
+          const currentVal = currentPolicy === null || currentPolicy === void 0 ? void 0 : currentPolicy[pkgName];
+          const otherVal = otherPolicy === null || otherPolicy === void 0 ? void 0 : otherPolicy[pkgName];
+          const baseVal = baseConfig !== '-' && (baseConfig === null || baseConfig === void 0 ? void 0 : (_baseConfig$policy = baseConfig.policy) === null || _baseConfig$policy === void 0 ? void 0 : (_baseConfig$policy$de = _baseConfig$policy[depType]) === null || _baseConfig$policy$de === void 0 ? void 0 : _baseConfig$policy$de[pkgName]);
+          if (this.isEnv(pkgName)) {
+            // ignore the envs
+            return;
+          }
+          if (currentVal === otherVal) {
+            // mergedPolicy[depType][pkgName] = currentVal;
+            return;
+          }
+          if (baseVal === otherVal) {
+            // mergedPolicy[depType][pkgName] = currentVal;
+            return;
+          }
+          if (baseVal === currentVal) {
+            mergedPolicy[depType].push({
+              name: pkgName,
+              version: otherVal,
+              force: true
+            });
+            isMerged = true;
+            return;
+          }
+          // either no baseVal, or baseVal is also different from both: other and local. that's a conflict.
+          hasConflict = true;
+          conflictedPolicy[depType].push({
+            name: pkgName,
+            version: `${conflictIndicator}${currentVal}::${otherVal}::`,
+            force: true
+          });
+        });
+      });
+    };
+    handleConfigMerge();
+    const lifecycleToDepType = {
+      runtime: 'dependencies',
+      dev: 'devDependencies',
+      peer: 'peerDependencies'
+    };
+    const hasConfigForDep = (depType, depName) => mergedPolicy[depType].find(d => d.name === depName);
+    const addSerializedDepToPolicy = dep => {
+      const depType = lifecycleToDepType[dep.lifecycle];
+      if (hasConfigForDep(depType, dep.id)) {
+        return; // there is already config for it.
+      }
+
+      mergedPolicy[depType].push({
+        name: dep.id,
+        version: dep.policy || dep.version,
+        force: false
+      });
+      isMerged = true;
+    };
+    const getAutoDeps = 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.filter(d => d.source === 'auto').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
+          if (!_semver().default.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 currentData = getAutoDeps(this.currentAspects);
+    const otherData = getAutoDeps(this.otherAspects);
+    const currentAndOtherData = (0, _lodash().uniqBy)(currentData.concat(otherData), d => d.id);
+    const baseData = getAutoDeps(this.baseAspects);
+
+    // uncomment to debug
+    // console.log('\n\n**************', this.compIdStr, '**************');
+    // console.log('currentData', currentData.length, '\n', currentData.map((d) => `${d.__type} ${d.id} ${d.version}`).join('\n'));
+    // console.log('otherData', otherData.length, '\n', otherData.map((d) => `${d.__type} ${d.id} ${d.version}`).join('\n'));
+    // console.log('otherData', baseData.length, '\n', baseData.map((d) => `${d.__type} ${d.id} ${d.version}`).join('\n'));
+    // console.log('** END **\n\n');
+
+    currentAndOtherData.forEach(depData => {
+      if (this.isEnv(depData.id)) {
+        // ignore the envs
+        return;
+      }
+      const currentDep = currentData.find(d => d.id === depData.id);
+      const otherDep = otherData.find(d => d.id === depData.id);
+      if (!otherDep) {
+        return;
+      }
+      if (!currentDep) {
+        // only on other
+        addSerializedDepToPolicy(otherDep);
+        return;
+      }
+      const currentId = currentDep.id;
+      const currentVer = currentDep.policy || currentDep.version;
+      const otherVer = otherDep.policy || otherDep.version;
+      if (currentVer === otherVer) {
+        return;
+      }
+      const baseDep = baseData.find(d => d.id === currentId);
+      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;
+      }
+      if (currentDep.__type === 'component' && this.isIdInWorkspace(currentId)) {
+        // dependencies that exist in the workspace, should be ignored. they'll be resolved later to the version in the ws.
+        return;
+      }
+      if (baseVer && baseVer === currentVer) {
+        addSerializedDepToPolicy(otherDep);
+        return;
+      }
+      // either no baseVal, or baseVal is also different from both: other and local. that's probably a conflict.
+      const depType = lifecycleToDepType[currentDep.lifecycle];
+      if (hasConfigForDep(depType, currentDep.id)) {
+        return; // there is already config for it.
+      }
+      // try to resolve according to semver
+      if (currentDep.policy && otherDep.policy && (0, _dependencyResolver().isRange)(currentDep.policy, currentDep.id) && (0, _dependencyResolver().isRange)(otherDep.policy, otherDep.id)) {
+        if (_semver().default.satisfies(currentDep.version, otherDep.policy)) {
+          return;
+        }
+        if (_semver().default.satisfies(otherDep.version, currentDep.policy)) {
+          addSerializedDepToPolicy(otherDep);
+          return;
+        }
+      }
+      hasConflict = true;
+      conflictedPolicy[depType].push({
+        name: currentDep.id,
+        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];
+    });
+    let conflictStr;
+    if (hasConflict) {
+      const mergedConfigSplit = JSON.stringify({
+        policy: conflictedPolicy
+      }, undefined, 2).split('\n');
+      const conflictLines = mergedConfigSplit.map(line => {
+        if (!line.includes(conflictIndicator)) return line;
+        const [, currentVal, otherVal] = line.split('::');
+        return `${'<'.repeat(7)} ${this.currentLabel}
+        "version": "${currentVal}",
+=======
+        "version": "${otherVal}",
+${'>'.repeat(7)} ${this.otherLabel}`;
+      });
+      // replace the first line with line with the id
+      conflictLines.shift();
+      conflictLines.unshift(`"${params.id}": {`);
+      conflictStr = conflictLines.join('\n');
+    }
+    const config = isMerged ? _objectSpread(_objectSpread({}, nonPolicyConfigToMerged), {}, {
+      policy: mergedPolicy
+    }) : undefined;
+    return {
+      id: params.id,
+      mergedConfig: config,
+      conflict: conflictStr
+    };
+  }
+  isIdInWorkspace(id) {
+    return Boolean(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']);
+  }
+}
+exports.ConfigMerger = ConfigMerger;
+
+//# sourceMappingURL=config-merger.js.map