@teambit/workspace-root 0.0.1

package/dist/workspace-root-data.js

@@ -0,0 +1,82 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.findWorkspaceRootMap = findWorkspaceRootMap;
+exports.isWorkspaceRootComponent = isWorkspaceRootComponent;
+exports.readWorkspaceRoot = readWorkspaceRoot;
+exports.writeWorkspaceRoot = writeWorkspaceRoot;
+function _componentId() {
+  const data = require("@teambit/component-id");
+  _componentId = function () {
+    return data;
+  };
+  return data;
+}
+function _legacy() {
+  const data = require("@teambit/legacy.extension-data");
+  _legacy = function () {
+    return data;
+  };
+  return data;
+}
+function _workspaceRoot() {
+  const data = require("./workspace-root.aspect");
+  _workspaceRoot = function () {
+    return data;
+  };
+  return data;
+}
+/**
+ * the aspect data of a workspace-root component and of its members. it is data, not config, on
+ * purpose: a Version's hash covers the extensions' config only, so neither entry ever makes a
+ * component modified, and the root moving on does not touch its members.
+ */
+
+/**
+ * the entry of the component that owns the workspace root (rootDir "."), if the workspace has one.
+ *
+ * a root created on another lane, or removed, stays in `.bitmap` so a switch back can restore it.
+ * it is not this workspace's root though, and tagging or snapping would otherwise bring it along.
+ */
+function findWorkspaceRootMap(bitMap) {
+  return bitMap.getWorkspaceRootMap();
+}
+function findData(extensions) {
+  return extensions.findCoreExtension(_workspaceRoot().WorkspaceRootAspect.id)?.data;
+}
+
+/**
+ * whether the component is a workspace-root component, by the marker its versions carry.
+ */
+function isWorkspaceRootComponent(extensions) {
+  return Boolean(findData(extensions)?.isRoot);
+}
+function readWorkspaceRoot(extensions) {
+  const root = findData(extensions)?.root;
+  return root ? _componentId().ComponentID.fromString(root) : undefined;
+}
+
+/**
+ * nothing clears this data: it is not inherited from the version before it. the loader supplies the
+ * aspect's data on every load, so a component arrives with the root of the workspace it is in now, or
+ * with none - what an earlier workspace recorded never reaches the next version. the data is replaced
+ * wholesale rather than merged, so a component that changes role (a member tracked at "." later, or a
+ * root moved into a directory of its own) does not keep the marker of the role it left.
+ */
+function writeWorkspaceRoot(extensions, rootId) {
+  const data = {
+    root: rootId.toString()
+  };
+  const existing = extensions.findCoreExtension(_workspaceRoot().WorkspaceRootAspect.id);
+  if (existing) {
+    existing.data = data;
+    return;
+  }
+  // core aspects are keyed by name in the extensions list, the same way the component loader adds
+  // aspect data (see WorkspaceComponentLoader.getDataEntry)
+  extensions.push(new (_legacy().ExtensionDataEntry)(undefined, undefined, _workspaceRoot().WorkspaceRootAspect.id, undefined, data));
+}
+
+//# sourceMappingURL=workspace-root-data.js.map

package/dist/workspace-root-data.js.map

