@teambit/forking 0.0.1

package/dist/fork.cmd.d.ts

@@ -0,0 +1,20 @@
+import { Command, CommandOptions } from '@teambit/cli';
+import { ForkingMain } from '.';
+export declare type ForkOptions = {
+    scope?: string;
+    path?: string;
+};
+export declare class ForkCmd implements Command {
+    private forking;
+    name: string;
+    description: string;
+    group: string;
+    skipWorkspace: boolean;
+    alias: string;
+    options: CommandOptions;
+    loader: boolean;
+    migration: boolean;
+    remoteOp: boolean;
+    constructor(forking: ForkingMain);
+    report([sourceId, targetId]: [string, string], options: ForkOptions): Promise<string>;
+}

package/dist/fork.cmd.js

@@ -0,0 +1,58 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+
+require("core-js/modules/es.array.iterator.js");
+
+require("core-js/modules/es.promise.js");
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.ForkCmd = void 0;
+
+function _defineProperty2() {
+  const data = _interopRequireDefault(require("@babel/runtime/helpers/defineProperty"));
+
+  _defineProperty2 = function () {
+    return data;
+  };
+
+  return data;
+}
+
+function _chalk() {
+  const data = _interopRequireDefault(require("chalk"));
+
+  _chalk = function () {
+    return data;
+  };
+
+  return data;
+}
+
+class ForkCmd {
+  constructor(forking) {
+    this.forking = forking;
+    (0, _defineProperty2().default)(this, "name", 'fork <source-id> [target-id]');
+    (0, _defineProperty2().default)(this, "description", 'EXPERIMENTAL. create a new component out of an existing one');
+    (0, _defineProperty2().default)(this, "group", 'collaborate');
+    (0, _defineProperty2().default)(this, "skipWorkspace", true);
+    (0, _defineProperty2().default)(this, "alias", '');
+    (0, _defineProperty2().default)(this, "options", [['s', 'scope', 'default scope for the newly created component'], ['p', 'path <string>', 'relative path in the workspace. by default the path is `<scope>/<namespace>/<name>`']]);
+    (0, _defineProperty2().default)(this, "loader", true);
+    (0, _defineProperty2().default)(this, "migration", true);
+    (0, _defineProperty2().default)(this, "remoteOp", true);
+  }
+
+  async report([sourceId, targetId], options) {
+    const results = await this.forking.fork(sourceId, targetId, options);
+    const targetIdStr = results.toString();
+    return _chalk().default.green(`successfully forked ${_chalk().default.bold(targetIdStr)} from ${_chalk().default.bold(sourceId)}`);
+  }
+
+}
+
+exports.ForkCmd = ForkCmd;
+
+//# sourceMappingURL=fork.cmd.js.map

