@teambit/checkout 1.0.108 → 1.0.109

package/artifacts/preview/teambit_component_checkout-preview.js

@@ -0,0 +1 @@
+!function(e,o){"object"==typeof exports&&"object"==typeof module?module.exports=o():"function"==typeof define&&define.amd?define([],o):"object"==typeof exports?exports["teambit.component/checkout-preview"]=o():e["teambit.component/checkout-preview"]=o()}(self,(()=>(()=>{"use strict";var e={d:(o,t)=>{for(var r in t)e.o(t,r)&&!e.o(o,r)&&Object.defineProperty(o,r,{enumerable:!0,get:t[r]})},o:(e,o)=>Object.prototype.hasOwnProperty.call(e,o),r:e=>{"undefined"!=typeof Symbol&&Symbol.toStringTag&&Object.defineProperty(e,Symbol.toStringTag,{value:"Module"}),Object.defineProperty(e,"__esModule",{value:!0})}},o={};e.r(o),e.d(o,{compositions:()=>t,compositions_metadata:()=>n,overview:()=>r});const t=[],r=[],n={compositions:[]};return o})()));

package/package.json

@@ -1,12 +1,12 @@
 {
   "name": "@teambit/checkout",
-  "version": "1.0.108",
+  "version": "1.0.109",
   "homepage": "https://bit.cloud/teambit/component/checkout",
   "main": "dist/index.js",
   "componentId": {
     "scope": "teambit.component",
     "name": "checkout",
-    "version": "1.0.108"
+    "version": "1.0.109"
   },
   "dependencies": {
     "chalk": "2.4.2",
@@ -15,20 +15,20 @@
     "@teambit/bit-error": "0.0.404",
     "@teambit/component-id": "1.2.0",
     "@teambit/harmony": "0.4.6",
-    "@teambit/cli": "0.0.840",
-    "@teambit/merging": "1.0.108",
-    "@teambit/component-writer": "1.0.108",
-    "@teambit/importer": "1.0.108",
-    "@teambit/logger": "0.0.933",
-    "@teambit/remove": "1.0.108",
-    "@teambit/workspace": "1.0.108"
+    "@teambit/cli": "0.0.841",
+    "@teambit/merging": "1.0.109",
+    "@teambit/component-writer": "1.0.109",
+    "@teambit/importer": "1.0.109",
+    "@teambit/logger": "0.0.934",
+    "@teambit/remove": "1.0.109",
+    "@teambit/workspace": "1.0.109"
   },
   "devDependencies": {
     "@types/lodash": "4.14.165",
     "@types/mocha": "9.1.0",
     "@types/jest": "^29.2.2",
     "@types/testing-library__jest-dom": "^5.9.5",
-    "@teambit/harmony.envs.core-aspect-env": "0.0.13"
+    "@teambit/harmony.envs.core-aspect-env": "0.0.14"
   },
   "peerDependencies": {
     "@teambit/legacy": "1.0.624"

package/checkout-cmd.ts

@@ -1,261 +0,0 @@
-import chalk from 'chalk';
-import { Command, CommandOptions } from '@teambit/cli';
-import {
-  ApplyVersionResults,
-  applyVersionReport,
-  conflictSummaryReport,
-  installationErrorOutput,
-  compilationErrorOutput,
-  getRemovedOutput,
-  getAddedOutput,
-} from '@teambit/merging';
-import { COMPONENT_PATTERN_HELP, HEAD, LATEST } from '@teambit/legacy/dist/constants';
-import { MergeStrategy } from '@teambit/legacy/dist/consumer/versions-ops/merge-version';
-import { ComponentID } from '@teambit/component-id';
-import { BitError } from '@teambit/bit-error';
-import { CheckoutMain, CheckoutProps } from './checkout.main.runtime';
-
-export class CheckoutCmd implements Command {
-  name = 'checkout <to> [component-pattern]';
-  arguments = [
-    {
-      name: 'to',
-      description:
-        "permitted values: [head, latest, reset, specific-version]. 'head' - last snap/tag. 'latest' - semver latest tag. 'reset' - removes local changes",
-    },
-    {
-      name: 'component-pattern',
-      description: COMPONENT_PATTERN_HELP,
-    },
-  ];
-  description = 'switch between component versions or remove local changes';
-  helpUrl = 'reference/components/merging-changes#checkout-snaps-to-the-working-directory';
-  group = 'development';
-  extendedDescription = `
-\`bit checkout <version> [component-pattern]\` => checkout the specified ids (or all components when --all is used) to the specified version
-\`bit checkout head [component-pattern]\` => checkout to the last snap/tag (use --latest if you only want semver tags), omit [component-pattern] to checkout head for all
-\`bit checkout latest [component-pattern]\` => checkout to the latest satisfying semver tag, omit [component-pattern] to checkout latest for all
-\`bit checkout reset [component-pattern]\` => remove local modifications from the specified ids (or all components when --all is used)
-when on a lane, "checkout head" only checks out components on this lane. to update main components, run "bit lane merge main"`;
-  alias = 'U';
-  options = [
-    [
-      'i',
-      'interactive-merge',
-      'when a component is modified and the merge process found conflicts, display options to resolve them',
-    ],
-    ['', 'ours', 'DEPRECATED. use --auto-merge-resolve. In the future, this flag will leave the current code intact'],
-    [
-      '',
-      'theirs',
-      'DEPRECATED. use --auto-merge-resolve. In the future, this flag will override the current code with the incoming code',
-    ],
-    ['', 'manual', 'DEPRECATED. use --auto-merge-resolve'],
-    [
-      '',
-      'auto-merge-resolve <merge-strategy>',
-      'in case of merge conflict, resolve according to the provided strategy: [ours, theirs, manual]',
-    ],
-    ['r', 'reset', 'revert changes that were not snapped/tagged'],
-    ['a', 'all', 'all components'],
-    [
-      'e',
-      'workspace-only',
-      "only relevant for 'bit checkout head' when on a lane. don't import components from the remote lane that are not already in the workspace",
-    ],
-    ['v', 'verbose', 'showing verbose output for inspection'],
-    ['x', 'skip-dependency-installation', 'do not auto-install dependencies of the imported components'],
-  ] as CommandOptions;
-  loader = true;
-
-  constructor(private checkout: CheckoutMain) {}
-
-  async report(
-    [to, componentPattern]: [string, string],
-    {
-      interactiveMerge = false,
-      ours = false,
-      theirs = false,
-      manual = false,
-      autoMergeResolve,
-      all = false,
-      workspaceOnly = false,
-      verbose = false,
-      skipDependencyInstallation = false,
-      revert = false,
-    }: {
-      interactiveMerge?: boolean;
-      ours?: boolean;
-      theirs?: boolean;
-      manual?: boolean;
-      autoMergeResolve?: MergeStrategy;
-      all?: boolean;
-      workspaceOnly?: boolean;
-      verbose?: boolean;
-      skipDependencyInstallation?: boolean;
-      revert?: boolean;
-    }
-  ) {
-    if (ours || theirs || manual) {
-      throw new BitError(
-        'the "--ours", "--theirs" and "--manual" flags are deprecated. use "--auto-merge-resolve" instead.'
-      );
-    }
-    if (
-      autoMergeResolve &&
-      autoMergeResolve !== 'ours' &&
-      autoMergeResolve !== 'theirs' &&
-      autoMergeResolve !== 'manual'
-    ) {
-      throw new BitError('--auto-merge-resolve must be one of the following: [ours, theirs, manual]');
-    }
-    if (workspaceOnly && to !== HEAD) {
-      throw new BitError('--workspace-only is only relevant when running "bit checkout head" on a lane');
-    }
-    const checkoutProps: CheckoutProps = {
-      promptMergeOptions: interactiveMerge,
-      mergeStrategy: autoMergeResolve,
-      all,
-      verbose,
-      isLane: false,
-      skipNpmInstall: skipDependencyInstallation,
-      workspaceOnly,
-      revert,
-    };
-    if (to === HEAD) checkoutProps.head = true;
-    else if (to === LATEST) checkoutProps.latest = true;
-    else if (to === 'reset') checkoutProps.reset = true;
-    else if (to === 'main') checkoutProps.main = true;
-    else {
-      if (!ComponentID.isValidVersion(to)) throw new BitError(`the specified version "${to}" is not a valid version`);
-      checkoutProps.version = to;
-    }
-
-    const checkoutResults = await this.checkout.checkoutByCLIValues(componentPattern || '', checkoutProps);
-    return checkoutOutput(checkoutResults, checkoutProps);
-  }
-}
-
-export function checkoutOutput(checkoutResults: ApplyVersionResults, checkoutProps: CheckoutProps) {
-  const {
-    components,
-    version,
-    failedComponents,
-    removedComponents,
-    addedComponents,
-    leftUnresolvedConflicts,
-    newFromLane,
-    newFromLaneAdded,
-    installationError,
-    compilationError,
-  }: ApplyVersionResults = checkoutResults;
-
-  const { head, reset, latest, main, revert, verbose, all } = checkoutProps;
-
-  // components that failed for no legitimate reason. e.g. merge-conflict.
-  const realFailedComponents = (failedComponents || []).filter((f) => !f.unchangedLegitimately);
-  // components that weren't checked out for legitimate reasons, e.g. up-to-date.
-  const notCheckedOutComponents = (failedComponents || []).filter((f) => f.unchangedLegitimately);
-
-  const getFailureOutput = () => {
-    if (!realFailedComponents.length) return '';
-    const title = 'the checkout has been failed on the following component(s)';
-    const body = realFailedComponents
-      .map(
-        (failedComponent) =>
-          `${chalk.bold(failedComponent.id.toString())} - ${chalk.red(failedComponent.unchangedMessage)}`
-      )
-      .join('\n');
-    return `${chalk.underline(title)}\n${body}\n\n`;
-  };
-  const getNotCheckedOutOutput = () => {
-    if (!notCheckedOutComponents.length) return '';
-    if (!verbose && all) {
-      return chalk.green(
-        `checkout was not needed for ${chalk.bold(
-          notCheckedOutComponents.length.toString()
-        )} components (use --verbose to get more details)\n`
-      );
-    }
-    const title = 'checkout was not required for the following component(s)';
-    const body = notCheckedOutComponents
-      .map((failedComponent) => `${failedComponent.id.toString()} - ${failedComponent.unchangedMessage}`)
-      .join('\n');
-    return `${chalk.underline(title)}\n${body}\n\n`;
-  };
-  const getConflictSummary = () => {
-    if (!components || !components.length || !leftUnresolvedConflicts) return '';
-    const title = `\n\nfiles with conflicts summary\n`;
-    const suggestion = `\n\nfix the conflicts above manually and then run "bit install".
-once ready, snap/tag the components to persist the changes`;
-    return chalk.underline(title) + conflictSummaryReport(components) + chalk.yellow(suggestion);
-  };
-  const getSuccessfulOutput = () => {
-    const switchedOrReverted = revert ? 'reverted' : 'switched';
-    if (!components || !components.length) return '';
-    if (components.length === 1) {
-      const component = components[0];
-      const componentName = reset ? component.id.toString() : component.id.toStringWithoutVersion();
-      if (reset) return `successfully reset ${chalk.bold(componentName)}\n`;
-      const title = `successfully ${switchedOrReverted} ${chalk.bold(componentName)} to version ${chalk.bold(
-        // @ts-ignore version is defined when !reset
-        head || latest ? component.id.version : version
-      )}\n`;
-      return chalk.bold(title) + applyVersionReport(components, false);
-    }
-    if (reset) {
-      const title = 'successfully reset the following components\n\n';
-      const body = components.map((component) => chalk.bold(component.id.toString())).join('\n');
-      return chalk.underline(title) + body;
-    }
-    const getVerOutput = () => {
-      if (head) return 'their head version';
-      if (latest) return 'their latest version';
-      if (main) return 'their main version';
-      // @ts-ignore version is defined when !reset
-      return `version ${chalk.bold(version)}`;
-    };
-    const versionOutput = getVerOutput();
-    const title = `successfully ${switchedOrReverted} ${components.length} components to ${versionOutput}\n`;
-    const showVersion = head || reset;
-    return chalk.bold(title) + applyVersionReport(components, true, showVersion);
-  };
-  const getNewOnLaneOutput = () => {
-    if (!newFromLane?.length) return '';
-    const title = newFromLaneAdded
-      ? `successfully added the following components from the lane`
-      : `the following components exist on the lane but were not added to the workspace. omit --workspace-only flag to add them`;
-    const body = newFromLane.join('\n');
-    return `\n\n${chalk.underline(title)}\n${body}`;
-  };
-  const getSummary = () => {
-    const checkedOut = components?.length || 0;
-    const notCheckedOutLegitimately = notCheckedOutComponents.length;
-    const failedToCheckOut = realFailedComponents.length;
-    const newLines = '\n\n';
-    const title = chalk.bold.underline('Summary');
-    const checkedOutStr = `\nTotal Changed: ${chalk.bold(checkedOut.toString())}`;
-    const unchangedLegitimatelyStr = `\nTotal Unchanged: ${chalk.bold(notCheckedOutLegitimately.toString())}`;
-    const failedToCheckOutStr = `\nTotal Failed: ${chalk.bold(failedToCheckOut.toString())}`;
-    const newOnLaneNum = newFromLane?.length || 0;
-    const newOnLaneAddedStr = newFromLaneAdded ? ' (added)' : ' (not added)';
-    const newOnLaneStr = newOnLaneNum
-      ? `\nNew on lane${newOnLaneAddedStr}: ${chalk.bold(newOnLaneNum.toString())}`
-      : '';
-
-    return newLines + title + checkedOutStr + unchangedLegitimatelyStr + failedToCheckOutStr + newOnLaneStr;
-  };
-
-  return (
-    getFailureOutput() +
-    getNotCheckedOutOutput() +
-    getSuccessfulOutput() +
-    getRemovedOutput(removedComponents) +
-    getAddedOutput(addedComponents) +
-    getNewOnLaneOutput() +
-    getConflictSummary() +
-    getSummary() +
-    installationErrorOutput(installationError) +
-    compilationErrorOutput(compilationError)
-  );
-}

package/checkout-version.ts

@@ -1,240 +0,0 @@
-import * as path from 'path';
-import { Consumer } from '@teambit/legacy/dist/consumer';
-import { ComponentID } from '@teambit/component-id';
-import GeneralError from '@teambit/legacy/dist/error/general-error';
-import Version from '@teambit/legacy/dist/scope/models/version';
-import { SourceFile } from '@teambit/legacy/dist/consumer/component/sources';
-import { pathNormalizeToLinux, PathOsBased } from '@teambit/legacy/dist/utils/path';
-import DataToPersist from '@teambit/legacy/dist/consumer/component/sources/data-to-persist';
-import RemovePath from '@teambit/legacy/dist/consumer/component/sources/remove-path';
-import {
-  ApplyVersionResult,
-  FilesStatus,
-  FileStatus,
-  MergeOptions,
-  MergeStrategy,
-} from '@teambit/legacy/dist/consumer/versions-ops/merge-version';
-import { MergeResultsThreeWay } from '@teambit/legacy/dist/consumer/versions-ops/merge-version/three-way-merge';
-import ConsumerComponent from '@teambit/legacy/dist/consumer/component';
-import { BitError } from '@teambit/bit-error';
-import chalk from 'chalk';
-
-export type CheckoutProps = {
-  version?: string; // if reset is true, the version is undefined
-  ids?: ComponentID[];
-  latestVersion?: boolean;
-  promptMergeOptions?: boolean;
-  mergeStrategy?: MergeStrategy | null;
-  verbose?: boolean;
-  skipNpmInstall?: boolean;
-  ignorePackageJson?: boolean;
-  writeConfig?: boolean;
-  reset?: boolean; // remove local changes. if set, the version is undefined.
-  all?: boolean; // checkout all ids
-  ignoreDist?: boolean;
-  isLane?: boolean;
-};
-
-export type ComponentStatusBase = {
-  currentComponent?: ConsumerComponent;
-  componentFromModel?: Version;
-  id: ComponentID;
-  shouldBeRemoved?: boolean; // in case the component is soft-removed, it should be removed from the workspace
-  unchangedMessage?: string; // this gets populated either upon skip or failure.
-  unchangedLegitimately?: boolean; // true for skipped legitimately (e.g. already up to date). false for failure.
-};
-
-export type ComponentStatus = ComponentStatusBase & {
-  mergeResults?: MergeResultsThreeWay | null | undefined;
-};
-
-export type ApplyVersionWithComps = {
-  applyVersionResult: ApplyVersionResult;
-  component?: ConsumerComponent;
-  // in case the component needs to be written to the filesystem, this is the component to write.
-  legacyCompToWrite?: ConsumerComponent;
-};
-
-/**
- * 1) when the files are modified with conflicts and the strategy is "ours", leave the FS as is
- * and update only bitmap id version. (not the componentMap object).
- *
- * 2) when the files are modified with conflicts and the strategy is "theirs", write the component
- * according to id.version.
- *
- * 3) when files are modified with no conflict or files are modified with conflicts and the
- * strategy is manual, load the component according to id.version and update component.files.
- * applyModifiedVersion() docs explains what files are updated/added.
- *
- * 4) when --reset flag is used, write the component according to the bitmap version
- *
- * Side note:
- * Deleted file => if files are in used version but not in the modified one, no need to delete it. (similar to git).
- * Added file => if files are not in used version but in the modified one, they'll be under mergeResults.addFiles
- */
-export async function applyVersion(
-  consumer: Consumer,
-  id: ComponentID,
-  componentFromFS: ConsumerComponent | null | undefined, // it can be null only when isLanes is true
-  mergeResults: MergeResultsThreeWay | null | undefined,
-  checkoutProps: CheckoutProps
-): Promise<ApplyVersionWithComps> {
-  if (!checkoutProps.isLane && !componentFromFS)
-    throw new Error(`applyVersion expect to get componentFromFS for ${id.toString()}`);
-  const { mergeStrategy } = checkoutProps;
-  let filesStatus = {};
-  if (mergeResults && mergeResults.hasConflicts && mergeStrategy === MergeOptions.ours) {
-    // even when isLane is true, the mergeResults is possible only when the component is on the filesystem
-    // otherwise it's impossible to have conflicts
-    if (!componentFromFS) throw new Error(`applyVersion expect to get componentFromFS for ${id.toString()}`);
-    componentFromFS.files.forEach((file) => {
-      filesStatus[pathNormalizeToLinux(file.relative)] = FileStatus.unchanged;
-    });
-    consumer.bitMap.updateComponentId(id);
-    return { applyVersionResult: { id, filesStatus } };
-  }
-  const component = await consumer.loadComponentFromModelImportIfNeeded(id);
-  const componentMap = componentFromFS && componentFromFS.componentMap;
-  if (componentFromFS && !componentMap) throw new GeneralError('applyVersion: componentMap was not found');
-
-  const files = component.files;
-  updateFileStatus(files, filesStatus, componentFromFS || undefined);
-
-  await removeFilesIfNeeded(filesStatus, componentFromFS || undefined);
-
-  if (mergeResults) {
-    // update files according to the merge results
-    const { filesStatus: modifiedStatus, modifiedFiles } = applyModifiedVersion(files, mergeResults, mergeStrategy);
-    filesStatus = { ...filesStatus, ...modifiedStatus };
-    component.files = modifiedFiles;
-  }
-
-  return {
-    applyVersionResult: { id, filesStatus },
-    component,
-  };
-}
-
-export function updateFileStatus(files: SourceFile[], filesStatus: FilesStatus, componentFromFS?: ConsumerComponent) {
-  files.forEach((file) => {
-    const fileFromFs = componentFromFS?.files.find((f) => f.relative === file.relative);
-    const areFilesEqual = fileFromFs && Buffer.compare(fileFromFs.contents, file.contents) === 0;
-    // @ts-ignore
-    filesStatus[pathNormalizeToLinux(file.relative)] = areFilesEqual ? FileStatus.unchanged : FileStatus.updated;
-  });
-}
-
-/**
- * when files exist on the filesystem but not on the checked out versions, they need to be deleted.
- * without this function, these files would be left on the filesystem. (we don't delete the comp-dir before writing).
- * this needs to be done *before* the component is written to the filesystem, otherwise, it won't work when a file
- * has a case change. e.g. from uppercase to lowercase. (see merge-lane.e2e 'renaming files from uppercase to lowercase').
- */
-export async function removeFilesIfNeeded(filesStatus: FilesStatus, componentFromFS?: ConsumerComponent) {
-  if (!componentFromFS) return;
-  const filePathsFromFS = componentFromFS.files || [];
-  const dataToPersist = new DataToPersist();
-  filePathsFromFS.forEach((file) => {
-    const filename = pathNormalizeToLinux(file.relative);
-    if (!filesStatus[filename]) {
-      // @ts-ignore todo: typescript has a good point here. it should be the string "removed", not chalk.green(removed).
-      filesStatus[filename] = FileStatus.removed;
-      dataToPersist.removePath(new RemovePath(file.path));
-    }
-  });
-  await dataToPersist.persistAllToFS();
-}
-
-/**
- * relevant only when
- * 1) there is no conflict => add files from mergeResults: addFiles, overrideFiles and modifiedFiles.output.
- * 2) there is conflict and mergeStrategy is manual => add files from mergeResults: addFiles, overrideFiles and modifiedFiles.conflict.
- *
- * this function only updates the files content, it doesn't write the files
- */
-export function applyModifiedVersion(
-  componentFiles: SourceFile[],
-  mergeResults: MergeResultsThreeWay,
-  mergeStrategy: MergeStrategy | null | undefined
-): { filesStatus: Record<string, any>; modifiedFiles: SourceFile[] } {
-  let modifiedFiles = componentFiles.map((file) => file.clone());
-  const filesStatus = {};
-  if (mergeResults.hasConflicts && mergeStrategy !== MergeOptions.manual) {
-    return { filesStatus, modifiedFiles };
-  }
-  mergeResults.modifiedFiles.forEach((file) => {
-    const filePath: PathOsBased = path.normalize(file.filePath);
-    const foundFile = modifiedFiles.find((componentFile) => componentFile.relative === filePath);
-    if (!foundFile) throw new GeneralError(`file ${filePath} not found`);
-    if (file.conflict) {
-      foundFile.contents = Buffer.from(file.conflict);
-      filesStatus[file.filePath] = FileStatus.manual;
-    } else if (typeof file.output === 'string') {
-      foundFile.contents = Buffer.from(file.output);
-      filesStatus[file.filePath] = FileStatus.merged;
-    } else if (file.isBinaryConflict) {
-      // leave the file as is and notify the user later about it.
-      foundFile.contents = file.fsFile.contents;
-      filesStatus[file.filePath] = FileStatus.binaryConflict;
-    } else {
-      throw new GeneralError(`file ${filePath} does not have output nor conflict`);
-    }
-  });
-
-  mergeResults.addFiles.forEach((file) => {
-    const filePath: PathOsBased = path.normalize(file.filePath);
-    if (modifiedFiles.find((m) => m.relative === filePath)) return;
-    modifiedFiles.push(file.fsFile);
-    filesStatus[file.filePath] = FileStatus.added;
-  });
-  mergeResults.deletedConflictFiles.forEach((file) => {
-    if (!file.fsFile) return;
-    const filePath: PathOsBased = path.normalize(file.filePath);
-    if (modifiedFiles.find((m) => m.relative === filePath)) return;
-    modifiedFiles.push(file.fsFile);
-    filesStatus[file.filePath] = FileStatus.added;
-  });
-  mergeResults.removeFiles.forEach((file) => {
-    const filePath: PathOsBased = path.normalize(file.filePath);
-    filesStatus[file.filePath] = FileStatus.removed;
-    modifiedFiles = modifiedFiles.filter((f) => f.relative !== filePath);
-  });
-  mergeResults.remainDeletedFiles.forEach((file) => {
-    const filePath: PathOsBased = path.normalize(file.filePath);
-    modifiedFiles = modifiedFiles.filter((f) => f.relative !== filePath);
-    filesStatus[file.filePath] = FileStatus.remainDeleted;
-  });
-  mergeResults.deletedConflictFiles.forEach((file) => {
-    filesStatus[file.filePath] = FileStatus.deletedConflict;
-  });
-
-  mergeResults.overrideFiles.forEach((file) => {
-    const filePath: PathOsBased = path.normalize(file.filePath);
-    const foundFile = modifiedFiles.find((componentFile) => componentFile.relative === filePath);
-    if (!foundFile) throw new GeneralError(`file ${filePath} not found`);
-    foundFile.contents = file.fsFile.contents;
-    filesStatus[file.filePath] = FileStatus.overridden;
-  });
-  mergeResults.updatedFiles.forEach((file) => {
-    const filePath: PathOsBased = path.normalize(file.filePath);
-    const foundFile = modifiedFiles.find((componentFile) => componentFile.relative === filePath);
-    if (!foundFile) throw new GeneralError(`file ${filePath} not found`);
-    foundFile.contents = file.content;
-    filesStatus[file.filePath] = FileStatus.updated;
-  });
-
-  return { filesStatus, modifiedFiles };
-}
-
-export function throwForFailures(allComponentsStatus: ComponentStatusBase[]) {
-  const failedComponents = allComponentsStatus.filter((c) => c.unchangedMessage && !c.unchangedLegitimately);
-  if (failedComponents.length) {
-    const failureMsgs = failedComponents
-      .map(
-        (failedComponent) =>
-          `${chalk.bold(failedComponent.id.toString())} - ${chalk.red(failedComponent.unchangedMessage as string)}`
-      )
-      .join('\n');
-    throw new BitError(`unable to proceed due to the following failures:\n${failureMsgs}`);
-  }
-}

package/checkout.aspect.ts

@@ -1,5 +0,0 @@
-import { Aspect } from '@teambit/harmony';
-
-export const CheckoutAspect = Aspect.create({
-  id: 'teambit.component/checkout',
-});

package/checkout.main.runtime.ts

@@ -1,514 +0,0 @@
-import { CLIAspect, CLIMain, MainRuntime } from '@teambit/cli';
-import { Logger, LoggerAspect, LoggerMain } from '@teambit/logger';
-import WorkspaceAspect, { OutsideWorkspaceError, Workspace } from '@teambit/workspace';
-import { BitError } from '@teambit/bit-error';
-import { compact } from 'lodash';
-import { BEFORE_CHECKOUT } from '@teambit/legacy/dist/cli/loader/loader-messages';
-import RemoveAspect, { RemoveMain } from '@teambit/remove';
-import { ApplyVersionResults, FailedComponents } from '@teambit/merging';
-import ImporterAspect, { ImporterMain } from '@teambit/importer';
-import { HEAD, LATEST } from '@teambit/legacy/dist/constants';
-import { ComponentWriterAspect, ComponentWriterMain } from '@teambit/component-writer';
-import {
-  getMergeStrategyInteractive,
-  MergeStrategy,
-  threeWayMerge,
-} from '@teambit/legacy/dist/consumer/versions-ops/merge-version';
-import GeneralError from '@teambit/legacy/dist/error/general-error';
-import mapSeries from 'p-map-series';
-import { ComponentIdList, ComponentID } from '@teambit/component-id';
-import { Version, ModelComponent, Lane } from '@teambit/legacy/dist/scope/models';
-import { Tmp } from '@teambit/legacy/dist/scope/repositories';
-import ComponentNotFoundInPath from '@teambit/legacy/dist/consumer/component/exceptions/component-not-found-in-path';
-import { CheckoutCmd } from './checkout-cmd';
-import { CheckoutAspect } from './checkout.aspect';
-import { applyVersion, ComponentStatus, ComponentStatusBase, throwForFailures } from './checkout-version';
-import { RevertCmd } from './revert-cmd';
-
-export type CheckoutProps = {
-  version?: string; // if reset/head/latest is true, the version is undefined
-  ids?: ComponentID[];
-  head?: boolean;
-  latest?: boolean;
-  main?: boolean; // relevant for "revert" only
-  promptMergeOptions?: boolean;
-  mergeStrategy?: MergeStrategy | null;
-  verbose?: boolean;
-  skipNpmInstall?: boolean;
-  reset?: boolean; // remove local changes. if set, the version is undefined.
-  revert?: boolean; // change the files according to the given version, but don't change the bitmap version and don't try to merge
-  all?: boolean; // checkout all ids
-  isLane?: boolean;
-  lane?: Lane; // currently needed for "bit switch" to tell the "fetch" where to fetch from
-  workspaceOnly?: boolean;
-  versionPerId?: ComponentID[]; // if given, the ComponentID.version is the version to checkout to.
-  skipUpdatingBitmap?: boolean; // needed for stash
-  restoreMissingComponents?: boolean; // in case .bitmap has a component and it's missing from the workspace, restore it (from model)
-  allowAddingComponentsFromScope?: boolean; // in case the id doesn't exist in .bitmap, add it from the scope (relevant for switch)
-  includeLocallyDeleted?: boolean; // include components that were deleted locally. currently enabled for "bit checkout reset" only.
-};
-
-export type ComponentStatusBeforeMergeAttempt = ComponentStatusBase & {
-  propsForMerge?: {
-    currentlyUsedVersion: string;
-    componentModel: ModelComponent;
-  };
-};
-
-export class CheckoutMain {
-  constructor(
-    private workspace: Workspace,
-    private logger: Logger,
-    private componentWriter: ComponentWriterMain,
-    private importer: ImporterMain,
-    private remove: RemoveMain
-  ) {}
-
-  async checkout(checkoutProps: CheckoutProps): Promise<ApplyVersionResults> {
-    const consumer = this.workspace.consumer;
-    const { version, ids, promptMergeOptions } = checkoutProps;
-    await this.syncNewComponents(checkoutProps);
-    const addedComponents = await this.restoreMissingComponents(checkoutProps);
-    const bitIds = ComponentIdList.fromArray(ids?.map((id) => id) || []);
-    // don't use Promise.all, it loads the components and this operation must be in sequence.
-    const allComponentStatusBeforeMerge = await mapSeries(bitIds, (id) =>
-      this.getComponentStatusBeforeMergeAttempt(id, checkoutProps)
-    );
-    const compsNeedMerge = allComponentStatusBeforeMerge.filter((c) => c.propsForMerge);
-    const compsNotNeedMerge = allComponentStatusBeforeMerge.filter((c) => !c.propsForMerge) as ComponentStatus[];
-
-    // in case the requested versions to checkout don't exist locally, import them.
-    const toImport = allComponentStatusBeforeMerge
-      .map((compStatus) => {
-        const idsToImport = [compStatus.id];
-        if (compStatus.propsForMerge) {
-          idsToImport.push(compStatus.id.changeVersion(compStatus.propsForMerge.currentlyUsedVersion));
-        }
-        return idsToImport;
-      })
-      .flat();
-
-    await this.workspace.scope.legacyScope.scopeImporter.importWithoutDeps(ComponentIdList.fromArray(toImport), {
-      cache: true,
-      lane: checkoutProps.lane,
-    });
-
-    const getComponentsStatusOfMergeNeeded = async (): Promise<ComponentStatus[]> => {
-      const tmp = new Tmp(consumer.scope);
-      try {
-        const afterMergeAttempt = await Promise.all(compsNeedMerge.map((c) => this.getMergeStatus(c)));
-        await tmp.clear();
-        return afterMergeAttempt;
-      } catch (err: any) {
-        await tmp.clear();
-        throw err;
-      }
-    };
-
-    const compStatusMergeNeeded = await getComponentsStatusOfMergeNeeded();
-
-    const allComponentsStatus: ComponentStatus[] = [...compStatusMergeNeeded, ...compsNotNeedMerge];
-    const componentWithConflict = allComponentsStatus.find(
-      (component) => component.mergeResults && component.mergeResults.hasConflicts
-    );
-    if (componentWithConflict) {
-      if (!promptMergeOptions && !checkoutProps.mergeStrategy) {
-        throw new GeneralError(
-          `automatic merge has failed for component ${componentWithConflict.id.toStringWithoutVersion()}.\nplease use "--auto-merge-resolve" with 'manual', 'ours' or 'theirs' to resolve the conflict/s`
-        );
-      }
-      if (!checkoutProps.mergeStrategy) checkoutProps.mergeStrategy = await getMergeStrategyInteractive();
-    }
-
-    throwForFailures(allComponentsStatus);
-
-    const failedComponents: FailedComponents[] = allComponentsStatus
-      .filter((componentStatus) => componentStatus.unchangedMessage)
-      .filter((componentStatus) => !componentStatus.shouldBeRemoved)
-      .map((componentStatus) => ({
-        id: componentStatus.id,
-        unchangedMessage: componentStatus.unchangedMessage as string,
-        unchangedLegitimately: componentStatus.unchangedLegitimately,
-      }));
-
-    const succeededComponents = allComponentsStatus.filter((componentStatus) => !componentStatus.unchangedMessage);
-    // do not use Promise.all for applyVersion. otherwise, it'll write all components in parallel,
-    // which can be an issue when some components are also dependencies of others
-    const checkoutPropsLegacy = { ...checkoutProps, ids: checkoutProps.ids?.map((id) => id) };
-    const componentsResults = await mapSeries(succeededComponents, ({ id, currentComponent, mergeResults }) => {
-      return applyVersion(consumer, id, currentComponent, mergeResults, checkoutPropsLegacy);
-    });
-
-    const componentsLegacy = compact(componentsResults.map((c) => c.component));
-
-    let newFromLane: ComponentID[] | undefined;
-    let newFromLaneAdded = false;
-    if (checkoutProps.head) {
-      newFromLane = await this.getNewComponentsFromLane(checkoutProps.ids || []);
-      if (!checkoutProps.workspaceOnly) {
-        const compsNewFromLane = await Promise.all(
-          newFromLane.map((id) => consumer.loadComponentFromModelImportIfNeeded(id))
-        );
-        componentsLegacy.push(...compsNewFromLane);
-        newFromLaneAdded = true;
-      }
-    }
-
-    const leftUnresolvedConflicts = componentWithConflict && checkoutProps.mergeStrategy === 'manual';
-    let componentWriterResults;
-    if (componentsLegacy.length) {
-      const manyComponentsWriterOpts = {
-        components: componentsLegacy,
-        skipDependencyInstallation: checkoutProps.skipNpmInstall || leftUnresolvedConflicts,
-        verbose: checkoutProps.verbose,
-        resetConfig: checkoutProps.reset,
-        skipUpdatingBitMap: checkoutProps.skipUpdatingBitmap,
-        reasonForBitmapChange: 'checkout',
-      };
-      componentWriterResults = await this.componentWriter.writeMany(manyComponentsWriterOpts);
-    }
-
-    const appliedVersionComponents = componentsResults.map((c) => c.applyVersionResult);
-
-    const componentIdsToRemove = allComponentsStatus
-      .filter((componentStatus) => componentStatus.shouldBeRemoved)
-      .map((c) => c.id.changeVersion(undefined));
-
-    if (componentIdsToRemove.length) {
-      await this.remove.removeLocallyByIds(componentIdsToRemove, { force: true });
-    }
-
-    return {
-      components: appliedVersionComponents,
-      removedComponents: componentIdsToRemove,
-      addedComponents,
-      version,
-      failedComponents,
-      leftUnresolvedConflicts,
-      newFromLane: newFromLane?.map((n) => n.toString()),
-      newFromLaneAdded,
-      installationError: componentWriterResults?.installationError,
-      compilationError: componentWriterResults?.compilationError,
-    };
-  }
-
-  /**
-   * if .bitmap entry exists but the rootDir is missing from the filesystem, find the component in the scope and restore it.
-   * returns the restored component ids.
-   */
-  async restoreMissingComponents(checkoutProps: CheckoutProps): Promise<ComponentID[] | undefined> {
-    if (!checkoutProps.restoreMissingComponents) return undefined;
-    const ids = checkoutProps.ids || [];
-    const missing: ComponentID[] = [];
-    await Promise.all(
-      ids.map(async (id) => {
-        const bitMapEntry = this.workspace.bitMap.getBitmapEntry(id, { ignoreVersion: true });
-        if (bitMapEntry.noFilesError && bitMapEntry.noFilesError instanceof ComponentNotFoundInPath) {
-          delete bitMapEntry.noFilesError;
-          missing.push(id);
-        }
-      })
-    );
-    if (!missing.length) return undefined;
-    const comps = await this.workspace.scope.getMany(missing);
-    await this.componentWriter.writeMany({
-      components: comps.map((c) => c.state._consumer),
-      skipDependencyInstallation: true,
-      skipUpdatingBitMap: true,
-    });
-
-    return missing;
-  }
-
-  async checkoutByCLIValues(componentPattern: string, checkoutProps: CheckoutProps): Promise<ApplyVersionResults> {
-    const { revert, head } = checkoutProps;
-    this.logger.setStatusLine(revert ? 'reverting components...' : BEFORE_CHECKOUT);
-    if (!this.workspace) throw new OutsideWorkspaceError();
-    const consumer = this.workspace.consumer;
-    await this.importer.importCurrentObjects(); // important. among others, it fetches the remote lane object and its new components.
-    if (head) await this.makeLaneComponentsAvailableOnMain();
-    await this.parseValues(componentPattern, checkoutProps);
-    const checkoutResults = await this.checkout(checkoutProps);
-    await consumer.onDestroy(`checkout (${componentPattern})`);
-    return checkoutResults;
-  }
-
-  private async syncNewComponents({ ids, head }: CheckoutProps) {
-    if (!head) return;
-    const notExported = ids?.filter((id) => !this.workspace.isExported(id)).map((id) => id.changeScope(id.scope));
-    const scopeComponentsImporter = this.workspace.consumer.scope.scopeImporter;
-    try {
-      await scopeComponentsImporter.importWithoutDeps(ComponentIdList.fromArray(notExported || []).toVersionLatest(), {
-        cache: false,
-        reason: 'for making sure the new components are really new and are not out-of-sync',
-        includeUnexported: true,
-      });
-    } catch (err) {
-      // don't stop the process. it's possible that the scope doesn't exist yet because these are new components
-      this.logger.error(`unable to sync new components, if these components are really new, ignore the error`, err);
-    }
-  }
-
-  private async makeLaneComponentsAvailableOnMain() {
-    const unavailableOnMain = await this.workspace.getUnavailableOnMainComponents();
-    if (!unavailableOnMain.length) return;
-    this.workspace.bitMap.makeComponentsAvailableOnMain(unavailableOnMain);
-  }
-
-  private async parseValues(componentPattern: string, checkoutProps: CheckoutProps) {
-    if (checkoutProps.head && !componentPattern) {
-      if (checkoutProps.all) {
-        this.logger.console(`"--all" is deprecated for "bit checkout ${HEAD}", please omit it.`);
-      }
-      checkoutProps.all = true;
-    }
-    if (checkoutProps.latest && !componentPattern) {
-      if (checkoutProps.all) {
-        this.logger.console(`"--all" is deprecated for "bit checkout ${LATEST}", please omit it.`);
-      }
-      checkoutProps.all = true;
-    }
-    if (componentPattern && checkoutProps.all) {
-      throw new GeneralError('please specify either [component-pattern] or --all, not both');
-    }
-    if (!componentPattern && !checkoutProps.all) {
-      throw new GeneralError('please specify [component-pattern] or use --all flag');
-    }
-    if (checkoutProps.workspaceOnly && !checkoutProps.head) {
-      throw new BitError(`--workspace-only flag can only be used with "head" (bit checkout head --workspace-only)`);
-    }
-    if (checkoutProps.revert) {
-      checkoutProps.skipUpdatingBitmap = true;
-    }
-    if (checkoutProps.reset || checkoutProps.head) {
-      checkoutProps.includeLocallyDeleted = true;
-    }
-
-    const getIds = async () => {
-      if (componentPattern) {
-        return this.workspace.idsByPattern(componentPattern, true, {
-          includeDeleted: checkoutProps.includeLocallyDeleted,
-        });
-      }
-      return checkoutProps.includeLocallyDeleted ? this.workspace.listIdsIncludeRemoved() : this.workspace.listIds();
-    };
-
-    const idsOnWorkspace = await getIds();
-
-    const currentLane = await this.workspace.consumer.getCurrentLaneObject();
-    const currentLaneIds = currentLane?.toBitIds();
-    const ids = currentLaneIds ? idsOnWorkspace.filter((id) => currentLaneIds.hasWithoutVersion(id)) : idsOnWorkspace;
-    checkoutProps.ids = ids.map((id) => (checkoutProps.head || checkoutProps.latest ? id.changeVersion(LATEST) : id));
-  }
-
-  private async getNewComponentsFromLane(ids: ComponentID[]): Promise<ComponentID[]> {
-    // current lane object is up to date due to the previous `importCurrentObjects()` call
-    const lane = await this.workspace.consumer.getCurrentLaneObject();
-    if (!lane) {
-      return [];
-    }
-    const laneBitIds = lane.toBitIds();
-    const newIds = laneBitIds.filter((bitId) => !ids.find((id) => id.isEqualWithoutVersion(bitId)));
-    const newComponentIds = await this.workspace.resolveMultipleComponentIds(newIds);
-    const nonRemovedNewIds: ComponentID[] = [];
-    await Promise.all(
-      newComponentIds.map(async (id) => {
-        const isRemoved = await this.workspace.scope.isComponentRemoved(id);
-        if (!isRemoved) nonRemovedNewIds.push(id);
-      })
-    );
-    return nonRemovedNewIds;
-  }
-
-  // eslint-disable-next-line complexity
-  private async getComponentStatusBeforeMergeAttempt(
-    id: ComponentID,
-    checkoutProps: CheckoutProps
-  ): Promise<ComponentStatusBeforeMergeAttempt> {
-    const consumer = this.workspace.consumer;
-    const { version, head: headVersion, reset, revert, main, latest: latestVersion, versionPerId } = checkoutProps;
-    const repo = consumer.scope.objects;
-
-    let existingBitMapId = consumer.bitMap.getComponentIdIfExist(id, { ignoreVersion: true });
-    const getComponent = async () => {
-      try {
-        // TODO: check if we really need the { loadExtensions: true } here
-        const results = await consumer.loadComponents(ComponentIdList.fromArray([id]), undefined, {
-          loadExtensions: true,
-        });
-        if (results.components[0]) return results.components[0];
-        if (checkoutProps.includeLocallyDeleted && results.removedComponents[0]) {
-          return results.removedComponents[0];
-        }
-      } catch (err) {
-        if (checkoutProps.allowAddingComponentsFromScope && !existingBitMapId) return undefined;
-        throw err;
-      }
-      return undefined;
-    };
-    const component = await getComponent();
-    if (component) {
-      // the component might fix an out-of-sync issue and as a result, the id has changed
-      id = component.id;
-      existingBitMapId = consumer.bitMap.getComponentIdIfExist(id, { ignoreVersion: true });
-    }
-
-    const componentModel = await consumer.scope.getModelComponentIfExist(id);
-    const componentStatus: ComponentStatusBeforeMergeAttempt = { id };
-    const returnFailure = (msg: string, unchangedLegitimately = false) => {
-      componentStatus.unchangedMessage = msg;
-      componentStatus.unchangedLegitimately = unchangedLegitimately;
-      return componentStatus;
-    };
-    if (!componentModel) {
-      return returnFailure(`component ${id.toString()} is new, no version to checkout`, true);
-    }
-    if (main && !componentModel.head) {
-      return returnFailure(`component ${id.toString()} is not available on main`);
-    }
-    const unmerged = repo.unmergedComponents.getEntry(id.fullName);
-    if (!reset && unmerged) {
-      return returnFailure(
-        `component ${id.toStringWithoutVersion()} is in during-merge state, please snap/tag it first (or use bit merge --resolve/--abort)`
-      );
-    }
-
-    const getNewVersion = async (): Promise<string> => {
-      // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
-      if (reset) return component!.id.version as string;
-      if (headVersion) return componentModel.headIncludeRemote(repo);
-      // we verified previously that head exists in case of "main"
-      if (main) return componentModel.head?.toString() as string;
-      if (latestVersion) {
-        const latest = componentModel.latestVersionIfExist();
-        return latest || componentModel.headIncludeRemote(repo);
-      }
-      if (versionPerId) {
-        return versionPerId.find((bitId) => bitId.isEqualWithoutVersion(id))?.version as string;
-      }
-
-      // if all above are false, the version is defined
-      return version as string;
-    };
-    const newVersion = await getNewVersion();
-    if (version && !headVersion) {
-      const hasVersion = await componentModel.hasVersion(version, repo);
-      if (!hasVersion) return returnFailure(`component ${id.toStringWithoutVersion()} doesn't have version ${version}`);
-    }
-    const currentlyUsedVersion = existingBitMapId?.version;
-    if (existingBitMapId && !currentlyUsedVersion) {
-      return returnFailure(`component ${id.toStringWithoutVersion()} is new`);
-    }
-    if (version && currentlyUsedVersion === version) {
-      // it won't be relevant for 'reset' as it doesn't have a version
-      return returnFailure(`component ${id.toStringWithoutVersion()} is already at version ${version}`, true);
-    }
-    if (headVersion && currentlyUsedVersion === newVersion) {
-      return returnFailure(
-        `component ${id.toStringWithoutVersion()} is already at the latest version, which is ${newVersion}`,
-        true
-      );
-    }
-    if (!reset) {
-      const divergeDataForMergePending = await componentModel.getDivergeDataForMergePending(repo);
-      const isMergePending = divergeDataForMergePending.isDiverged();
-      if (isMergePending) {
-        return returnFailure(`component is merge-pending and cannot be checked out, run "bit status" for more info`);
-      }
-    }
-    let isModified = false;
-    if (currentlyUsedVersion) {
-      const currentVersionObject: Version = await componentModel.loadVersion(currentlyUsedVersion, repo);
-      // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
-      isModified = await consumer.isComponentModified(currentVersionObject, component!);
-      const isRemoved = component && component.isRemoved();
-      if (!isModified && !isRemoved && reset) {
-        return returnFailure(`component ${id.toStringWithoutVersion()} is not modified`, true);
-      }
-    }
-
-    const versionRef = componentModel.getRef(newVersion);
-    if (!versionRef) throw new Error(`unable to get ref ${newVersion} from ${componentModel.id()}`);
-    const componentVersion = (await consumer.scope.getObject(versionRef.hash)) as Version | undefined;
-    if (componentVersion?.isRemoved()) {
-      if (existingBitMapId) componentStatus.shouldBeRemoved = true;
-      return returnFailure(`component has been removed`, true);
-    }
-
-    const newId = id.changeVersion(newVersion);
-
-    if (reset || !isModified || revert || !currentlyUsedVersion) {
-      // if the component is not modified, no need to try merge the files, they will be written later on according to the
-      // checked out version. same thing when no version is specified, it'll be reset to the model-version later.
-
-      // if !currentlyUsedVersion it only exists in the model, so just write it. (happening during bit-switch/bit-lane-import)
-      return { currentComponent: component, componentFromModel: componentVersion, id: newId };
-    }
-
-    const propsForMerge = {
-      currentlyUsedVersion,
-      componentModel,
-    };
-
-    return { currentComponent: component, componentFromModel: componentVersion, id: newId, propsForMerge };
-  }
-
-  private async getMergeStatus({
-    currentComponent: componentFromFS,
-    componentFromModel,
-    id,
-    propsForMerge,
-  }: ComponentStatusBeforeMergeAttempt): Promise<ComponentStatus> {
-    if (!propsForMerge) throw new Error(`propsForMerge is missing for ${id.toString()}`);
-    if (!componentFromFS) throw new Error(`componentFromFS is missing for ${id.toString()}`);
-    const consumer = this.workspace.consumer;
-    const repo = consumer.scope.objects;
-    const { currentlyUsedVersion, componentModel } = propsForMerge;
-
-    // this is tricky. imagine the user is 0.0.2+modification and wants to checkout to 0.0.1.
-    // the base is 0.0.1, as it's the common version for 0.0.1 and 0.0.2. however, if we let git merge-file use the 0.0.1
-    // as the base, then, it'll get the changes done since 0.0.1 to 0.0.1, which is nothing, and put them on top of
-    // 0.0.2+modification. in other words, it won't make any change.
-    // this scenario of checking out while there are modified files, is forbidden in Git. here, we want to simulate a similar
-    // experience of "git stash", then "git checkout", then "git stash pop". practically, we want the changes done on 0.0.2
-    // to be added to 0.0.1
-    // if there is no modification, it doesn't go the threeWayMerge anyway, so it doesn't matter what the base is.
-    const baseVersion = currentlyUsedVersion;
-    const newVersion = id.version as string;
-    const baseComponent: Version = await componentModel.loadVersion(baseVersion, repo);
-    const otherComponent: Version = await componentModel.loadVersion(newVersion, repo);
-    const mergeResults = await threeWayMerge({
-      consumer,
-      otherComponent,
-      otherLabel: newVersion,
-      currentComponent: componentFromFS,
-      currentLabel: `${currentlyUsedVersion} modified`,
-      baseComponent,
-    });
-
-    return { currentComponent: componentFromFS, componentFromModel, id, mergeResults };
-  }
-
-  static slots = [];
-  static dependencies = [CLIAspect, WorkspaceAspect, LoggerAspect, ComponentWriterAspect, ImporterAspect, RemoveAspect];
-
-  static runtime = MainRuntime;
-
-  static async provider([cli, workspace, loggerMain, compWriter, importer, remove]: [
-    CLIMain,
-    Workspace,
-    LoggerMain,
-    ComponentWriterMain,
-    ImporterMain,
-    RemoveMain
-  ]) {
-    const logger = loggerMain.createLogger(CheckoutAspect.id);
-    const checkoutMain = new CheckoutMain(workspace, logger, compWriter, importer, remove);
-    cli.register(new CheckoutCmd(checkoutMain), new RevertCmd(checkoutMain));
-    return checkoutMain;
-  }
-}
-
-CheckoutAspect.addRuntime(CheckoutMain);
-
-export default CheckoutMain;

package/index.ts

@@ -1,21 +0,0 @@
-import { CheckoutAspect } from './checkout.aspect';
-
-export type { CheckoutMain, CheckoutProps } from './checkout.main.runtime';
-export default CheckoutAspect;
-export { CheckoutAspect };
-
-export {
-  applyModifiedVersion,
-  applyVersion,
-  removeFilesIfNeeded,
-  updateFileStatus,
-  throwForFailures,
-} from './checkout-version';
-
-export type {
-  CheckoutProps as CheckoutPropsLegacy,
-  ComponentStatus,
-  ComponentStatusBase,
-  ApplyVersionWithComps,
-} from './checkout-version';
-export { checkoutOutput } from './checkout-cmd';

package/revert-cmd.ts

@@ -1,45 +0,0 @@
-import { Command, CommandOptions } from '@teambit/cli';
-import { COMPONENT_PATTERN_HELP } from '@teambit/legacy/dist/constants';
-import { CheckoutMain } from './checkout.main.runtime';
-import { CheckoutCmd } from './checkout-cmd';
-
-export class RevertCmd implements Command {
-  name = 'revert <component-pattern> <to>';
-  arguments = [
-    {
-      name: 'component-pattern',
-      description: COMPONENT_PATTERN_HELP,
-    },
-    {
-      name: 'to',
-      description: "permitted values: [main, specific-version]. 'main' - head version on main.",
-    },
-  ];
-  description = 'replace the current component files by the specified version, leave the version intact';
-  group = 'development';
-  alias = '';
-  options = [
-    ['v', 'verbose', 'showing verbose output for inspection'],
-    ['x', 'skip-dependency-installation', 'do not install packages of the imported components'],
-  ] as CommandOptions;
-  loader = true;
-
-  constructor(private checkout: CheckoutMain) {}
-
-  async report(
-    [componentPattern, to]: [string, string],
-    {
-      verbose = false,
-      skipDependencyInstallation = false,
-    }: {
-      verbose?: boolean;
-      skipDependencyInstallation?: boolean;
-    }
-  ) {
-    return new CheckoutCmd(this.checkout).report([to, componentPattern], {
-      verbose,
-      skipDependencyInstallation,
-      revert: true,
-    });
-  }
-}