@@ -0,0 +1 @@
+{"version":3,"names":["_componentId","data","require","_legacy","_workspaceRoot","findWorkspaceRootMap","bitMap","getWorkspaceRootMap","findData","extensions","findCoreExtension","WorkspaceRootAspect","id","isWorkspaceRootComponent","Boolean","isRoot","readWorkspaceRoot","root","ComponentID","fromString","undefined","writeWorkspaceRoot","rootId","toString","existing","push","ExtensionDataEntry"],"sources":["workspace-root-data.ts"],"sourcesContent":["import { ComponentID } from '@teambit/component-id';\nimport type { BitMap, ComponentMap } from '@teambit/legacy.bit-map';\nimport type { ExtensionDataList } from '@teambit/legacy.extension-data';\nimport { ExtensionDataEntry } from '@teambit/legacy.extension-data';\nimport { WorkspaceRootAspect } from './workspace-root.aspect';\n\n/**\n * the aspect data of a workspace-root component and of its members. it is data, not config, on\n * purpose: a Version's hash covers the extensions' config only, so neither entry ever makes a\n * component modified, and the root moving on does not touch its members.\n */\nexport type WorkspaceRootData = {\n  /**\n   * on the workspace-root component itself. set when it is loaded in a workspace and saved with\n   * every version, so the root is told from the model alone - by an import onto \".\", a CI, a clone -\n   * and not by the files it happens to carry.\n   */\n  isRoot?: boolean;\n  /**\n   * on a member: the root of the workspace it was snapped in, at the version the root had at that\n   * moment, e.g. \"my-org.my-scope/my-root@0.0.7\". tag and snap bring a new or modified root into\n   * their batch, so a member they made always has the version.\n   */\n  root?: string;\n};\n\n/**\n * the entry of the component that owns the workspace root (rootDir \".\"), if the workspace has one.\n *\n * a root created on another lane, or removed, stays in `.bitmap` so a switch back can restore it.\n * it is not this workspace's root though, and tagging or snapping would otherwise bring it along.\n */\nexport function findWorkspaceRootMap(bitMap: BitMap): ComponentMap | undefined {\n  return bitMap.getWorkspaceRootMap();\n}\n\nfunction findData(extensions: ExtensionDataList): WorkspaceRootData | undefined {\n  return extensions.findCoreExtension(WorkspaceRootAspect.id)?.data;\n}\n\n/**\n * whether the component is a workspace-root component, by the marker its versions carry.\n */\nexport function isWorkspaceRootComponent(extensions: ExtensionDataList): boolean {\n  return Boolean(findData(extensions)?.isRoot);\n}\n\nexport function readWorkspaceRoot(extensions: ExtensionDataList): ComponentID | undefined {\n  const root = findData(extensions)?.root;\n  return root ? ComponentID.fromString(root) : undefined;\n}\n\n/**\n * nothing clears this data: it is not inherited from the version before it. the loader supplies the\n * aspect's data on every load, so a component arrives with the root of the workspace it is in now, or\n * with none - what an earlier workspace recorded never reaches the next version. the data is replaced\n * wholesale rather than merged, so a component that changes role (a member tracked at \".\" later, or a\n * root moved into a directory of its own) does not keep the marker of the role it left.\n */\nexport function writeWorkspaceRoot(extensions: ExtensionDataList, rootId: ComponentID): void {\n  const data: WorkspaceRootData = { root: rootId.toString() };\n  const existing = extensions.findCoreExtension(WorkspaceRootAspect.id);\n  if (existing) {\n    existing.data = data;\n    return;\n  }\n  // core aspects are keyed by name in the extensions list, the same way the component loader adds\n  // aspect data (see WorkspaceComponentLoader.getDataEntry)\n  extensions.push(new ExtensionDataEntry(undefined, undefined, WorkspaceRootAspect.id, undefined, data));\n}\n"],"mappings":";;;;;;;;;AAAA,SAAAA,aAAA;EAAA,MAAAC,IAAA,GAAAC,OAAA;EAAAF,YAAA,YAAAA,CAAA;IAAA,OAAAC,IAAA;EAAA;EAAA,OAAAA,IAAA;AAAA;AAGA,SAAAE,QAAA;EAAA,MAAAF,IAAA,GAAAC,OAAA;EAAAC,OAAA,YAAAA,CAAA;IAAA,OAAAF,IAAA;EAAA;EAAA,OAAAA,IAAA;AAAA;AACA,SAAAG,eAAA;EAAA,MAAAH,IAAA,GAAAC,OAAA;EAAAE,cAAA,YAAAA,CAAA;IAAA,OAAAH,IAAA;EAAA;EAAA,OAAAA,IAAA;AAAA;AAEA;AACA;AACA;AACA;AACA;;AAgBA;AACA;AACA;AACA;AACA;AACA;AACO,SAASI,oBAAoBA,CAACC,MAAc,EAA4B;EAC7E,OAAOA,MAAM,CAACC,mBAAmB,CAAC,CAAC;AACrC;AAEA,SAASC,QAAQA,CAACC,UAA6B,EAAiC;EAC9E,OAAOA,UAAU,CAACC,iBAAiB,CAACC,oCAAmB,CAACC,EAAE,CAAC,EAAEX,IAAI;AACnE;;AAEA;AACA;AACA;AACO,SAASY,wBAAwBA,CAACJ,UAA6B,EAAW;EAC/E,OAAOK,OAAO,CAACN,QAAQ,CAACC,UAAU,CAAC,EAAEM,MAAM,CAAC;AAC9C;AAEO,SAASC,iBAAiBA,CAACP,UAA6B,EAA2B;EACxF,MAAMQ,IAAI,GAAGT,QAAQ,CAACC,UAAU,CAAC,EAAEQ,IAAI;EACvC,OAAOA,IAAI,GAAGC,0BAAW,CAACC,UAAU,CAACF,IAAI,CAAC,GAAGG,SAAS;AACxD;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;AACO,SAASC,kBAAkBA,CAACZ,UAA6B,EAAEa,MAAmB,EAAQ;EAC3F,MAAMrB,IAAuB,GAAG;IAAEgB,IAAI,EAAEK,MAAM,CAACC,QAAQ,CAAC;EAAE,CAAC;EAC3D,MAAMC,QAAQ,GAAGf,UAAU,CAACC,iBAAiB,CAACC,oCAAmB,CAACC,EAAE,CAAC;EACrE,IAAIY,QAAQ,EAAE;IACZA,QAAQ,CAACvB,IAAI,GAAGA,IAAI;IACpB;EACF;EACA;EACA;EACAQ,UAAU,CAACgB,IAAI,CAAC,KAAIC,4BAAkB,EAACN,SAAS,EAAEA,SAAS,EAAET,oCAAmB,CAACC,EAAE,EAAEQ,SAAS,EAAEnB,IAAI,CAAC,CAAC;AACxG","ignoreList":[]}