package/dist/fork.cmd.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["fork.cmd.ts"],"names":["ForkCmd","constructor","forking","report","sourceId","targetId","options","results","fork","targetIdStr","toString","chalk","green","bold"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;AAAA;AAAA;;AAAA;AAAA;AAAA;;AAAA;AAAA;;AASO,MAAMA,OAAN,CAAiC;AActCC,EAAAA,WAAW,CAASC,OAAT,EAA+B;AAAA,SAAtBA,OAAsB,GAAtBA,OAAsB;AAAA,kDAbnC,8BAamC;AAAA,yDAZ5B,6DAY4B;AAAA,mDAXlC,aAWkC;AAAA,2DAV1B,IAU0B;AAAA,mDATlC,EASkC;AAAA,qDARhC,CACR,CAAC,GAAD,EAAM,OAAN,EAAe,+CAAf,CADQ,EAER,CAAC,GAAD,EAAM,eAAN,EAAuB,qFAAvB,CAFQ,CAQgC;AAAA,oDAJjC,IAIiC;AAAA,uDAH9B,IAG8B;AAAA,sDAF/B,IAE+B;AAAE;;AAEhC,QAANC,MAAM,CAAC,CAACC,QAAD,EAAWC,QAAX,CAAD,EAAyCC,OAAzC,EAAgF;AAC1F,UAAMC,OAAO,GAAG,MAAM,KAAKL,OAAL,CAAaM,IAAb,CAAkBJ,QAAlB,EAA4BC,QAA5B,EAAsCC,OAAtC,CAAtB;AACA,UAAMG,WAAW,GAAGF,OAAO,CAACG,QAAR,EAApB;AACA,WAAOC,iBAAMC,KAAN,CAAa,uBAAsBD,iBAAME,IAAN,CAAWJ,WAAX,CAAwB,SAAQE,iBAAME,IAAN,CAAWT,QAAX,CAAqB,EAAxF,CAAP;AACD;;AApBqC","sourcesContent":["import chalk from 'chalk';\nimport { Command, CommandOptions } from '@teambit/cli';\nimport { ForkingMain } from '.';\n\nexport type ForkOptions = {\n  scope?: string;\n  path?: string;\n};\n\nexport class ForkCmd implements Command {\n  name = 'fork <source-id> [target-id]';\n  description = 'EXPERIMENTAL. create a new component out of an existing one';\n  group = 'collaborate';\n  skipWorkspace = true;\n  alias = '';\n  options = [\n    ['s', 'scope', 'default scope for the newly created component'],\n    ['p', 'path <string>', 'relative path in the workspace. by default the path is `<scope>/<namespace>/<name>`'],\n  ] as CommandOptions;\n  loader = true;\n  migration = true;\n  remoteOp = true;\n\n  constructor(private forking: ForkingMain) {}\n\n  async report([sourceId, targetId]: [string, string], options: ForkOptions): Promise<string> {\n    const results = await this.forking.fork(sourceId, targetId, options);\n    const targetIdStr = results.toString();\n    return chalk.green(`successfully forked ${chalk.bold(targetIdStr)} from ${chalk.bold(sourceId)}`);\n  }\n}\n"]}

package/dist/forking.aspect.d.ts

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

package/dist/forking.aspect.js

@@ -0,0 +1,24 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.ForkingAspect = void 0;
+
+function _harmony() {
+  const data = require("@teambit/harmony");
+
+  _harmony = function () {
+    return data;
+  };
+
+  return data;
+}
+
+const ForkingAspect = _harmony().Aspect.create({
+  id: 'teambit.component/forking'
+});
+
+exports.ForkingAspect = ForkingAspect;
+
+//# sourceMappingURL=forking.aspect.js.map

package/dist/forking.aspect.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["forking.aspect.ts"],"names":["ForkingAspect","Aspect","create","id"],"mappings":";;;;;;;AAAA;AAAA;;AAAA;AAAA;AAAA;;AAAA;AAAA;;AAEO,MAAMA,aAAa,GAAGC,kBAAOC,MAAP,CAAc;AACzCC,EAAAA,EAAE,EAAE;AADqC,CAAd,CAAtB","sourcesContent":["import { Aspect } from '@teambit/harmony';\n\nexport const ForkingAspect = Aspect.create({\n  id: 'teambit.component/forking',\n});\n"]}

package/dist/forking.fragment.d.ts

@@ -0,0 +1,16 @@
+import { Component, ShowFragment } from '@teambit/component';
+import { ForkingMain } from './forking.main.runtime';
+export declare class ForkingFragment implements ShowFragment {
+    private forking;
+    constructor(forking: ForkingMain);
+    title: string;
+    renderRow(component: Component): Promise<{
+        title: string;
+        content: string;
+    }>;
+    json(component: Component): Promise<{
+        title: string;
+        json: import("./forking.main.runtime").ForkInfo | null;
+    }>;
+    weight: number;
+}

package/dist/forking.fragment.js

@@ -0,0 +1,49 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+
+require("core-js/modules/es.promise.js");
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.ForkingFragment = void 0;
+
+function _defineProperty2() {
+  const data = _interopRequireDefault(require("@babel/runtime/helpers/defineProperty"));
+
+  _defineProperty2 = function () {
+    return data;
+  };
+
+  return data;
+}
+
+class ForkingFragment {
+  constructor(forking) {
+    this.forking = forking;
+    (0, _defineProperty2().default)(this, "title", 'forking');
+    (0, _defineProperty2().default)(this, "weight", 3);
+  }
+
+  async renderRow(component) {
+    const forkingInfo = this.forking.getForkInfo(component);
+    const content = forkingInfo ? `origin: ${forkingInfo.forkedFrom.toString()}` : '';
+    return {
+      title: this.title,
+      content
+    };
+  }
+
+  async json(component) {
+    return {
+      title: this.title,
+      json: this.forking.getForkInfo(component)
+    };
+  }
+
+}
+
+exports.ForkingFragment = ForkingFragment;
+
+//# sourceMappingURL=forking.fragment.js.map

