@teambit/merge-lanes 0.0.0-012f21d51d884d0035b43584f4bd41f1410e77b9

package/dist/merge-lanes.main.runtime.js

@@ -0,0 +1,792 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = exports.MergeLanesMain = void 0;
+function _bitError() {
+  const data = require("@teambit/bit-error");
+  _bitError = function () {
+    return data;
+  };
+  return data;
+}
+function _path() {
+  const data = _interopRequireDefault(require("path"));
+  _path = function () {
+    return data;
+  };
+  return data;
+}
+function _cli() {
+  const data = require("@teambit/cli");
+  _cli = function () {
+    return data;
+  };
+  return data;
+}
+function _importer() {
+  const data = require("@teambit/importer");
+  _importer = function () {
+    return data;
+  };
+  return data;
+}
+function _lanes() {
+  const data = require("@teambit/lanes");
+  _lanes = function () {
+    return data;
+  };
+  return data;
+}
+function _merging() {
+  const data = require("@teambit/merging");
+  _merging = function () {
+    return data;
+  };
+  return data;
+}
+function _componentModules() {
+  const data = require("@teambit/component.modules.merge-helper");
+  _componentModules = function () {
+    return data;
+  };
+  return data;
+}
+function _workspace() {
+  const data = require("@teambit/workspace");
+  _workspace = function () {
+    return data;
+  };
+  return data;
+}
+function _configStore() {
+  const data = require("@teambit/config-store");
+  _configStore = function () {
+    return data;
+  };
+  return data;
+}
+function _harmonyModules() {
+  const data = require("@teambit/harmony.modules.get-basic-log");
+  _harmonyModules = function () {
+    return data;
+  };
+  return data;
+}
+function _componentId() {
+  const data = require("@teambit/component-id");
+  _componentId = function () {
+    return data;
+  };
+  return data;
+}
+function _pMapSeries() {
+  const data = _interopRequireDefault(require("p-map-series"));
+  _pMapSeries = function () {
+    return data;
+  };
+  return data;
+}
+function _scope() {
+  const data = require("@teambit/scope");
+  _scope = function () {
+    return data;
+  };
+  return data;
+}
+function _laneId() {
+  const data = require("@teambit/lane-id");
+  _laneId = function () {
+    return data;
+  };
+  return data;
+}
+function _logger() {
+  const data = require("@teambit/logger");
+  _logger = function () {
+    return data;
+  };
+  return data;
+}
+function _checkout() {
+  const data = require("@teambit/checkout");
+  _checkout = function () {
+    return data;
+  };
+  return data;
+}
+function _remove() {
+  const data = require("@teambit/remove");
+  _remove = function () {
+    return data;
+  };
+  return data;
+}
+function _lodash() {
+  const data = require("lodash");
+  _lodash = function () {
+    return data;
+  };
+  return data;
+}
+function _export() {
+  const data = require("@teambit/export");
+  _export = function () {
+    return data;
+  };
+  return data;
+}
+function _mergeLanes() {
+  const data = require("./merge-lanes.aspect");
+  _mergeLanes = function () {
+    return data;
+  };
+  return data;
+}
+function _mergeLane() {
+  const data = require("./merge-lane.cmd");
+  _mergeLane = function () {
+    return data;
+  };
+  return data;
+}
+function _missingCompsToMerge() {
+  const data = require("./exceptions/missing-comps-to-merge");
+  _missingCompsToMerge = function () {
+    return data;
+  };
+  return data;
+}
+function _mergeAbort() {
+  const data = require("./merge-abort.cmd");
+  _mergeAbort = function () {
+    return data;
+  };
+  return data;
+}
+function _lastMerged() {
+  const data = require("./last-merged");
+  _lastMerged = function () {
+    return data;
+  };
+  return data;
+}
+function _mergeMove() {
+  const data = require("./merge-move.cmd");
+  _mergeMove = function () {
+    return data;
+  };
+  return data;
+}
+function _express() {
+  const data = require("@teambit/express");
+  _express = function () {
+    return data;
+  };
+  return data;
+}
+function _lanesCheckConflicts() {
+  const data = require("./lanes-check-conflicts.route");
+  _lanesCheckConflicts = function () {
+    return data;
+  };
+  return data;
+}
+function _interopRequireDefault(e) { return e && e.__esModule ? e : { default: e }; }
+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(e, r, t) { return (r = _toPropertyKey(r)) in e ? Object.defineProperty(e, r, { value: t, enumerable: !0, configurable: !0, writable: !0 }) : e[r] = t, e; }
+function _toPropertyKey(t) { var i = _toPrimitive(t, "string"); return "symbol" == typeof i ? i : 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); }
+class MergeLanesMain {
+  constructor(workspace, merging, lanes, logger, remove, scope, exporter, importer, checkout) {
+    this.workspace = workspace;
+    this.merging = merging;
+    this.lanes = lanes;
+    this.logger = logger;
+    this.remove = remove;
+    this.scope = scope;
+    this.exporter = exporter;
+    this.importer = importer;
+    this.checkout = checkout;
+  }
+  async mergeLaneByCLI(laneName, options) {
+    if (!this.workspace) {
+      throw new (_bitError().BitError)(`unable to merge a lane outside of Bit workspace`);
+    }
+    const currentLaneId = this.workspace.consumer.getCurrentLaneId();
+    const otherLaneId = await this.workspace.consumer.getParsedLaneId(laneName);
+    return this.mergeLane(otherLaneId, currentLaneId, options);
+  }
+
+  /**
+   * merge otherLaneId into currentLaneId
+   */
+  async mergeLane(otherLaneId, currentLaneId, options) {
+    this.validateMergeFlags(otherLaneId, currentLaneId, options);
+    const {
+      currentLane,
+      otherLane,
+      laneToFetchArtifactsFrom,
+      idsToMerge
+    } = await this.resolveMergeContext(otherLaneId, currentLaneId, options);
+    const {
+      mergeStrategy,
+      noAutoSnap,
+      noSnap,
+      tag,
+      snapMessage,
+      existingOnWorkspaceOnly,
+      build,
+      loose,
+      keepReadme,
+      squash,
+      noSquash,
+      pattern,
+      includeDeps,
+      skipDependencyInstallation,
+      resolveUnrelated,
+      ignoreConfigChanges,
+      throwIfNotUpToDate,
+      detachHead
+    } = options;
+    const legacyScope = this.scope.legacyScope;
+    const consumer = this.workspace?.consumer;
+    if (throwIfNotUpToDate) await this.throwIfNotUpToDate(otherLaneId, currentLaneId);
+    this.logger.debug(`merging the following ids: ${idsToMerge.toString()}`);
+    const shouldSquash = squash || currentLaneId.isDefault() && !noSquash;
+    let allComponentsStatus = await this.merging.getMergeStatus(idsToMerge, {
+      resolveUnrelated,
+      ignoreConfigChanges,
+      shouldSquash,
+      mergeStrategy,
+      handleTargetAheadAsDiverged: noSnap,
+      detachHead,
+      shouldMergeAspectsData: true
+    }, currentLane, otherLane);
+    if (pattern) {
+      const componentIds = idsToMerge;
+      const compIdsFromPattern = await (this.workspace || this.scope).filterIdsFromPoolIdsByPattern(pattern, componentIds);
+      allComponentsStatus = await filterComponentsStatus(allComponentsStatus, compIdsFromPattern, idsToMerge, legacyScope, includeDeps, otherLane, shouldSquash);
+      idsToMerge.forEach(bitId => {
+        if (!allComponentsStatus.find(c => c.id.isEqualWithoutVersion(bitId))) {
+          allComponentsStatus.push({
+            id: bitId,
+            unchangedLegitimately: true,
+            unchangedMessage: `excluded by pattern`
+          });
+        }
+      });
+    }
+    if (existingOnWorkspaceOnly && this.workspace) {
+      const workspaceIds = this.workspace.listIds();
+      const compIdsFromPattern = workspaceIds.filter(id => allComponentsStatus.find(c => c.id.isEqualWithoutVersion(id)));
+      allComponentsStatus = await filterComponentsStatus(allComponentsStatus, compIdsFromPattern, idsToMerge, legacyScope, includeDeps, otherLane, shouldSquash);
+      idsToMerge.forEach(bitId => {
+        if (!allComponentsStatus.find(c => c.id.isEqualWithoutVersion(bitId))) {
+          allComponentsStatus.push({
+            id: bitId,
+            unchangedLegitimately: true,
+            unchangedMessage: `not in the workspace`
+          });
+        }
+      });
+    }
+    (0, _checkout().throwForFailures)(allComponentsStatus);
+    const succeededComponents = allComponentsStatus.filter(c => !c.unchangedMessage);
+    if (shouldSquash) {
+      await squashSnaps(succeededComponents, currentLaneId, otherLaneId, legacyScope, {
+        messageTitle: options.snapMessage,
+        detachHead
+      });
+    }
+    if (laneToFetchArtifactsFrom) {
+      const ids = allComponentsStatus.map(c => c.id);
+      await this.importer.importHeadArtifactsFromLane(laneToFetchArtifactsFrom, ids, true);
+    }
+    const lastMerged = consumer ? new (_lastMerged().LastMerged)(this.scope, consumer, this.logger) : undefined;
+    const snapshot = await lastMerged?.takeSnapshot(currentLane);
+    const mergeResults = await this.merging.mergeSnaps({
+      mergeStrategy,
+      allComponentsStatus,
+      otherLaneId,
+      currentLane,
+      noAutoSnap,
+      noSnap,
+      tag,
+      snapMessage,
+      build,
+      skipDependencyInstallation,
+      detachHead,
+      loose
+    });
+    if (snapshot) await lastMerged?.persistSnapshot(snapshot);
+    const mergedSuccessfully = !mergeResults.failedComponents || mergeResults.failedComponents.length === 0 || mergeResults.failedComponents.every(failedComponent => failedComponent.unchangedLegitimately);
+    let deleteResults = {};
+    if (!keepReadme && otherLane && otherLane.readmeComponent && mergedSuccessfully) {
+      const readmeComponentId = otherLane.readmeComponent.id.changeVersion(otherLane.readmeComponent?.head?.hash);
+      deleteResults = await this.remove.removeLocallyByIds([readmeComponentId], {
+        reasonForRemoval: 'lane-merge'
+      });
+    } else if (otherLane && !otherLane.readmeComponent) {
+      deleteResults = {
+        readmeResult: ''
+      };
+    }
+    const configMergeResults = (0, _lodash().compact)(allComponentsStatus.map(c => c.configMergeResult));
+    const mergedSnapIds = _componentId().ComponentIdList.fromArray(mergeResults.mergeSnapResults?.snappedComponents.map(c => c.id) || []);
+    const componentsWithConfigConflicts = configMergeResults.filter(c => c.hasConflicts()).map(c => c.compIdStr);
+    const conflicts = [];
+    const mergedSuccessfullyIds = [];
+    mergeResults.components?.forEach(c => {
+      const files = Object.keys(c.filesStatus).filter(f => c.filesStatus[f] === _componentModules().FileStatus.manual || c.filesStatus[f] === _componentModules().FileStatus.binaryConflict);
+      const config = componentsWithConfigConflicts.includes(c.id.toStringWithoutVersion());
+      if (files.length || config) {
+        conflicts.push({
+          id: c.id,
+          files,
+          config
+        });
+      } else {
+        const snappedId = mergedSnapIds.searchWithoutVersion(c.id);
+        mergedSuccessfullyIds.push(snappedId || c.id);
+      }
+    });
+    await this.workspace?.consumer.onDestroy(`lane-merge (${otherLaneId.name})`);
+    return {
+      mergeResults,
+      deleteResults,
+      configMergeResults,
+      mergedSuccessfullyIds,
+      conflicts
+    };
+  }
+  validateMergeFlags(otherLaneId, currentLaneId, options) {
+    const {
+      tag,
+      resolveUnrelated,
+      detachHead
+    } = options;
+    if (tag && !currentLaneId.isDefault()) {
+      throw new (_bitError().BitError)(`--tag only possible when on main. currently checked out to ${currentLaneId.toString()}`);
+    }
+    if (otherLaneId.isEqual(currentLaneId)) {
+      throw new (_bitError().BitError)(`unable to merge lane "${otherLaneId.toString()}", you're already at this lane. to get updates, simply run "bit checkout head"`);
+    }
+    if (resolveUnrelated && currentLaneId.isDefault()) {
+      throw new (_bitError().BitError)(`unable to resolve unrelated when on main. switch to ${otherLaneId.toString()} and run "bit lane merge main --resolve-unrelated"`);
+    }
+    if (detachHead && !currentLaneId.isDefault()) {
+      throw new (_bitError().BitError)(`unable to detach head. the current lane is not main`);
+    }
+  }
+  async resolveMergeContext(otherLaneId, currentLaneId, options) {
+    const {
+      skipFetch,
+      excludeNonLaneComps,
+      shouldIncludeUpdateDependents,
+      fetchCurrent
+    } = options;
+    const legacyScope = this.scope.legacyScope;
+    if (fetchCurrent && !currentLaneId.isDefault()) {
+      // if current is default, it'll be fetch later on
+      await this.lanes.fetchLaneWithItsComponents(currentLaneId);
+    }
+    const currentLane = currentLaneId.isDefault() ? undefined : await legacyScope.loadLane(currentLaneId);
+    const isDefaultLane = otherLaneId.isDefault();
+    if (isDefaultLane) {
+      if (!skipFetch) {
+        const ids = await this.getMainIdsToMerge(currentLane, !excludeNonLaneComps);
+        const compIdList = _componentId().ComponentIdList.fromArray(ids).toVersionLatest();
+        await this.importer.importObjectsFromMainIfExist(compIdList);
+      }
+    }
+    let laneToFetchArtifactsFrom;
+    const getOtherLane = async () => {
+      let lane = await legacyScope.loadLane(otherLaneId);
+      const shouldFetch = !lane || !skipFetch && !lane.isNew;
+      if (shouldFetch) {
+        // don't assign `lane` to the result of this command. otherwise, if you have local snaps, it'll ignore them and use the remote-lane.
+        const otherLane = await this.lanes.fetchLaneWithItsComponents(otherLaneId, shouldIncludeUpdateDependents);
+        laneToFetchArtifactsFrom = otherLane;
+        lane = await legacyScope.loadLane(otherLaneId);
+      }
+      return lane;
+    };
+    const otherLane = isDefaultLane ? undefined : await getOtherLane();
+    if (fetchCurrent && otherLane && currentLaneId.isDefault()) {
+      const ids = await this.getMainIdsToMerge(otherLane, false, shouldIncludeUpdateDependents);
+      const compIdList = _componentId().ComponentIdList.fromArray(ids).toVersionLatest();
+      await this.importer.importObjectsFromMainIfExist(compIdList);
+    }
+    const getBitIds = async () => {
+      if (isDefaultLane) {
+        const ids = await this.getMainIdsToMerge(currentLane, !excludeNonLaneComps, shouldIncludeUpdateDependents);
+        const modelComponents = await Promise.all(ids.map(id => this.scope.legacyScope.getModelComponent(id)));
+        return (0, _lodash().compact)(modelComponents.map(c => {
+          if (!c.head) return null; // probably the component was never merged to main
+          return c.toComponentId().changeVersion(c.head.toString());
+        }));
+      }
+      if (!otherLane) throw new Error(`lane must be defined for non-default`);
+      return shouldIncludeUpdateDependents ? otherLane.toComponentIdsIncludeUpdateDependents() : otherLane.toComponentIds();
+    };
+    const idsToMerge = await getBitIds();
+    return {
+      currentLane,
+      otherLane,
+      laneToFetchArtifactsFrom,
+      idsToMerge
+    };
+  }
+
+  /**
+   * check conflicts in case of merging sourceLaneId into targetLaneId
+   */
+  async checkLaneForConflicts(sourceLaneIdStr, targetLaneIdStr, options) {
+    const legacyScope = this.scope.legacyScope;
+    const otherLaneId = await legacyScope.lanes.parseLaneIdFromString(sourceLaneIdStr);
+    const currentLaneId = await legacyScope.lanes.parseLaneIdFromString(targetLaneIdStr);
+    options.excludeNonLaneComps = true;
+    const {
+      currentLane,
+      otherLane,
+      idsToMerge
+    } = await this.resolveMergeContext(otherLaneId, currentLaneId, options);
+    const allComponentsStatus = await this.merging.getMergeStatus(idsToMerge, {
+      mergeStrategy: 'manual'
+    }, currentLane, otherLane);
+    (0, _checkout().throwForFailures)(allComponentsStatus);
+    const configMergeResults = (0, _lodash().compact)(allComponentsStatus.map(c => c.configMergeResult));
+    const componentsWithConfigConflicts = configMergeResults.filter(c => c.hasConflicts()).map(c => c.compIdStr);
+    const conflicts = [];
+    allComponentsStatus.forEach(c => {
+      const files = c.mergeResults?.modifiedFiles.filter(f => f.conflict || f.isBinaryConflict) || [];
+      const config = componentsWithConfigConflicts.includes(c.id.toStringWithoutVersion());
+      if (files.length || config) {
+        const configData = configMergeResults.find(co => co.compIdStr === c.id.toStringWithoutVersion());
+        const configConflict = configData?.generateMergeConflictFile() || undefined;
+        conflicts.push({
+          id: c.id,
+          files: files.map(f => f.filePath),
+          config,
+          configConflict
+        });
+      }
+    });
+    return {
+      conflicts
+    };
+  }
+  async mergeMove(newLaneName, options) {
+    if (!this.workspace) throw new (_workspace().OutsideWorkspaceError)();
+    const lastMerge = new (_lastMerged().LastMerged)(this.scope, this.workspace.consumer, this.logger);
+    await lastMerge.restoreLaneObjectFromLastMerged();
+    const newLaneResult = await this.lanes.createLane(newLaneName, {
+      scope: options.scope
+    });
+    return newLaneResult;
+  }
+  async abortLaneMerge(checkoutProps, mergeAbortOpts) {
+    if (!this.workspace) throw new (_workspace().OutsideWorkspaceError)();
+    const lastMerge = new (_lastMerged().LastMerged)(this.scope, this.workspace.consumer, this.logger);
+    const currentLane = await this.lanes.getCurrentLane();
+    const {
+      compDirsToRemove
+    } = await lastMerge.restoreFromLastMerged(mergeAbortOpts, currentLane);
+    await this.workspace._reloadConsumer();
+    this.workspace.consumer.scope.objects.unmergedComponents.removeAllComponents();
+    await this.workspace.consumer.scope.objects.unmergedComponents.write();
+    const configMergeFile = this.workspace.getConflictMergeFile();
+    await configMergeFile.delete();
+    let checkoutResults;
+    let checkoutError;
+    checkoutProps.ids = this.workspace.listIds();
+    checkoutProps.restoreMissingComponents = true;
+    try {
+      checkoutResults = await this.checkout.checkout(checkoutProps);
+    } catch (err) {
+      this.logger.error(`merge-abort got an error during the checkout stage`, err);
+      checkoutError = err;
+    }
+    const restoredItems = [`${_path().default.basename(this.workspace.consumer.bitMap.mapPath)} file`, `${_path().default.basename(this.workspace.consumer.config.path)} file`];
+    if (compDirsToRemove.length) {
+      restoredItems.push(`deleted components directories: ${compDirsToRemove.join(', ')}`);
+    }
+    if (currentLane) {
+      restoredItems.push(`${currentLane.id()} lane object`);
+    }
+    return {
+      checkoutResults,
+      restoredItems,
+      checkoutError
+    };
+  }
+  async getMainIdsToMerge(lane, includeNonLaneComps = true, includeUpdateDependents = false) {
+    if (!lane) throw new Error(`unable to merge ${_laneId().DEFAULT_LANE}, the current lane was not found`);
+    const laneIds = includeUpdateDependents ? lane.toComponentIdsIncludeUpdateDependents() : lane.toComponentIds();
+    const ids = laneIds.filter(id => this.scope.isExported(id));
+    if (includeNonLaneComps) {
+      if (!this.workspace) {
+        throw new (_bitError().BitError)(`getMainIdsToMerge needs workspace`);
+      }
+      const workspaceIds = this.workspace.listIds();
+      const mainNotOnLane = workspaceIds.filter(id => !laneIds.find(laneId => laneId.isEqualWithoutVersion(id)) && this.scope.isExported(id));
+      ids.push(...mainNotOnLane);
+    }
+    return ids;
+  }
+  async throwIfNotUpToDate(fromLaneId, toLaneId) {
+    const status = await this.lanes.diffStatus(fromLaneId, toLaneId, {
+      skipChanges: true
+    });
+    const compsNotUpToDate = status.componentsStatus.filter(s => !s.upToDate);
+    if (compsNotUpToDate.length) {
+      throw new Error(`unable to merge, the following components are not up-to-date:
+${compsNotUpToDate.map(s => s.componentId.toString()).join('\n')}`);
+    }
+  }
+  static async provider([lanes, cli, workspace, merging, loggerMain, remove, scope, exporter, importer, checkout, configStore, express]) {
+    const logger = loggerMain.createLogger(_mergeLanes().MergeLanesAspect.id);
+    const lanesCommand = cli.getCommand('lane');
+    const mergeLanesMain = new MergeLanesMain(workspace, merging, lanes, logger, remove, scope, exporter, importer, checkout);
+    lanesCommand?.commands?.push(new (_mergeLane().MergeLaneCmd)(mergeLanesMain, configStore));
+    lanesCommand?.commands?.push(new (_mergeAbort().MergeAbortLaneCmd)(mergeLanesMain));
+    lanesCommand?.commands?.push(new (_mergeMove().MergeMoveLaneCmd)(mergeLanesMain));
+    express.register([new (_lanesCheckConflicts().LanesCheckConflictsRoute)(mergeLanesMain, logger)]);
+    return mergeLanesMain;
+  }
+}
+exports.MergeLanesMain = MergeLanesMain;
+_defineProperty(MergeLanesMain, "slots", []);
+_defineProperty(MergeLanesMain, "dependencies", [_lanes().LanesAspect, _cli().CLIAspect, _workspace().WorkspaceAspect, _merging().MergingAspect, _logger().LoggerAspect, _remove().RemoveAspect, _scope().ScopeAspect, _export().ExportAspect, _importer().ImporterAspect, _checkout().CheckoutAspect, _configStore().ConfigStoreAspect, _express().ExpressAspect]);
+_defineProperty(MergeLanesMain, "runtime", _cli().MainRuntime);
+async function filterComponentsStatus(allComponentsStatus, compIdsToKeep, allBitIds, legacyScope, includeDeps = false, otherLane,
+// lane that gets merged into the current lane. if not provided, it's main that gets merged into the current lane
+shouldSquash) {
+  const bitIdsFromPattern = _componentId().ComponentIdList.fromArray(compIdsToKeep);
+  const bitIdsNotFromPattern = allBitIds.filter(bitId => !bitIdsFromPattern.hasWithoutVersion(bitId));
+  const filteredComponentStatus = [];
+  const depsToAdd = [];
+  const missingDepsFromHead = {};
+  const missingDepsFromHistory = [];
+  const versionsToCheckPerId = await (0, _pMapSeries().default)(compIdsToKeep, async compId => {
+    const fromStatus = allComponentsStatus.find(c => c.id.isEqualWithoutVersion(compId));
+    if (!fromStatus) {
+      throw new Error(`filterComponentsStatus: unable to find ${compId.toString()} in component-status`);
+    }
+    filteredComponentStatus.push(fromStatus);
+    if (fromStatus.unchangedMessage) {
+      return undefined;
+    }
+    if (!otherLane) {
+      // if merging main, no need to check whether the deps are included in the pattern.
+      return undefined;
+    }
+    const {
+      divergeData
+    } = fromStatus;
+    if (!divergeData) {
+      throw new Error(`filterComponentsStatus: unable to find divergeData for ${compId.toString()}`);
+    }
+    let targetVersions = divergeData.snapsOnTargetOnly;
+    if (!targetVersions.length) {
+      return undefined;
+    }
+    const modelComponent = await legacyScope.getModelComponent(compId);
+    if (shouldSquash) {
+      // no need to check all versions, we merge only the head
+      const headOnTarget = otherLane ? otherLane.getCompHeadIncludeUpdateDependents(compId) : modelComponent.head;
+      if (!headOnTarget) {
+        throw new Error(`filterComponentsStatus: unable to find head for ${compId.toString()}`);
+      }
+      targetVersions = [headOnTarget];
+    }
+    return {
+      compId,
+      targetVersions,
+      modelComponent
+    };
+  });
+
+  // all these versions needs to be imported to load them later and check whether they have dependencies on the target lane
+  const toImport = (0, _lodash().compact)(versionsToCheckPerId).map(c => c.targetVersions.map(v => c.compId.changeVersion(v.toString()))).flat();
+  await legacyScope.scopeImporter.importWithoutDeps(_componentId().ComponentIdList.fromArray(toImport), {
+    lane: otherLane,
+    cache: true,
+    includeVersionHistory: false,
+    reason: 'import all history of given patterns components to check whether they have dependencies on the lane'
+  });
+  await (0, _pMapSeries().default)((0, _lodash().compact)(versionsToCheckPerId), async ({
+    compId,
+    targetVersions,
+    modelComponent
+  }) => {
+    await (0, _pMapSeries().default)(targetVersions, async remoteVersion => {
+      const versionObj = await modelComponent.loadVersion(remoteVersion.toString(), legacyScope.objects);
+      const flattenedDeps = versionObj.getAllFlattenedDependencies();
+      const depsNotIncludeInPattern = flattenedDeps.filter(id => bitIdsNotFromPattern.find(bitId => bitId.isEqualWithoutVersion(id)));
+      if (!depsNotIncludeInPattern.length) {
+        return;
+      }
+      const depsOnLane = [];
+      await Promise.all(depsNotIncludeInPattern.map(async dep => {
+        const isOnLane = await legacyScope.isIdOnLane(dep, otherLane);
+        if (isOnLane) {
+          depsOnLane.push(dep);
+        }
+      }));
+      if (!depsOnLane.length) {
+        return;
+      }
+      if (includeDeps) {
+        depsToAdd.push(...depsOnLane);
+      } else {
+        const headOnTarget = otherLane ? otherLane.getCompHeadIncludeUpdateDependents(compId) : modelComponent.head;
+        const depsOnLaneStr = depsOnLane.map(dep => dep.toStringWithoutVersion());
+        if (headOnTarget?.isEqual(remoteVersion)) {
+          depsOnLaneStr.forEach(dep => {
+            (missingDepsFromHead[dep] ||= []).push(compId.toStringWithoutVersion());
+          });
+        } else {
+          missingDepsFromHistory.push(...depsOnLaneStr);
+        }
+      }
+    });
+  });
+  if (Object.keys(missingDepsFromHead).length || missingDepsFromHistory.length) {
+    throw new (_missingCompsToMerge().MissingCompsToMerge)(missingDepsFromHead, (0, _lodash().uniq)(missingDepsFromHistory));
+  }
+  if (depsToAdd.length) {
+    // remove the version, otherwise, the uniq gives duplicate components with different versions.
+    const depsWithoutVersion = depsToAdd.map(d => d.changeVersion(undefined));
+    const depsUniqWithoutVersion = _componentId().ComponentIdList.uniqFromArray(depsWithoutVersion);
+    depsUniqWithoutVersion.forEach(id => {
+      const fromStatus = allComponentsStatus.find(c => c.id.isEqualWithoutVersion(id));
+      if (!fromStatus) {
+        throw new Error(`filterComponentsStatus: unable to find ${id.toString()} in component-status`);
+      }
+      filteredComponentStatus.push(fromStatus);
+    });
+  }
+  return filteredComponentStatus;
+}
+async function getLogForSquash(otherLaneId) {
+  const basicLog = await (0, _harmonyModules().getBasicLog)();
+  const log = _objectSpread(_objectSpread({}, basicLog), {}, {
+    message: `squashed during merge from ${otherLaneId.toString()}`
+  });
+  return log;
+}
+async function squashSnaps(succeededComponents, currentLaneId, otherLaneId, scope, opts = {}) {
+  const currentLaneName = currentLaneId.name;
+  const log = await getLogForSquash(otherLaneId);
+  await Promise.all(succeededComponents.map(async ({
+    id,
+    divergeData,
+    componentFromModel
+  }) => {
+    if (!divergeData) {
+      throw new Error(`unable to squash. divergeData is missing from ${id.toString()}`);
+    }
+    const modifiedComp = await squashOneComp(currentLaneName, otherLaneId, id, divergeData, log, scope, componentFromModel, opts);
+    if (modifiedComp) {
+      scope.objects.add(modifiedComp);
+      const modelComponent = await scope.getModelComponent(id);
+      const versionHistory = await modelComponent.updateRebasedVersionHistory(scope.objects, [modifiedComp]);
+      if (versionHistory) scope.objects.add(versionHistory);
+    }
+  }));
+}
+
+/**
+ * returns Version object if it was modified. otherwise, returns undefined
+ */
+async function squashOneComp(currentLaneName, otherLaneId, id, divergeData, log, scope, componentFromModel, opts = {}) {
+  const {
+    messageTitle,
+    detachHead
+  } = opts;
+  const shouldSquash = () => {
+    if (divergeData.isDiverged()) {
+      if (detachHead) {
+        // for detach head, it's ok to have it as diverged. as long as the target is ahead, we want to squash.
+        return true;
+      }
+      throw new (_bitError().BitError)(`unable to squash because ${id.toString()} is diverged in history.
+  consider switching to "${otherLaneId.name}" first, merging "${currentLaneName}", then switching back to "${currentLaneName}" and merging "${otherLaneId.name}"
+  alternatively, use "--no-squash" flag to keep the entire history of "${otherLaneId.name}"`);
+    }
+    if (divergeData.isSourceAhead()) {
+      // nothing to do. current is ahead, nothing to merge. (it was probably filtered out already as a "failedComponent")
+      return false;
+    }
+    if (!divergeData.isTargetAhead()) {
+      // nothing to do. current and remote are the same, nothing to merge. (it was probably filtered out already as a "failedComponent")
+      return false;
+    }
+    return true;
+  };
+  if (!shouldSquash()) {
+    return undefined;
+  }
+
+  // remote is ahead and was not diverge.
+  const remoteSnaps = divergeData.snapsOnTargetOnly;
+  if (remoteSnaps.length === 0) {
+    throw new Error(`remote is ahead but it has no snaps. it's impossible`);
+  }
+  const getAllMessages = async () => {
+    if (!messageTitle) return [];
+    await scope.scopeImporter.importManyObjects({
+      [otherLaneId.scope]: remoteSnaps.map(s => s.toString())
+    });
+    const versionObjects = await Promise.all(remoteSnaps.map(s => scope.objects.load(s)));
+    return (0, _lodash().compact)(versionObjects).map(v => v.log.message);
+  };
+  const getFinalMessage = async () => {
+    if (!messageTitle) return undefined;
+    const allMessage = await getAllMessages();
+    const allMessageStr = (0, _lodash().compact)(allMessage).map(m => `[*] ${m}`).join('\n');
+    return `${messageTitle}\n${allMessageStr}`;
+  };
+  if (!componentFromModel) {
+    throw new Error('unable to squash, the componentFromModel is missing');
+  }
+  const currentParents = componentFromModel.parents;
+
+  // if the remote has only one snap, there is nothing to squash.
+  // other checks here is to make sure `componentFromModel.addAsOnlyParent` call is not needed.
+  if (remoteSnaps.length === 1 && divergeData.commonSnapBeforeDiverge && currentParents.length === 1) {
+    return undefined;
+  }
+  const doSquash = async () => {
+    if (divergeData.commonSnapBeforeDiverge) {
+      componentFromModel.addAsOnlyParent(divergeData.commonSnapBeforeDiverge);
+      return;
+    }
+    if (currentLaneName !== _laneId().DEFAULT_LANE) {
+      // when squashing into lane, we have to take main into account
+      const modelComponent = await scope.getModelComponentIfExist(id);
+      if (!modelComponent) throw new Error(`missing ModelComponent for ${id.toString()}`);
+      if (modelComponent.head) {
+        componentFromModel.addAsOnlyParent(modelComponent.head);
+        return;
+      }
+    }
+    // there is no commonSnapBeforeDiverge. the local has no snaps, all are remote, no need for parents. keep only head.
+    componentFromModel.parents.forEach(ref => componentFromModel.removeParent(ref));
+  };
+  await doSquash();
+  const finalMessage = await getFinalMessage();
+  componentFromModel.setSquashed({
+    previousParents: currentParents,
+    laneId: otherLaneId
+  }, log, finalMessage);
+  return componentFromModel;
+}
+_mergeLanes().MergeLanesAspect.addRuntime(MergeLanesMain);
+var _default = exports.default = MergeLanesMain;
+
+//# sourceMappingURL=merge-lanes.main.runtime.js.map