package/dist/workspace-root-data.spec.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/workspace-root-data.spec.js

@@ -0,0 +1,159 @@
+"use strict";
+
+function _chai() {
+  const data = require("chai");
+  _chai = function () {
+    return data;
+  };
+  return data;
+}
+function _componentId() {
+  const data = require("@teambit/component-id");
+  _componentId = function () {
+    return data;
+  };
+  return data;
+}
+function _legacy() {
+  const data = require("@teambit/legacy.bit-map");
+  _legacy = function () {
+    return data;
+  };
+  return data;
+}
+function _legacy2() {
+  const data = require("@teambit/legacy.constants");
+  _legacy2 = function () {
+    return data;
+  };
+  return data;
+}
+function _legacy3() {
+  const data = require("@teambit/legacy.extension-data");
+  _legacy3 = function () {
+    return data;
+  };
+  return data;
+}
+function _workspaceRootData() {
+  const data = require("./workspace-root-data");
+  _workspaceRootData = function () {
+    return data;
+  };
+  return data;
+}
+function _workspaceRoot() {
+  const data = require("./workspace-root.aspect");
+  _workspaceRoot = function () {
+    return data;
+  };
+  return data;
+}
+const rootId = _componentId().ComponentID.fromString('my-scope/my-root@0.0.7');
+describe('workspace-root data', () => {
+  describe('findWorkspaceRootMap', () => {
+    // a real BitMap rather than a stand-in: the rule lives on it (getWorkspaceRootMap), and a mock
+    // that answers isRemoved() itself would only be testing the mock
+    const bitMapWith = async entries => {
+      const bitMap = await _legacy().BitMap.load(__dirname, '');
+      bitMap.loadComponents(entries, 'my-scope');
+      return bitMap;
+    };
+    const rootEntry = {
+      name: 'my-root',
+      scope: 'my-scope',
+      version: '0.0.7',
+      mainFile: 'README.md',
+      rootDir: '.'
+    };
+    const nestedEntry = {
+      name: 'comp1',
+      scope: 'my-scope',
+      version: '0.0.1',
+      mainFile: 'index.js',
+      rootDir: 'comp1'
+    };
+    it('should return the entry tracked at the workspace root', async () => {
+      const bitMap = await bitMapWith({
+        'my-scope/comp1': nestedEntry,
+        'my-scope/my-root': rootEntry
+      });
+      (0, _chai().expect)((0, _workspaceRootData().findWorkspaceRootMap)(bitMap)?.id.toString()).to.equal(rootId.toString());
+    });
+    it('should return undefined when no component owns the workspace root', async () => {
+      const bitMap = await bitMapWith({
+        'my-scope/comp1': nestedEntry
+      });
+      (0, _chai().expect)((0, _workspaceRootData().findWorkspaceRootMap)(bitMap)).to.be.undefined;
+    });
+    it('should ignore a root of another lane, this lane is rootless', async () => {
+      // it stays in .bitmap so a switch back can restore it. snapping here would otherwise tag it along
+      const bitMap = await bitMapWith({
+        'my-scope/my-root': rootEntry
+      });
+      bitMap.components[0].isAvailableOnCurrentLane = false;
+      (0, _chai().expect)((0, _workspaceRootData().findWorkspaceRootMap)(bitMap)).to.be.undefined;
+    });
+    it('should ignore a removed root', async () => {
+      const bitMap = await bitMapWith({
+        'my-scope/my-root': rootEntry
+      });
+      bitMap.components[0].config = {
+        [_legacy2().Extensions.remove]: {
+          removed: true
+        }
+      };
+      (0, _chai().expect)((0, _workspaceRootData().findWorkspaceRootMap)(bitMap)).to.be.undefined;
+    });
+  });
+  describe('isWorkspaceRootComponent', () => {
+    const withData = data => _legacy3().ExtensionDataList.fromArray([new (_legacy3().ExtensionDataEntry)(undefined, undefined, _workspaceRoot().WorkspaceRootAspect.id, undefined, data)]);
+    it('should recognize the marker the root carries', () => {
+      (0, _chai().expect)((0, _workspaceRootData().isWorkspaceRootComponent)(withData({
+        isRoot: true
+      }))).to.be.true;
+    });
+    it('should not take a member, which carries the pointer to its root, for a root', () => {
+      (0, _chai().expect)((0, _workspaceRootData().isWorkspaceRootComponent)(withData({
+        root: rootId.toString()
+      }))).to.be.false;
+    });
+    it('should be false for a component with no data of this aspect', () => {
+      (0, _chai().expect)((0, _workspaceRootData().isWorkspaceRootComponent)(_legacy3().ExtensionDataList.fromArray([]))).to.be.false;
+    });
+  });
+  describe('writeWorkspaceRoot and readWorkspaceRoot', () => {
+    it('should round-trip the root id with its version', () => {
+      const extensions = _legacy3().ExtensionDataList.fromArray([]);
+      (0, _workspaceRootData().writeWorkspaceRoot)(extensions, rootId);
+      (0, _chai().expect)((0, _workspaceRootData().readWorkspaceRoot)(extensions)?.toString()).to.equal('my-scope/my-root@0.0.7');
+    });
+    it('should replace an existing pointer rather than add a second entry', () => {
+      const extensions = _legacy3().ExtensionDataList.fromArray([]);
+      (0, _workspaceRootData().writeWorkspaceRoot)(extensions, rootId);
+      (0, _workspaceRootData().writeWorkspaceRoot)(extensions, rootId.changeVersion('0.0.8'));
+      (0, _chai().expect)(extensions).to.have.lengthOf(1);
+      (0, _chai().expect)((0, _workspaceRootData().readWorkspaceRoot)(extensions)?.version).to.equal('0.0.8');
+    });
+    it('should keep a root that was never snapped without a version', () => {
+      const extensions = _legacy3().ExtensionDataList.fromArray([]);
+      (0, _workspaceRootData().writeWorkspaceRoot)(extensions, _componentId().ComponentID.fromString('my-scope/my-root'));
+      (0, _chai().expect)((0, _workspaceRootData().readWorkspaceRoot)(extensions)?.hasVersion()).to.be.false;
+    });
+    it('should return undefined for a component with no pointer', () => {
+      (0, _chai().expect)((0, _workspaceRootData().readWorkspaceRoot)(_legacy3().ExtensionDataList.fromArray([]))).to.be.undefined;
+    });
+    it('should replace the data rather than merge into it, so a former root is not both', () => {
+      // a root moved out of "." into a directory of its own becomes an ordinary member. merging would
+      // leave the isRoot marker behind and the version would claim both roles at once
+      const extensions = _legacy3().ExtensionDataList.fromArray([new (_legacy3().ExtensionDataEntry)(undefined, undefined, _workspaceRoot().WorkspaceRootAspect.id, undefined, {
+        isRoot: true
+      })]);
+      (0, _workspaceRootData().writeWorkspaceRoot)(extensions, rootId);
+      (0, _chai().expect)((0, _workspaceRootData().isWorkspaceRootComponent)(extensions)).to.be.false;
+      (0, _chai().expect)((0, _workspaceRootData().readWorkspaceRoot)(extensions)?.toString()).to.equal(rootId.toString());
+    });
+  });
+});
+
+//# sourceMappingURL=workspace-root-data.spec.js.map