package/dist/forking.fragment.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["forking.fragment.ts"],"names":["ForkingFragment","constructor","forking","renderRow","component","forkingInfo","getForkInfo","content","forkedFrom","toString","title","json"],"mappings":";;;;;;;;;;;;;;;;;;;;;AAGO,MAAMA,eAAN,CAA8C;AACnDC,EAAAA,WAAW,CAASC,OAAT,EAA+B;AAAA,SAAtBA,OAAsB,GAAtBA,OAAsB;AAAA,mDAElC,SAFkC;AAAA,oDAoBjC,CApBiC;AAAE;;AAI7B,QAATC,SAAS,CAACC,SAAD,EAAuB;AACpC,UAAMC,WAAW,GAAG,KAAKH,OAAL,CAAaI,WAAb,CAAyBF,SAAzB,CAApB;AACA,UAAMG,OAAO,GAAGF,WAAW,GAAI,WAAUA,WAAW,CAACG,UAAZ,CAAuBC,QAAvB,EAAkC,EAAhD,GAAoD,EAA/E;AACA,WAAO;AACLC,MAAAA,KAAK,EAAE,KAAKA,KADP;AAELH,MAAAA;AAFK,KAAP;AAID;;AAES,QAAJI,IAAI,CAACP,SAAD,EAAuB;AAC/B,WAAO;AACLM,MAAAA,KAAK,EAAE,KAAKA,KADP;AAELC,MAAAA,IAAI,EAAE,KAAKT,OAAL,CAAaI,WAAb,CAAyBF,SAAzB;AAFD,KAAP;AAID;;AAnBkD","sourcesContent":["import { Component, ShowFragment } from '@teambit/component';\nimport { ForkingMain } from './forking.main.runtime';\n\nexport class ForkingFragment implements ShowFragment {\n  constructor(private forking: ForkingMain) {}\n\n  title = 'forking';\n\n  async renderRow(component: Component) {\n    const forkingInfo = this.forking.getForkInfo(component);\n    const content = forkingInfo ? `origin: ${forkingInfo.forkedFrom.toString()}` : '';\n    return {\n      title: this.title,\n      content,\n    };\n  }\n\n  async json(component: Component) {\n    return {\n      title: this.title,\n      json: this.forking.getForkInfo(component),\n    };\n  }\n\n  weight = 3;\n}\n"]}

package/dist/forking.main.runtime.d.ts

@@ -0,0 +1,34 @@
+import { CLIMain } from '@teambit/cli';
+import { DependencyResolverMain } from '@teambit/dependency-resolver';
+import { Workspace } from '@teambit/workspace';
+import { Component, ComponentID, ComponentMain } from '@teambit/component';
+import { ComponentIdObj } from '@teambit/component-id';
+import { NewComponentHelperMain } from '@teambit/new-component-helper';
+import { ForkOptions } from './fork.cmd';
+export declare type ForkInfo = {
+    forkedFrom: ComponentID;
+};
+export declare class ForkingMain {
+    private workspace;
+    private dependencyResolver;
+    private newComponentHelper;
+    constructor(workspace: Workspace, dependencyResolver: DependencyResolverMain, newComponentHelper: NewComponentHelperMain);
+    fork(sourceIdStr: string, targetId?: string, options?: ForkOptions): Promise<ComponentID>;
+    getForkInfo(component: Component): ForkInfo | null;
+    private forkExistingInWorkspace;
+    private forkRemoteComponent;
+    private getConfig;
+    static slots: never[];
+    static dependencies: import("@teambit/harmony").Aspect[];
+    static runtime: import("@teambit/harmony").RuntimeDefinition;
+    static provider([cli, workspace, dependencyResolver, componentMain, newComponentHelper]: [
+        CLIMain,
+        Workspace,
+        DependencyResolverMain,
+        ComponentMain,
+        NewComponentHelperMain
+    ]): Promise<ForkingMain>;
+}
+export declare type ForkConfig = {
+    forkedFrom: ComponentIdObj;
+};

package/dist/forking.main.runtime.js

