@teambit/ci 1.0.487 → 1.0.489

package/dist/{preview-1785883495880.js → preview-1785958716068.js}

@@ -1,5 +1,5 @@
 ;
-import * as overview_0 from '/home/circleci/Library/Caches/Bit/capsules/8891be5ad/teambit.git_ci@1.0.487/dist/ci.docs.mdx';
+import * as overview_0 from '/home/circleci/Library/Caches/Bit/capsules/8891be5ad/teambit.git_ci@1.0.489/dist/ci.docs.mdx';
 
 export const compositions = [];
 export const overview = [overview_0];

package/dist/sync/adopt-lane-new-components.d.ts

@@ -0,0 +1,36 @@
+import type { CheckoutMain } from '@teambit/checkout';
+import type { ComponentID } from '@teambit/component-id';
+import type { LanesMain } from '@teambit/lanes';
+import type { Logger } from '@teambit/logger';
+import type { Workspace } from '@teambit/workspace';
+export type AdoptLaneNewComponentsDeps = {
+    workspace: Workspace;
+    lanes: LanesMain;
+    logger: Logger;
+};
+export type AdoptRetryDeps = AdoptLaneNewComponentsDeps & {
+    checkout: CheckoutMain;
+    reloadWorkspace: () => Promise<void>;
+};
+/**
+ * The lane merge (`sources.mergeLane` in the legacy scope) throws a plain Error with this wording
+ * when a lane component's objects are absent. A typed error needs a change outside the ci aspect;
+ * the stale-lane recovery of `bit ci pr` matches the same text.
+ */
+export declare function isLaneMissingComponentError(err: unknown): boolean;
+/**
+ * A versionless `.bitmap` entry reads as local and unexported, so a lane fetch drops its id and
+ * the lane merge fails with `the component … was not found`. Adopt the lane's version into each
+ * such entry, and import the adopted objects (`includeUnexported`, because the entries made them
+ * look local). The mutation is in memory; the caller owns the rollback on a failed retry.
+ * The returned ids already record the lane's version, so a retried switch skips their files; an
+ * importing caller must write them (`checkout --reset`).
+ */
+export declare function adoptNewComponentsTheLaneProvides(laneName: string, { workspace, lanes, logger }: AdoptLaneNewComponentsDeps): Promise<ComponentID[]>;
+/**
+ * Runs after a switch failed with the missing-component marker: adopt the lane's versions, then
+ * retry the switch once. Returns undefined on success, and the error to report on failure. A
+ * failed retry reloads the workspace from disk — the failed switch never wrote to it — so the
+ * in-memory adoption disappears completely (including `updatedIds` and the changed flag).
+ */
+export declare function adoptAndRetrySwitch(laneName: string, originalErr: Error, doSwitch: () => Promise<unknown>, writeAdoptedFiles: boolean | undefined, deps: AdoptRetryDeps): Promise<Error | undefined>;

package/dist/sync/adopt-lane-new-components.js