package/dist/workspace-root-data.spec.js.map

@@ -0,0 +1 @@
+{"version":3,"names":["_chai","data","require","_componentId","_legacy","_legacy2","_legacy3","_workspaceRootData","_workspaceRoot","rootId","ComponentID","fromString","describe","bitMapWith","entries","bitMap","BitMap","load","__dirname","loadComponents","rootEntry","name","scope","version","mainFile","rootDir","nestedEntry","it","expect","findWorkspaceRootMap","id","toString","to","equal","be","undefined","components","isAvailableOnCurrentLane","config","Extensions","remove","removed","withData","ExtensionDataList","fromArray","ExtensionDataEntry","WorkspaceRootAspect","isWorkspaceRootComponent","isRoot","true","root","false","extensions","writeWorkspaceRoot","readWorkspaceRoot","changeVersion","have","lengthOf","hasVersion"],"sources":["workspace-root-data.spec.ts"],"sourcesContent":["import { expect } from 'chai';\nimport { ComponentID } from '@teambit/component-id';\nimport { BitMap } from '@teambit/legacy.bit-map';\nimport { Extensions } from '@teambit/legacy.constants';\nimport { ExtensionDataEntry, ExtensionDataList } from '@teambit/legacy.extension-data';\nimport {\n  findWorkspaceRootMap,\n  isWorkspaceRootComponent,\n  readWorkspaceRoot,\n  writeWorkspaceRoot,\n} from './workspace-root-data';\nimport { WorkspaceRootAspect } from './workspace-root.aspect';\n\nconst rootId = ComponentID.fromString('my-scope/my-root@0.0.7');\n\ndescribe('workspace-root data', () => {\n  describe('findWorkspaceRootMap', () => {\n    // a real BitMap rather than a stand-in: the rule lives on it (getWorkspaceRootMap), and a mock\n    // that answers isRemoved() itself would only be testing the mock\n    const bitMapWith = async (entries: Record<string, any>) => {\n      const bitMap = await BitMap.load(__dirname, '');\n      bitMap.loadComponents(entries, 'my-scope');\n      return bitMap;\n    };\n    const rootEntry = { name: 'my-root', scope: 'my-scope', version: '0.0.7', mainFile: 'README.md', rootDir: '.' };\n    const nestedEntry = { name: 'comp1', scope: 'my-scope', version: '0.0.1', mainFile: 'index.js', rootDir: 'comp1' };\n    it('should return the entry tracked at the workspace root', async () => {\n      const bitMap = await bitMapWith({ 'my-scope/comp1': nestedEntry, 'my-scope/my-root': rootEntry });\n      expect(findWorkspaceRootMap(bitMap)?.id.toString()).to.equal(rootId.toString());\n    });\n    it('should return undefined when no component owns the workspace root', async () => {\n      const bitMap = await bitMapWith({ 'my-scope/comp1': nestedEntry });\n      expect(findWorkspaceRootMap(bitMap)).to.be.undefined;\n    });\n    it('should ignore a root of another lane, this lane is rootless', async () => {\n      // it stays in .bitmap so a switch back can restore it. snapping here would otherwise tag it along\n      const bitMap = await bitMapWith({ 'my-scope/my-root': rootEntry });\n      bitMap.components[0].isAvailableOnCurrentLane = false;\n      expect(findWorkspaceRootMap(bitMap)).to.be.undefined;\n    });\n    it('should ignore a removed root', async () => {\n      const bitMap = await bitMapWith({ 'my-scope/my-root': rootEntry });\n      bitMap.components[0].config = { [Extensions.remove]: { removed: true } };\n      expect(findWorkspaceRootMap(bitMap)).to.be.undefined;\n    });\n  });\n  describe('isWorkspaceRootComponent', () => {\n    const withData = (data: Record<string, any>) =>\n      ExtensionDataList.fromArray([\n        new ExtensionDataEntry(undefined, undefined, WorkspaceRootAspect.id, undefined, data),\n      ]);\n    it('should recognize the marker the root carries', () => {\n      expect(isWorkspaceRootComponent(withData({ isRoot: true }))).to.be.true;\n    });\n    it('should not take a member, which carries the pointer to its root, for a root', () => {\n      expect(isWorkspaceRootComponent(withData({ root: rootId.toString() }))).to.be.false;\n    });\n    it('should be false for a component with no data of this aspect', () => {\n      expect(isWorkspaceRootComponent(ExtensionDataList.fromArray([]))).to.be.false;\n    });\n  });\n  describe('writeWorkspaceRoot and readWorkspaceRoot', () => {\n    it('should round-trip the root id with its version', () => {\n      const extensions = ExtensionDataList.fromArray([]);\n      writeWorkspaceRoot(extensions, rootId);\n      expect(readWorkspaceRoot(extensions)?.toString()).to.equal('my-scope/my-root@0.0.7');\n    });\n    it('should replace an existing pointer rather than add a second entry', () => {\n      const extensions = ExtensionDataList.fromArray([]);\n      writeWorkspaceRoot(extensions, rootId);\n      writeWorkspaceRoot(extensions, rootId.changeVersion('0.0.8'));\n      expect(extensions).to.have.lengthOf(1);\n      expect(readWorkspaceRoot(extensions)?.version).to.equal('0.0.8');\n    });\n    it('should keep a root that was never snapped without a version', () => {\n      const extensions = ExtensionDataList.fromArray([]);\n      writeWorkspaceRoot(extensions, ComponentID.fromString('my-scope/my-root'));\n      expect(readWorkspaceRoot(extensions)?.hasVersion()).to.be.false;\n    });\n    it('should return undefined for a component with no pointer', () => {\n      expect(readWorkspaceRoot(ExtensionDataList.fromArray([]))).to.be.undefined;\n    });\n    it('should replace the data rather than merge into it, so a former root is not both', () => {\n      // a root moved out of \".\" into a directory of its own becomes an ordinary member. merging would\n      // leave the isRoot marker behind and the version would claim both roles at once\n      const extensions = ExtensionDataList.fromArray([\n        new ExtensionDataEntry(undefined, undefined, WorkspaceRootAspect.id, undefined, { isRoot: true }),\n      ]);\n      writeWorkspaceRoot(extensions, rootId);\n      expect(isWorkspaceRootComponent(extensions)).to.be.false;\n      expect(readWorkspaceRoot(extensions)?.toString()).to.equal(rootId.toString());\n    });\n  });\n});\n"],"mappings":"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","ignoreList":[]}