@@ -0,0 +1,223 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+
+require("core-js/modules/es.array.iterator.js");
+
+require("core-js/modules/es.promise.js");
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.ForkingMain = void 0;
+
+function _defineProperty2() {
+  const data = _interopRequireDefault(require("@babel/runtime/helpers/defineProperty"));
+
+  _defineProperty2 = function () {
+    return data;
+  };
+
+  return data;
+}
+
+function _cli() {
+  const data = require("@teambit/cli");
+
+  _cli = function () {
+    return data;
+  };
+
+  return data;
+}
+
+function _dependencyResolver() {
+  const data = require("@teambit/dependency-resolver");
+
+  _dependencyResolver = function () {
+    return data;
+  };
+
+  return data;
+}
+
+function _legacyBitId() {
+  const data = require("@teambit/legacy-bit-id");
+
+  _legacyBitId = function () {
+    return data;
+  };
+
+  return data;
+}
+
+function _workspace() {
+  const data = _interopRequireDefault(require("@teambit/workspace"));
+
+  _workspace = function () {
+    return data;
+  };
+
+  return data;
+}
+
+function _component() {
+  const data = _interopRequireWildcard(require("@teambit/component"));
+
+  _component = function () {
+    return data;
+  };
+
+  return data;
+}
+
+function _newComponentHelper() {
+  const data = _interopRequireDefault(require("@teambit/new-component-helper"));
+
+  _newComponentHelper = function () {
+    return data;
+  };
+
+  return data;
+}
+
+function _fork() {
+  const data = require("./fork.cmd");
+
+  _fork = function () {
+    return data;
+  };
+
+  return data;
+}
+
+function _forking() {
+  const data = require("./forking.aspect");
+
+  _forking = function () {
+    return data;
+  };
+
+  return data;
+}
+
+function _forking2() {
+  const data = require("./forking.fragment");
+
+  _forking2 = function () {
+    return data;
+  };
+
+  return data;
+}
+
+function _getRequireWildcardCache(nodeInterop) { if (typeof WeakMap !== "function") return null; var cacheBabelInterop = new WeakMap(); var cacheNodeInterop = new WeakMap(); return (_getRequireWildcardCache = function (nodeInterop) { return nodeInterop ? cacheNodeInterop : cacheBabelInterop; })(nodeInterop); }
+
+function _interopRequireWildcard(obj, nodeInterop) { if (!nodeInterop && obj && obj.__esModule) { return obj; } if (obj === null || typeof obj !== "object" && typeof obj !== "function") { return { default: obj }; } var cache = _getRequireWildcardCache(nodeInterop); if (cache && cache.has(obj)) { return cache.get(obj); } var newObj = {}; var hasPropertyDescriptor = Object.defineProperty && Object.getOwnPropertyDescriptor; for (var key in obj) { if (key !== "default" && Object.prototype.hasOwnProperty.call(obj, key)) { var desc = hasPropertyDescriptor ? Object.getOwnPropertyDescriptor(obj, key) : null; if (desc && (desc.get || desc.set)) { Object.defineProperty(newObj, key, desc); } else { newObj[key] = obj[key]; } } } newObj.default = obj; if (cache) { cache.set(obj, newObj); } return newObj; }
+
+function ownKeys(object, enumerableOnly) { var keys = Object.keys(object); if (Object.getOwnPropertySymbols) { var symbols = Object.getOwnPropertySymbols(object); enumerableOnly && (symbols = symbols.filter(function (sym) { return Object.getOwnPropertyDescriptor(object, sym).enumerable; })), keys.push.apply(keys, symbols); } return keys; }
+
+function _objectSpread(target) { for (var i = 1; i < arguments.length; i++) { var source = null != arguments[i] ? arguments[i] : {}; i % 2 ? ownKeys(Object(source), !0).forEach(function (key) { (0, _defineProperty2().default)(target, key, source[key]); }) : Object.getOwnPropertyDescriptors ? Object.defineProperties(target, Object.getOwnPropertyDescriptors(source)) : ownKeys(Object(source)).forEach(function (key) { Object.defineProperty(target, key, Object.getOwnPropertyDescriptor(source, key)); }); } return target; }
+
+class ForkingMain {
+  constructor(workspace, dependencyResolver, newComponentHelper) {
+    this.workspace = workspace;
+    this.dependencyResolver = dependencyResolver;
+    this.newComponentHelper = newComponentHelper;
+  }
+
+  async fork(sourceIdStr, targetId, options) {
+    const sourceId = await this.workspace.resolveComponentId(sourceIdStr);
+    const existingInWorkspace = await this.workspace.getIfExist(sourceId);
+
+    if (existingInWorkspace) {
+      return this.forkExistingInWorkspace(existingInWorkspace, targetId, options);
+    }
+
+    const sourceIdWithScope = sourceId._legacy.scope ? sourceId : _component().ComponentID.fromLegacy(_legacyBitId().BitId.parse(sourceIdStr, true));
+    return this.forkRemoteComponent(sourceIdWithScope, targetId, options);
+  }
+
+  getForkInfo(component) {
+    var _component$state$aspe;
+
+    const forkConfig = (_component$state$aspe = component.state.aspects.get(_forking().ForkingAspect.id)) === null || _component$state$aspe === void 0 ? void 0 : _component$state$aspe.config;
+    if (!forkConfig) return null;
+    return {
+      forkedFrom: _component().ComponentID.fromObject(forkConfig.forkedFrom)
+    };
+  }
+
+  async forkExistingInWorkspace(existing, targetId, options) {
+    if (!targetId) {
+      throw new Error(`error: unable to create "${existing.id.toStringWithoutVersion()}" component, a component with the same name already exists.
+please specify the target-id arg`);
+    }
+
+    const targetCompId = this.newComponentHelper.getNewComponentId(targetId, undefined, options === null || options === void 0 ? void 0 : options.scope);
+    const targetPath = this.newComponentHelper.getNewComponentPath(targetCompId, options === null || options === void 0 ? void 0 : options.path);
+    const config = await this.getConfig(existing);
+    await this.newComponentHelper.writeAndAddNewComp(existing, targetPath, targetCompId, config);
+    return targetCompId;
+  }
+
+  async forkRemoteComponent(sourceId, targetId, options) {
+    const targetName = targetId || sourceId.fullName;
+    const targetCompId = this.newComponentHelper.getNewComponentId(targetName, undefined, options === null || options === void 0 ? void 0 : options.scope);
+    const targetPath = this.newComponentHelper.getNewComponentPath(targetCompId, options === null || options === void 0 ? void 0 : options.path);
+    const comp = await this.workspace.scope.getRemoteComponent(sourceId);
+    const deps = await this.dependencyResolver.getDependencies(comp); // only bring auto-resolved dependencies, others should be set in the workspace.jsonc template
+
+    const workspacePolicyEntries = deps.filter(dep => dep.source === 'auto').map(dep => {
+      var _dep$getPackageName;
+
+      return {
+        dependencyId: ((_dep$getPackageName = dep.getPackageName) === null || _dep$getPackageName === void 0 ? void 0 : _dep$getPackageName.call(dep)) || dep.id,
+        lifecycleType: dep.lifecycle === 'dev' ? 'runtime' : dep.lifecycle,
+        value: {
+          version: dep.version
+        }
+      };
+    });
+    this.dependencyResolver.addToRootPolicy(workspacePolicyEntries, {
+      updateExisting: true
+    });
+    const config = await this.getConfig(comp);
+    await this.newComponentHelper.writeAndAddNewComp(comp, targetPath, targetCompId, config);
+    await this.dependencyResolver.persistConfig(this.workspace.path);
+    await this.workspace.install(undefined, {
+      dedupe: true,
+      import: false,
+      copyPeerToRuntimeOnRoot: true,
+      copyPeerToRuntimeOnComponents: false,
+      updateExisting: false
+    });
+    return targetCompId;
+  }
+
+  async getConfig(comp) {
+    const fromExisting = await this.newComponentHelper.getConfigFromExistingToNewComponent(comp);
+    return _objectSpread(_objectSpread({}, fromExisting), {}, {
+      [_forking().ForkingAspect.id]: {
+        forkedFrom: comp.id.toObject()
+      }
+    });
+  }
+
+  static async provider([cli, workspace, dependencyResolver, componentMain, newComponentHelper]) {
+    const forkingMain = new ForkingMain(workspace, dependencyResolver, newComponentHelper);
+    cli.register(new (_fork().ForkCmd)(forkingMain));
+    componentMain.registerShowFragments([new (_forking2().ForkingFragment)(forkingMain)]);
+    return forkingMain;
+  }
+
+}
+
+exports.ForkingMain = ForkingMain;
+(0, _defineProperty2().default)(ForkingMain, "slots", []);
+(0, _defineProperty2().default)(ForkingMain, "dependencies", [_cli().CLIAspect, _workspace().default, _dependencyResolver().DependencyResolverAspect, _component().default, _newComponentHelper().default]);
+(0, _defineProperty2().default)(ForkingMain, "runtime", _cli().MainRuntime);
+
+_forking().ForkingAspect.addRuntime(ForkingMain);
+
+//# sourceMappingURL=forking.main.runtime.js.map