@@ -0,0 +1,146 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.adoptAndRetrySwitch = adoptAndRetrySwitch;
+exports.adoptNewComponentsTheLaneProvides = adoptNewComponentsTheLaneProvides;
+exports.isLaneMissingComponentError = isLaneMissingComponentError;
+function _chalk() {
+  const data = _interopRequireDefault(require("chalk"));
+  _chalk = function () {
+    return data;
+  };
+  return data;
+}
+function _componentId() {
+  const data = require("@teambit/component-id");
+  _componentId = function () {
+    return data;
+  };
+  return data;
+}
+function _laneSyncExecutor() {
+  const data = require("./lane-sync-executor");
+  _laneSyncExecutor = function () {
+    return data;
+  };
+  return data;
+}
+function _interopRequireDefault(e) { return e && e.__esModule ? e : { default: e }; }
+/**
+ * The lane merge (`sources.mergeLane` in the legacy scope) throws a plain Error with this wording
+ * when a lane component's objects are absent. A typed error needs a change outside the ci aspect;
+ * the stale-lane recovery of `bit ci pr` matches the same text.
+ */
+function isLaneMissingComponentError(err) {
+  const msg = err?.message ?? String(err ?? '');
+  return msg.includes('unable to merge lane') && msg.includes('was not found');
+}
+
+/**
+ * A versionless `.bitmap` entry reads as local and unexported, so a lane fetch drops its id and
+ * the lane merge fails with `the component … was not found`. Adopt the lane's version into each
+ * such entry, and import the adopted objects (`includeUnexported`, because the entries made them
+ * look local). The mutation is in memory; the caller owns the rollback on a failed retry.
+ * The returned ids already record the lane's version, so a retried switch skips their files; an
+ * importing caller must write them (`checkout --reset`).
+ */
+async function adoptNewComponentsTheLaneProvides(laneName, {
+  workspace,
+  lanes,
+  logger
+}) {
+  const newIds = await workspace.newComponentIds();
+  if (!newIds.length) return [];
+  const laneId = await lanes.parseLaneId(laneName);
+  if (laneId.isDefault()) return [];
+  const lane = await lanes.importLaneObject(laneId);
+  const newIdsList = _componentId().ComponentIdList.fromArray(newIds);
+  const adoptedIds = lane.toComponentIdsIncludeUpdateDependents().filter(laneCompId => newIdsList.hasWithoutVersion(laneCompId));
+  if (!adoptedIds.length) return [];
+  logger.console(_chalk().default.blue(`Adopting the lane's version for component(s) this workspace tracks as new: ` + (0, _laneSyncExecutor().capEntries)(adoptedIds.map(id => id.toStringWithoutVersion())).join(', ')));
+  const bitMap = workspace.consumer.bitMap;
+  adoptedIds.forEach(id => {
+    bitMap.updateComponentId(id);
+    bitMap.setOnLanesOnly(id, true);
+  });
+  // cached component lists still reflect the pre-adoption `.bitmap`
+  workspace.clearAllComponentsCache();
+  await workspace.scope.legacyScope.scopeImporter.importMany({
+    ids: _componentId().ComponentIdList.fromArray(adoptedIds),
+    lane,
+    includeUnexported: true,
+    includeUpdateDependents: true,
+    reason: `lane ${laneId.toString()} provides component(s) this workspace tracks as new`
+  });
+  return adoptedIds;
+}
+
+/**
+ * Runs after a switch failed with the missing-component marker: adopt the lane's versions, then
+ * retry the switch once. Returns undefined on success, and the error to report on failure. A
+ * failed retry reloads the workspace from disk — the failed switch never wrote to it — so the
+ * in-memory adoption disappears completely (including `updatedIds` and the changed flag).
+ */
+async function adoptAndRetrySwitch(laneName, originalErr, doSwitch, writeAdoptedFiles, deps) {
+  const {
+    logger,
+    reloadWorkspace
+  } = deps;
+  const rollback = async err => {
+    await reloadWorkspace().catch(reloadErr => {
+      logger.console(_chalk().default.yellow(`Failed to reload the workspace after the adoption retry: ${reloadErr?.toString() ?? reloadErr}`));
+    });
+    return err;
+  };
+  const adopted = await adoptNewComponentsTheLaneProvides(laneName, deps).catch(adoptErr => {
+    logger.console(_chalk().default.yellow(`The adoption retry failed: ${adoptErr?.toString() ?? adoptErr}`));
+    return [];
+  });
+  if (!adopted.length) return rollback(originalErr);
+  try {
+    await doSwitch();
+    // the retried switch skips an id already at the lane's version, so its files are still unwritten
+    if (writeAdoptedFiles) await writeFilesKeepingConfig(adopted, deps);
+    return undefined;
+  } catch (retryErr) {
+    return rollback(retryErr);
+  }
+}
+
+/**
+ * `checkout --reset` writes the files of an entry that already records the target version, but its
+ * `resetConfig` also deletes the entry's `.bitmap` config — keep the config across the call.
+ */
+async function writeFilesKeepingConfig(adopted, {
+  workspace,
+  checkout
+}) {
+  const bitMap = workspace.consumer.bitMap;
+  const entryConfig = id => bitMap.getComponentIfExist(id, {
+    ignoreVersion: true
+  })?.config;
+  const configs = adopted.map(id => ({
+    id,
+    config: entryConfig(id)
+  }));
+  await checkout.checkout({
+    ids: adopted,
+    reset: true,
+    skipNpmInstall: true
+  });
+  configs.forEach(({
+    id,
+    config
+  }) => {
+    const entry = bitMap.getComponentIfExist(id, {
+      ignoreVersion: true
+    });
+    if (!config || !entry || entry.config) return;
+    entry.config = config;
+    bitMap.markAsChanged();
+  });
+}
+
+//# sourceMappingURL=adopt-lane-new-components.js.map