package/dist/workspace-root.aspect.d.ts

@@ -0,0 +1,3 @@
+import { Aspect } from '@teambit/harmony';
+export declare const WorkspaceRootAspect: Aspect;
+export default WorkspaceRootAspect;

package/dist/workspace-root.aspect.js

@@ -0,0 +1,19 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = exports.WorkspaceRootAspect = void 0;
+function _harmony() {
+  const data = require("@teambit/harmony");
+  _harmony = function () {
+    return data;
+  };
+  return data;
+}
+const WorkspaceRootAspect = exports.WorkspaceRootAspect = _harmony().Aspect.create({
+  id: 'teambit.workspace/workspace-root'
+});
+var _default = exports.default = WorkspaceRootAspect;
+
+//# sourceMappingURL=workspace-root.aspect.js.map

package/dist/workspace-root.aspect.js.map

@@ -0,0 +1 @@
+{"version":3,"names":["_harmony","data","require","WorkspaceRootAspect","exports","Aspect","create","id","_default","default"],"sources":["workspace-root.aspect.ts"],"sourcesContent":["import { Aspect } from '@teambit/harmony';\n\nexport const WorkspaceRootAspect = Aspect.create({\n  id: 'teambit.workspace/workspace-root',\n});\n\nexport default WorkspaceRootAspect;\n"],"mappings":";;;;;;AAAA,SAAAA,SAAA;EAAA,MAAAC,IAAA,GAAAC,OAAA;EAAAF,QAAA,YAAAA,CAAA;IAAA,OAAAC,IAAA;EAAA;EAAA,OAAAA,IAAA;AAAA;AAEO,MAAME,mBAAmB,GAAAC,OAAA,CAAAD,mBAAA,GAAGE,iBAAM,CAACC,MAAM,CAAC;EAC/CC,EAAE,EAAE;AACN,CAAC,CAAC;AAAC,IAAAC,QAAA,GAAAJ,OAAA,CAAAK,OAAA,GAEYN,mBAAmB","ignoreList":[]}

