@teambit/workspace-root 0.0.1

package/dist/workspace-root.main.runtime.js

@@ -0,0 +1,176 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.WorkspaceRootMain = void 0;
+function _bitError() {
+  const data = require("@teambit/bit-error");
+  _bitError = function () {
+    return data;
+  };
+  return data;
+}
+function _cli() {
+  const data = require("@teambit/cli");
+  _cli = function () {
+    return data;
+  };
+  return data;
+}
+function _component() {
+  const data = require("@teambit/component");
+  _component = 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 _workspace() {
+  const data = require("@teambit/workspace");
+  _workspace = function () {
+    return data;
+  };
+  return data;
+}
+function _clone() {
+  const data = require("./clone");
+  _clone = function () {
+    return data;
+  };
+  return data;
+}
+function _clone2() {
+  const data = require("./clone.cmd");
+  _clone2 = function () {
+    return data;
+  };
+  return data;
+}
+function _workspaceRoot() {
+  const data = require("./workspace-root.aspect");
+  _workspaceRoot = function () {
+    return data;
+  };
+  return data;
+}
+function _workspaceRoot2() {
+  const data = require("./workspace-root.fragment");
+  _workspaceRoot2 = function () {
+    return data;
+  };
+  return data;
+}
+function _workspaceRootData() {
+  const data = require("./workspace-root-data");
+  _workspaceRootData = function () {
+    return data;
+  };
+  return data;
+}
+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); }
+/**
+ * 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.
+ */
+class WorkspaceRootMain {
+  constructor(workspace) {
+    this.workspace = workspace;
+    _defineProperty(this, "loadBit", void 0);
+  }
+
+  /**
+   * 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) {
+    this.loadBit = loadBit;
+  }
+
+  /**
+   * 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.
+   */
+  async clone(idStr, dir, options = {}) {
+    if (this.workspace) {
+      throw new (_bitError().BitError)(`unable to clone inside the workspace at "${this.workspace.path}", a clone is a new workspace. run it from a directory outside of any workspace`);
+    }
+    if (!this.loadBit) throw new Error('WorkspaceRootMain.clone: loadBit was not set, see load-bit.ts');
+    return (0, _clone().cloneWorkspace)(_componentId().ComponentID.fromString(idStr), dir, options, this.loadBit);
+  }
+
+  /**
+   * the id of the component that owns the workspace root, if the workspace has one.
+   */
+  getRootComponentId() {
+    if (!this.workspace) return undefined;
+    return (0, _workspaceRootData().findWorkspaceRootMap)(this.workspace.consumer.bitMap)?.id;
+  }
+
+  /**
+   * 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) {
+    return (0, _workspaceRootData().isWorkspaceRootComponent)(this.extensionsOf(component));
+  }
+
+  /**
+   * 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) {
+    return (0, _workspaceRootData().readWorkspaceRoot)(this.extensionsOf(component));
+  }
+  extensionsOf(component) {
+    return component.state._consumer.extensions;
+  }
+  static async provider([workspace, component, cli]) {
+    const workspaceRoot = new WorkspaceRootMain(workspace);
+    component.registerShowFragments([new (_workspaceRoot2().WorkspaceRootFragment)(workspaceRoot)]);
+    cli.register(new (_clone2().CloneCmd)(workspaceRoot));
+    workspace?.registerOnComponentLoad(markWorkspaceRoot);
+    return workspaceRoot;
+  }
+}
+
+/**
+ * the root marks itself as such in its aspect data when loaded. the snap saves the data with the
+ * version, and every consumer of the model reads the marker rather than guessing from the files.
+ */
+exports.WorkspaceRootMain = WorkspaceRootMain;
+_defineProperty(WorkspaceRootMain, "runtime", _cli().MainRuntime);
+_defineProperty(WorkspaceRootMain, "dependencies", [_workspace().WorkspaceAspect, _component().ComponentAspect, _cli().CLIAspect]);
+async function markWorkspaceRoot(component) {
+  const consumerComponent = component.state._consumer;
+  return consumerComponent.componentMap?.rootDir === _legacy().WORKSPACE_ROOT_DIR ? {
+    isRoot: true
+  } : undefined;
+}
+_workspaceRoot().WorkspaceRootAspect.addRuntime(WorkspaceRootMain);
+
+//# sourceMappingURL=workspace-root.main.runtime.js.map

package/dist/workspace-root.main.runtime.js.map

@@ -0,0 +1 @@
+{"version":3,"names":["_bitError","data","require","_cli","_component","_componentId","_legacy","_workspace","_clone","_clone2","_workspaceRoot","_workspaceRoot2","_workspaceRootData","_defineProperty","e","r","t","_toPropertyKey","Object","defineProperty","value","enumerable","configurable","writable","i","_toPrimitive","Symbol","toPrimitive","call","TypeError","String","Number","WorkspaceRootMain","constructor","workspace","setLoadBit","loadBit","clone","idStr","dir","options","BitError","path","Error","cloneWorkspace","ComponentID","fromString","getRootComponentId","undefined","findWorkspaceRootMap","consumer","bitMap","id","isWorkspaceRootComponent","component","extensionsOf","getRootOf","readWorkspaceRoot","state","_consumer","extensions","provider","cli","workspaceRoot","registerShowFragments","WorkspaceRootFragment","register","CloneCmd","registerOnComponentLoad","markWorkspaceRoot","exports","MainRuntime","WorkspaceAspect","ComponentAspect","CLIAspect","consumerComponent","componentMap","rootDir","WORKSPACE_ROOT_DIR","isRoot","WorkspaceRootAspect","addRuntime"],"sources":["workspace-root.main.runtime.ts"],"sourcesContent":["import { BitError } from '@teambit/bit-error';\nimport type { CLIMain } from '@teambit/cli';\nimport { CLIAspect, MainRuntime } from '@teambit/cli';\nimport type { Component, ComponentMain } from '@teambit/component';\nimport { ComponentAspect } from '@teambit/component';\nimport { ComponentID } from '@teambit/component-id';\nimport { WORKSPACE_ROOT_DIR } from '@teambit/legacy.bit-map';\nimport type { ConsumerComponent } from '@teambit/legacy.consumer-component';\nimport type { Workspace } from '@teambit/workspace';\nimport { WorkspaceAspect } from '@teambit/workspace';\nimport type { CloneOptions, CloneResult, LoadBit } from './clone';\nimport { cloneWorkspace } from './clone';\nimport { CloneCmd } from './clone.cmd';\nimport { WorkspaceRootAspect } from './workspace-root.aspect';\nimport { WorkspaceRootFragment } from './workspace-root.fragment';\nimport type { WorkspaceRootData } from './workspace-root-data';\nimport { findWorkspaceRootMap, isWorkspaceRootComponent, readWorkspaceRoot } from './workspace-root-data';\n\n/**\n * the workspace-root component is the one tracked at the workspace root (rootDir \".\"). it versions\n * the workspace's own files - workspace.jsonc, .bitmap, the lockfile, repo scripts and configs - and\n * a git-free workspace is restored from it. this aspect is the home of that concept: the marker that\n * tells a root apart wherever it is, and the record every member carries of the root it was snapped\n * in.\n *\n * \"workspace-root component\" rather than \"root component\", which is the dependency-resolver's\n * rootComponents, or \"workspace component\", which is every component loaded from a workspace.\n */\nexport class WorkspaceRootMain {\n  private loadBit?: LoadBit;\n\n  constructor(private workspace?: Workspace) {}\n\n  /**\n   * a clone loads bit for the new workspace, in a process that started outside of one. the function\n   * belongs to the bit aspect, which depends on this one, so it is handed over rather than imported\n   * (see load-bit.ts).\n   */\n  setLoadBit(loadBit: LoadBit) {\n    this.loadBit = loadBit;\n  }\n\n  /**\n   * make a workspace out of a workspace-root component: its files at the root, every component it\n   * lists in the directory it records, then install. see cloneWorkspace.\n   */\n  async clone(idStr: string, dir: string | undefined, options: CloneOptions = {}): Promise<CloneResult> {\n    if (this.workspace) {\n      throw new BitError(\n        `unable to clone inside the workspace at \"${this.workspace.path}\", a clone is a new workspace. run it from a directory outside of any workspace`\n      );\n    }\n    if (!this.loadBit) throw new Error('WorkspaceRootMain.clone: loadBit was not set, see load-bit.ts');\n    return cloneWorkspace(ComponentID.fromString(idStr), dir, options, this.loadBit);\n  }\n\n  /**\n   * the id of the component that owns the workspace root, if the workspace has one.\n   */\n  getRootComponentId(): ComponentID | undefined {\n    if (!this.workspace) return undefined;\n    return findWorkspaceRootMap(this.workspace.consumer.bitMap)?.id;\n  }\n\n  /**\n   * whether the component is a workspace-root component. read from its aspect data, so it works\n   * for a component loaded from a scope as well as from a workspace.\n   */\n  isWorkspaceRootComponent(component: Component): boolean {\n    return isWorkspaceRootComponent(this.extensionsOf(component));\n  }\n\n  /**\n   * the workspace-root component a component was snapped in, at the version the root had then. the\n   * snap records it as aspect data, so it is available wherever the component is, a bare scope\n   * included. it is the way to know which root files (lockfile, tsconfig, scripts) a version was\n   * made with. a component snapped in a workspace without a root component has none.\n   */\n  getRootOf(component: Component): ComponentID | undefined {\n    return readWorkspaceRoot(this.extensionsOf(component));\n  }\n\n  private extensionsOf(component: Component) {\n    return (component.state._consumer as ConsumerComponent).extensions;\n  }\n\n  static runtime = MainRuntime;\n\n  static dependencies = [WorkspaceAspect, ComponentAspect, CLIAspect];\n\n  static async provider([workspace, component, cli]: [Workspace | undefined, ComponentMain, CLIMain]) {\n    const workspaceRoot = new WorkspaceRootMain(workspace);\n    component.registerShowFragments([new WorkspaceRootFragment(workspaceRoot)]);\n    cli.register(new CloneCmd(workspaceRoot));\n    workspace?.registerOnComponentLoad(markWorkspaceRoot);\n    return workspaceRoot;\n  }\n}\n\n/**\n * the root marks itself as such in its aspect data when loaded. the snap saves the data with the\n * version, and every consumer of the model reads the marker rather than guessing from the files.\n */\nasync function markWorkspaceRoot(component: Component): Promise<WorkspaceRootData | undefined> {\n  const consumerComponent = component.state._consumer as ConsumerComponent;\n  return consumerComponent.componentMap?.rootDir === WORKSPACE_ROOT_DIR ? { isRoot: true } : undefined;\n}\n\nWorkspaceRootAspect.addRuntime(WorkspaceRootMain);\n"],"mappings":"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","ignoreList":[]}

package/package.json

@@ -0,0 +1,68 @@
+{
+  "name": "@teambit/workspace-root",
+  "version": "0.0.1",
+  "main": "dist/index.js",
+  "componentId": {
+    "name": "workspace-root",
+    "version": "0.0.1",
+    "scope": "teambit.workspace"
+  },
+  "dependencies": {
+    "fs-extra": "10.0.0",
+    "@teambit/bit-error": "0.0.404",
+    "@teambit/component-id": "1.2.4",
+    "@teambit/harmony": "0.4.12",
+    "@teambit/lane-id": "0.0.312",
+    "@teambit/legacy.utils": "0.0.51",
+    "@teambit/cli": "0.0.1394",
+    "@teambit/host-initializer": "0.0.888",
+    "@teambit/importer": "1.0.1175",
+    "@teambit/install": "1.0.1175",
+    "@teambit/legacy.bit-map": "0.0.222",
+    "@teambit/legacy.constants": "0.0.45",
+    "@teambit/scope.remotes": "0.0.165",
+    "@teambit/scope": "1.0.1175",
+    "@teambit/workspace.modules.workspace-locator": "0.0.46",
+    "@teambit/workspace": "1.0.1175",
+    "@teambit/legacy.extension-data": "0.0.167",
+    "@teambit/component": "1.0.1175",
+    "@teambit/legacy.consumer-component": "0.0.166"
+  },
+  "devDependencies": {
+    "@types/fs-extra": "9.0.7",
+    "@teambit/harmony.envs.core-aspect-env": "2.1.1"
+  },
+  "peerDependencies": {
+    "chai": "5.2.1"
+  },
+  "license": "Apache-2.0",
+  "optionalDependencies": {},
+  "peerDependenciesMeta": {},
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "node": {
+        "require": "./dist/index.js"
+      },
+      "default": "./dist/index.js"
+    },
+    "./dist/*": "./dist/*",
+    "./artifacts/*": "./artifacts/*"
+  },
+  "private": false,
+  "engines": {
+    "node": ">=16.0.0"
+  },
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/teambit/bit"
+  },
+  "keywords": [
+    "bit",
+    "bit-aspect",
+    "bit-core-aspect",
+    "components",
+    "collaboration",
+    "web"
+  ]
+}

