@teambit/tracker 1.0.108 → 1.0.110

package/artifacts/preview/teambit_component_tracker-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/tracker-preview"]=o():e["teambit.component/tracker-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/tracker",
-  "version": "1.0.108",
+  "version": "1.0.110",
   "homepage": "https://bit.cloud/teambit/component/tracker",
   "main": "dist/index.js",
   "componentId": {
     "scope": "teambit.component",
     "name": "tracker",
-    "version": "1.0.108"
+    "version": "1.0.110"
   },
   "dependencies": {
     "chalk": "2.4.2",
@@ -20,18 +20,18 @@
     "@teambit/component-id": "1.2.0",
     "@teambit/legacy-bit-id": "1.1.0",
     "@teambit/harmony": "0.4.6",
-    "@teambit/cli": "0.0.840",
-    "@teambit/workspace.modules.node-modules-linker": "0.0.158",
-    "@teambit/workspace": "1.0.108",
-    "@teambit/envs": "1.0.108",
-    "@teambit/logger": "0.0.933"
+    "@teambit/cli": "0.0.842",
+    "@teambit/workspace.modules.node-modules-linker": "0.0.159",
+    "@teambit/workspace": "1.0.110",
+    "@teambit/envs": "1.0.110",
+    "@teambit/logger": "0.0.935"
   },
   "devDependencies": {
     "@types/fs-extra": "9.0.7",
     "@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.15"
   },
   "peerDependencies": {
     "@teambit/legacy": "1.0.624"
@@ -40,11 +40,15 @@
   "optionalDependencies": {},
   "peerDependenciesMeta": {},
   "exports": {
-    "node": {
-      "require": "./dist/index.js",
-      "import": "./dist/esm.mjs"
+    ".": {
+      "node": {
+        "require": "./dist/index.js",
+        "import": "./dist/esm.mjs"
+      },
+      "default": "./dist/index.js"
     },
-    "default": "./dist/index.js"
+    "./dist/*": "./dist/*",
+    "./artifacts/*": "./artifacts/*"
   },
   "private": false,
   "engines": {

package/add-cmd.ts

@@ -1,124 +0,0 @@
-import { Command, CommandOptions } from '@teambit/cli';
-import chalk from 'chalk';
-import * as path from 'path';
-import { BitError } from '@teambit/bit-error';
-import { PathLinux, PathOsBased } from '@teambit/legacy/dist/utils/path';
-import R from 'ramda';
-import { AddActionResults, Warnings } from './add-components';
-import { TrackerMain } from './tracker.main.runtime';
-
-type AddFlags = {
-  id: string | null | undefined;
-  main: string | null | undefined;
-  namespace: string | null | undefined;
-  scope?: string;
-  env?: string;
-  override: boolean;
-};
-
-type AddResults = {
-  addedComponents: Array<{ id: string; files: PathLinux[] }>;
-  warnings: Warnings;
-};
-
-export class AddCmd implements Command {
-  name = 'add [path...]';
-  description = 'Add any subset of files to be tracked as a component(s).';
-  group = 'development';
-  extendedDescription = 'Learn the recommended workflow for tracking directories as components, in the link below.';
-  helpUrl = 'reference/workspace/component-directory';
-  alias = 'a';
-  options = [
-    ['i', 'id <name>', 'manually set component id'],
-    ['m', 'main <file>', 'define component entry point'],
-    ['n', 'namespace <namespace>', 'organize component in a namespace'],
-    ['o', 'override <boolean>', 'override existing component if exists (default = false)'],
-    [
-      's',
-      'scope <string>',
-      `sets the component's scope. if not entered, the default-scope from workspace.jsonc will be used`,
-    ],
-    ['e', 'env <string>', "set the component's environment. (overrides the env from variants if exists)"],
-    ['j', 'json', 'output as json format'],
-  ] as CommandOptions;
-  loader = true;
-  migration = true;
-
-  constructor(private tracker: TrackerMain) {}
-
-  async report([paths = []]: [string[]], addFlags: AddFlags) {
-    const { addedComponents, warnings }: AddResults = await this.json([paths], addFlags);
-
-    const paintWarning = () => {
-      const alreadyUsedOutput = () => {
-        const alreadyUsedWarning = Object.keys(warnings.alreadyUsed)
-          .map((key) =>
-            chalk.yellow(
-              `warning: files ${chalk.bold(warnings.alreadyUsed[key].join(', '))} already used by component: ${key}`
-            )
-          )
-          .filter((x) => x)
-          .join('\n');
-        return R.isEmpty(alreadyUsedWarning) ? '' : `${alreadyUsedWarning}\n`;
-      };
-      const emptyDirectoryOutput = () => {
-        if (!warnings.emptyDirectory.length) return '';
-        return chalk.yellow(
-          `warning: the following directories are empty or all their files were excluded\n${chalk.bold(
-            warnings.emptyDirectory.join('\n')
-          )}\n`
-        );
-      };
-      return alreadyUsedOutput() + emptyDirectoryOutput();
-    };
-
-    if (addedComponents.length > 1) {
-      return paintWarning() + chalk.green(`tracking ${addedComponents.length} new components`);
-    }
-
-    return (
-      paintWarning() +
-      R.flatten(
-        addedComponents.map((result) => {
-          if (result.files.length === 0) {
-            return chalk.underline.red(`could not track component ${chalk.bold(result.id)}: no files to track`);
-          }
-          const title = chalk.underline(`tracking component ${chalk.bold(result.id)}:\n`);
-          const files = result.files.map((file) => chalk.green(`added ${file}`));
-          return title + files.join('\n');
-        })
-      ).join('\n\n')
-    );
-  }
-
-  async json(
-    [paths = []]: [string[]],
-    { id, main, namespace, scope, env, override = false }: AddFlags
-  ): Promise<AddResults> {
-    if (namespace && id) {
-      throw new BitError(
-        'please use either [id] or [namespace] to add a particular component - they cannot be used together'
-      );
-    }
-
-    const normalizedPaths: PathOsBased[] = paths.map((p) => path.normalize(p));
-    const { addedComponents, warnings }: AddActionResults = await this.tracker.addForCLI({
-      componentPaths: normalizedPaths,
-      // @ts-ignore AUTO-ADDED-AFTER-MIGRATION-PLEASE-FIX!
-      id,
-      main: main ? path.normalize(main) : undefined,
-      // @ts-ignore AUTO-ADDED-AFTER-MIGRATION-PLEASE-FIX!
-      namespace,
-      defaultScope: scope,
-      override,
-      env,
-    });
-    return {
-      addedComponents: addedComponents.map((added) => ({
-        id: added.id.toString(),
-        files: added.files.map((f) => f.relativePath),
-      })),
-      warnings,
-    };
-  }
-}

package/add-components.ts

@@ -1,734 +0,0 @@
-import arrayDiff from 'array-difference';
-import fs from 'fs-extra';
-import ignore from 'ignore';
-import groupby from 'lodash.groupby';
-import * as path from 'path';
-import R from 'ramda';
-import format from 'string-format';
-import { Analytics } from '@teambit/legacy/dist/analytics/analytics';
-import { ComponentID } from '@teambit/component-id';
-import { BitIdStr, BitId } from '@teambit/legacy-bit-id';
-import { PACKAGE_JSON, VERSION_DELIMITER } from '@teambit/legacy/dist/constants';
-import BitMap from '@teambit/legacy/dist/consumer/bit-map';
-import Consumer from '@teambit/legacy/dist/consumer/consumer';
-import GeneralError from '@teambit/legacy/dist/error/general-error';
-import logger from '@teambit/legacy/dist/logger/logger';
-import { calculateFileInfo, glob, isAutoGeneratedFile, isDir, pathNormalizeToLinux } from '@teambit/legacy/dist/utils';
-import { BitError } from '@teambit/bit-error';
-import { PathLinux, PathLinuxRelative, PathOsBased } from '@teambit/legacy/dist/utils/path';
-import ComponentMap, {
-  ComponentMapFile,
-  Config,
-  getIgnoreListHarmony,
-} from '@teambit/legacy/dist/consumer/bit-map/component-map';
-import MissingMainFile from '@teambit/legacy/dist/consumer/bit-map/exceptions/missing-main-file';
-import {
-  DuplicateIds,
-  EmptyDirectory,
-  ExcludedMainFile,
-  MainFileIsDir,
-  NoFiles,
-  PathsNotExist,
-} from '@teambit/legacy/dist/consumer/component-ops/add-components/exceptions';
-import { AddingIndividualFiles } from '@teambit/legacy/dist/consumer/component-ops/add-components/exceptions/adding-individual-files';
-import MissingMainFileMultipleComponents from '@teambit/legacy/dist/consumer/component-ops/add-components/exceptions/missing-main-file-multiple-components';
-import { ParentDirTracked } from '@teambit/legacy/dist/consumer/component-ops/add-components/exceptions/parent-dir-tracked';
-import PathOutsideConsumer from '@teambit/legacy/dist/consumer/component-ops/add-components/exceptions/path-outside-consumer';
-import VersionShouldBeRemoved from '@teambit/legacy/dist/consumer/component-ops/add-components/exceptions/version-should-be-removed';
-import { linkToNodeModulesByIds } from '@teambit/workspace.modules.node-modules-linker';
-import { Workspace } from '@teambit/workspace';
-import determineMainFile from './determine-main-file';
-
-export type AddResult = { id: ComponentID; files: ComponentMapFile[] };
-export type Warnings = {
-  alreadyUsed: Record<string, any>;
-  emptyDirectory: string[];
-  existInScope: ComponentID[];
-};
-export type AddActionResults = { addedComponents: AddResult[]; warnings: Warnings };
-export type PathOrDSL = PathOsBased | string; // can be a path or a DSL, e.g: tests/{PARENT}/{FILE_NAME}
-// @ts-ignore AUTO-ADDED-AFTER-MIGRATION-PLEASE-FIX!
-// @ts-ignore AUTO-ADDED-AFTER-MIGRATION-PLEASE-FIX!
-type PathsStats = { [PathOsBased]: { isDir: boolean } };
-export type AddedComponent = {
-  componentId: ComponentID;
-  files: ComponentMapFile[];
-  mainFile?: PathOsBased | null | undefined;
-  trackDir: PathOsBased;
-  idFromPath:
-    | {
-        name: string;
-        namespace: string;
-      }
-    | null
-    | undefined;
-  immediateDir?: string;
-};
-const REGEX_DSL_PATTERN = /{([^}]+)}/g;
-
-export type AddProps = {
-  componentPaths: PathOsBased[];
-  id?: string;
-  main?: PathOsBased;
-  namespace?: string;
-  override: boolean;
-  trackDirFeature?: boolean;
-  defaultScope?: string;
-  config?: Config;
-  shouldHandleOutOfSync?: boolean;
-  env?: string;
-};
-// This is the contxt of the add operation. By default, the add is executed in the same folder in which the consumer is located and it is the process.cwd().
-// In that case , give the value false to overridenConsumer .
-// There is a possibility to execute add when the process.cwd() is different from the project directory. In that case , when add is done on a folder wchih is
-// Different from process.cwd(), transfer true.
-// Required for determining if the paths are relative to consumer or to process.cwd().
-export type AddContext = {
-  workspace: Workspace;
-  alternateCwd?: string;
-};
-
-export default class AddComponents {
-  workspace: Workspace;
-  consumer: Consumer;
-  bitMap: BitMap;
-  componentPaths: PathOsBased[];
-  id: string | null | undefined; // id entered by the user
-  main: PathOsBased | null | undefined;
-  namespace: string | null | undefined;
-  override: boolean; // (default = false) replace the files array or only add files.
-  trackDirFeature: boolean | null | undefined;
-  warnings: Warnings;
-  // @ts-ignore AUTO-ADDED-AFTER-MIGRATION-PLEASE-FIX!
-  ignoreList: string[];
-  gitIgnore: any;
-  alternateCwd: string | null | undefined;
-  addedComponents: AddResult[];
-  defaultScope?: string; // helpful for out-of-sync
-  config?: Config;
-  shouldHandleOutOfSync?: boolean; // only bit-add (not bit-create/new) should handle out-of-sync scenario
-  constructor(context: AddContext, addProps: AddProps) {
-    this.alternateCwd = context.alternateCwd;
-    this.workspace = context.workspace;
-    this.consumer = context.workspace.consumer;
-    this.bitMap = this.consumer.bitMap;
-    this.componentPaths = this.joinConsumerPathIfNeeded(addProps.componentPaths);
-    this.id = addProps.id;
-    this.main = addProps.main;
-    this.namespace = addProps.namespace;
-    this.override = addProps.override;
-    this.trackDirFeature = addProps.trackDirFeature;
-    this.warnings = {
-      alreadyUsed: {},
-      emptyDirectory: [],
-      existInScope: [],
-    };
-    this.addedComponents = [];
-    this.defaultScope = addProps.defaultScope;
-    this.config = addProps.config;
-    this.shouldHandleOutOfSync = addProps.shouldHandleOutOfSync;
-  }
-
-  joinConsumerPathIfNeeded(paths: PathOrDSL[]): PathOrDSL[] {
-    if (paths.length > 0) {
-      if (this.alternateCwd !== undefined && this.alternateCwd !== null) {
-        const alternate = this.alternateCwd;
-        return paths.map((file) => path.join(alternate, file));
-      }
-      return paths;
-    }
-    return [];
-  }
-
-  /**
-   * @param {string[]} files - array of file-paths from which it should search for the dsl patterns.
-   * @param {*} filesWithPotentialDsl - array of file-path which may have DSL patterns
-   *
-   * @returns array of file-paths from 'files' parameter that match the patterns from 'filesWithPotentialDsl' parameter
-   */
-  async getFilesAccordingToDsl(files: PathLinux[], filesWithPotentialDsl: PathOrDSL[]): Promise<PathLinux[]> {
-    const filesListAllMatches = filesWithPotentialDsl.map(async (dsl) => {
-      const filesListMatch = files.map(async (file) => {
-        const fileInfo = calculateFileInfo(file);
-        const generatedFile = format(dsl, fileInfo);
-        const matches = await glob(generatedFile);
-        const matchesAfterGitIgnore = this.gitIgnore.filter(matches);
-        return matchesAfterGitIgnore.filter((match) => fs.existsSync(match));
-      });
-      return Promise.all(filesListMatch);
-    });
-
-    const filesListFlatten = R.flatten(await Promise.all(filesListAllMatches));
-    const filesListUnique = R.uniq(filesListFlatten);
-    return filesListUnique.map((file) => {
-      // when files array has the test file with different letter case, use the one from the file array
-      const fileNormalized = pathNormalizeToLinux(file);
-      const fileWithCorrectCase = files.find((f) => f.toLowerCase() === fileNormalized.toLowerCase()) || fileNormalized;
-      const relativeToConsumer = this.consumer.getPathRelativeToConsumer(fileWithCorrectCase);
-      return pathNormalizeToLinux(relativeToConsumer);
-    });
-  }
-
-  /**
-   * for imported component, the package.json in the root directory is a bit-generated file and as
-   * such, it should be ignored
-   */
-  _isPackageJsonOnRootDir(pathRelativeToConsumerRoot: PathLinux, componentMap: ComponentMap) {
-    if (!componentMap.rootDir) {
-      throw new Error('_isPackageJsonOnRootDir should not get called on non imported components');
-    }
-    return path.join(componentMap.rootDir, PACKAGE_JSON) === path.normalize(pathRelativeToConsumerRoot);
-  }
-
-  /**
-   * imported components might have wrapDir, when they do, files should not be added outside of
-   * that wrapDir
-   */
-  _isOutsideOfWrapDir(pathRelativeToConsumerRoot: PathLinux, componentMap: ComponentMap) {
-    if (!componentMap.rootDir) {
-      throw new Error('_isOutsideOfWrapDir should not get called on non imported components');
-    }
-    if (!componentMap.wrapDir) return false;
-    const wrapDirRelativeToConsumerRoot = path.join(componentMap.rootDir, componentMap.wrapDir);
-    return !path.normalize(pathRelativeToConsumerRoot).startsWith(wrapDirRelativeToConsumerRoot);
-  }
-
-  /**
-   * Add or update existing (imported and new) component according to bitmap
-   * there are 3 options:
-   * 1. a user is adding a new component. there is no record for this component in bit.map
-   * 2. a user is updating an existing component. there is a record for this component in bit.map
-   * 3. some or all the files of this component were previously added as another component-id.
-   */
-  async addOrUpdateComponentInBitMap(component: AddedComponent): Promise<AddResult | null | undefined> {
-    const consumerPath = this.consumer.getPath();
-    const parsedBitId = component.componentId;
-    const componentFromScope = await this.consumer.scope.getModelComponentIfExist(parsedBitId);
-    const files: ComponentMapFile[] = component.files;
-    const foundComponentFromBitMap = this.bitMap.getComponentIfExist(component.componentId, {
-      ignoreVersion: true,
-    });
-    const componentFilesP = files.map(async (file: ComponentMapFile) => {
-      // $FlowFixMe null is removed later on
-      const filePath = path.join(consumerPath, file.relativePath);
-      const isAutoGenerated = await isAutoGeneratedFile(filePath);
-      if (isAutoGenerated) {
-        return null;
-      }
-      const caseSensitive = false;
-      const existingIdOfFile = this.bitMap.getComponentIdByPath(file.relativePath, caseSensitive);
-      const idOfFileIsDifferent = existingIdOfFile && !existingIdOfFile.isEqual(parsedBitId);
-      if (idOfFileIsDifferent) {
-        // not imported component file but exists in bitmap
-        // @ts-ignore AUTO-ADDED-AFTER-MIGRATION-PLEASE-FIX!
-        if (this.warnings.alreadyUsed[existingIdOfFile]) {
-          // @ts-ignore AUTO-ADDED-AFTER-MIGRATION-PLEASE-FIX!
-          this.warnings.alreadyUsed[existingIdOfFile].push(file.relativePath);
-        } else {
-          // @ts-ignore AUTO-ADDED-AFTER-MIGRATION-PLEASE-FIX!
-          this.warnings.alreadyUsed[existingIdOfFile] = [file.relativePath];
-        }
-        return null;
-      }
-      if (!foundComponentFromBitMap && componentFromScope && this.shouldHandleOutOfSync) {
-        const newId = componentFromScope.toComponentIdWithLatestVersion();
-        if (!this.defaultScope || this.defaultScope === newId.scope) {
-          // otherwise, if defaultScope !== newId.scope, they're different components,
-          // and no need to change the id.
-          // for more details about this scenario, see https://github.com/teambit/bit/issues/1543, last case.
-          component.componentId = newId;
-          this.warnings.existInScope.push(newId);
-        }
-      }
-      return file;
-    });
-    // @ts-ignore it can't be null due to the filter function
-    const componentFiles: ComponentMapFile[] = (await Promise.all(componentFilesP)).filter((file) => file);
-    if (!componentFiles.length) return { id: component.componentId, files: [] };
-    if (foundComponentFromBitMap) {
-      this._updateFilesAccordingToExistingRootDir(foundComponentFromBitMap, componentFiles, component);
-    }
-    if (this.trackDirFeature) {
-      // @ts-ignore AUTO-ADDED-AFTER-MIGRATION-PLEASE-FIX!
-      if (this.bitMap._areFilesArraysEqual(foundComponentFromBitMap.files, componentFiles)) {
-        // @ts-ignore AUTO-ADDED-AFTER-MIGRATION-PLEASE-FIX!
-        return foundComponentFromBitMap;
-      }
-    }
-    if (!this.override && foundComponentFromBitMap) {
-      this._updateFilesWithCurrentLetterCases(foundComponentFromBitMap, componentFiles);
-      component.files = this._mergeFilesWithExistingComponentMapFiles(componentFiles, foundComponentFromBitMap.files);
-    } else {
-      component.files = componentFiles;
-    }
-
-    const { componentId, trackDir } = component;
-    const mainFile = determineMainFile(component, foundComponentFromBitMap);
-    const getRootDir = (): PathLinuxRelative => {
-      if (this.trackDirFeature) throw new Error('track dir should not calculate the rootDir');
-      if (foundComponentFromBitMap) return foundComponentFromBitMap.rootDir;
-      if (!trackDir) throw new Error(`addOrUpdateComponentInBitMap expect to have trackDir for non-legacy workspace`);
-      const fileNotInsideTrackDir = componentFiles.find(
-        (file) => !pathNormalizeToLinux(file.relativePath).startsWith(`${pathNormalizeToLinux(trackDir)}/`)
-      );
-      if (fileNotInsideTrackDir) {
-        // we check for this error before. however, it's possible that a user have one trackDir
-        // and another dir for the tests.
-        throw new AddingIndividualFiles(fileNotInsideTrackDir.relativePath);
-      }
-      return pathNormalizeToLinux(trackDir);
-    };
-    const getComponentMap = async (): Promise<ComponentMap> => {
-      if (this.trackDirFeature) {
-        return this.bitMap.addFilesToComponent({ componentId, files: component.files });
-      }
-      const rootDir = getRootDir();
-      const getDefaultScope = async () => {
-        if (componentId.hasScope()) return undefined;
-        return this.getDefaultScope(rootDir, componentId.fullName);
-      };
-      const defaultScope = await getDefaultScope();
-      const componentMap = this.bitMap.addComponent({
-        componentId: new ComponentID(componentId._legacy, defaultScope),
-        files: component.files,
-        defaultScope,
-        config: this.config,
-        mainFile,
-        // @ts-ignore AUTO-ADDED-AFTER-MIGRATION-PLEASE-FIX!
-        override: this.override,
-      });
-      componentMap.changeRootDirAndUpdateFilesAccordingly(rootDir);
-      return componentMap;
-    };
-    const componentMap = await getComponentMap();
-    return { id: componentId, files: componentMap.files };
-  }
-
-  /**
-   * current componentFiles are relative to the workspace. we want them relative to the rootDir.
-   */
-  _updateFilesAccordingToExistingRootDir(
-    foundComponentFromBitMap: ComponentMap,
-    componentFiles: ComponentMapFile[],
-    component: AddedComponent
-  ) {
-    const existingRootDir = foundComponentFromBitMap.rootDir;
-    if (!existingRootDir) return; // nothing to do.
-    const areFilesInsideExistingRootDir = componentFiles.every((file) =>
-      pathNormalizeToLinux(file.relativePath).startsWith(`${existingRootDir}/`)
-    );
-    if (areFilesInsideExistingRootDir) {
-      ComponentMap.changeFilesPathAccordingToItsRootDir(existingRootDir, componentFiles);
-      return;
-    }
-    // some (or all) added files are outside the existing rootDir, the rootDir needs to be changed
-    // if a directory was added and it's a parent of the existing rootDir, change the rootDir to
-    // the currently added rootDir.
-    const currentlyAddedDir = pathNormalizeToLinux(component.trackDir);
-    const currentlyAddedDirParentOfRootDir = currentlyAddedDir && existingRootDir.startsWith(`${currentlyAddedDir}/`);
-    if (currentlyAddedDirParentOfRootDir) {
-      foundComponentFromBitMap.changeRootDirAndUpdateFilesAccordingly(currentlyAddedDir);
-      ComponentMap.changeFilesPathAccordingToItsRootDir(currentlyAddedDir, componentFiles);
-      return;
-    }
-    throw new GeneralError(`unable to add individual files outside the root dir (${existingRootDir}) of ${component.componentId}.
-you can add the directory these files are located at and it'll change the root dir of the component accordingly`);
-    // we might want to change the behavior here to not throw an error and only change the rootDir to "."
-    // foundComponentFromBitMap.changeRootDirAndUpdateFilesAccordingly('.');
-  }
-
-  /**
-   * the risk with merging the currently added files with the existing bitMap files is overriding
-   * the `test` property. e.g. the component directory is re-added without adding the tests flag to
-   * track new files in that directory. in this case, we want to preserve the `test` property.
-   */
-  _mergeFilesWithExistingComponentMapFiles(
-    componentFiles: ComponentMapFile[],
-    existingComponentMapFile: ComponentMapFile[]
-  ) {
-    return R.unionWith(R.eqBy(R.prop('relativePath')), existingComponentMapFile, componentFiles);
-  }
-
-  /**
-   * if an existing file is for example uppercase and the new file is lowercase it has different
-   * behavior according to the OS. some OS are case sensitive, some are not.
-   * it's safer to avoid saving both files and instead, replacing the old file with the new one.
-   * in case a file has replaced and it is also a mainFile, replace the mainFile as well
-   */
-  _updateFilesWithCurrentLetterCases(currentComponentMap: ComponentMap, newFiles: ComponentMapFile[]) {
-    const currentFiles = currentComponentMap.files;
-    currentFiles.forEach((currentFile) => {
-      const sameFile = newFiles.find(
-        (newFile) => newFile.relativePath.toLowerCase() === currentFile.relativePath.toLowerCase()
-      );
-      if (sameFile && currentFile.relativePath !== sameFile.relativePath) {
-        if (currentComponentMap.mainFile === currentFile.relativePath) {
-          currentComponentMap.mainFile = sameFile.relativePath;
-        }
-        currentFile.relativePath = sameFile.relativePath;
-      }
-    });
-  }
-
-  /**
-   * if the id is already saved in bitmap file, it might have more data (such as scope, version)
-   * use that id instead.
-   */
-  private _getIdAccordingToExistingComponent(currentId: BitIdStr): ComponentID | undefined {
-    const idWithScope = this.defaultScope ? `${this.defaultScope}/${currentId}` : currentId;
-    const existingComponentId = this.bitMap.getExistingBitId(idWithScope, false);
-    if (currentId.includes(VERSION_DELIMITER)) {
-      if (
-        !existingComponentId || // this id is new, it shouldn't have a version
-        !existingComponentId.hasVersion() || // this component is new, it shouldn't have a version
-        // user shouldn't add files to a an existing component with different version
-        existingComponentId.version !== ComponentID.getVersionFromString(currentId)
-      ) {
-        throw new VersionShouldBeRemoved(currentId);
-      }
-    }
-    return existingComponentId;
-  }
-
-  _getIdAccordingToTrackDir(dir: PathOsBased): ComponentID | null | undefined {
-    const dirNormalizedToLinux = pathNormalizeToLinux(dir);
-    const trackDirs = this.bitMap.getAllTrackDirs();
-    if (!trackDirs) return null;
-    return trackDirs[dirNormalizedToLinux];
-  }
-
-  /**
-   * used for updating main file if exists or doesn't exists
-   */
-  _addMainFileToFiles(files: ComponentMapFile[]): PathOsBased | null | undefined {
-    let mainFile = this.main;
-    if (mainFile && mainFile.match(REGEX_DSL_PATTERN)) {
-      // it's a DSL
-      files.forEach((file) => {
-        const fileInfo = calculateFileInfo(file.relativePath);
-        const generatedFile = format(mainFile, fileInfo);
-        const foundFile = this._findMainFileInFiles(generatedFile, files);
-        if (foundFile) {
-          mainFile = foundFile.relativePath;
-        }
-        if (fs.existsSync(generatedFile) && !foundFile) {
-          const shouldIgnore = this.gitIgnore.ignores(generatedFile);
-          if (shouldIgnore) {
-            // check if file is in exclude list
-            throw new ExcludedMainFile(generatedFile);
-          }
-          files.push({
-            relativePath: pathNormalizeToLinux(generatedFile),
-            test: false,
-            name: path.basename(generatedFile),
-          });
-          mainFile = generatedFile;
-        }
-      });
-    }
-    if (!mainFile) return undefined;
-    if (this.alternateCwd) {
-      mainFile = path.join(this.alternateCwd, mainFile);
-    }
-    const mainFileRelativeToConsumer = this.consumer.getPathRelativeToConsumer(mainFile);
-    const mainPath = this.consumer.toAbsolutePath(mainFileRelativeToConsumer);
-    if (fs.existsSync(mainPath)) {
-      const shouldIgnore = this.gitIgnore.ignores(mainFileRelativeToConsumer);
-      if (shouldIgnore) throw new ExcludedMainFile(mainFileRelativeToConsumer);
-      if (isDir(mainPath)) {
-        throw new MainFileIsDir(mainPath);
-      }
-      const foundFile = this._findMainFileInFiles(mainFileRelativeToConsumer, files);
-      if (foundFile) {
-        return foundFile.relativePath;
-      }
-      files.push({
-        relativePath: pathNormalizeToLinux(mainFileRelativeToConsumer),
-        test: false,
-        name: path.basename(mainFileRelativeToConsumer),
-      });
-      return mainFileRelativeToConsumer;
-    }
-    return mainFile;
-  }
-
-  _findMainFileInFiles(mainFile: string, files: ComponentMapFile[]) {
-    const normalizedMainFile = pathNormalizeToLinux(mainFile).toLowerCase();
-    return files.find((file) => file.relativePath.toLowerCase() === normalizedMainFile);
-  }
-
-  private async getDefaultScope(rootDir: string, componentName: string): Promise<string> {
-    return (this.defaultScope ||
-      (await this.workspace.componentDefaultScopeFromComponentDirAndName(rootDir, componentName))) as string;
-  }
-
-  /**
-   * given the component paths, prepare the id, mainFile and files to be added later on to bitmap
-   * the id of the component is either entered by the user or, if not entered, concluded by the path.
-   * e.g. bar/foo.js, the id would be bar/foo.
-   * in case bitmap has already the same id, the complete id is taken from bitmap (see _getIdAccordingToExistingComponent)
-   */
-  async addOneComponent(componentPath: PathOsBased): Promise<AddedComponent> {
-    let finalBitId: ComponentID | undefined; // final id to use for bitmap file
-    let idFromPath;
-    if (this.id) {
-      finalBitId = this._getIdAccordingToExistingComponent(this.id);
-    }
-    const relativeComponentPath = this.consumer.getPathRelativeToConsumer(componentPath);
-    this._throwForOutsideConsumer(relativeComponentPath);
-    this.throwForExistingParentDir(relativeComponentPath);
-    const matches = await glob(path.join(relativeComponentPath, '**'), {
-      cwd: this.consumer.getPath(),
-      nodir: true,
-    });
-
-    if (!matches.length) throw new EmptyDirectory(componentPath);
-
-    const filteredMatches = this.gitIgnore.filter(matches);
-
-    if (!filteredMatches.length) {
-      throw new NoFiles(matches);
-    }
-
-    const filteredMatchedFiles = filteredMatches.map((match: PathOsBased) => {
-      return { relativePath: pathNormalizeToLinux(match), test: false, name: path.basename(match) };
-    });
-    const resolvedMainFile = this._addMainFileToFiles(filteredMatchedFiles);
-
-    const absoluteComponentPath = path.resolve(componentPath);
-    const splitPath = absoluteComponentPath.split(path.sep);
-    const lastDir = splitPath[splitPath.length - 1];
-    const idOfTrackDir = this._getIdAccordingToTrackDir(componentPath);
-    if (!finalBitId) {
-      if (this.id) {
-        const bitId = BitId.parse(this.id, false);
-        const defaultScope = await this.getDefaultScope(relativeComponentPath, bitId.name);
-        finalBitId = new ComponentID(bitId, defaultScope);
-      } else if (idOfTrackDir) {
-        finalBitId = idOfTrackDir;
-      } else {
-        const nameSpaceOrDir = this.namespace || splitPath[splitPath.length - 2];
-        if (!this.namespace) {
-          idFromPath = { namespace: BitId.getValidIdChunk(nameSpaceOrDir), name: BitId.getValidIdChunk(lastDir) };
-        }
-        const bitId = BitId.getValidBitId(nameSpaceOrDir, lastDir);
-        const defaultScope = await this.getDefaultScope(relativeComponentPath, bitId.name);
-        finalBitId = new ComponentID(bitId, defaultScope);
-      }
-    }
-    const trackDir = relativeComponentPath;
-    const addedComp = {
-      componentId: finalBitId,
-      files: filteredMatchedFiles,
-      mainFile: resolvedMainFile,
-      trackDir,
-      idFromPath,
-      immediateDir: lastDir,
-    };
-
-    return addedComp;
-  }
-
-  getIgnoreList(): string[] {
-    const consumerPath = this.consumer.getPath();
-    return getIgnoreListHarmony(consumerPath);
-  }
-
-  async add(): Promise<AddActionResults> {
-    this.ignoreList = this.getIgnoreList();
-    this.gitIgnore = ignore().add(this.ignoreList); // add ignore list
-
-    let componentPathsStats: PathsStats = {};
-
-    const resolvedComponentPathsWithoutGitIgnore = R.flatten(
-      await Promise.all(this.componentPaths.map((componentPath) => glob(componentPath)))
-    );
-    this.gitIgnore = ignore().add(this.ignoreList); // add ignore list
-
-    const resolvedComponentPathsWithGitIgnore = this.gitIgnore.filter(resolvedComponentPathsWithoutGitIgnore);
-    // Run diff on both arrays to see what was filtered out because of the gitignore file
-    const diff = arrayDiff(resolvedComponentPathsWithGitIgnore, resolvedComponentPathsWithoutGitIgnore);
-
-    if (R.isEmpty(resolvedComponentPathsWithoutGitIgnore)) {
-      throw new PathsNotExist(this.componentPaths);
-    }
-    if (!R.isEmpty(resolvedComponentPathsWithGitIgnore)) {
-      componentPathsStats = validatePaths(resolvedComponentPathsWithGitIgnore);
-    } else {
-      throw new NoFiles(diff);
-    }
-    Object.keys(componentPathsStats).forEach((compPath) => {
-      if (!componentPathsStats[compPath].isDir) {
-        throw new AddingIndividualFiles(compPath);
-      }
-    });
-    if (Object.keys(componentPathsStats).length > 1 && this.id) {
-      throw new BitError(
-        `the --id flag (${this.id}) is used for a single component only, however, got ${this.componentPaths.length} paths`
-      );
-    }
-    // if a user entered multiple paths and entered an id, he wants all these paths to be one component
-    // conversely, if a user entered multiple paths without id, he wants each dir as an individual component
-    const isMultipleComponents = Object.keys(componentPathsStats).length > 1;
-    if (isMultipleComponents) {
-      await this.addMultipleComponents(componentPathsStats);
-    } else {
-      logger.debugAndAddBreadCrumb('add-components', 'adding one component');
-      // when a user enters more than one directory, he would like to keep the directories names
-      // so then when a component is imported, it will write the files into the original directories
-      const addedOne = await this.addOneComponent(Object.keys(componentPathsStats)[0]);
-      await this._removeNamespaceIfNotNeeded([addedOne]);
-      if (!R.isEmpty(addedOne.files)) {
-        const addedResult = await this.addOrUpdateComponentInBitMap(addedOne);
-        if (addedResult) this.addedComponents.push(addedResult);
-      }
-    }
-    await this.linkComponents(this.addedComponents.map((item) => item.id));
-    Analytics.setExtraData('num_components', this.addedComponents.length);
-    return { addedComponents: this.addedComponents, warnings: this.warnings };
-  }
-
-  async linkComponents(ids: ComponentID[]) {
-    if (this.trackDirFeature) {
-      // if trackDirFeature is set, it happens during the component-load and because we load the
-      // components in the next line, it gets into an infinite loop.
-      return;
-    }
-    await linkToNodeModulesByIds(this.workspace, ids);
-  }
-
-  async addMultipleComponents(componentPathsStats: PathsStats): Promise<void> {
-    logger.debugAndAddBreadCrumb('add-components', 'adding multiple components');
-    this._removeDirectoriesWhenTheirFilesAreAdded(componentPathsStats);
-    const added = await this._tryAddingMultiple(componentPathsStats);
-    validateNoDuplicateIds(added);
-    await this._removeNamespaceIfNotNeeded(added);
-    await this._addMultipleToBitMap(added);
-  }
-
-  /**
-   * some uses of wildcards might add directories and their files at the same time, in such cases
-   * only the files are needed and the directories can be ignored.
-   * @see https://github.com/teambit/bit/issues/1406 for more details
-   */
-  _removeDirectoriesWhenTheirFilesAreAdded(componentPathsStats: PathsStats) {
-    const allPaths = Object.keys(componentPathsStats);
-    allPaths.forEach((componentPath) => {
-      const foundDir = allPaths.find((p) => p === path.dirname(componentPath));
-      if (foundDir && componentPathsStats[foundDir]) {
-        logger.debug(`add-components._removeDirectoriesWhenTheirFilesAreAdded, ignoring ${foundDir}`);
-        delete componentPathsStats[foundDir];
-      }
-    });
-  }
-
-  async _addMultipleToBitMap(added: AddedComponent[]): Promise<void> {
-    const missingMainFiles = [];
-    await Promise.all(
-      added.map(async (component) => {
-        if (!R.isEmpty(component.files)) {
-          try {
-            const addedComponent = await this.addOrUpdateComponentInBitMap(component);
-            if (addedComponent && addedComponent.files.length) this.addedComponents.push(addedComponent);
-          } catch (err: any) {
-            if (!(err instanceof MissingMainFile)) throw err;
-            // @ts-ignore AUTO-ADDED-AFTER-MIGRATION-PLEASE-FIX!
-            missingMainFiles.push(err);
-          }
-        }
-      })
-    );
-    if (missingMainFiles.length) {
-      // @ts-ignore AUTO-ADDED-AFTER-MIGRATION-PLEASE-FIX!
-      throw new MissingMainFileMultipleComponents(missingMainFiles.map((err) => err.componentId).sort());
-    }
-  }
-
-  async _removeNamespaceIfNotNeeded(addedComponents: AddedComponent[]) {
-    const allIds = this.bitMap.getAllBitIdsFromAllLanes();
-    await Promise.all(
-      addedComponents.map(async (addedComponent) => {
-        if (!addedComponent.idFromPath) return; // when the id was not generated from the path do nothing.
-        const componentsWithSameName = addedComponents.filter(
-          (a) => a.idFromPath && a.idFromPath.name === addedComponent.idFromPath?.name
-        );
-        const bitIdFromNameOnly = new BitId({ name: addedComponent.idFromPath.name });
-        const defaultScope = await this.getDefaultScope(addedComponent.trackDir, bitIdFromNameOnly.name);
-        const componentIdFromNameOnly = new ComponentID(bitIdFromNameOnly, defaultScope);
-        const existingComponentWithSameName = allIds.searchWithoutScopeAndVersion(componentIdFromNameOnly);
-        if (componentsWithSameName.length === 1 && !existingComponentWithSameName) {
-          addedComponent.componentId = componentIdFromNameOnly;
-        }
-      })
-    );
-  }
-
-  async _tryAddingMultiple(componentPathsStats: PathsStats): Promise<AddedComponent[]> {
-    const addedP = Object.keys(componentPathsStats).map(async (onePath) => {
-      try {
-        const addedComponent = await this.addOneComponent(onePath);
-        return addedComponent;
-      } catch (err: any) {
-        if (!(err instanceof EmptyDirectory)) throw err;
-        this.warnings.emptyDirectory.push(onePath);
-        return null;
-      }
-    });
-    const added = await Promise.all(addedP);
-    return R.reject(R.isNil, added);
-  }
-
-  _throwForOutsideConsumer(relativeToConsumerPath: PathOsBased) {
-    if (relativeToConsumerPath.startsWith('..')) {
-      throw new PathOutsideConsumer(relativeToConsumerPath);
-    }
-  }
-
-  private throwForExistingParentDir(relativeToConsumerPath: PathOsBased) {
-    const isParentDir = (parent: string) => {
-      const relative = path.relative(parent, relativeToConsumerPath);
-      return relative && !relative.startsWith('..') && !path.isAbsolute(relative);
-    };
-    this.bitMap.components.forEach((componentMap) => {
-      if (!componentMap.rootDir) return;
-      if (isParentDir(componentMap.rootDir)) {
-        throw new ParentDirTracked(
-          componentMap.rootDir,
-          componentMap.id.toStringWithoutVersion(),
-          relativeToConsumerPath
-        );
-      }
-    });
-  }
-}
-
-/**
- * validatePaths - validate if paths entered by user exist and if not throw an error
- *
- * @param {string[]} fileArray - array of paths
- * @returns {PathsStats} componentPathsStats
- */
-function validatePaths(fileArray: string[]): PathsStats {
-  const componentPathsStats = {};
-  fileArray.forEach((componentPath) => {
-    if (!fs.existsSync(componentPath)) {
-      throw new PathsNotExist([componentPath]);
-    }
-    componentPathsStats[componentPath] = {
-      isDir: isDir(componentPath),
-    };
-  });
-  return componentPathsStats;
-}
-
-/**
- * validate that no two files where added with the same id in the same bit add command
- */
-function validateNoDuplicateIds(addComponents: Record<string, any>[]) {
-  const duplicateIds = {};
-  const newGroupedComponents = groupby(addComponents, 'componentId');
-  Object.keys(newGroupedComponents).forEach((key) => {
-    if (newGroupedComponents[key].length > 1) duplicateIds[key] = newGroupedComponents[key];
-  });
-  if (!R.isEmpty(duplicateIds) && !R.isNil(duplicateIds)) throw new DuplicateIds(duplicateIds);
-}

package/determine-main-file.ts

@@ -1,140 +0,0 @@
-import * as path from 'path';
-import R from 'ramda';
-
-import {
-  ANGULAR_BIT_ENTRY_POINT_FILE,
-  DEFAULT_INDEX_EXTS,
-  DEFAULT_INDEX_NAME,
-  DEFAULT_SEPARATOR,
-} from '@teambit/legacy/dist/constants';
-import { pathJoinLinux, PathLinux, pathNormalizeToLinux } from '@teambit/legacy/dist/utils/path';
-import ComponentMap from '@teambit/legacy/dist/consumer/bit-map/component-map';
-import { MissingMainFile } from '@teambit/legacy/dist/consumer/bit-map/exceptions';
-import { AddedComponent } from './add-components';
-
-export default function determineMainFile(
-  addedComponent: AddedComponent,
-  existingComponentMap: ComponentMap | null | undefined
-): PathLinux {
-  const mainFile = addedComponent.mainFile;
-  const componentIdStr = addedComponent.componentId.toString();
-  const files = addedComponent.files.filter((file) => !file.test);
-  const rootDir = existingComponentMap && existingComponentMap.rootDir;
-  const strategies: Function[] = [
-    getExistingIfNotChanged,
-    getUserSpecifiedMainFile,
-    onlyOneFileEnteredUseIt,
-    searchForFileNameIndex,
-    searchForSameFileNameAsImmediateDir,
-    searchForAngularEntryPoint,
-  ];
-
-  for (const strategy of strategies) {
-    const foundMainFile = strategy();
-    if (foundMainFile) {
-      return foundMainFile;
-    }
-  }
-  const mainFileString = `${DEFAULT_INDEX_NAME}.[${DEFAULT_INDEX_EXTS.join(', ')}]`;
-  throw new MissingMainFile(
-    componentIdStr,
-    mainFileString,
-    files.map((file) => path.normalize(file.relativePath))
-  );
-
-  /**
-   * user didn't enter mainFile but the component already exists with mainFile
-   */
-  function getExistingIfNotChanged(): PathLinux | null | undefined {
-    if (!mainFile && existingComponentMap) {
-      return existingComponentMap.mainFile;
-    }
-    return null;
-  }
-  /**
-   * user entered mainFile => search the mainFile in the files array, throw error if not found
-   */
-  function getUserSpecifiedMainFile(): PathLinux | null | undefined {
-    if (mainFile) {
-      const foundMainFile = _searchMainFile(pathNormalizeToLinux(mainFile));
-      if (foundMainFile) return foundMainFile;
-      throw new MissingMainFile(
-        componentIdStr,
-        mainFile,
-        files.map((file) => path.normalize(file.relativePath))
-      );
-    }
-    return null;
-  }
-  /**
-   * user didn't enter mainFile and the component has only one file, use that file as the main file
-   */
-  function onlyOneFileEnteredUseIt(): PathLinux | null | undefined {
-    if (files.length === 1) {
-      return files[0].relativePath;
-    }
-    return null;
-  }
-  /**
-   * user didn't enter mainFile and the component has multiple files, search for file name "index",
-   * e.g. `index.js`, `index.css`, etc.
-   */
-  function searchForFileNameIndex(): PathLinux | null | undefined {
-    for (const ext of DEFAULT_INDEX_EXTS) {
-      const mainFileNameToSearch = `${DEFAULT_INDEX_NAME}.${ext}`;
-      const searchResult = _searchMainFile(mainFileNameToSearch);
-      if (searchResult) {
-        return searchResult;
-      }
-    }
-    return null;
-  }
-  /**
-   * user didn't enter mainFile and the component has multiple files, search for file with the same
-   * name as the directory (see #1714)
-   */
-  function searchForSameFileNameAsImmediateDir(): PathLinux | null | undefined {
-    if (addedComponent.immediateDir) {
-      for (const ext of DEFAULT_INDEX_EXTS) {
-        const mainFileNameToSearch = `${addedComponent.immediateDir}.${ext}`;
-        const searchResult = _searchMainFile(mainFileNameToSearch);
-        if (searchResult) {
-          return searchResult;
-        }
-      }
-    }
-    return null;
-  }
-  /**
-   * The component is an angular component and uses the angular entry point
-   */
-  function searchForAngularEntryPoint(): PathLinux | null | undefined {
-    for (const entryPoint of ANGULAR_BIT_ENTRY_POINT_FILE) {
-      const searchResult = _searchMainFile(entryPoint);
-      if (searchResult) {
-        return searchResult;
-      }
-    }
-    return null;
-  }
-
-  function _searchMainFile(baseMainFile: PathLinux): PathLinux | null | undefined {
-    // search for an exact relative-path
-    let mainFileFromFiles = files.find((file) => file.relativePath === baseMainFile);
-    if (mainFileFromFiles) return baseMainFile;
-    if (rootDir) {
-      const mainFileUsingRootDir = files.find((file) => pathJoinLinux(rootDir, file.relativePath) === baseMainFile);
-      if (mainFileUsingRootDir) return mainFileUsingRootDir.relativePath;
-    }
-    // search for a file-name
-    const potentialMainFiles = files.filter((file) => file.name === baseMainFile);
-    if (!potentialMainFiles.length) return null;
-    // when there are several files that met the criteria, choose the closer to the root
-    const sortByNumOfDirs = (a, b) =>
-      a.relativePath.split(DEFAULT_SEPARATOR).length - b.relativePath.split(DEFAULT_SEPARATOR).length;
-    potentialMainFiles.sort(sortByNumOfDirs);
-    mainFileFromFiles = R.head(potentialMainFiles);
-    // @ts-ignore AUTO-ADDED-AFTER-MIGRATION-PLEASE-FIX!
-    return mainFileFromFiles.relativePath;
-  }
-}

package/index.ts

@@ -1,5 +0,0 @@
-import { TrackerAspect } from './tracker.aspect';
-
-export type { TrackerMain } from './tracker.main.runtime';
-export default TrackerAspect;
-export { TrackerAspect };

package/tracker.aspect.ts

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

package/tracker.main.runtime.ts

@@ -1,123 +0,0 @@
-import { CLIAspect, CLIMain, MainRuntime } from '@teambit/cli';
-import EnvsAspect from '@teambit/envs';
-import WorkspaceAspect, { OutsideWorkspaceError, Workspace } from '@teambit/workspace';
-import { Logger, LoggerAspect, LoggerMain } from '@teambit/logger';
-import { PathOsBasedRelative } from '@teambit/legacy/dist/utils/path';
-import { AddCmd } from './add-cmd';
-import AddComponents, { AddActionResults, AddContext, AddProps, Warnings } from './add-components';
-import { TrackerAspect } from './tracker.aspect';
-
-export type TrackResult = { componentName: string; files: string[]; warnings: Warnings };
-
-export type TrackData = {
-  rootDir: PathOsBasedRelative; // path relative to the workspace
-  componentName?: string; // if empty, it'll be generated from the path
-  mainFile?: string; // if empty, attempts will be made to guess the best candidate
-  defaultScope?: string; // can be entered as part of "bit create" command, helpful for out-of-sync logic
-  config?: { [aspectName: string]: any }; // config specific to this component, which overrides variants of workspace.jsonc
-};
-
-export class TrackerMain {
-  constructor(private workspace: Workspace, private logger: Logger) {}
-
-  /**
-   * add a new component to the .bitmap file.
-   * this method only adds the records in memory but doesn't persist to the filesystem.
-   * to write the .bitmap file once completed, run "await this.bitMap.write();"
-   */
-  async track(trackData: TrackData): Promise<TrackResult> {
-    const defaultScope = trackData.defaultScope ? await this.addOwnerToScopeName(trackData.defaultScope) : undefined;
-    const addComponent = new AddComponents(
-      { workspace: this.workspace },
-      {
-        componentPaths: [trackData.rootDir],
-        id: trackData.componentName,
-        main: trackData.mainFile,
-        override: false,
-        defaultScope,
-        config: trackData.config,
-      }
-    );
-    const result = await addComponent.add();
-    const addedComponent = result.addedComponents[0];
-    const componentName = addedComponent?.id.fullName || (trackData.componentName as string);
-    const files = addedComponent?.files.map((f) => f.relativePath) || [];
-    return { componentName, files, warnings: result.warnings };
-  }
-
-  async addForCLI(addProps: AddProps): Promise<AddActionResults> {
-    if (!this.workspace) throw new OutsideWorkspaceError();
-    const addContext: AddContext = { workspace: this.workspace };
-    addProps.shouldHandleOutOfSync = true;
-    if (addProps.env) {
-      const config = {};
-      await this.addEnvToConfig(addProps.env, config);
-      addProps.config = config;
-    }
-    const addComponents = new AddComponents(addContext, addProps);
-    const addResults = await addComponents.add();
-    await this.workspace.consumer.onDestroy('add');
-
-    return addResults;
-  }
-
-  async addEnvToConfig(env: string, config: { [aspectName: string]: any }) {
-    const userEnvId = await this.workspace.resolveComponentId(env);
-    let userEnvIdWithPotentialVersion: string;
-    try {
-      userEnvIdWithPotentialVersion = await this.workspace.resolveEnvIdWithPotentialVersionForConfig(userEnvId);
-    } catch (err) {
-      // the env needs to be without version
-      userEnvIdWithPotentialVersion = userEnvId.toStringWithoutVersion();
-    }
-    config[userEnvIdWithPotentialVersion] = {};
-    config[EnvsAspect.id] = config[EnvsAspect.id] || {};
-    config[EnvsAspect.id].env = userEnvId.toStringWithoutVersion();
-  }
-
-  /**
-   * scopes in bit.dev are "owner.collection".
-   * we might have the scope-name only without the owner and we need to retrieve it from the defaultScope in the
-   * workspace.jsonc file.
-   *
-   * @param scopeName scopeName that might not have the owner part.
-   * @returns full scope name
-   */
-  private async addOwnerToScopeName(scopeName: string): Promise<string> {
-    if (scopeName.includes('.')) return scopeName; // it has owner.
-    const isSelfHosted = !(await this.isHostedByBit(scopeName));
-    if (isSelfHosted) return scopeName;
-    const wsDefaultScope = this.workspace.defaultScope;
-    if (!wsDefaultScope.includes('.')) {
-      this.logger.warn(`the entered scope ${scopeName} has no owner nor the defaultScope in workspace.jsonc`);
-      // it's possible that the user entered a non-exist scope just to test the command and will change it later.
-      return scopeName;
-    }
-    const [owner] = wsDefaultScope.split('.');
-    return `${owner}.${scopeName}`;
-  }
-
-  /**
-   * whether a scope is hosted by Bit cloud.
-   * otherwise, it is self-hosted
-   */
-  private async isHostedByBit(scopeName: string): Promise<boolean> {
-    // TODO: once scope create a new API for this, replace it with the new one
-    const remotes = await this.workspace.scope._legacyRemotes();
-    return remotes.isHub(scopeName);
-  }
-
-  static slots = [];
-  static dependencies = [CLIAspect, WorkspaceAspect, LoggerAspect];
-  static runtime = MainRuntime;
-  static async provider([cli, workspace, loggerMain]: [CLIMain, Workspace, LoggerMain]) {
-    const logger = loggerMain.createLogger(TrackerAspect.id);
-    const trackerMain = new TrackerMain(workspace, logger);
-    cli.register(new AddCmd(trackerMain));
-    return trackerMain;
-  }
-}
-
-TrackerAspect.addRuntime(TrackerMain);
-
-export default TrackerMain;