package/dist/forking.main.runtime.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["forking.main.runtime.ts"],"names":["ForkingMain","constructor","workspace","dependencyResolver","newComponentHelper","fork","sourceIdStr","targetId","options","sourceId","resolveComponentId","existingInWorkspace","getIfExist","forkExistingInWorkspace","sourceIdWithScope","_legacy","scope","ComponentID","fromLegacy","BitId","parse","forkRemoteComponent","getForkInfo","component","forkConfig","state","aspects","get","ForkingAspect","id","config","forkedFrom","fromObject","existing","Error","toStringWithoutVersion","targetCompId","getNewComponentId","undefined","targetPath","getNewComponentPath","path","getConfig","writeAndAddNewComp","targetName","fullName","comp","getRemoteComponent","deps","getDependencies","workspacePolicyEntries","filter","dep","source","map","dependencyId","getPackageName","lifecycleType","lifecycle","value","version","addToRootPolicy","updateExisting","persistConfig","install","dedupe","import","copyPeerToRuntimeOnRoot","copyPeerToRuntimeOnComponents","fromExisting","getConfigFromExistingToNewComponent","toObject","provider","cli","componentMain","forkingMain","register","ForkCmd","registerShowFragments","ForkingFragment","CLIAspect","WorkspaceAspect","DependencyResolverAspect","ComponentAspect","NewComponentHelperAspect","MainRuntime","addRuntime"],"mappings":"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","sourcesContent":["import { CLIAspect, CLIMain, MainRuntime } from '@teambit/cli';\nimport { DependencyResolverAspect, DependencyResolverMain } from '@teambit/dependency-resolver';\nimport { BitId } from '@teambit/legacy-bit-id';\nimport WorkspaceAspect, { Workspace } from '@teambit/workspace';\nimport ComponentAspect, { Component, ComponentID, ComponentMain } from '@teambit/component';\nimport { ComponentIdObj } from '@teambit/component-id';\nimport NewComponentHelperAspect, { NewComponentHelperMain } from '@teambit/new-component-helper';\nimport { ForkCmd, ForkOptions } from './fork.cmd';\nimport { ForkingAspect } from './forking.aspect';\nimport { ForkingFragment } from './forking.fragment';\n\nexport type ForkInfo = {\n  forkedFrom: ComponentID;\n};\n\nexport class ForkingMain {\n  constructor(\n    private workspace: Workspace,\n    private dependencyResolver: DependencyResolverMain,\n    private newComponentHelper: NewComponentHelperMain\n  ) {}\n\n  async fork(sourceIdStr: string, targetId?: string, options?: ForkOptions): Promise<ComponentID> {\n    const sourceId = await this.workspace.resolveComponentId(sourceIdStr);\n    const existingInWorkspace = await this.workspace.getIfExist(sourceId);\n    if (existingInWorkspace) {\n      return this.forkExistingInWorkspace(existingInWorkspace, targetId, options);\n    }\n    const sourceIdWithScope = sourceId._legacy.scope\n      ? sourceId\n      : ComponentID.fromLegacy(BitId.parse(sourceIdStr, true));\n    return this.forkRemoteComponent(sourceIdWithScope, targetId, options);\n  }\n\n  getForkInfo(component: Component): ForkInfo | null {\n    const forkConfig = component.state.aspects.get(ForkingAspect.id)?.config as ForkConfig | undefined;\n    if (!forkConfig) return null;\n    return {\n      forkedFrom: ComponentID.fromObject(forkConfig.forkedFrom),\n    };\n  }\n\n  private async forkExistingInWorkspace(existing: Component, targetId?: string, options?: ForkOptions) {\n    if (!targetId) {\n      throw new Error(`error: unable to create \"${existing.id.toStringWithoutVersion()}\" component, a component with the same name already exists.\nplease specify the target-id arg`);\n    }\n    const targetCompId = this.newComponentHelper.getNewComponentId(targetId, undefined, options?.scope);\n    const targetPath = this.newComponentHelper.getNewComponentPath(targetCompId, options?.path);\n    const config = await this.getConfig(existing);\n    await this.newComponentHelper.writeAndAddNewComp(existing, targetPath, targetCompId, config);\n\n    return targetCompId;\n  }\n  private async forkRemoteComponent(sourceId: ComponentID, targetId?: string, options?: ForkOptions) {\n    const targetName = targetId || sourceId.fullName;\n    const targetCompId = this.newComponentHelper.getNewComponentId(targetName, undefined, options?.scope);\n    const targetPath = this.newComponentHelper.getNewComponentPath(targetCompId, options?.path);\n    const comp = await this.workspace.scope.getRemoteComponent(sourceId);\n\n    const deps = await this.dependencyResolver.getDependencies(comp);\n    // only bring auto-resolved dependencies, others should be set in the workspace.jsonc template\n    const workspacePolicyEntries = deps\n      .filter((dep) => dep.source === 'auto')\n      .map((dep) => ({\n        dependencyId: dep.getPackageName?.() || dep.id,\n        lifecycleType: dep.lifecycle === 'dev' ? 'runtime' : dep.lifecycle,\n        value: {\n          version: dep.version,\n        },\n      }));\n    this.dependencyResolver.addToRootPolicy(workspacePolicyEntries, { updateExisting: true });\n    const config = await this.getConfig(comp);\n    await this.newComponentHelper.writeAndAddNewComp(comp, targetPath, targetCompId, config);\n    await this.dependencyResolver.persistConfig(this.workspace.path);\n    await this.workspace.install(undefined, {\n      dedupe: true,\n      import: false,\n      copyPeerToRuntimeOnRoot: true,\n      copyPeerToRuntimeOnComponents: false,\n      updateExisting: false,\n    });\n\n    return targetCompId;\n  }\n\n  private async getConfig(comp: Component) {\n    const fromExisting = await this.newComponentHelper.getConfigFromExistingToNewComponent(comp);\n    return {\n      ...fromExisting,\n      [ForkingAspect.id]: {\n        forkedFrom: comp.id.toObject(),\n      },\n    };\n  }\n\n  static slots = [];\n  static dependencies = [\n    CLIAspect,\n    WorkspaceAspect,\n    DependencyResolverAspect,\n    ComponentAspect,\n    NewComponentHelperAspect,\n  ];\n  static runtime = MainRuntime;\n  static async provider([cli, workspace, dependencyResolver, componentMain, newComponentHelper]: [\n    CLIMain,\n    Workspace,\n    DependencyResolverMain,\n    ComponentMain,\n    NewComponentHelperMain\n  ]) {\n    const forkingMain = new ForkingMain(workspace, dependencyResolver, newComponentHelper);\n    cli.register(new ForkCmd(forkingMain));\n    componentMain.registerShowFragments([new ForkingFragment(forkingMain)]);\n    return forkingMain;\n  }\n}\n\nForkingAspect.addRuntime(ForkingMain);\n\nexport type ForkConfig = {\n  forkedFrom: ComponentIdObj;\n};\n"]}

