@teambit/tracker 1.0.1174 → 1.0.1176

package/dist/add-components.js

@@ -4,6 +4,7 @@ Object.defineProperty(exports, "__esModule", {
   value: true
 });
 exports.addMultipleFromResolvedTrackData = addMultipleFromResolvedTrackData;
+exports.configForWorkspaceRoot = configForWorkspaceRoot;
 exports.default = void 0;
 function _arrayDifference() {
   const data = _interopRequireDefault(require("array-difference"));
@@ -175,6 +176,8 @@ function _determineMainFile() {
 }
 function _interopRequireWildcard(e, t) { if ("function" == typeof WeakMap) var r = new WeakMap(), n = new WeakMap(); return (_interopRequireWildcard = function (e, t) { if (!t && e && e.__esModule) return e; var o, i, f = { __proto__: null, default: e }; if (null === e || "object" != typeof e && "function" != typeof e) return f; if (o = t ? n : r) { if (o.has(e)) return o.get(e); o.set(e, f); } for (const t in e) "default" !== t && {}.hasOwnProperty.call(e, t) && ((i = (o = Object.defineProperty) && Object.getOwnPropertyDescriptor(e, t)) && (i.get || i.set) ? o(f, t, i) : f[t] = e[t]); return f; })(e, t); }
 function _interopRequireDefault(e) { return e && e.__esModule ? e : { default: e }; }
+function ownKeys(e, r) { var t = Object.keys(e); if (Object.getOwnPropertySymbols) { var o = Object.getOwnPropertySymbols(e); r && (o = o.filter(function (r) { return Object.getOwnPropertyDescriptor(e, r).enumerable; })), t.push.apply(t, o); } return t; }
+function _objectSpread(e) { for (var r = 1; r < arguments.length; r++) { var t = null != arguments[r] ? arguments[r] : {}; r % 2 ? ownKeys(Object(t), !0).forEach(function (r) { _defineProperty(e, r, t[r]); }) : Object.getOwnPropertyDescriptors ? Object.defineProperties(e, Object.getOwnPropertyDescriptors(t)) : ownKeys(Object(t)).forEach(function (r) { Object.defineProperty(e, r, Object.getOwnPropertyDescriptor(t, r)); }); } return e; }
 function _defineProperty(e, r, t) { return (r = _toPropertyKey(r)) in e ? Object.defineProperty(e, r, { value: t, enumerable: !0, configurable: !0, writable: !0 }) : e[r] = t, e; }
 function _toPropertyKey(t) { var i = _toPrimitive(t, "string"); return "symbol" == typeof i ? i : i + ""; }
 function _toPrimitive(t, r) { if ("object" != typeof t || !t) return t; var e = t[Symbol.toPrimitive]; if (void 0 !== e) { var i = e.call(t, r || "default"); if ("object" != typeof i) return i; throw new TypeError("@@toPrimitive must return a primitive value."); } return ("string" === r ? String : Number)(t); }
@@ -183,7 +186,6 @@ function _toPrimitive(t, r) { if ("object" != typeof t || !t) return t; var e =
 
 const REGEX_DSL_PATTERN = /{([^}]+)}/g;
 class AddComponents {
-  // only bit-add (not bit-create/new) should handle out-of-sync scenario
   constructor(context, addProps) {
     _defineProperty(this, "workspace", void 0);
     _defineProperty(this, "consumer", void 0);
@@ -204,6 +206,8 @@ class AddComponents {
     // helpful for out-of-sync
     _defineProperty(this, "config", void 0);
     _defineProperty(this, "shouldHandleOutOfSync", void 0);
+    // only bit-add (not bit-create/new) should handle out-of-sync scenario
+    _defineProperty(this, "root", void 0);
     this.workspace = context.workspace;
     this.consumer = context.workspace.consumer;
     this.bitMap = this.consumer.bitMap;
@@ -222,6 +226,40 @@ class AddComponents {
     this.defaultScope = addProps.defaultScope;
     this.config = addProps.config;
     this.shouldHandleOutOfSync = addProps.shouldHandleOutOfSync;
+    this.root = addProps.root;
+  }
+
+  /**
+   * tracking the workspace root turns the workspace itself into a component: it owns every file no
+   * other component claims, `.bitmap` included, and every other component becomes a member of it.
+   * "bit add ." is one keystroke away from "git add .", which means something else entirely, so the
+   * intent is spelled out rather than inferred from the path.
+   *
+   * only the workspace root needs the flag, and it is the only thing the flag does: "bit add ." from
+   * a sub-directory names that directory, not the root, and is tracked like any other path.
+   *
+   * a workspace that already has a root does not ask again. what the flag guards against is creating
+   * one by accident, and there is none to create here - the add either refreshes the root that exists
+   * or names a second owner for ".", which has its own message saying who holds it.
+   */
+  /**
+   * the paths reach here as the user typed them - relative to the cwd, or absolute - so the workspace
+   * root arrives as ".", as "", or as the workspace path itself, depending on where the command ran.
+   */
+  isWorkspaceRootPath(onePath) {
+    return ((0, _legacy5().pathNormalizeToLinux)(this.consumer.getPathRelativeToConsumer(onePath)) || _legacy3().WORKSPACE_ROOT_DIR) === _legacy3().WORKSPACE_ROOT_DIR;
+  }
+  throwForWorkspaceRootFlagMismatch(resolvedPaths) {
+    const tracksRoot = resolvedPaths.some(onePath => this.isWorkspaceRootPath(onePath));
+    if (tracksRoot && !this.root && !this.bitMap.getWorkspaceRootMap()) {
+      throw new (_bitError().BitError)(`unable to track the workspace root without the --root flag.
+it makes the workspace itself a component - it owns every file no other component claims, .bitmap included, and every other component becomes a member of it.
+if that is what you want, run "bit add . --root". to track a component, pass its directory, e.g. "bit add my-component"`);
+    }
+    if (!tracksRoot && this.root) {
+      throw new (_bitError().BitError)(`the --root flag tracks the workspace root, but none of the given paths is the workspace root.
+run "bit add . --root" from the workspace root, or drop the flag to track the given paths as ordinary components`);
+    }
   }
   async add() {
     this.ignoreList = await this.getIgnoreList();
@@ -246,6 +284,7 @@ class AddComponents {
         throw new (_addingIndividualFiles().AddingIndividualFiles)(compPath);
       }
     });
+    this.throwForWorkspaceRootFlagMismatch(Object.keys(componentPathsStats));
     if (Object.keys(componentPathsStats).length > 1 && this.id) {
       throw new (_bitError().BitError)(`the --id flag (${this.id}) is used for a single component only, however, got ${this.componentPaths.length} paths`);
     }
@@ -340,17 +379,32 @@ class AddComponents {
     const foundComponentFromBitMap = this.bitMap.getComponentIfExist(component.componentId, {
       ignoreVersion: true
     });
+    // the workspace-root component owns every file no other component claims, so it "owns" a file
+    // only until a more specific component is added for it: the component being added wins, and the
+    // root subtracts the new root-dir from its own file-set on the next scan. the one file it cannot
+    // give away is its main file - without it, it fails to load from the next scan on.
+    const workspaceRootMap = this.bitMap.getWorkspaceRootMap();
+    const isWorkspaceRoot = component.trackDir === _legacy3().WORKSPACE_ROOT_DIR;
+    if (workspaceRootMap && !isWorkspaceRoot && !parsedBitId.isEqualWithoutVersion(workspaceRootMap.id)) {
+      throwForTakingWorkspaceRootMainFile(workspaceRootMap, parsedBitId, (0, _legacy5().pathNormalizeToLinux)(component.trackDir));
+    }
     const componentFilesP = files.map(async file => {
       // $FlowFixMe null is removed later on
       const filePath = path().join(consumerPath, file.relativePath);
+      // the workspace map carries the auto-generated banner, but the root component tracks it on
+      // purpose (see isWorkspaceMapFile), and the rescan keeps it. the add-time file-set does too.
       const isAutoGenerated = await isAutoGeneratedFile(filePath);
-      if (isAutoGenerated) {
+      // trackAllFiles keeps the files bit generates, and the rescan never looks at the banner at all
+      // (see getFilesByDir) - so dropping them here would leave the add-time file-set short of it.
+      const keepAutoGenerated = this.consumer.config.trackAllFiles || isWorkspaceRoot && (0, _legacy3().isWorkspaceMapFile)(file.relativePath);
+      if (isAutoGenerated && !keepAutoGenerated) {
         return null;
       }
       const caseSensitive = false;
       const existingIdOfFile = this.bitMap.getComponentIdByPath(file.relativePath, caseSensitive);
       const idOfFileIsDifferent = existingIdOfFile && !existingIdOfFile.isEqual(parsedBitId);
-      if (idOfFileIsDifferent) {
+      const ownedByWorkspaceRoot = Boolean(workspaceRootMap && existingIdOfFile?.isEqualWithoutVersion(workspaceRootMap.id));
+      if (idOfFileIsDifferent && !ownedByWorkspaceRoot) {
         // not imported component file but exists in bitmap
         // @ts-ignore AUTO-ADDED-AFTER-MIGRATION-PLEASE-FIX!
         if (this.warnings.alreadyUsed[existingIdOfFile]) {
@@ -389,7 +443,9 @@ class AddComponents {
         return foundComponentFromBitMap;
       }
     }
-    if (!this.override && foundComponentFromBitMap) {
+    // the root's files are whatever the scan says. a component nested since the previous add owns the
+    // files the previous entry listed for the root, so they are not merged back.
+    if (!this.override && foundComponentFromBitMap && !isWorkspaceRoot) {
       this._updateFilesWithCurrentLetterCases(foundComponentFromBitMap, componentFiles);
       component.files = this._mergeFilesWithExistingComponentMapFiles(componentFiles, foundComponentFromBitMap.files);
     } else {
@@ -404,7 +460,8 @@ class AddComponents {
       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 => !(0, _legacy5().pathNormalizeToLinux)(file.relativePath).startsWith(`${(0, _legacy5().pathNormalizeToLinux)(trackDir)}/`));
+      // every file in the workspace is inside the workspace root, so there is nothing to check.
+      const fileNotInsideTrackDir = trackDir === _legacy3().WORKSPACE_ROOT_DIR ? undefined : componentFiles.find(file => !(0, _legacy5().pathNormalizeToLinux)(file.relativePath).startsWith(`${(0, _legacy5().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.
@@ -429,7 +486,7 @@ class AddComponents {
         componentId: new (_componentId().ComponentID)(componentId._legacy, defaultScope),
         files: component.files,
         defaultScope,
-        config: this.config,
+        config: rootDir === _legacy3().WORKSPACE_ROOT_DIR ? configForWorkspaceRoot(foundComponentFromBitMap?.config, this.config) : this.config,
         mainFile,
         // @ts-ignore AUTO-ADDED-AFTER-MIGRATION-PLEASE-FIX!
         override: this.override
@@ -450,6 +507,11 @@ class AddComponents {
   _updateFilesAccordingToExistingRootDir(foundComponentFromBitMap, componentFiles, component) {
     const existingRootDir = foundComponentFromBitMap.rootDir;
     if (!existingRootDir) return; // nothing to do.
+    // every file in the workspace is inside the workspace root, and its paths are already relative
+    // to it, so there is nothing to check and nothing to rewrite. without this, re-running
+    // "bit add ." would compare "README.md" against a "./" prefix, decide the files are outside the
+    // root, and throw.
+    if (existingRootDir === _legacy3().WORKSPACE_ROOT_DIR) return;
     const areFilesInsideExistingRootDir = componentFiles.every(file => (0, _legacy5().pathNormalizeToLinux)(file.relativePath).startsWith(`${existingRootDir}/`));
     if (areFilesInsideExistingRootDir) {
       _legacy3().ComponentMap.changeFilesPathAccordingToItsRootDir(existingRootDir, componentFiles);
@@ -588,21 +650,49 @@ you can add the directory these files are located at and it'll change the root d
    * 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) {
+  async addOneComponent(componentPath, batchRootDirs = []) {
     let finalBitId; // final id to use for bitmap file
     let idFromPath;
     if (this.id) {
       finalBitId = this._getIdAccordingToExistingComponent(this.id);
     }
-    const relativeComponentPath = this.consumer.getPathRelativeToConsumer(componentPath);
+    // when the tracked dir is the workspace root itself, the relative path is empty. normalize it
+    // to "." so it is a real rootDir rather than a falsy one.
+    const relativeComponentPath = this.consumer.getPathRelativeToConsumer(componentPath) || _legacy3().WORKSPACE_ROOT_DIR;
     this._throwForOutsideConsumer(relativeComponentPath);
-    throwForExistingParentDir(this.bitMap, relativeComponentPath);
+    // the component this add is for: the one the user named, tracked already or not, or else the
+    // one already tracking this dir. for the workspace root, this is what tells a re-add from a
+    // second owner.
+    const idOfTrackDir = this._getIdAccordingToTrackDir(relativeComponentPath);
+    const idToAdd = this.id ? finalBitId : idOfTrackDir;
+    throwForExistingParentDir(this.bitMap, relativeComponentPath, idToAdd || undefined);
+    // files of components nested inside this dir belong to them, not to the component being added -
+    // whether they are tracked already or added by the same command.
+    const nestedRootDirs = (0, _lodash().uniq)([...this.bitMap.getNestedRootDirs(relativeComponentPath), ...batchRootDirs.filter(other => other !== relativeComponentPath && (relativeComponentPath === _legacy3().WORKSPACE_ROOT_DIR || other.startsWith(`${relativeComponentPath}/`)))]);
     const matches = await (0, _glob().glob)((0, _legacy5().pathNormalizeToLinux)(path().join(relativeComponentPath, '**')), {
       cwd: this.consumer.getPath(),
-      nodir: true
+      nodir: true,
+      // dotfiles are component files like any other (the workspace root is full of them: .gitignore,
+      // .github/**). the rescan, getFilesByDir(), scans with dot: true, and the add-time file-set has to
+      // agree with it rather than be corrected by the next command.
+      dot: true,
+      // the same exclusions the rescan applies, see getFilesByDir().
+      ignore: (0, _legacy3().getScanIgnorePatterns)(relativeComponentPath, nestedRootDirs)
     });
     if (!matches.length) throw new (_exceptions().EmptyDirectory)(componentPath);
-    const filteredMatches = this.gitIgnore.filter(matches);
+
+    // the config files "bit ws-config write" generates are not source - the same rule the rescan
+    // applies (see getFilesByDir), so the add-time file-set matches the next rescan.
+    const generatedAtRoot = new Set(_legacy2().IGNORE_ROOT_ONLY_LIST.map(file => (0, _legacy5().pathNormalizeToLinux)(path().join(relativeComponentPath, file))));
+    const matchesNotIgnored = await (0, _legacy3().filterByIgnoreFiles)(relativeComponentPath, this.consumer.getPath(), this.gitIgnore, matches.map(_legacy5().pathNormalizeToLinux), this.consumer.config.trackAllFiles);
+    // and by the component's own ignore file, the rule the rescan applies (see getFilesByDir) - it
+    // takes paths relative to the component, the matches are relative to the workspace.
+    const relativeToComponent = match => path().posix.relative(relativeComponentPath, match);
+    const keptByOwnIgnoreFile = new Set(await (0, _legacy3().filterByOwnIgnoreFile)(relativeComponentPath, this.consumer.getPath(), matchesNotIgnored.map(relativeToComponent)));
+    // the rules the rescan applies too (see getFilesByDir), so the add-time file-set matches it. the
+    // main file is checked against the same predicate below - it is put back after this filtering.
+    const isTrackable = match => keptByOwnIgnoreFile.has(relativeToComponent(match)) && (this.consumer.config.trackAllFiles || !generatedAtRoot.has(match));
+    const filteredMatches = matchesNotIgnored.filter(isTrackable);
     if (!filteredMatches.length) {
       throw new (_exceptions().NoFiles)(matches);
     }
@@ -614,10 +704,29 @@ you can add the directory these files are located at and it'll change the root d
       };
     });
     const resolvedMainFile = this._addMainFileToFiles(filteredMatchedFiles);
+    // that puts the main file back into the list after the filtering above, and checks it against the
+    // workspace ignore rules only. without applying the rest of them here, the add fails further down
+    // on a main file the rescan already dropped, saying it was removed - the config files bit treats
+    // as generated (tsconfig.json and friends) reach it that way, as does a component ignore file.
+    if (resolvedMainFile) {
+      const mainNormalized = (0, _legacy5().pathNormalizeToLinux)(resolvedMainFile);
+      // it is in the file-set only if it was found on disk. a missing one is reported further down,
+      // where the error says so rather than blaming an ignore rule.
+      const inFileSet = filteredMatchedFiles.some(file => file.relativePath === mainNormalized);
+      // some paths the scan never yields at all - bit's own dirs, a nested workspace map, the
+      // root-dir of a component nested in this one - so they never reach `matches` and the ignore
+      // rules below have nothing to compare them against. either way an explicit main file is put
+      // into the file-set without going through the scan, and the next rescan drops it again: the
+      // component then fails to load, saying the main file was removed.
+      const excludedFromScan = !(0, _legacy3().filterByScanIgnorePatterns)(relativeComponentPath, [mainNormalized], nestedRootDirs).length;
+      const excludedByIgnoreRules = matchesNotIgnored.includes(mainNormalized) && !isTrackable(mainNormalized);
+      if (inFileSet && excludedFromScan || excludedByIgnoreRules) {
+        throw new (_exceptions().ExcludedMainFile)(relativeToComponent(mainNormalized));
+      }
+    }
     const absoluteComponentPath = (0, _legacy5().pathNormalizeToLinux)(path().resolve(componentPath));
     const splitPath = absoluteComponentPath.split('/');
     const lastDir = splitPath[splitPath.length - 1];
-    const idOfTrackDir = this._getIdAccordingToTrackDir(componentPath);
     if (!finalBitId) {
       if (this.id) {
         const bitId = _legacyBitId().BitId.parse(this.id, false);
@@ -651,7 +760,7 @@ you can add the directory these files are located at and it'll change the root d
   }
   async getIgnoreList() {
     const consumerPath = this.consumer.getPath();
-    return (0, _legacy3().getIgnoreListHarmony)(consumerPath, this.consumer.config.ignoredFiles);
+    return (0, _legacy3().getIgnoreListHarmony)(consumerPath, this.consumer.config.ignoredFiles, this.consumer.config.trackAllFiles);
   }
   async linkComponents(ids) {
     if (this.trackDirFeature) {
@@ -678,8 +787,13 @@ you can add the directory these files are located at and it'll change the root d
   _removeDirectoriesWhenTheirFilesAreAdded(componentPathsStats) {
     const allPaths = Object.keys(componentPathsStats);
     allPaths.forEach(componentPath => {
-      const foundDir = allPaths.find(p => p === path().dirname(componentPath));
-      if (foundDir && componentPathsStats[foundDir]) {
+      // the dirname of "." is "." itself - the workspace root is not a wildcard expansion of itself.
+      const foundDir = allPaths.find(p => p !== componentPath && p === path().dirname(componentPath));
+      // nor of what sits directly below it. the workspace root contains every other component by
+      // design, so a component inside it is no reason to drop it: it was asked for by name, and the
+      // --root flag says so in as many words (see throwForWorkspaceRootFlagMismatch). without this,
+      // "bit add . comp --root" tracks comp alone and reports success, the root never created.
+      if (foundDir && componentPathsStats[foundDir] && !this.isWorkspaceRootPath(foundDir)) {
         _legacy4().logger.debug(`add-components._removeDirectoriesWhenTheirFilesAreAdded, ignoring ${foundDir}`);
         delete componentPathsStats[foundDir];
       }
@@ -721,9 +835,10 @@ you can add the directory these files are located at and it'll change the root d
     }));
   }
   async _tryAddingMultiple(componentPathsStats) {
+    const batchRootDirs = Object.keys(componentPathsStats).map(onePath => (0, _legacy5().pathNormalizeToLinux)(this.consumer.getPathRelativeToConsumer(onePath)) || _legacy3().WORKSPACE_ROOT_DIR);
     const addedP = Object.keys(componentPathsStats).map(async onePath => {
       try {
-        const addedComponent = await this.addOneComponent(onePath);
+        const addedComponent = await this.addOneComponent(onePath, batchRootDirs);
         return addedComponent;
       } catch (err) {
         if (!(err instanceof _exceptions().EmptyDirectory)) throw err;
@@ -741,13 +856,28 @@ you can add the directory these files are located at and it'll change the root d
   }
 }
 exports.default = AddComponents;
-function throwForExistingParentDir(bitMap, relativeToConsumerPath) {
+function throwForExistingParentDir(bitMap, relativeToConsumerPath, addedId) {
+  if (relativeToConsumerPath === _legacy3().WORKSPACE_ROOT_DIR) {
+    // only one component can own the workspace root. rejected before the (expensive) scan of the
+    // whole workspace, with a message that says which component already owns it. re-adding the same
+    // component is fine. the root component contains every other component by design, so there is no
+    // parent-dir conflict to check for it.
+    const currentOwner = bitMap.getComponentIdByRootPath(_legacy3().WORKSPACE_ROOT_DIR);
+    if (currentOwner && !addedId?.isEqual(currentOwner, {
+      ignoreVersion: true
+    })) {
+      throw new (_bitError().BitError)(`unable to track the workspace root, it is already tracked by "${currentOwner.toStringWithoutVersion()}"`);
+    }
+    return;
+  }
   const isParentDir = parent => {
     const relative = path().relative(parent, relativeToConsumerPath);
     return relative && !relative.startsWith('..') && !path().isAbsolute(relative);
   };
   bitMap.components.forEach(componentMap => {
-    if (!componentMap.rootDir) return;
+    // the workspace-root component contains every other component by design, and subtracts their
+    // root-dirs from its own file-set.
+    if (!componentMap.rootDir || componentMap.rootDir === _legacy3().WORKSPACE_ROOT_DIR) return;
     if (isParentDir(componentMap.rootDir)) {
       throw new (_parentDirTracked().ParentDirTracked)(componentMap.rootDir, componentMap.id.toStringWithoutVersion(), relativeToConsumerPath);
     }
@@ -809,46 +939,135 @@ async function isAutoGeneratedFile(filePath) {
   const line = await (0, _firstline().default)(filePath);
   return line.includes(_legacy2().AUTO_GENERATED_STAMP);
 }
+
+/**
+ * the env the workspace-root component is tracked with. hardcoded, the same way the envs aspect
+ * names its default env - the tracker does not depend on the env aspects.
+ */
+const WORKSPACE_ROOT_ENV = 'teambit.harmony/empty-env';
+
+/**
+ * the workspace-root component (rootDir ".") is a bag of config files, not a source component:
+ * nothing compiles it, nothing tests it, and nothing imports it as a package. the regular default
+ * env would give it a compiler and a dependency policy it can never satisfy, so it is tracked with
+ * the empty env - as explicit config, so every path that resolves an env or a dependency policy
+ * sees the same answer. an env configured by the caller, or set later with "bit env set", wins.
+ */
+function configForWorkspaceRoot(existingConfig, addedConfig) {
+  const configuredEnv = addedConfig?.[_legacy2().Extensions.envs] ?? existingConfig?.[_legacy2().Extensions.envs];
+  if (configuredEnv) return _objectSpread(_objectSpread({}, existingConfig), addedConfig);
+  // the same two entries "bit env set" writes: the env aspect itself, and the env selection
+  return _objectSpread(_objectSpread(_objectSpread({}, existingConfig), addedConfig), {}, {
+    [WORKSPACE_ROOT_ENV]: {},
+    [_legacy2().Extensions.envs]: {
+      env: WORKSPACE_ROOT_ENV
+    }
+  });
+}
 async function addMultipleFromResolvedTrackData(workspace, trackData) {
   const bitMap = workspace.consumer.bitMap;
-  const ignoreList = await (0, _legacy3().getIgnoreListHarmony)(workspace.path, workspace.consumer.config.ignoredFiles);
+  const {
+    ignoredFiles,
+    trackAllFiles
+  } = workspace.consumer.config;
+  const ignoreList = await (0, _legacy3().getIgnoreListHarmony)(workspace.path, ignoredFiles, trackAllFiles);
   const gitIgnore = (0, _ignore().default)().add(ignoreList);
-  const componentMaps = trackData.map(data => {
+  // normalized once, the way the map stores it, so "./" is the workspace root here as well as there
+  const normalizeRootDir = rootDir => (0, _legacy5().pathNormalizeToLinux)(path().normalize(rootDir));
+  const batchRootDirs = trackData.map(data => normalizeRootDir(data.rootDir));
+  const componentMaps = [];
+  for (const data of trackData) {
     const {
-      rootDir,
       files,
       componentName,
       defaultScope,
-      mainFile,
       config
     } = data;
-    if (path().isAbsolute(rootDir)) throw new (_bitError().BitError)(`path is absolute, got ${rootDir}`);
-    throwForExistingParentDir(bitMap, rootDir);
-    const filtered = gitIgnore.filter(files);
-    if (!filtered.length) {
-      throw new (_exceptions().NoFiles)(files);
-    }
-    const componentFiles = filtered.map(match => {
-      return {
-        relativePath: (0, _legacy5().pathNormalizeToLinux)(match),
-        name: path().basename(match)
-      };
+    if (path().isAbsolute(data.rootDir)) throw new (_bitError().BitError)(`path is absolute, got ${data.rootDir}`);
+    const rootDir = normalizeRootDir(data.rootDir);
+    const componentId = _componentId().ComponentID.fromObject({
+      name: componentName
+    }, defaultScope);
+    // re-tracking the workspace root with the same id is a no-op, not a second owner
+    throwForExistingParentDir(bitMap, rootDir, componentId);
+    const isWorkspaceRoot = rootDir === _legacy3().WORKSPACE_ROOT_DIR;
+    // re-tracking keeps the entry's id, version included, the way "bit add" does: the id built from
+    // the name alone would replace it and make a snapped component look newly tracked.
+    const existingEntry = bitMap.getComponentIfExist(componentId, {
+      ignoreVersion: true
     });
+    const idToTrack = existingEntry?.id ?? componentId;
+    // the workspace root has no entry point of its own, workspace.jsonc stands in for it, the way
+    // "bit add ." resolves it (see determine-main-file). re-tracking keeps the entry's main file.
+    const mainFile = data.mainFile ?? existingEntry?.mainFile ?? (isWorkspaceRoot ? _legacy2().WORKSPACE_JSONC : undefined);
+    if (!mainFile) throw new (_bitError().BitError)(`unable to track "${rootDir}" as "${componentName}", no main file was given`);
+    const existingConfig = isWorkspaceRoot ? existingEntry?.config : undefined;
+    const componentFiles = isWorkspaceRoot ? await scanWorkspaceRootFiles(workspace, gitIgnore, batchRootDirs) : await filterResolvedFiles(rootDir, workspace.path, files, gitIgnore, trackAllFiles);
+    // a nested component may take any file from a tracked workspace root but its main file, the
+    // rule "bit add" applies. a root tracked later in the same call scans around this component.
+    const workspaceRootMap = bitMap.getWorkspaceRootMap();
+    if (!isWorkspaceRoot && workspaceRootMap) throwForTakingWorkspaceRootMainFile(workspaceRootMap, idToTrack, rootDir);
     const componentMap = bitMap.addComponent({
-      componentId: _componentId().ComponentID.fromObject({
-        name: componentName
-      }, defaultScope),
+      componentId: idToTrack,
       files: componentFiles,
-      defaultScope,
-      config,
+      defaultScope: idToTrack.hasScope() ? undefined : defaultScope,
+      config: isWorkspaceRoot ? configForWorkspaceRoot(existingConfig, config) : config,
       mainFile,
       rootDir
     });
-    return componentMap;
-  });
+    componentMaps.push(componentMap);
+  }
   const allIds = componentMaps.map(c => c.id);
   await (0, _workspaceModules().linkToNodeModulesByIds)(workspace, allIds);
   return allIds;
 }
 
+/**
+ * the workspace-root component owns every file no other component claims, so it gives a file away to
+ * a more specific component - all but its main file: without it, it fails to load from the next scan on.
+ */
+function throwForTakingWorkspaceRootMainFile(workspaceRootMap, componentId, rootDir) {
+  // checked on the directory rather than on the files the component keeps: the root's next scan
+  // subtracts the whole directory, whether or not the component itself tracks that file. the
+  // ownership lookups are case-insensitive, so this comparison is too.
+  if (!workspaceRootMap.mainFile.toLowerCase().startsWith(`${rootDir.toLowerCase()}/`)) return;
+  throw new (_bitError().BitError)(`unable to add "${rootDir}" as "${componentId.toString()}", it contains "${workspaceRootMap.mainFile}", the main file of the workspace-root component "${workspaceRootMap.id.toStringWithoutVersion()}". set a different main file for it first: bit add . --main ${_legacy2().WORKSPACE_JSONC}`);
+}
+
+/**
+ * the workspace-root's file-set is derived by scanning, the way every load derives it, rather than
+ * taken from the caller: the scan is what knows the nested components (tracked already, or by the same
+ * call), the ignore files below the root and bit's own exclusions. a main file the scan leaves out
+ * fails the map validation before the map is written, not on the next load.
+ */
+async function scanWorkspaceRootFiles(workspace, gitIgnore, batchRootDirs) {
+  const nestedRootDirs = (0, _lodash().uniq)([...workspace.consumer.bitMap.getNestedRootDirs(_legacy3().WORKSPACE_ROOT_DIR), ...batchRootDirs.filter(dir => dir !== _legacy3().WORKSPACE_ROOT_DIR)]);
+  const {
+    trackAllFiles
+  } = workspace.consumer.config;
+  return (0, _legacy3().getFilesByDir)(_legacy3().WORKSPACE_ROOT_DIR, workspace.path, gitIgnore, nestedRootDirs, trackAllFiles);
+}
+
+/**
+ * the files the caller resolved for a component, minus the config files "bit ws-config write"
+ * generates and the ignored ones - the rules the rescan applies, see getFilesByDir. the workspace
+ * ignore rules are written against the workspace root, so a file is matched by its workspace-relative
+ * path and mapped back to the component-relative one the map stores; the component's own ignore file
+ * is applied to the latter.
+ */
+async function filterResolvedFiles(rootDir, consumerPath, files, gitIgnore, trackAllFiles) {
+  const notGenerated = files.map(_legacy5().pathNormalizeToLinux).filter(file => trackAllFiles || !_legacy2().IGNORE_ROOT_ONLY_LIST.includes(file));
+  // what a scan never yields (bit's and git's own dirs, a nested workspace map) is not tracked here either,
+  // or the next rescan would drop it
+  const workspaceRelative = (0, _legacy3().filterByScanIgnorePatterns)(rootDir, notGenerated.map(file => path().posix.join(rootDir, file)));
+  const filteredByWorkspaceRules = gitIgnore.filter(workspaceRelative).map(file => path().posix.relative(rootDir, file));
+  const filtered = await (0, _legacy3().filterByOwnIgnoreFile)(rootDir, consumerPath, filteredByWorkspaceRules);
+  if (!filtered.length) throw new (_exceptions().NoFiles)(files);
+  return filtered.map(relativePath => ({
+    relativePath,
+    name: path().basename(relativePath),
+    test: false
+  }));
+}
+
 //# sourceMappingURL=add-components.js.map