@teambit/ci 1.0.486 → 1.0.488

package/dist/ci.main.runtime.d.ts

@@ -11,6 +11,10 @@ import { type ImporterMain } from '@teambit/importer';
 import { type CheckoutMain } from '@teambit/checkout';
 import type { MergeStrategy } from '@teambit/component.modules.merge-helper';
 import type { ReleaseType } from 'semver';
+export type CiSwitchLaneOptions = SwitchLaneOptions & {
+    /** after an adoption retry, write the adopted components' files (`checkout --reset`) */
+    writeAdoptedFiles?: boolean;
+};
 import type { CiSyncConfig } from './sync/sync-config';
 import type { GitHostProvider } from './sync/git-host-provider';
 /**
@@ -150,6 +154,9 @@ export declare class CiMain {
      * out" no-op case). Callers that need to react to a specific failure mode (e.g. stale lane) can
      * inspect the returned error; existing callers ignore it and rely on a follow-up
      * `getCurrentLane()` check.
+     *
+     * A switch that fails because the lane provides a component the workspace tracks as new retries
+     * once after adopting the lane's version — see `adoptNewComponentsTheLaneProvides`.
      */
     private switchToLane;
     /**
@@ -157,7 +164,7 @@ export declare class CiMain {
      * throwing. `switchToLane` spreads caller options AFTER its defaults, so `forceOurs: true` is
      * overridable — the sync import direction depends on that. Do not reorder that spread.
      */
-    switchToLaneForSync(laneName: string, options?: SwitchLaneOptions): Promise<Error | undefined>;
+    switchToLaneForSync(laneName: string, options?: CiSwitchLaneOptions): Promise<Error | undefined>;
     /**
      * Re-read `.bitmap` from disk into the live workspace. `bit ci sync` moves the git checkout
      * underneath a running process, and until the reload every bit operation resolves against the

package/dist/ci.main.runtime.js

@@ -228,6 +228,13 @@ function _pullRequestRef() {
   };
   return data;
 }
+function _adoptLaneNewComponents() {
+  const data = require("./sync/adopt-lane-new-components");
+  _adoptLaneNewComponents = function () {
+    return data;
+  };
+  return data;
+}
 function _syncOrchestrator() {
   const data = require("./sync/sync-orchestrator");
   _syncOrchestrator = function () {
@@ -256,9 +263,12 @@ function _syncConfig() {
   };
   return data;
 }
+const _excluded = ["writeAdoptedFiles"];
 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 _objectWithoutProperties(e, t) { if (null == e) return {}; var o, r, i = _objectWithoutPropertiesLoose(e, t); if (Object.getOwnPropertySymbols) { var n = Object.getOwnPropertySymbols(e); for (r = 0; r < n.length; r++) o = n[r], -1 === t.indexOf(o) && {}.propertyIsEnumerable.call(e, o) && (i[o] = e[o]); } return i; }
+function _objectWithoutPropertiesLoose(r, e) { if (null == r) return {}; var t = {}; for (var n in r) if ({}.hasOwnProperty.call(r, n)) { if (-1 !== e.indexOf(n)) continue; t[n] = r[n]; } return t; }
 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); }
@@ -536,22 +546,41 @@ class CiMain {
    * out" no-op case). Callers that need to react to a specific failure mode (e.g. stale lane) can
    * inspect the returned error; existing callers ignore it and rely on a follow-up
    * `getCurrentLane()` check.
+   *
+   * A switch that fails because the lane provides a component the workspace tracks as new retries
+   * once after adopting the lane's version — see `adoptNewComponentsTheLaneProvides`.
    */
   async switchToLane(laneName, options = {}) {
     this.logger.console(_chalk().default.blue(`Switching to ${laneName}`));
+    const {
+        writeAdoptedFiles
+      } = options,
+      switchOptions = _objectWithoutProperties(options, _excluded);
+    const doSwitch = () => this.lanes.switchLanes(laneName, _objectSpread({
+      forceOurs: true,
+      workspaceOnly: true,
+      skipDependencyInstallation: true
+    }, switchOptions));
+    const failure = err => {
+      this.logger.console(_chalk().default.red(`Failed switching to ${laneName}: ${err?.toString() ?? err}`));
+      return err;
+    };
     try {
-      await this.lanes.switchLanes(laneName, _objectSpread({
-        forceOurs: true,
-        workspaceOnly: true,
-        skipDependencyInstallation: true
-      }, options));
+      await doSwitch();
     } catch (e) {
       if (e?.toString().includes('already checked out')) {
         this.logger.console(_chalk().default.yellow(`Lane ${laneName} already checked out, skipping checkout`));
         return undefined;
       }
-      this.logger.console(_chalk().default.red(`Failed switching to ${laneName}: ${e?.toString() ?? e}`));
-      return e;
+      if (!(0, _adoptLaneNewComponents().isLaneMissingComponentError)(e)) return failure(e);
+      const retryErr = await (0, _adoptLaneNewComponents().adoptAndRetrySwitch)(laneName, e, doSwitch, writeAdoptedFiles, {
+        workspace: this.workspace,
+        lanes: this.lanes,
+        logger: this.logger,
+        checkout: this.checkout,
+        reloadWorkspace: () => this.reloadWorkspaceFromDisk()
+      });
+      if (retryErr) return failure(retryErr);
     }
     return undefined;
   }