package/dist/workspace-root.docs.mdx

@@ -0,0 +1,62 @@
+---
+description: The component that owns the workspace root, and the record its members keep of it
+labels: ['core aspect', 'workspace', 'workspace-root']
+---
+
+## Overview
+
+A workspace-root component is tracked at the workspace root (`rootDir: "."`). It versions the
+workspace's own files, such as `workspace.jsonc`, `.bitmap`, the lockfile and repo-level scripts and
+configs, and a git-free workspace is restored from it.
+
+This aspect owns two pieces of data, both saved with every version. The root marks itself, so it is
+told from the model alone rather than by the files it happens to carry:
+
+```json
+"teambit.workspace/workspace-root": {
+  "data": { "isRoot": true }
+}
+```
+
+Every member the workspace snaps records which root it was snapped in and at which version:
+
+```json
+"teambit.workspace/workspace-root": {
+  "data": { "root": "my-org.my-scope/my-root@0.0.7" }
+}
+```
+
+A new or modified root joins every `bit tag` and `bit snap` of its members, so the recorded version
+is always the one that has the files the member was made with. A root tagged along is bumped as a
+patch, whatever version the members were given.
+
+Both are aspect data, not config, so they never make a component modified and the root moving on
+does not touch its members. Their consumers are tools that need the root's files a version was made
+with, such as a CI building the component or a workspace clone.
+
+## Cloning a workspace
+
+`bit clone <root-id> [dir]` makes a workspace out of a workspace-root component, the way `git clone`
+makes a working tree out of a repository. It runs outside a workspace, in an empty or absent
+directory (default: the component name), and needs no `bit init`:
+
+- the root's files land at the workspace root, `workspace.jsonc` included;
+- every component the root's versioned `.bitmap` lists is imported into the directory it records;
+- the dependencies are installed and the components compiled (`--skip-dependency-installation` to skip).
+
+The versioned `.bitmap` holds no versions, only which components exist and where, so the components
+come at their heads on main. `--lane <scope>/<name>` clones the workspace as it is on a lane: the
+workspace comes out on the lane and the components at their heads there. A version on the root id
+pins the root files only. A component the root lists that its remote does not have, one never
+exported for instance, is reported and the clone goes on without it.
+
+A clone comes out with nothing modified. What the root versions of its `.bitmap` is normalized to the
+part an export does not change, so the map the clone writes is the map the root carries.
+
+Scopes on bit.cloud resolve by name. For a self-hosted scope that is not in the global remotes,
+`--remote <url>` registers it in the new workspace first.
+
+## Terminology
+
+"Workspace-root component", because "root component" is taken by the dependency-resolver's
+`rootComponents`, and "workspace component" means any component loaded from a workspace.

