@teambit/merging 0.0.455 → 0.0.456

package/dist/merging.main.runtime.js

@@ -1,9 +1,7 @@
 "use strict";
 
 var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
-require("core-js/modules/es.array.flat.js");
 require("core-js/modules/es.array.iterator.js");
-require("core-js/modules/es.array.unscopables.flat.js");
 require("core-js/modules/es.promise.js");
 require("core-js/modules/es.regexp.exec.js");
 require("core-js/modules/es.string.replace.js");
@@ -102,13 +100,6 @@ function _laneId() {
   };
   return data;
 }
-function _getDivergeData() {
-  const data = require("@teambit/legacy/dist/scope/component-ops/get-diverge-data");
-  _getDivergeData = function () {
-    return data;
-  };
-  return data;
-}
 function _chalk() {
   const data = _interopRequireDefault(require("chalk"));
   _chalk = function () {
@@ -130,13 +121,6 @@ function _remove() {
   };
   return data;
 }
-function _repositories() {
-  const data = require("@teambit/legacy/dist/scope/repositories");
-  _repositories = function () {
-    return data;
-  };
-  return data;
-}
 function _utils() {
   const data = require("@teambit/legacy/dist/utils");
   _utils = function () {
@@ -172,20 +156,6 @@ function _lodash() {
   };
   return data;
 }
-function _threeWayMerge() {
-  const data = _interopRequireDefault(require("@teambit/legacy/dist/consumer/versions-ops/merge-version/three-way-merge"));
-  _threeWayMerge = function () {
-    return data;
-  };
-  return data;
-}
-function _noCommonSnap() {
-  const data = require("@teambit/legacy/dist/scope/exceptions/no-common-snap");
-  _noCommonSnap = function () {
-    return data;
-  };
-  return data;
-}
 function _dependencyResolver() {
   const data = require("@teambit/dependency-resolver");
   _dependencyResolver = function () {
@@ -242,16 +212,16 @@ function _merging() {
   };
   return data;
 }
-function _configMerger() {
-  const data = require("./config-merger");
-  _configMerger = function () {
+function _configMergeResult() {
+  const data = require("./config-merge-result");
+  _configMergeResult = function () {
     return data;
   };
   return data;
 }
-function _configMergeResult() {
-  const data = require("./config-merge-result");
-  _configMergeResult = function () {
+function _mergeStatusProvider() {
+  const data = require("./merge-status-provider");
+  _mergeStatusProvider = function () {
     return data;
   };
   return data;
@@ -610,285 +580,8 @@ class MergingMain {
   otherLane,
   // the lane we want to merged to our lane. (null if it's "main").
   options) {
-    if (!currentLane && otherLane) {
-      await this.importer.importObjectsFromMainIfExist(otherLane.toBitIds().toVersionLatest());
-    }
-    const componentStatusBeforeMergeAttempt = await (0, _pMapSeries().default)(bitIds, id => this.getComponentStatusBeforeMergeAttempt(id, currentLane, options));
-    const toImport = componentStatusBeforeMergeAttempt.map(compStatus => {
-      if (!compStatus.divergeData) return [];
-      const versionsToImport = (0, _lodash().compact)([...compStatus.divergeData.snapsOnTargetOnly, compStatus.divergeData.commonSnapBeforeDiverge]);
-      return versionsToImport.map(v => compStatus.id.changeVersion(v.toString()));
-    }).flat();
-    await this.workspace.consumer.scope.scopeImporter.importWithoutDeps(_bitId().BitIds.fromArray(toImport), {
-      lane: otherLane || undefined,
-      cache: true,
-      includeVersionHistory: false
-    });
-    const compStatusNotNeedMerge = componentStatusBeforeMergeAttempt.filter(c => !c.mergeProps);
-    const compStatusNeedMerge = componentStatusBeforeMergeAttempt.filter(c => c.mergeProps);
-    const getComponentsStatusNeedMerge = async () => {
-      const tmp = new (_repositories().Tmp)(this.workspace.consumer.scope);
-      try {
-        const componentsStatus = await Promise.all(compStatusNeedMerge.map(compStatus => this.getComponentMergeStatus(currentLane, otherLane || undefined, compStatus)));
-        await tmp.clear();
-        return componentsStatus;
-      } catch (err) {
-        await tmp.clear();
-        throw err;
-      }
-    };
-    const results = await getComponentsStatusNeedMerge();
-    results.push(...compStatusNotNeedMerge);
-    return results;
-  }
-
-  // eslint-disable-next-line complexity
-  async getComponentStatusBeforeMergeAttempt(id,
-  // the id.version is the version we want to merge to the current component
-  localLane,
-  // currently checked out lane. if on main, then it's null.
-  options) {
-    const consumer = this.workspace.consumer;
-    const componentStatus = {
-      id
-    };
-    const returnUnmerged = (msg, unmergedLegitimately = false) => {
-      componentStatus.unmergedMessage = msg;
-      componentStatus.unmergedLegitimately = unmergedLegitimately;
-      return componentStatus;
-    };
-    const modelComponent = await consumer.scope.getModelComponentIfExist(id);
-    if (!modelComponent) {
-      return returnUnmerged(`component ${id.toString()} is on the lane/main but its objects were not found, please re-import the lane`);
-    }
-    const unmerged = consumer.scope.objects.unmergedComponents.getEntry(id.name);
-    if (unmerged) {
-      return returnUnmerged(`component ${id.toStringWithoutVersion()} is in during-merge state a previous merge, please snap/tag it first (or use bit merge --resolve/--abort/ bit lane merge-abort)`);
-    }
-    const repo = consumer.scope.objects;
-    const version = id.version;
-    const otherLaneHead = modelComponent.getRef(version);
-    const existingBitMapId = consumer.bitMap.getBitIdIfExist(id, {
-      ignoreVersion: true
-    });
-    const componentOnOther = await modelComponent.loadVersion(version, consumer.scope.objects);
-    const idOnCurrentLane = localLane === null || localLane === void 0 ? void 0 : localLane.getComponent(id);
-    if (componentOnOther.isRemoved()) {
-      // if exist in current lane, we want the current lane to get the soft-remove update.
-      // or if it was removed with --update-main, we want to merge it so then main will get the update.
-      const shouldMerge = idOnCurrentLane || componentOnOther.shouldRemoveFromMain();
-      if (shouldMerge) {
-        // remove the component from the workspace if exist.
-        componentStatus.shouldBeRemoved = true;
-      } else {
-        // on main, don't merge soft-removed components unless it's marked with removeOnMain.
-        // on lane, if it's not part of the current lane, don't merge it.
-        return returnUnmerged(`component has been removed`, true);
-      }
-    }
-    const getCurrentId = () => {
-      if (existingBitMapId) return existingBitMapId;
-      if (localLane) {
-        if (!idOnCurrentLane) return null;
-        return idOnCurrentLane.id.changeVersion(idOnCurrentLane.head.toString());
-      }
-      // it's on main
-      const head = modelComponent.getHeadAsTagIfExist();
-      if (head) {
-        return id.changeVersion(head);
-      }
-      return null;
-    };
-    const currentId = getCurrentId();
-    if (!currentId) {
-      const divergeData = await (0, _getDivergeData().getDivergeData)({
-        repo,
-        modelComponent,
-        targetHead: otherLaneHead,
-        throws: false
-      });
-      return _objectSpread(_objectSpread({}, componentStatus), {}, {
-        componentFromModel: componentOnOther,
-        divergeData
-      });
-    }
-    const getCurrentComponent = () => {
-      if (existingBitMapId) return consumer.loadComponent(existingBitMapId);
-      return consumer.scope.getConsumerComponent(currentId);
-    };
-    const currentComponent = await getCurrentComponent();
-    if (currentComponent.isRemoved()) {
-      // we have a few options:
-      // 1. other is ahead. in this case, other recovered the component. so we can continue with the merge.
-      // it is possible that it is diverged, in which case, still continue with the merge, and later on, the
-      // merge-config will show a config conflict of the remove aspect.
-      // 2. other is not ahead. in this case, just ignore this component, no point to merge it, we want it removed.
-      // 3. there are errors when calculating the divergeData, e.g. no snap in common. in such cases, we assume
-      // there are issues with this component, and is better not to merge it.
-      const divergeData = await (0, _getDivergeData().getDivergeData)({
-        repo,
-        modelComponent,
-        targetHead: otherLaneHead,
-        throws: false
-      });
-      if (divergeData.err || !divergeData.isTargetAhead()) {
-        return returnUnmerged(`component has been removed`, true);
-      }
-    }
-    const isModified = async () => {
-      const componentModificationStatus = await consumer.getComponentStatusById(currentComponent.id);
-      if (!componentModificationStatus.modified) return undefined;
-      if (!existingBitMapId) return undefined;
-      const baseComponent = await modelComponent.loadVersion(existingBitMapId.version, consumer.scope.objects);
-      const isSourceCodeModified = await consumer.isComponentSourceCodeModified(baseComponent, currentComponent);
-      if (isSourceCodeModified) return 'code';
-      return 'config';
-    };
-    const modifiedType = await isModified();
-    if (modifiedType === 'config' && !(options !== null && options !== void 0 && options.ignoreConfigChanges)) {
-      return returnUnmerged(`component has config changes, please snap/tag it first. alternatively, use --ignore-config-changes flag to bypass`);
-    }
-    if (modifiedType === 'code') {
-      return returnUnmerged(`component is modified, please snap/tag it first`);
-    }
-    if (!otherLaneHead) {
-      throw new Error(`merging: unable finding a hash for the version ${version} of ${id.toString()}`);
-    }
-    const divergeData = await (0, _getDivergeData().getDivergeData)({
-      repo,
-      modelComponent,
-      targetHead: otherLaneHead,
-      throws: false
-    });
-    if (divergeData.err) {
-      const mainHead = modelComponent.head;
-      if (divergeData.err instanceof _noCommonSnap().NoCommonSnap && options !== null && options !== void 0 && options.resolveUnrelated && mainHead) {
-        const hasResolvedFromMain = async hashToCompare => {
-          const divergeDataFromMain = await (0, _getDivergeData().getDivergeData)({
-            repo,
-            modelComponent,
-            sourceHead: hashToCompare,
-            targetHead: mainHead,
-            throws: false
-          });
-          if (!divergeDataFromMain.err) return true;
-          return !(divergeDataFromMain.err instanceof _noCommonSnap().NoCommonSnap);
-        };
-        const hasResolvedLocally = await hasResolvedFromMain(modelComponent.getHeadRegardlessOfLane());
-        const hasResolvedRemotely = await hasResolvedFromMain(otherLaneHead);
-        if (!hasResolvedLocally && !hasResolvedRemotely) {
-          return returnUnmerged(`unable to traverse ${currentComponent.id.toString()} history. the main-head ${mainHead.toString()} doesn't appear in both lanes, it was probably created in each lane separately`);
-        }
-        const versionToSaveInLane = hasResolvedLocally ? currentComponent.id.version : id.version;
-        const resolvedRef = modelComponent.getRef(versionToSaveInLane);
-        if (!resolvedRef) throw new Error(`unable to get ref of "${versionToSaveInLane}" for "${id.toString()}"`);
-        if ((options === null || options === void 0 ? void 0 : options.resolveUnrelated) === 'theirs') {
-          // just override with the model data
-          return {
-            currentComponent,
-            componentFromModel: componentOnOther,
-            id,
-            divergeData,
-            resolvedUnrelated: {
-              strategy: 'theirs',
-              head: resolvedRef
-            }
-          };
-        }
-        if ((options === null || options === void 0 ? void 0 : options.resolveUnrelated) === 'ours') {
-          return {
-            currentComponent,
-            id,
-            divergeData,
-            resolvedUnrelated: {
-              strategy: 'ours',
-              head: resolvedRef
-            }
-          };
-        }
-        throw new Error(`unsupported strategy "${options === null || options === void 0 ? void 0 : options.resolveUnrelated}" of resolve-unrelated. supported strategies are: [ours, theirs]`);
-      }
-      return returnUnmerged(`unable to traverse ${currentComponent.id.toString()} history. error: ${divergeData.err.message}`);
-    }
-    if (!divergeData.isDiverged()) {
-      if (divergeData.isSourceAhead()) {
-        // do nothing!
-        return returnUnmerged(`component ${currentComponent.id.toString()} is ahead, nothing to merge`, true);
-      }
-      if (divergeData.isTargetAhead()) {
-        // just override with the model data
-        return _objectSpread(_objectSpread({}, componentStatus), {}, {
-          currentComponent,
-          componentFromModel: componentOnOther,
-          divergeData
-        });
-      }
-      // we know that localHead and remoteHead are set, so if none of them is ahead they must be equal
-      return returnUnmerged(`component ${currentComponent.id.toString()} is already merged`, true);
-    }
-
-    // it's diverged and needs merge operation
-    const mergeProps = {
-      otherLaneHead,
-      currentId,
-      modelComponent
-    };
-    return _objectSpread(_objectSpread({}, componentStatus), {}, {
-      currentComponent,
-      mergeProps,
-      divergeData
-    });
-  }
-  async getComponentMergeStatus(localLane,
-  // currently checked out lane. if on main, then it's null.
-  otherLane,
-  // the lane name we want to merged to our lane. (can be also "main").
-  componentMergeStatusBeforeMergeAttempt) {
-    const {
-      id,
-      divergeData,
-      currentComponent,
-      mergeProps
-    } = componentMergeStatusBeforeMergeAttempt;
-    if (!mergeProps) throw new Error(`getDivergedMergeStatus, mergeProps is missing for ${id.toString()}`);
-    const {
-      otherLaneHead,
-      currentId,
-      modelComponent
-    } = mergeProps;
-    const repo = this.workspace.consumer.scope.objects;
-    if (!divergeData) throw new Error(`getDivergedMergeStatus, divergeData is missing for ${id.toString()}`);
-    if (!currentComponent) throw new Error(`getDivergedMergeStatus, currentComponent is missing for ${id.toString()}`);
-    const baseSnap = divergeData.commonSnapBeforeDiverge; // must be set when isTrueMerge
-    this.logger.debug(`merging snaps details:
-id:      ${id.toStringWithoutVersion()}
-base:    ${baseSnap.toString()}
-current: ${currentId.version}
-other:   ${otherLaneHead.toString()}`);
-    const baseComponent = await modelComponent.loadVersion(baseSnap.toString(), repo);
-    const otherComponent = await modelComponent.loadVersion(otherLaneHead.toString(), repo);
-    const currentLaneName = (localLane === null || localLane === void 0 ? void 0 : localLane.toLaneId().toString()) || 'main';
-    const otherLaneName = otherLane ? otherLane.toLaneId().toString() : _laneId().DEFAULT_LANE;
-    const currentLabel = `${currentId.version} (${currentLaneName === otherLaneName ? 'current' : currentLaneName})`;
-    const otherLabel = `${otherLaneHead.toString()} (${otherLaneName === currentLaneName ? 'incoming' : otherLaneName})`;
-    const workspaceIds = await this.workspace.listIds();
-    const configMerger = new (_configMerger().ConfigMerger)(id.toStringWithoutVersion(), workspaceIds, otherLane, currentComponent.extensions, baseComponent.extensions, otherComponent.extensions, currentLabel, otherLabel, this.logger);
-    const configMergeResult = configMerger.merge();
-    const mergeResults = await (0, _threeWayMerge().default)({
-      consumer: this.workspace.consumer,
-      otherComponent,
-      otherLabel,
-      currentComponent,
-      currentLabel,
-      baseComponent
-    });
-    return {
-      currentComponent,
-      id,
-      mergeResults,
-      divergeData,
-      configMergeResult
-    };
+    const mergeStatusProvider = new (_mergeStatusProvider().MergeStatusProvider)(this.workspace, this.logger, this.importer, currentLane || undefined, otherLane || undefined, options);
+    return mergeStatusProvider.getStatus(bitIds);
   }
   async applyVersion({
     currentComponent,
@@ -910,25 +603,25 @@ other:   ${otherLaneHead.toString()}`);
         scope: id.scope
       },
       head: remoteHead,
-      remote: laneId.scope,
-      // @todo: remove. it has been deprecated around 0.0.832
-      lane: laneId.name,
-      // @todo: remove. it has been deprecated around 0.0.832
       laneId
     };
     id = currentComponent ? currentComponent.id : id;
     const modelComponent = await consumer.scope.getModelComponent(id);
     const handleResolveUnrelated = () => {
       if (!currentComponent) throw new Error('currentComponent must be defined when resolvedUnrelated');
+      // because when on a main, we don't allow merging lanes with unrelated. we asks users to switch to the lane
+      // first and then merge with --resolve-unrelated
       if (!localLane) throw new Error('localLane must be defined when resolvedUnrelated');
-      if (!(resolvedUnrelated !== null && resolvedUnrelated !== void 0 && resolvedUnrelated.head)) throw new Error('resolvedUnrelated must have head prop');
+      if (!resolvedUnrelated) throw new Error('resolvedUnrelated must be populated');
       localLane.addComponent({
         id,
-        head: resolvedUnrelated.head
+        head: resolvedUnrelated.headOnCurrentLane
       });
-      unmergedComponent.laneId = localLane.toLaneId();
-      unmergedComponent.head = resolvedUnrelated.head;
-      unmergedComponent.unrelated = true;
+      unmergedComponent.unrelated = {
+        unrelatedHead: resolvedUnrelated.unrelatedHead,
+        headOnCurrentLane: resolvedUnrelated.headOnCurrentLane,
+        unrelatedLaneId: resolvedUnrelated.unrelatedLaneId
+      };
       consumer.scope.objects.unmergedComponents.addEntry(unmergedComponent);
       return {
         applyVersionResult: {