package/dist/sync/adopt-lane-new-components.js.map

@@ -0,0 +1 @@
+{"version":3,"names":["_chalk","data","_interopRequireDefault","require","_componentId","_laneSyncExecutor","e","__esModule","default","isLaneMissingComponentError","err","msg","message","String","includes","adoptNewComponentsTheLaneProvides","laneName","workspace","lanes","logger","newIds","newComponentIds","length","laneId","parseLaneId","isDefault","lane","importLaneObject","newIdsList","ComponentIdList","fromArray","adoptedIds","toComponentIdsIncludeUpdateDependents","filter","laneCompId","hasWithoutVersion","console","chalk","blue","capEntries","map","id","toStringWithoutVersion","join","bitMap","consumer","forEach","updateComponentId","setOnLanesOnly","clearAllComponentsCache","scope","legacyScope","scopeImporter","importMany","ids","includeUnexported","includeUpdateDependents","reason","toString","adoptAndRetrySwitch","originalErr","doSwitch","writeAdoptedFiles","deps","reloadWorkspace","rollback","catch","reloadErr","yellow","adopted","adoptErr","writeFilesKeepingConfig","undefined","retryErr","checkout","entryConfig","getComponentIfExist","ignoreVersion","config","configs","reset","skipNpmInstall","entry","markAsChanged"],"sources":["adopt-lane-new-components.ts"],"sourcesContent":["import chalk from 'chalk';\nimport type { CheckoutMain } from '@teambit/checkout';\nimport type { ComponentID } from '@teambit/component-id';\nimport { ComponentIdList } from '@teambit/component-id';\nimport type { LanesMain } from '@teambit/lanes';\nimport type { Logger } from '@teambit/logger';\nimport type { Workspace } from '@teambit/workspace';\nimport { capEntries } from './lane-sync-executor';\n\nexport type AdoptLaneNewComponentsDeps = {\n  workspace: Workspace;\n  lanes: LanesMain;\n  logger: Logger;\n};\n\nexport type AdoptRetryDeps = AdoptLaneNewComponentsDeps & {\n  checkout: CheckoutMain;\n  reloadWorkspace: () => Promise<void>;\n};\n\n/**\n * The lane merge (`sources.mergeLane` in the legacy scope) throws a plain Error with this wording\n * when a lane component's objects are absent. A typed error needs a change outside the ci aspect;\n * the stale-lane recovery of `bit ci pr` matches the same text.\n */\nexport function isLaneMissingComponentError(err: unknown): boolean {\n  const msg = (err as Error)?.message ?? String(err ?? '');\n  return msg.includes('unable to merge lane') && msg.includes('was not found');\n}\n\n/**\n * A versionless `.bitmap` entry reads as local and unexported, so a lane fetch drops its id and\n * the lane merge fails with `the component … was not found`. Adopt the lane's version into each\n * such entry, and import the adopted objects (`includeUnexported`, because the entries made them\n * look local). The mutation is in memory; the caller owns the rollback on a failed retry.\n * The returned ids already record the lane's version, so a retried switch skips their files; an\n * importing caller must write them (`checkout --reset`).\n */\nexport async function adoptNewComponentsTheLaneProvides(\n  laneName: string,\n  { workspace, lanes, logger }: AdoptLaneNewComponentsDeps\n): Promise<ComponentID[]> {\n  const newIds = await workspace.newComponentIds();\n  if (!newIds.length) return [];\n  const laneId = await lanes.parseLaneId(laneName);\n  if (laneId.isDefault()) return [];\n  const lane = await lanes.importLaneObject(laneId);\n  const newIdsList = ComponentIdList.fromArray(newIds);\n  const adoptedIds = lane\n    .toComponentIdsIncludeUpdateDependents()\n    .filter((laneCompId) => newIdsList.hasWithoutVersion(laneCompId));\n  if (!adoptedIds.length) return [];\n  logger.console(\n    chalk.blue(\n      `Adopting the lane's version for component(s) this workspace tracks as new: ` +\n        capEntries(adoptedIds.map((id) => id.toStringWithoutVersion())).join(', ')\n    )\n  );\n  const bitMap = workspace.consumer.bitMap;\n  adoptedIds.forEach((id) => {\n    bitMap.updateComponentId(id);\n    bitMap.setOnLanesOnly(id, true);\n  });\n  // cached component lists still reflect the pre-adoption `.bitmap`\n  workspace.clearAllComponentsCache();\n  await workspace.scope.legacyScope.scopeImporter.importMany({\n    ids: ComponentIdList.fromArray(adoptedIds),\n    lane,\n    includeUnexported: true,\n    includeUpdateDependents: true,\n    reason: `lane ${laneId.toString()} provides component(s) this workspace tracks as new`,\n  });\n  return adoptedIds;\n}\n\n/**\n * Runs after a switch failed with the missing-component marker: adopt the lane's versions, then\n * retry the switch once. Returns undefined on success, and the error to report on failure. A\n * failed retry reloads the workspace from disk — the failed switch never wrote to it — so the\n * in-memory adoption disappears completely (including `updatedIds` and the changed flag).\n */\nexport async function adoptAndRetrySwitch(\n  laneName: string,\n  originalErr: Error,\n  doSwitch: () => Promise<unknown>,\n  writeAdoptedFiles: boolean | undefined,\n  deps: AdoptRetryDeps\n): Promise<Error | undefined> {\n  const { logger, reloadWorkspace } = deps;\n  const rollback = async (err: Error) => {\n    await reloadWorkspace().catch((reloadErr) => {\n      logger.console(\n        chalk.yellow(`Failed to reload the workspace after the adoption retry: ${reloadErr?.toString() ?? reloadErr}`)\n      );\n    });\n    return err;\n  };\n  const adopted = await adoptNewComponentsTheLaneProvides(laneName, deps).catch((adoptErr) => {\n    logger.console(chalk.yellow(`The adoption retry failed: ${adoptErr?.toString() ?? adoptErr}`));\n    return [];\n  });\n  if (!adopted.length) return rollback(originalErr);\n  try {\n    await doSwitch();\n    // the retried switch skips an id already at the lane's version, so its files are still unwritten\n    if (writeAdoptedFiles) await writeFilesKeepingConfig(adopted, deps);\n    return undefined;\n  } catch (retryErr: any) {\n    return rollback(retryErr);\n  }\n}\n\n/**\n * `checkout --reset` writes the files of an entry that already records the target version, but its\n * `resetConfig` also deletes the entry's `.bitmap` config — keep the config across the call.\n */\nasync function writeFilesKeepingConfig(adopted: ComponentID[], { workspace, checkout }: AdoptRetryDeps) {\n  const bitMap = workspace.consumer.bitMap;\n  const entryConfig = (id: ComponentID) => bitMap.getComponentIfExist(id, { ignoreVersion: true })?.config;\n  const configs = adopted.map((id) => ({ id, config: entryConfig(id) }));\n  await checkout.checkout({ ids: adopted, reset: true, skipNpmInstall: true });\n  configs.forEach(({ id, config }) => {\n    const entry = bitMap.getComponentIfExist(id, { ignoreVersion: true });\n    if (!config || !entry || entry.config) return;\n    entry.config = config;\n    bitMap.markAsChanged();\n  });\n}\n"],"mappings":"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","ignoreList":[]}

package/dist/sync/lane-sync-executor.js

@@ -1040,7 +1040,8 @@ class LaneSyncExecutor {
     }
     const switchErr = await this.deps.ci.switchToLaneForSync(laneIdStr, {
       forceOurs: false,
-      forceTheirs: true
+      forceTheirs: true,
+      writeAdoptedFiles: true
     });
     if (switchErr) return switchErr;