package/dist/index.d.ts

@@ -0,0 +1,4 @@
+import { ForkingAspect } from './forking.aspect';
+export type { ForkingMain } from './forking.main.runtime';
+export default ForkingAspect;
+export { ForkingAspect };

package/dist/index.js

@@ -0,0 +1,28 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+Object.defineProperty(exports, "ForkingAspect", {
+  enumerable: true,
+  get: function () {
+    return _forking().ForkingAspect;
+  }
+});
+exports.default = void 0;
+
+function _forking() {
+  const data = require("./forking.aspect");
+
+  _forking = function () {
+    return data;
+  };
+
+  return data;
+}
+
+var _default = _forking().ForkingAspect;
+
+exports.default = _default;
+
+//# sourceMappingURL=index.js.map

package/dist/index.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["index.ts"],"names":["ForkingAspect"],"mappings":";;;;;;;;;;;;;AAAA;AAAA;;AAAA;AAAA;AAAA;;AAAA;AAAA;;eAGeA,wB","sourcesContent":["import { ForkingAspect } from './forking.aspect';\n\nexport type { ForkingMain } from './forking.main.runtime';\nexport default ForkingAspect;\nexport { ForkingAspect };\n"]}

package/package.json

@@ -0,0 +1,87 @@
+{
+  "name": "@teambit/forking",
+  "version": "0.0.1",
+  "main": "dist/index.js",
+  "componentId": {
+    "scope": "teambit.component",
+    "name": "forking",
+    "version": "0.0.1"
+  },
+  "dependencies": {
+    "chalk": "2.4.2",
+    "@teambit/harmony": "0.2.11",
+    "@babel/runtime": "7.12.18",
+    "core-js": "^3.0.0",
+    "@teambit/cli": "0.0.410",
+    "@teambit/component": "0.0.597",
+    "@teambit/component-id": "0.0.398",
+    "@teambit/dependency-resolver": "0.0.597",
+    "@teambit/legacy-bit-id": "0.0.397",
+    "@teambit/new-component-helper": "0.0.1",
+    "@teambit/workspace": "0.0.597"
+  },
+  "devDependencies": {
+    "@types/mocha": "5.2.7",
+    "@types/testing-library__jest-dom": "5.9.5",
+    "@types/jest": "^26.0.0",
+    "@types/react-dom": "^17.0.5",
+    "@types/react": "^17.0.8",
+    "@types/node": "12.20.4"
+  },
+  "peerDependencies": {
+    "@teambit/legacy": "1.0.197",
+    "react-dom": "^16.8.0 || ^17.0.0",
+    "react": "^16.8.0 || ^17.0.0"
+  },
+  "license": "Apache-2.0",
+  "bit": {
+    "bindingPrefix": "@teambit",
+    "env": {},
+    "overrides": {
+      "dependencies": {
+        "@teambit/legacy": "-",
+        "@babel/runtime": "7.12.18",
+        "core-js": "^3.0.0",
+        "react-dom": "-",
+        "react": "-"
+      },
+      "devDependencies": {
+        "@teambit/legacy": "-",
+        "@types/mocha": "5.2.7",
+        "@types/testing-library__jest-dom": "5.9.5",
+        "@types/jest": "^26.0.0",
+        "@types/react-dom": "^17.0.5",
+        "@types/react": "^17.0.8",
+        "@types/node": "12.20.4",
+        "react-dom": "-",
+        "react": "-"
+      },
+      "peerDependencies": {
+        "@teambit/legacy": "1.0.197",
+        "react-dom": "^16.8.0 || ^17.0.0",
+        "react": "^16.8.0 || ^17.0.0"
+      }
+    }
+  },
+  "private": false,
+  "engines": {
+    "node": ">=12.22.0"
+  },
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/teambit/bit"
+  },
+  "keywords": [
+    "bit",
+    "bit-aspect",
+    "components",
+    "collaboration",
+    "web",
+    "react",
+    "react-components",
+    "angular",
+    "angular-components",
+    "vue",
+    "vue-components"
+  ]
+}

package/tsconfig.json

@@ -0,0 +1,34 @@
+{
+  "compilerOptions": {
+    "lib": [
+      "es2019",
+      "DOM",
+      "ES6",
+      "DOM.Iterable",
+      "ScriptHost"
+    ],
+    "target": "es2015",
+    "module": "commonjs",
+    "jsx": "react",
+    "declaration": true,
+    "sourceMap": true,
+    "skipLibCheck": true,
+    "moduleResolution": "node",
+    "esModuleInterop": true,
+    "resolveJsonModule": true,
+    "composite": true,
+    "emitDeclarationOnly": true,
+    "outDir": "dist",
+    "experimentalDecorators": true,
+    "emitDecoratorMetadata": true,
+    "allowSyntheticDefaultImports": true,
+    "strictPropertyInitialization": false,
+    "strict": true,
+    "noImplicitAny": false,
+    "rootDir": ".",
+    "preserveConstEnums": true
+  },
+  "exclude": [
+    "dist"
+  ]
+}

package/types/asset.d.ts

@@ -0,0 +1,29 @@
+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;
+}
+
+// @TODO Gilad
+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;
+}

package/types/style.d.ts

@@ -0,0 +1,42 @@
+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;
+}