@teambit/workspace-root 0.0.1

package/.npmignore

@@ -0,0 +1,18 @@
+dist/tsconfig.tsbuildinfo
+dist/tsconfig.json
+/tsconfig.json
+
+package-tar/
+.bit-capsule-ready
+/*.ts
+artifacts/*
+!artifacts/env-template
+!artifacts/ui-bundle
+!artifacts/preview-bundle
+package-tar/
+.bit-capsule-ready
+/*.ts
+artifacts/*
+!artifacts/env-template
+!artifacts/ui-bundle
+!artifacts/preview-bundle

package/dist/clone.cmd.d.ts

@@ -0,0 +1,27 @@
+import type { Command, CommandOptions } from '@teambit/cli';
+import type { CloneResult } from './clone';
+import type { WorkspaceRootMain } from './workspace-root.main.runtime';
+type CloneCmdOptions = {
+    lane?: string;
+    remote?: string;
+    skipDependencyInstallation?: boolean;
+};
+export declare class CloneCmd implements Command {
+    private workspaceRoot;
+    name: string;
+    description: string;
+    extendedDescription: string;
+    arguments: {
+        name: string;
+        description: string;
+    }[];
+    group: string;
+    skipWorkspace: boolean;
+    remoteOp: boolean;
+    loader: boolean;
+    options: CommandOptions;
+    constructor(workspaceRoot: WorkspaceRootMain);
+    report([id, dir]: [string, string], options: CloneCmdOptions): Promise<string>;
+}
+export declare function formatCloneResult(result: CloneResult, relativeDir: string): string;
+export {};

package/dist/clone.cmd.js

@@ -0,0 +1,67 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.CloneCmd = void 0;
+exports.formatCloneResult = formatCloneResult;
+function _path() {
+  const data = _interopRequireDefault(require("path"));
+  _path = function () {
+    return data;
+  };
+  return data;
+}
+function _cli() {
+  const data = require("@teambit/cli");
+  _cli = function () {
+    return data;
+  };
+  return data;
+}
+function _interopRequireDefault(e) { return e && e.__esModule ? e : { default: 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); }
+class CloneCmd {
+  constructor(workspaceRoot) {
+    this.workspaceRoot = workspaceRoot;
+    _defineProperty(this, "name", 'clone <component-id> [dir]');
+    _defineProperty(this, "description", 'create a workspace from its workspace-root component, with every component it lists');
+    _defineProperty(this, "extendedDescription", `the workspace-root component is the one tracked at a workspace root ("bit add ."). it versions the workspace's own files - workspace.jsonc, .bitmap, lockfile, configs - and this command makes a workspace out of it, the way "git clone" makes a working tree out of a repository: the root files land at the root, every component the root lists is imported into the directory it records, then the dependencies are installed.
+the components come at their heads on main, or on the lane given with --lane. a version on the root id pins the root files only.
+runs outside a workspace. the directory must be empty or not exist, and defaults to the component name.`);
+    _defineProperty(this, "arguments", [{
+      name: 'component-id',
+      description: 'the workspace-root component, with its scope. a version pins the root files'
+    }, {
+      name: 'dir',
+      description: 'where to create the workspace. defaults to the component name, must be empty or absent'
+    }]);
+    _defineProperty(this, "group", 'workspace-setup');
+    _defineProperty(this, "skipWorkspace", true);
+    _defineProperty(this, "remoteOp", true);
+    _defineProperty(this, "loader", true);
+    _defineProperty(this, "options", [['l', 'lane <lane-id>', 'clone the workspace as it is on this lane ("scope/name"): it comes out on the lane, with the components at their heads there'], ['', 'remote <url>', 'url of the scope hosting the components, when it is neither on bit.cloud nor in the global remotes'], ['x', 'skip-dependency-installation', 'do not install the dependencies, and so do not compile, after the clone']]);
+  }
+  async report([id, dir], options) {
+    // the clone changes the cwd to the new workspace, so the path is relative to where the user ran it
+    const cwd = process.cwd();
+    const result = await this.workspaceRoot.clone(id, dir, options);
+    return formatCloneResult(result, _path().default.relative(cwd, result.workspacePath) || '.');
+  }
+}
+exports.CloneCmd = CloneCmd;
+function formatCloneResult(result, relativeDir) {
+  const count = result.components.length;
+  const summary = (0, _cli().formatSuccessSummary)(`cloned ${result.rootId.toString()} into "${relativeDir}" with ${count} component${count === 1 ? '' : 's'}`);
+  const lane = result.laneId ? (0, _cli().formatHint)(`(the workspace is on lane ${result.laneId.toString()})`) : '';
+  // missing state takes the error symbol, on the title as well as on the items - see the error
+  // sections of cli-output-style-guide.md. the clone itself succeeded, which the summary above says.
+  const missing = (0, _cli().formatSection)(`${_cli().errorSymbol} components the root lists that are not on their remote`, 'never exported, or exported elsewhere - the clone is without them', result.missing.map(missingId => (0, _cli().formatItem)(missingId, _cli().errorSymbol)));
+  const installation = result.installationError ? (0, _cli().formatWarningSummary)(`the dependencies were not installed: ${result.installationError.message}\nrun "bit install" in the workspace to retry`) : '';
+  const next = relativeDir === '.' ? '' : (0, _cli().formatHint)(`cd ${relativeDir}`);
+  return (0, _cli().joinSections)([summary, lane, missing, installation, next]);
+}
+
+//# sourceMappingURL=clone.cmd.js.map

package/dist/clone.cmd.js.map

@@ -0,0 +1 @@
+{"version":3,"names":["_path","data","_interopRequireDefault","require","_cli","e","__esModule","default","_defineProperty","r","t","_toPropertyKey","Object","defineProperty","value","enumerable","configurable","writable","i","_toPrimitive","Symbol","toPrimitive","call","TypeError","String","Number","CloneCmd","constructor","workspaceRoot","name","description","report","id","dir","options","cwd","process","result","clone","formatCloneResult","path","relative","workspacePath","exports","relativeDir","count","components","length","summary","formatSuccessSummary","rootId","toString","lane","laneId","formatHint","missing","formatSection","errorSymbol","map","missingId","formatItem","installation","installationError","formatWarningSummary","message","next","joinSections"],"sources":["clone.cmd.ts"],"sourcesContent":["import path from 'path';\nimport type { Command, CommandOptions } from '@teambit/cli';\nimport {\n  errorSymbol,\n  formatHint,\n  formatItem,\n  formatSection,\n  formatSuccessSummary,\n  formatWarningSummary,\n  joinSections,\n} from '@teambit/cli';\nimport type { CloneResult } from './clone';\nimport type { WorkspaceRootMain } from './workspace-root.main.runtime';\n\ntype CloneCmdOptions = {\n  lane?: string;\n  remote?: string;\n  skipDependencyInstallation?: boolean;\n};\n\nexport class CloneCmd implements Command {\n  name = 'clone <component-id> [dir]';\n  description = 'create a workspace from its workspace-root component, with every component it lists';\n  extendedDescription = `the workspace-root component is the one tracked at a workspace root (\"bit add .\"). it versions the workspace's own files - workspace.jsonc, .bitmap, lockfile, configs - and this command makes a workspace out of it, the way \"git clone\" makes a working tree out of a repository: the root files land at the root, every component the root lists is imported into the directory it records, then the dependencies are installed.\nthe components come at their heads on main, or on the lane given with --lane. a version on the root id pins the root files only.\nruns outside a workspace. the directory must be empty or not exist, and defaults to the component name.`;\n  arguments = [\n    {\n      name: 'component-id',\n      description: 'the workspace-root component, with its scope. a version pins the root files',\n    },\n    {\n      name: 'dir',\n      description: 'where to create the workspace. defaults to the component name, must be empty or absent',\n    },\n  ];\n  group = 'workspace-setup';\n  skipWorkspace = true;\n  remoteOp = true;\n  loader = true;\n  options = [\n    [\n      'l',\n      'lane <lane-id>',\n      'clone the workspace as it is on this lane (\"scope/name\"): it comes out on the lane, with the components at their heads there',\n    ],\n    [\n      '',\n      'remote <url>',\n      'url of the scope hosting the components, when it is neither on bit.cloud nor in the global remotes',\n    ],\n    ['x', 'skip-dependency-installation', 'do not install the dependencies, and so do not compile, after the clone'],\n  ] as CommandOptions;\n\n  constructor(private workspaceRoot: WorkspaceRootMain) {}\n\n  async report([id, dir]: [string, string], options: CloneCmdOptions): Promise<string> {\n    // the clone changes the cwd to the new workspace, so the path is relative to where the user ran it\n    const cwd = process.cwd();\n    const result = await this.workspaceRoot.clone(id, dir, options);\n    return formatCloneResult(result, path.relative(cwd, result.workspacePath) || '.');\n  }\n}\n\nexport function formatCloneResult(result: CloneResult, relativeDir: string): string {\n  const count = result.components.length;\n  const summary = formatSuccessSummary(\n    `cloned ${result.rootId.toString()} into \"${relativeDir}\" with ${count} component${count === 1 ? '' : 's'}`\n  );\n  const lane = result.laneId ? formatHint(`(the workspace is on lane ${result.laneId.toString()})`) : '';\n  // missing state takes the error symbol, on the title as well as on the items - see the error\n  // sections of cli-output-style-guide.md. the clone itself succeeded, which the summary above says.\n  const missing = formatSection(\n    `${errorSymbol} components the root lists that are not on their remote`,\n    'never exported, or exported elsewhere - the clone is without them',\n    result.missing.map((missingId) => formatItem(missingId, errorSymbol))\n  );\n  const installation = result.installationError\n    ? formatWarningSummary(\n        `the dependencies were not installed: ${result.installationError.message}\\nrun \"bit install\" in the workspace to retry`\n      )\n    : '';\n  const next = relativeDir === '.' ? '' : formatHint(`cd ${relativeDir}`);\n  return joinSections([summary, lane, missing, installation, next]);\n}\n"],"mappings":";;;;;;;AAAA,SAAAA,MAAA;EAAA,MAAAC,IAAA,GAAAC,sBAAA,CAAAC,OAAA;EAAAH,KAAA,YAAAA,CAAA;IAAA,OAAAC,IAAA;EAAA;EAAA,OAAAA,IAAA;AAAA;AAEA,SAAAG,KAAA;EAAA,MAAAH,IAAA,GAAAE,OAAA;EAAAC,IAAA,YAAAA,CAAA;IAAA,OAAAH,IAAA;EAAA;EAAA,OAAAA,IAAA;AAAA;AAQsB,SAAAC,uBAAAG,CAAA,WAAAA,CAAA,IAAAA,CAAA,CAAAC,UAAA,GAAAD,CAAA,KAAAE,OAAA,EAAAF,CAAA;AAAA,SAAAG,gBAAAH,CAAA,EAAAI,CAAA,EAAAC,CAAA,YAAAD,CAAA,GAAAE,cAAA,CAAAF,CAAA,MAAAJ,CAAA,GAAAO,MAAA,CAAAC,cAAA,CAAAR,CAAA,EAAAI,CAAA,IAAAK,KAAA,EAAAJ,CAAA,EAAAK,UAAA,MAAAC,YAAA,MAAAC,QAAA,UAAAZ,CAAA,CAAAI,CAAA,IAAAC,CAAA,EAAAL,CAAA;AAAA,SAAAM,eAAAD,CAAA,QAAAQ,CAAA,GAAAC,YAAA,CAAAT,CAAA,uCAAAQ,CAAA,GAAAA,CAAA,GAAAA,CAAA;AAAA,SAAAC,aAAAT,CAAA,EAAAD,CAAA,2BAAAC,CAAA,KAAAA,CAAA,SAAAA,CAAA,MAAAL,CAAA,GAAAK,CAAA,CAAAU,MAAA,CAAAC,WAAA,kBAAAhB,CAAA,QAAAa,CAAA,GAAAb,CAAA,CAAAiB,IAAA,CAAAZ,CAAA,EAAAD,CAAA,uCAAAS,CAAA,SAAAA,CAAA,YAAAK,SAAA,yEAAAd,CAAA,GAAAe,MAAA,GAAAC,MAAA,EAAAf,CAAA;AAUf,MAAMgB,QAAQ,CAAoB;EAkCvCC,WAAWA,CAASC,aAAgC,EAAE;IAAA,KAAlCA,aAAgC,GAAhCA,aAAgC;IAAApB,eAAA,eAjC7C,4BAA4B;IAAAA,eAAA,sBACrB,qFAAqF;IAAAA,eAAA,8BAC7E;AACxB;AACA,wGAAwG;IAAAA,eAAA,oBAC1F,CACV;MACEqB,IAAI,EAAE,cAAc;MACpBC,WAAW,EAAE;IACf,CAAC,EACD;MACED,IAAI,EAAE,KAAK;MACXC,WAAW,EAAE;IACf,CAAC,CACF;IAAAtB,eAAA,gBACO,iBAAiB;IAAAA,eAAA,wBACT,IAAI;IAAAA,eAAA,mBACT,IAAI;IAAAA,eAAA,iBACN,IAAI;IAAAA,eAAA,kBACH,CACR,CACE,GAAG,EACH,gBAAgB,EAChB,8HAA8H,CAC/H,EACD,CACE,EAAE,EACF,cAAc,EACd,oGAAoG,CACrG,EACD,CAAC,GAAG,EAAE,8BAA8B,EAAE,yEAAyE,CAAC,CACjH;EAEsD;EAEvD,MAAMuB,MAAMA,CAAC,CAACC,EAAE,EAAEC,GAAG,CAAmB,EAAEC,OAAwB,EAAmB;IACnF;IACA,MAAMC,GAAG,GAAGC,OAAO,CAACD,GAAG,CAAC,CAAC;IACzB,MAAME,MAAM,GAAG,MAAM,IAAI,CAACT,aAAa,CAACU,KAAK,CAACN,EAAE,EAAEC,GAAG,EAAEC,OAAO,CAAC;IAC/D,OAAOK,iBAAiB,CAACF,MAAM,EAAEG,eAAI,CAACC,QAAQ,CAACN,GAAG,EAAEE,MAAM,CAACK,aAAa,CAAC,IAAI,GAAG,CAAC;EACnF;AACF;AAACC,OAAA,CAAAjB,QAAA,GAAAA,QAAA;AAEM,SAASa,iBAAiBA,CAACF,MAAmB,EAAEO,WAAmB,EAAU;EAClF,MAAMC,KAAK,GAAGR,MAAM,CAACS,UAAU,CAACC,MAAM;EACtC,MAAMC,OAAO,GAAG,IAAAC,2BAAoB,EAClC,UAAUZ,MAAM,CAACa,MAAM,CAACC,QAAQ,CAAC,CAAC,UAAUP,WAAW,UAAUC,KAAK,aAAaA,KAAK,KAAK,CAAC,GAAG,EAAE,GAAG,GAAG,EAC3G,CAAC;EACD,MAAMO,IAAI,GAAGf,MAAM,CAACgB,MAAM,GAAG,IAAAC,iBAAU,EAAC,6BAA6BjB,MAAM,CAACgB,MAAM,CAACF,QAAQ,CAAC,CAAC,GAAG,CAAC,GAAG,EAAE;EACtG;EACA;EACA,MAAMI,OAAO,GAAG,IAAAC,oBAAa,EAC3B,GAAGC,kBAAW,yDAAyD,EACvE,mEAAmE,EACnEpB,MAAM,CAACkB,OAAO,CAACG,GAAG,CAAEC,SAAS,IAAK,IAAAC,iBAAU,EAACD,SAAS,EAAEF,kBAAW,CAAC,CACtE,CAAC;EACD,MAAMI,YAAY,GAAGxB,MAAM,CAACyB,iBAAiB,GACzC,IAAAC,2BAAoB,EAClB,wCAAwC1B,MAAM,CAACyB,iBAAiB,CAACE,OAAO,+CAC1E,CAAC,GACD,EAAE;EACN,MAAMC,IAAI,GAAGrB,WAAW,KAAK,GAAG,GAAG,EAAE,GAAG,IAAAU,iBAAU,EAAC,MAAMV,WAAW,EAAE,CAAC;EACvE,OAAO,IAAAsB,mBAAY,EAAC,CAAClB,OAAO,EAAEI,IAAI,EAAEG,OAAO,EAAEM,YAAY,EAAEI,IAAI,CAAC,CAAC;AACnE","ignoreList":[]}

package/dist/clone.d.ts

@@ -0,0 +1,103 @@
+import type { ComponentID } from '@teambit/component-id';
+import type { Harmony } from '@teambit/harmony';
+import { LaneId } from '@teambit/lane-id';
+import type { VersionedBitmapEntry } from '@teambit/legacy.bit-map';
+export type LoadBit = (workspacePath?: string) => Promise<Harmony>;
+export type CloneOptions = {
+    /**
+     * clone the workspace as it is on this lane, "scope/name". the workspace comes out on the lane,
+     * and the components at their heads there; a component the lane does not have comes from main.
+     */
+    lane?: string;
+    /**
+     * url of the scope hosting the components, for a scope that is neither on bit.cloud nor in the
+     * global remotes. it is registered in the new workspace.
+     */
+    remote?: string;
+    skipDependencyInstallation?: boolean;
+};
+export type CloneResult = {
+    /** the root, at the version the workspace was made from */
+    rootId: ComponentID;
+    workspacePath: string;
+    /** the components the root lists, at the versions they were written with */
+    components: ComponentID[];
+    /**
+     * components the root lists that their remote does not have - never exported, or exported to
+     * another scope - so the clone is without them.
+     */
+    missing: string[];
+    laneId?: LaneId;
+    /** the clone is complete without the install; the user re-runs it in the workspace */
+    installationError?: Error;
+};
+/**
+ * makes a workspace out of a workspace-root component, the way `git clone` makes a working tree out of
+ * a repository: a fresh workspace in an empty directory, the root's files at its root, every component
+ * the root's `.bitmap` lists in the directory it records, then install. the versioned `.bitmap` has
+ * no versions on purpose (see normalizeBitmapContentForVersioning), so the components come at their
+ * heads - on main, or on the lane when one is given - and a root version pins the root files only.
+ *
+ * the directory must be empty or absent, and outside any workspace. there is no override: this is a
+ * new workspace, not an import into one, so nothing at the target is the user's.
+ */
+export declare function cloneWorkspace(rootId: ComponentID, dir: string | undefined, options: CloneOptions, loadBit: LoadBit): Promise<CloneResult>;
+/**
+ * the directory of a component the root lists, inside the workspace. the list comes from a remote,
+ * so a root-dir that escapes the workspace - "../x", an absolute path - is refused, and so are the
+ * workspace root itself, which only the root component owns, a directory bit or git keeps for
+ * itself, and a missing root-dir, which no `.bitmap` of the current schema has.
+ */
+export declare function resolveComponentDir(workspacePath: string, entry: VersionedBitmapEntry): string;
+/**
+ * where each member the root lists is written to, by id.
+ *
+ * built through a Map rather than straight onto the object the importer takes, because an id read
+ * out of a remote `.bitmap` is an arbitrary string: assigning one that reads `__proto__` runs the
+ * inherited setter instead of creating an own property, and two entries can resolve to a single id
+ * (the key and the name/scope fields are independent, see readVersionedBitmapEntries) so the later
+ * one overwrites the earlier. either way that member leaves no trace here - it is absent from the
+ * import request, and absent from the missing-members report too, since that reports what the remote
+ * did not have. the clone comes out short of a component with nothing to say why, so a collision is
+ * refused instead.
+ */
+export declare function resolveWriteToPathPerId(workspacePath: string, entries: VersionedBitmapEntry[], rootId: ComponentID): Record<string, string>;
+/**
+ * two members the root lists may not share a directory, nor sit one inside another. a `.bitmap` bit
+ * wrote holds neither - it refuses a duplicate root-dir, and a component under another component's
+ * directory - but this one came from a remote. left to the writer, a collision is relocated and then
+ * moved back to the path each component was asked for, so the later one lands on the earlier one's
+ * files and the clone comes out missing a component it reported as written.
+ */
+export declare function throwForOverlappingDirs(dirPerId: Record<string, string>): void;
+/**
+ * where the clone lands: the directory given, or one named after the component, as `git clone` names
+ * the working tree after the repository. relative to the cwd, the clone runs outside a workspace.
+ */
+export declare function resolveClonePath(dir: string | undefined, rootId: ComponentID): string;
+/**
+ * the destination with the directories above it resolved through any symbolic link, and its own last
+ * segment left as it is.
+ *
+ * a link above the target redirects everything that follows - the directory creation, the init, the
+ * files, and the cleanup of a failed clone - while the lexical path says nothing about it, so the
+ * workspace check would look in one place and the writes land in another, inside someone else's
+ * workspace. the last segment is deliberately not resolved: a link *at* the destination is refused
+ * rather than followed, which is ensureEmptyDir's rule.
+ */
+export declare function resolveThroughExistingAncestors(dirPath: string): Promise<string>;
+/**
+ * the highest directory on the way to the destination that does not exist yet, or undefined when the
+ * destination is already there. what a failed clone removes, so that the levels made on the way to it
+ * go too rather than being left standing empty.
+ */
+export declare function topmostAbsentDir(dirPath: string): Promise<string | undefined>;
+/**
+ * the workspace is written into this directory and a failed clone empties it again, so it has to be
+ * the directory it appears to be: a symbolic link would put the workspace, and then the cleanup,
+ * wherever it points. the same rule the writer applies to the files of a root (see
+ * throwForSymlinksInTheWay).
+ *
+ * @returns whether the directory was created here, so a failed clone knows to remove it
+ */
+export declare function ensureEmptyDir(dirPath: string): Promise<boolean>;