package/dist/workspace-root.fragment.d.ts

@@ -0,0 +1,21 @@
+import type { Component, ShowFragment } from '@teambit/component';
+import type { WorkspaceRootMain } from './workspace-root.main.runtime';
+export declare class WorkspaceRootFragment implements ShowFragment {
+    private workspaceRoot;
+    constructor(workspaceRoot: WorkspaceRootMain);
+    title: string;
+    renderRow(component: Component): Promise<{
+        title: string;
+        content: string;
+    }>;
+    json(component: Component): Promise<{
+        title: string;
+        json: {
+            isRoot: true;
+            root?: undefined;
+        } | {
+            isRoot?: undefined;
+            root: string;
+        } | undefined;
+    }>;
+}

package/dist/workspace-root.fragment.js

@@ -0,0 +1,36 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.WorkspaceRootFragment = void 0;
+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); }
+class WorkspaceRootFragment {
+  constructor(workspaceRoot) {
+    this.workspaceRoot = workspaceRoot;
+    _defineProperty(this, "title", 'workspace root');
+  }
+  async renderRow(component) {
+    return {
+      title: this.title,
+      content: this.workspaceRoot.isWorkspaceRootComponent(component) ? 'this component' : this.workspaceRoot.getRootOf(component)?.toString() ?? ''
+    };
+  }
+  async json(component) {
+    const isRoot = this.workspaceRoot.isWorkspaceRootComponent(component);
+    const root = this.workspaceRoot.getRootOf(component)?.toString();
+    return {
+      title: this.title,
+      json: isRoot ? {
+        isRoot
+      } : root ? {
+        root
+      } : undefined
+    };
+  }
+}
+exports.WorkspaceRootFragment = WorkspaceRootFragment;
+
+//# sourceMappingURL=workspace-root.fragment.js.map

package/dist/workspace-root.fragment.js.map