package/types/asset.d.ts

@@ -0,0 +1,41 @@
+declare module '*.png' {
+  const value: any;
+  export = value;
+}
+declare module '*.svg' {
+  import type { FunctionComponent, SVGProps } from 'react';
+
+  export const ReactComponent: FunctionComponent<
+    SVGProps<SVGSVGElement> & { title?: string }
+  >;
+  const src: string;
+  export default src;
+}
+declare module '*.jpg' {
+  const value: any;
+  export = value;
+}
+declare module '*.jpeg' {
+  const value: any;
+  export = value;
+}
+declare module '*.gif' {
+  const value: any;
+  export = value;
+}
+declare module '*.bmp' {
+  const value: any;
+  export = value;
+}
+declare module '*.otf' {
+  const value: any;
+  export = value;
+}
+declare module '*.woff' {
+  const value: any;
+  export = value;
+}
+declare module '*.woff2' {
+  const value: any;
+  export = value;
+}

package/types/style.d.ts

@@ -0,0 +1,46 @@
+declare module '*.module.css' {
+  const classes: { readonly [key: string]: string };
+  export default classes;
+}
+declare module '*.module.scss' {
+  const classes: { readonly [key: string]: string };
+  export default classes;
+}
+declare module '*.module.sass' {
+  const classes: { readonly [key: string]: string };
+  export default classes;
+}
+
+declare module '*.module.less' {
+  const classes: { readonly [key: string]: string };
+  export default classes;
+}
+
+declare module '*.less' {
+  const classes: { readonly [key: string]: string };
+  export default classes;
+}
+
+declare module '*.css' {
+  const classes: { readonly [key: string]: string };
+  export default classes;
+}
+
+declare module '*.sass' {
+  const classes: { readonly [key: string]: string };
+  export default classes;
+}
+
+declare module '*.scss' {
+  const classes: { readonly [key: string]: string };
+  export default classes;
+}
+
+declare module '*.mdx' {
+  const component: any;
+  export default component;
+}
+
+// `reset-css` ships only `reset.css` (no `.d.ts`). TS6 refuses bare
+// side-effect imports without declarations, so we declare the module here.
+declare module 'reset-css';

package/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.