@@ -0,0 +1 @@
+{"version":3,"names":["WorkspaceRootFragment","constructor","workspaceRoot","_defineProperty","renderRow","component","title","content","isWorkspaceRootComponent","getRootOf","toString","json","isRoot","root","undefined","exports"],"sources":["workspace-root.fragment.ts"],"sourcesContent":["import type { Component, ShowFragment } from '@teambit/component';\nimport type { WorkspaceRootMain } from './workspace-root.main.runtime';\n\nexport class WorkspaceRootFragment implements ShowFragment {\n  constructor(private workspaceRoot: WorkspaceRootMain) {}\n\n  title = 'workspace root';\n\n  async renderRow(component: Component) {\n    return {\n      title: this.title,\n      content: this.workspaceRoot.isWorkspaceRootComponent(component)\n        ? 'this component'\n        : (this.workspaceRoot.getRootOf(component)?.toString() ?? ''),\n    };\n  }\n\n  async json(component: Component) {\n    const isRoot = this.workspaceRoot.isWorkspaceRootComponent(component);\n    const root = this.workspaceRoot.getRootOf(component)?.toString();\n    return {\n      title: this.title,\n      json: isRoot ? { isRoot } : root ? { root } : undefined,\n    };\n  }\n}\n"],"mappings":";;;;;;;;;AAGO,MAAMA,qBAAqB,CAAyB;EACzDC,WAAWA,CAASC,aAAgC,EAAE;IAAA,KAAlCA,aAAgC,GAAhCA,aAAgC;IAAAC,eAAA,gBAE5C,gBAAgB;EAF+B;EAIvD,MAAMC,SAASA,CAACC,SAAoB,EAAE;IACpC,OAAO;MACLC,KAAK,EAAE,IAAI,CAACA,KAAK;MACjBC,OAAO,EAAE,IAAI,CAACL,aAAa,CAACM,wBAAwB,CAACH,SAAS,CAAC,GAC3D,gBAAgB,GACf,IAAI,CAACH,aAAa,CAACO,SAAS,CAACJ,SAAS,CAAC,EAAEK,QAAQ,CAAC,CAAC,IAAI;IAC9D,CAAC;EACH;EAEA,MAAMC,IAAIA,CAACN,SAAoB,EAAE;IAC/B,MAAMO,MAAM,GAAG,IAAI,CAACV,aAAa,CAACM,wBAAwB,CAACH,SAAS,CAAC;IACrE,MAAMQ,IAAI,GAAG,IAAI,CAACX,aAAa,CAACO,SAAS,CAACJ,SAAS,CAAC,EAAEK,QAAQ,CAAC,CAAC;IAChE,OAAO;MACLJ,KAAK,EAAE,IAAI,CAACA,KAAK;MACjBK,IAAI,EAAEC,MAAM,GAAG;QAAEA;MAAO,CAAC,GAAGC,IAAI,GAAG;QAAEA;MAAK,CAAC,GAAGC;IAChD,CAAC;EACH;AACF;AAACC,OAAA,CAAAf,qBAAA,GAAAA,qBAAA","ignoreList":[]}

package/dist/workspace-root.main.runtime.d.ts

@@ -0,0 +1,51 @@
+import type { CLIMain } from '@teambit/cli';
+import type { Component, ComponentMain } from '@teambit/component';
+import { ComponentID } from '@teambit/component-id';
+import type { Workspace } from '@teambit/workspace';
+import type { CloneOptions, CloneResult, LoadBit } from './clone';
+/**
+ * the workspace-root component is the one tracked at the workspace root (rootDir "."). it versions
+ * the workspace's own files - workspace.jsonc, .bitmap, the lockfile, repo scripts and configs - and
+ * a git-free workspace is restored from it. this aspect is the home of that concept: the marker that
+ * tells a root apart wherever it is, and the record every member carries of the root it was snapped
+ * in.
+ *
+ * "workspace-root component" rather than "root component", which is the dependency-resolver's
+ * rootComponents, or "workspace component", which is every component loaded from a workspace.
+ */
+export declare class WorkspaceRootMain {
+    private workspace?;
+    private loadBit?;
+    constructor(workspace?: Workspace | undefined);
+    /**
+     * a clone loads bit for the new workspace, in a process that started outside of one. the function
+     * belongs to the bit aspect, which depends on this one, so it is handed over rather than imported
+     * (see load-bit.ts).
+     */
+    setLoadBit(loadBit: LoadBit): void;
+    /**
+     * make a workspace out of a workspace-root component: its files at the root, every component it
+     * lists in the directory it records, then install. see cloneWorkspace.
+     */
+    clone(idStr: string, dir: string | undefined, options?: CloneOptions): Promise<CloneResult>;
+    /**
+     * the id of the component that owns the workspace root, if the workspace has one.
+     */
+    getRootComponentId(): ComponentID | undefined;
+    /**
+     * whether the component is a workspace-root component. read from its aspect data, so it works
+     * for a component loaded from a scope as well as from a workspace.
+     */
+    isWorkspaceRootComponent(component: Component): boolean;
+    /**
+     * the workspace-root component a component was snapped in, at the version the root had then. the
+     * snap records it as aspect data, so it is available wherever the component is, a bare scope
+     * included. it is the way to know which root files (lockfile, tsconfig, scripts) a version was
+     * made with. a component snapped in a workspace without a root component has none.
+     */
+    getRootOf(component: Component): ComponentID | undefined;
+    private extensionsOf;
+    static runtime: import("@teambit/harmony").RuntimeDefinition;
+    static dependencies: import("@teambit/harmony").Aspect[];
+    static provider([workspace, component, cli]: [Workspace | undefined, ComponentMain, CLIMain]): Promise<WorkspaceRootMain>;
+}