@teambit/isolator 0.0.555 → 0.0.556

package/package.json

@@ -1,12 +1,12 @@
 {
   "name": "@teambit/isolator",
-  "version": "0.0.555",
+  "version": "0.0.556",
   "homepage": "https://bit.dev/teambit/component/isolator",
   "main": "dist/index.js",
   "componentId": {
     "scope": "teambit.component",
     "name": "isolator",
-    "version": "0.0.555"
+    "version": "0.0.556"
   },
   "dependencies": {
     "@teambit/harmony": "0.2.11",
@@ -23,14 +23,14 @@
     "execa": "2.1.0",
     "@babel/runtime": "7.12.18",
     "core-js": "^3.0.0",
-    "@teambit/component": "0.0.555",
-    "@teambit/legacy-bit-id": "0.0.375",
-    "@teambit/cli": "0.0.386",
-    "@teambit/component-package-version": "0.0.372",
-    "@teambit/dependency-resolver": "0.0.555",
-    "@teambit/global-config": "0.0.387",
-    "@teambit/graph": "0.0.555",
-    "@teambit/logger": "0.0.471"
+    "@teambit/component": "0.0.556",
+    "@teambit/legacy-bit-id": "0.0.376",
+    "@teambit/cli": "0.0.387",
+    "@teambit/component-package-version": "0.0.373",
+    "@teambit/dependency-resolver": "0.0.556",
+    "@teambit/global-config": "0.0.388",
+    "@teambit/graph": "0.0.556",
+    "@teambit/logger": "0.0.472"
   },
   "devDependencies": {
     "@types/fs-extra": "9.0.7",
@@ -45,7 +45,7 @@
     "@types/node": "12.20.4"
   },
   "peerDependencies": {
-    "@teambit/legacy": "1.0.172",
+    "@teambit/legacy": "1.0.173",
     "react-dom": "^16.8.0 || ^17.0.0",
     "react": "^16.8.0 || ^17.0.0"
   },
@@ -73,12 +73,18 @@
         "react": "-"
       },
       "peerDependencies": {
-        "@teambit/legacy": "1.0.172",
+        "@teambit/legacy": "1.0.173",
         "react-dom": "^16.8.0 || ^17.0.0",
         "react": "^16.8.0 || ^17.0.0"
       }
     }
   },
+  "files": [
+    "dist",
+    "!dist/tsconfig.tsbuildinfo",
+    "README.md",
+    "README.mdx"
+  ],
   "private": false,
   "engines": {
     "node": ">=12.22.0"

package/capsule/capsule.ts

@@ -1,138 +0,0 @@
-import { NodeFS } from '@teambit/any-fs';
-import { Capsule as CapsuleTemplate, Console, Exec, State } from '@teambit/capsule';
-import { Component } from '@teambit/component';
-import filenamify from 'filenamify';
-import { realpathSync } from 'fs';
-import glob from 'glob';
-import path from 'path';
-import v4 from 'uuid';
-
-import FsContainer, { BitExecOption } from './container';
-import ContainerExec from './container-exec';
-
-export default class Capsule extends CapsuleTemplate<Exec, NodeFS> {
-  private _wrkDir: string;
-  constructor(
-    /**
-     * container implementation the capsule is being executed within.
-     */
-    protected container: FsContainer,
-    /**
-     * the capsule's file system.
-     */
-    readonly fs: NodeFS,
-    /**
-     * console for controlling process streams as stdout, stdin and stderr.
-     */
-    readonly console: Console = new Console(),
-    /**
-     * capsule's state.
-     */
-    readonly state: State,
-    readonly component: Component
-  ) {
-    super(container, fs, console, state);
-    this._wrkDir = container.wrkDir;
-  }
-
-  /**
-   * @deprecated please use `this.path`
-   */
-  get wrkDir(): string {
-    return this.path;
-  }
-
-  get path(): string {
-    return realpathSync(this._wrkDir);
-  }
-
-  start(): Promise<any> {
-    return this.container.start();
-  }
-
-  async execNode(executable: string, args: any, exec: ContainerExec) {
-    return this.typedExec(
-      {
-        command: ['node', executable, ...(args.args || [])],
-        cwd: '',
-      },
-      exec
-    );
-  }
-
-  async typedExec(opts: BitExecOption, exec = new ContainerExec()) {
-    return this.container.exec(opts, exec);
-  }
-
-  outputFile(file: string, data: any, options?: any): Promise<any> {
-    return this.container.outputFile(file, data, options);
-  }
-
-  removePath(dir: string): Promise<any> {
-    return this.container.removePath(dir);
-  }
-
-  symlink(src: string, dest: string): Promise<any> {
-    return this.container.symlink(src, dest);
-  }
-
-  // TODO: refactor this crap and simplify capsule API
-  async execute(cmd: string, options?: Record<string, any> | null | undefined) {
-    // @ts-ignore AUTO-ADDED-AFTER-MIGRATION-PLEASE-FIX!
-    const execResults = await this.exec({ command: cmd.split(' '), options });
-    let stdout = '';
-    let stderr = '';
-    return new Promise((resolve, reject) => {
-      execResults.stdout.on('data', (data: string) => {
-        stdout += data;
-      });
-      execResults.stdout.on('error', (error: string) => {
-        return reject(error);
-      });
-      // @ts-ignore
-      execResults.on('close', () => {
-        return resolve({ stdout, stderr });
-      });
-      execResults.stderr.on('error', (error: string) => {
-        return reject(error);
-      });
-      execResults.stderr.on('data', (data: string) => {
-        stderr += data;
-      });
-    });
-  }
-
-  /**
-   * @todo: fix.
-   * it skips the capsule fs because for some reason `capsule.fs.promises.readdir` doesn't work
-   * the same as `capsule.fs.readdir` and it doesn't have the capsule dir as pwd.
-   *
-   * returns the paths inside the capsule
-   */
-  getAllFilesPaths(dir = '.', options: { ignore?: string[] } = {}) {
-    const files = glob.sync('**', { cwd: path.join(this.path, dir), nodir: true, ...options });
-    return files.map((file) => path.join(dir, file));
-  }
-
-  static getCapsuleDirName(component: Component, config: { alwaysNew?: boolean; name?: string } = {}) {
-    return config.name || filenamify(component.id.toString(), { replacement: '_' });
-  }
-
-  static getCapsuleRootDir(component: Component, baseDir: string, config: { alwaysNew?: boolean; name?: string } = {}) {
-    return path.join(baseDir, Capsule.getCapsuleDirName(component, config));
-  }
-
-  static async createFromComponent(
-    component: Component,
-    baseDir: string,
-    config: { alwaysNew?: boolean; name?: string } = {}
-  ): Promise<Capsule> {
-    // TODO: make this a static method and combine with ComponentCapsule
-    const capsuleDirName = Capsule.getCapsuleDirName(component, config);
-    const wrkDir = path.join(baseDir, config.alwaysNew ? `${capsuleDirName}_${v4()}` : capsuleDirName);
-    const container = new FsContainer(wrkDir);
-    const capsule = new Capsule(container, container.fs, new Console(), new State(), component);
-    await capsule.start();
-    return capsule;
-  }
-}

package/capsule/container-exec.ts

@@ -1,31 +0,0 @@
-import { DuplexBufferStream, Exec, ExecStatus } from '@teambit/capsule';
-import { EventEmitter } from 'events';
-
-export default class ContainerExec extends EventEmitter implements Exec {
-  constructor(private _code: number = 0) {
-    super();
-  }
-
-  stdout: DuplexBufferStream = new DuplexBufferStream();
-  stderr: DuplexBufferStream = new DuplexBufferStream();
-  stdin: DuplexBufferStream = new DuplexBufferStream();
-
-  setStatus(status: number): void {
-    this._code = status;
-    this.emit('close');
-  }
-
-  get code(): number {
-    return this._code;
-  }
-
-  inspect(): Promise<ExecStatus> {
-    return Promise.resolve({
-      running: true,
-      pid: 1,
-    });
-  }
-  abort(): Promise<void> {
-    throw new Error('Method not implemented.');
-  }
-}

package/capsule/container.ts

@@ -1,128 +0,0 @@
-import { AnyFS, NodeFS } from '@teambit/any-fs';
-import { Container, ContainerFactoryOptions, ContainerStatus, Exec, ExecOptions } from '@teambit/capsule';
-import execa from 'execa';
-import fs from 'fs-extra';
-import * as path from 'path';
-import { Stream } from 'stream';
-
-import ContainerExec from './container-exec';
-
-const debug = require('debug')('fs-container');
-
-export interface BitExecOption extends ExecOptions {
-  cwd: string;
-  stdio?: 'pipe' | 'ipc' | 'ignore' | 'inherit' | Stream | number | undefined;
-}
-export interface BitContainerConfig extends ContainerFactoryOptions {
-  other?: string;
-}
-
-export default class FsContainer implements Container<Exec, AnyFS> {
-  id = 'FS Container';
-
-  fs: NodeFS = new NodeFS(this.wrkDir);
-
-  constructor(readonly wrkDir: string) {}
-
-  // TODO: do we need this?
-  public getPath() {
-    return this.wrkDir;
-  }
-
-  private composePath(pathToCompose) {
-    return path.join(this.getPath(), pathToCompose);
-  }
-
-  outputFile(file, data, options) {
-    const filePath = this.composePath(file);
-    debug(`writing file on ${filePath}`);
-    return fs.outputFile(filePath, data, options);
-  }
-
-  removePath(dir: string): Promise<any> {
-    const pathToRemove = this.composePath(dir);
-    return fs.remove(pathToRemove);
-  }
-
-  async symlink(src: string, dest: string): Promise<any> {
-    const srcPath = this.composePath(src);
-    const destPath = this.composePath(dest);
-    await fs.ensureDir(path.dirname(destPath));
-    return fs.ensureSymlink(srcPath, destPath);
-  }
-
-  async exec(execOptions: BitExecOption, exec = new ContainerExec()): Promise<ContainerExec> {
-    const cwd = execOptions.cwd ? this.composePath(execOptions.cwd) : this.getPath();
-    debug(`executing the following command: ${execOptions.command.join(' ')}, on cwd: ${cwd}`);
-    const subprocessP = execa.command(execOptions.command.join(' '), {
-      shell: true,
-      cwd,
-      stdio: ['ipc'],
-    });
-
-    // @TODO: FIX! This probably causes errors ad the promise is not handled properly!
-    // eslint-disable-next-line @typescript-eslint/no-floating-promises
-    subprocessP.on('message', function (msg: any) {
-      exec.emit('message', msg);
-    });
-    /* eslint-disable @typescript-eslint/no-non-null-assertion */
-    subprocessP.stderr?.pipe(exec.stderr);
-    subprocessP.stdout?.pipe(exec.stdout);
-    ['close', 'exit'].forEach(function (eventName: string) {
-      // @TODO: FIX! This probably causes errors ad the promise is not handled properly!
-      // eslint-disable-next-line @typescript-eslint/no-floating-promises
-      subprocessP.on(eventName, function (statusCode) {
-        exec.setStatus(statusCode);
-      });
-    });
-
-    return exec;
-  }
-
-  async execP(execOptions: BitExecOption): Promise<string> {
-    let hasError = false;
-    const exec = await this.exec(execOptions);
-    return new Promise((resolve, reject) => {
-      exec.stdout.on('error', () => {
-        hasError = true;
-      });
-      exec.on('close', () => {
-        if (hasError) reject(exec.stderr.getContents!(exec.stderr.size).toString());
-        resolve(exec.stdout.getContents!(exec.stdout.size).toString());
-      });
-    });
-  }
-
-  async terminal() {
-    const cwd = this.getPath();
-    return execa.command(process.env.SHELL || '/bin/zsh', { cwd, stdio: 'inherit' });
-  }
-
-  start(): Promise<void> {
-    return fs.ensureDir(this.wrkDir);
-  }
-  // @ts-ignore
-  async inspect(): Promise<ContainerStatus> {
-    // todo: probably not needed for this container
-  }
-  async pause(): Promise<void> {
-    // do nothing
-  }
-  async resume(): Promise<void> {
-    // do nothing
-  }
-  // eslint-disable-next-line
-  stop(ttl?: number | undefined): Promise<void> {
-    return fs.remove(this.wrkDir);
-  }
-  async destroy(): Promise<void> {
-    await this.stop();
-  }
-  log(): Promise<Exec> {
-    throw new Error('Method not implemented.');
-  }
-  on(event: string, fn: (data: any) => void): void {
-    return fn(event);
-    // throw new Error('Method not implemented.');
-  }
-}

package/capsule/index.ts

@@ -1,3 +0,0 @@
-export { default as Capsule } from './capsule';
-export { default as FsContainer } from './container';
-export { default as ContainerExec } from './container-exec';

package/capsule-list.ts

@@ -1,33 +0,0 @@
-import type { Component, ComponentID } from '@teambit/component';
-import { normalize } from 'path';
-import { BitId } from '@teambit/legacy-bit-id';
-import { Capsule } from './capsule';
-
-export default class CapsuleList extends Array<Capsule> {
-  getCapsule(id: ComponentID): Capsule | undefined {
-    return this.find((capsule) => capsule.component.id.isEqual(id));
-  }
-  getCapsuleByLegacyId(id: BitId): Capsule | undefined {
-    return this.find((capsule) => capsule.component.id._legacy.isEqual(id));
-  }
-  getCapsuleIgnoreVersion(id: ComponentID): Capsule | undefined {
-    return this.find((capsule) => capsule.component.id._legacy.isEqualWithoutVersion(id._legacy));
-  }
-  getCapsuleIgnoreScopeAndVersion(id: ComponentID): Capsule | undefined {
-    return this.find((capsule) => capsule.component.id._legacy.isEqualWithoutScopeAndVersion(id._legacy));
-  }
-  getAllCapsuleDirs(): string[] {
-    return this.map((capsule) => capsule.path);
-  }
-  getIdByPathInCapsule(pathInCapsule: string): ComponentID | null {
-    const normalizedPathInCapsule = normalize(pathInCapsule);
-    const found = this.find((capsule) => normalizedPathInCapsule === normalize(capsule.path));
-    return found ? found.component.id : null;
-  }
-  getAllComponents(): Component[] {
-    return this.map((c) => c.component);
-  }
-  static fromArray(capsules: Capsule[]) {
-    return new CapsuleList(...capsules);
-  }
-}

package/index.ts

@@ -1,6 +0,0 @@
-export { IsolateComponentsOptions } from './isolator.main.runtime';
-export { Network } from './network';
-export { FsContainer, Capsule, ContainerExec } from './capsule';
-export type { IsolatorMain } from './isolator.main.runtime';
-export { IsolatorAspect } from './isolator.aspect';
-export { default as CapsuleList } from './capsule-list';

package/isolator.aspect.ts

@@ -1,7 +0,0 @@
-import { Aspect } from '@teambit/harmony';
-
-export const IsolatorAspect = Aspect.create({
-  id: 'teambit.component/isolator',
-  dependencies: [],
-  defaultConfig: {},
-});

package/isolator.docs.md

@@ -1,41 +0,0 @@
----
-description: Isolate components for build, debugging, development and testing.
-labels: ['isolation', 'component']
----
-
-## Isolate a component
-
-```bash
-bit create-capsule ui/button
-```
-
-## Entities
-
-### Capsule
-
-Bit implements a filesystem capsule, which is an isolated folder containing the component files.
-Capsules include the component files and links to other capsules that include the component's dependencies.
-
-### Network
-
-A network is a group of capsules, related to one another by their dependencies.
-A network includes a graph of all seed components given to it, as well as a list of the capsules.
-
-Example:
-
-```javascript
-const Network = {
-  graph: Graph,
-  capsules: CapsuleList,
-};
-```
-
-## API
-
-The exact particularities of this API are beyond the scope of this readme. Instead, this document opts to
-provide a general description of the methods of this API and their purpose.
-
-### Isolator.isolateComponents
-
-This method receives a list of components, create capsule for the components and write the components data into the capsule.
-It returns a list of capsules.

package/isolator.main.runtime.ts

@@ -1,520 +0,0 @@
-import { MainRuntime } from '@teambit/cli';
-import { compact, pick } from 'lodash';
-import { Component, ComponentMap, ComponentAspect, ComponentID } from '@teambit/component';
-import type { ComponentMain, ComponentFactory } from '@teambit/component';
-import { getComponentPackageVersion } from '@teambit/component-package-version';
-import { GraphAspect } from '@teambit/graph';
-import type { GraphBuilder } from '@teambit/graph';
-import {
-  DependencyResolverAspect,
-  DependencyResolverMain,
-  LinkingOptions,
-  WorkspacePolicy,
-  InstallOptions,
-  DependencyList,
-  ComponentDependency,
-  KEY_NAME_BY_LIFECYCLE_TYPE,
-} from '@teambit/dependency-resolver';
-import legacyLogger from '@teambit/legacy/dist/logger/logger';
-import { Logger, LoggerAspect, LoggerMain } from '@teambit/logger';
-import { BitIds } from '@teambit/legacy/dist/bit-id';
-import LegacyScope from '@teambit/legacy/dist/scope/scope';
-import GlobalConfigAspect, { GlobalConfigMain } from '@teambit/global-config';
-import {
-  CACHE_ROOT,
-  DEPENDENCIES_FIELDS,
-  PACKAGE_JSON,
-  CFG_CAPSULES_ROOT_BASE_DIR,
-} from '@teambit/legacy/dist/constants';
-import ConsumerComponent from '@teambit/legacy/dist/consumer/component';
-import PackageJsonFile from '@teambit/legacy/dist/consumer/component/package-json-file';
-import { importMultipleDistsArtifacts } from '@teambit/legacy/dist/consumer/component/sources/artifact-files';
-import { PathOsBasedAbsolute } from '@teambit/legacy/dist/utils/path';
-import { Scope } from '@teambit/legacy/dist/scope';
-import fs from 'fs-extra';
-import hash from 'object-hash';
-import path from 'path';
-import equals from 'ramda/src/equals';
-import BitMap from '@teambit/legacy/dist/consumer/bit-map';
-import ComponentWriter, { ComponentWriterProps } from '@teambit/legacy/dist/consumer/component-ops/component-writer';
-import { Capsule } from './capsule';
-import CapsuleList from './capsule-list';
-import { IsolatorAspect } from './isolator.aspect';
-import { symlinkBitLegacyToCapsules } from './symlink-bit-legacy-to-capsules';
-import { symlinkOnCapsuleRoot, symlinkDependenciesToCapsules } from './symlink-dependencies-to-capsules';
-import { Network } from './network';
-
-const DEFAULT_CAPSULES_BASE_DIR = path.join(CACHE_ROOT, 'capsules'); // TODO: move elsewhere
-
-export type ListResults = {
-  workspace: string;
-  capsules: string[];
-};
-
-export type IsolateComponentsInstallOptions = {
-  installPackages?: boolean; // default: true
-  // TODO: add back when depResolver.getInstaller support it
-  // packageManager?: string;
-  dedupe?: boolean;
-  copyPeerToRuntimeOnComponents?: boolean;
-  copyPeerToRuntimeOnRoot?: boolean;
-  installTeambitBit?: boolean;
-};
-
-type CreateGraphOptions = {
-  /**
-   * include components that exists in nested hosts. for example include components that exist in scope but not in the workspace
-   */
-  includeFromNestedHosts?: boolean;
-
-  /**
-   * Force specific host to get the component from.
-   */
-  host?: ComponentFactory;
-};
-
-export type IsolateComponentsOptions = CreateGraphOptions & {
-  name?: string;
-  /**
-   * absolute path to put all the capsules dirs inside.
-   */
-  rootBaseDir?: string;
-
-  /**
-   * the capsule root-dir based on a *hash* of this baseDir, not on the baseDir itself.
-   * A folder with this hash as its name will be created in the rootBaseDir
-   * By default this value will be the host path
-   */
-  baseDir?: string;
-
-  /**
-   * create a new capsule with a random string attached to the path suffix
-   */
-  alwaysNew?: boolean;
-
-  /**
-   * installation options
-   */
-  installOptions?: IsolateComponentsInstallOptions;
-
-  linkingOptions?: LinkingOptions;
-
-  /**
-   * delete the capsule rootDir first. it makes sure that the isolation process starts fresh with
-   * no previous capsules. for build and tag this is true.
-   */
-  emptyRootDir?: boolean;
-
-  /**
-   * skip the reproduction of the capsule in case it exists.
-   */
-  skipIfExists?: boolean;
-
-  /**
-   * get existing capsule without doing any changes, no writes, no installations.
-   */
-  getExistingAsIs?: boolean;
-
-  /**
-   * place the package-manager cache on the capsule-root
-   */
-  cachePackagesOnCapsulesRoot?: boolean;
-
-  /**
-   * do not build graph with all dependencies. isolate the seeders only.
-   */
-  seedersOnly?: boolean;
-
-  /**
-   * Force specific host to get the component from.
-   */
-  host?: ComponentFactory;
-};
-
-type CapsulePackageJsonData = {
-  capsule: Capsule;
-  currentPackageJson?: Record<string, any>;
-  previousPackageJson: Record<string, any> | null;
-};
-
-const DEFAULT_ISOLATE_INSTALL_OPTIONS: IsolateComponentsInstallOptions = {
-  installPackages: true,
-  dedupe: true,
-  copyPeerToRuntimeOnComponents: false,
-  copyPeerToRuntimeOnRoot: true,
-};
-
-export class IsolatorMain {
-  static runtime = MainRuntime;
-  static dependencies = [DependencyResolverAspect, LoggerAspect, ComponentAspect, GraphAspect, GlobalConfigAspect];
-  static defaultConfig = {};
-  _componentsPackagesVersionCache: { [idStr: string]: string } = {}; // cache packages versions of components
-
-  static async provider([dependencyResolver, loggerExtension, componentAspect, graphAspect, globalConfig]: [
-    DependencyResolverMain,
-    LoggerMain,
-    ComponentMain,
-    GraphBuilder,
-    GlobalConfigMain
-  ]): Promise<IsolatorMain> {
-    const logger = loggerExtension.createLogger(IsolatorAspect.id);
-    const isolator = new IsolatorMain(dependencyResolver, logger, componentAspect, graphAspect, globalConfig);
-    return isolator;
-  }
-  constructor(
-    private dependencyResolver: DependencyResolverMain,
-    private logger: Logger,
-    private componentAspect: ComponentMain,
-    private graphBuilder: GraphBuilder,
-    private globalConfig: GlobalConfigMain
-  ) {}
-
-  // TODO: the legacy scope used for the component writer, which then decide if it need to write the artifacts and dists
-  // TODO: we should think of another way to provide it (maybe a new opts) then take the scope internally from the host
-  async isolateComponents(
-    seeders: ComponentID[],
-    opts: IsolateComponentsOptions = {},
-    legacyScope?: LegacyScope
-  ): Promise<Network> {
-    const host = this.componentAspect.getHost();
-    const longProcessLogger = this.logger.createLongProcessLogger('create capsules network');
-    legacyLogger.debug(
-      `isolatorExt, createNetwork ${seeders.join(', ')}. opts: ${JSON.stringify(
-        Object.assign({}, opts, { host: opts.host?.name })
-      )}`
-    );
-    const createGraphOpts = pick(opts, ['includeFromNestedHosts', 'host']);
-    const componentsToIsolate = opts.seedersOnly
-      ? await host.getMany(seeders)
-      : await this.createGraph(seeders, createGraphOpts);
-    opts.baseDir = opts.baseDir || host.path;
-    const capsuleList = await this.createCapsules(componentsToIsolate, opts, legacyScope);
-    longProcessLogger.end();
-    this.logger.consoleSuccess();
-    return new Network(capsuleList, seeders, this.getCapsulesRootDir(opts.baseDir, opts.rootBaseDir));
-  }
-
-  private async createGraph(seeders: ComponentID[], opts: CreateGraphOptions = {}): Promise<Component[]> {
-    const host = this.componentAspect.getHost();
-    const getGraphOpts = pick(opts, ['host']);
-    const graph = await this.graphBuilder.getGraph(seeders, getGraphOpts);
-    const successorsSubgraph = graph.successorsSubgraph(seeders.map((id) => id.toString()));
-    const compsAndDeps = successorsSubgraph.nodes.map((node) => node.attr);
-    // do not ignore the version here. a component might be in .bitmap with one version and
-    // installed as a package with another version. we don't want them both.
-    const existingCompsP = compsAndDeps.map(async (c) => {
-      let existing;
-      if (opts.includeFromNestedHosts) {
-        existing = await host.hasIdNested(c.id, true);
-      } else {
-        existing = await host.hasId(c.id);
-      }
-      if (existing) return c;
-      return undefined;
-    });
-    const existingComps = await Promise.all(existingCompsP);
-    return compact(existingComps);
-  }
-
-  /**
-   * Create capsules for the provided components
-   * do not use this outside directly, use isolate components which build the entire network
-   * @param components
-   * @param opts
-   * @param legacyScope
-   */
-  private async createCapsules(
-    components: Component[],
-    opts: IsolateComponentsOptions,
-    legacyScope?: Scope
-  ): Promise<CapsuleList> {
-    const config = { installPackages: true, ...opts };
-    const capsulesDir = this.getCapsulesRootDir(opts.baseDir as string, opts.rootBaseDir);
-    if (opts.emptyRootDir) {
-      await fs.emptyDir(capsulesDir);
-    }
-    const capsules = await this.createCapsulesFromComponents(components, capsulesDir, config);
-    const capsuleList = CapsuleList.fromArray(capsules);
-    if (opts.getExistingAsIs) {
-      return capsuleList;
-    }
-
-    if (opts.skipIfExists) {
-      const existingCapsules = CapsuleList.fromArray(
-        capsuleList.filter((capsule) => capsule.fs.existsSync('package.json'))
-      );
-
-      if (existingCapsules.length === capsuleList.length) return existingCapsules;
-    }
-    const capsulesWithPackagesData = await this.getCapsulesPreviousPackageJson(capsules);
-
-    await this.writeComponentsInCapsules(components, capsuleList, legacyScope);
-    await this.updateWithCurrentPackageJsonData(capsulesWithPackagesData, capsuleList);
-    const installOptions = Object.assign({}, DEFAULT_ISOLATE_INSTALL_OPTIONS, opts.installOptions || {});
-    if (installOptions.installPackages) {
-      await this.installInCapsules(capsulesDir, capsuleList, installOptions, opts.cachePackagesOnCapsulesRoot ?? false);
-      await this.linkInCapsules(capsulesDir, capsuleList, capsulesWithPackagesData, opts.linkingOptions ?? {});
-    }
-
-    // rewrite the package-json with the component dependencies in it. the original package.json
-    // that was written before, didn't have these dependencies in order for the package-manager to
-    // be able to install them without crushing when the versions don't exist yet
-    capsulesWithPackagesData.forEach((capsuleWithPackageData) => {
-      capsuleWithPackageData.capsule.fs.writeFileSync(
-        PACKAGE_JSON,
-        JSON.stringify(capsuleWithPackageData.currentPackageJson, null, 2)
-      );
-    });
-
-    return capsuleList;
-  }
-
-  private async installInCapsules(
-    capsulesDir: string,
-    capsuleList: CapsuleList,
-    isolateInstallOptions: IsolateComponentsInstallOptions,
-    cachePackagesOnCapsulesRoot: boolean
-  ) {
-    const installer = this.dependencyResolver.getInstaller({
-      rootDir: capsulesDir,
-      cacheRootDirectory: cachePackagesOnCapsulesRoot ? capsulesDir : undefined,
-    });
-    // When using isolator we don't want to use the policy defined in the workspace directly,
-    // we only want to instal deps from components and the peer from the workspace
-
-    const peerOnlyPolicy = this.getPeersOnlyPolicy();
-    const installOptions: InstallOptions = {
-      installTeambitBit: !!isolateInstallOptions.installTeambitBit,
-    };
-    const packageManagerInstallOptions = {
-      dedupe: isolateInstallOptions.dedupe,
-      copyPeerToRuntimeOnComponents: isolateInstallOptions.copyPeerToRuntimeOnComponents,
-      copyPeerToRuntimeOnRoot: isolateInstallOptions.copyPeerToRuntimeOnRoot,
-    };
-    await installer.install(
-      capsulesDir,
-      peerOnlyPolicy,
-      this.toComponentMap(capsuleList),
-      installOptions,
-      packageManagerInstallOptions
-    );
-  }
-
-  private async linkInCapsules(
-    capsulesDir: string,
-    capsuleList: CapsuleList,
-    capsulesWithPackagesData: CapsulePackageJsonData[],
-    linkingOptions: LinkingOptions
-  ) {
-    const linker = this.dependencyResolver.getLinker({
-      rootDir: capsulesDir,
-      linkingOptions,
-    });
-    const peerOnlyPolicy = this.getPeersOnlyPolicy();
-    const capsulesWithModifiedPackageJson = this.getCapsulesWithModifiedPackageJson(capsulesWithPackagesData);
-    await linker.link(capsulesDir, peerOnlyPolicy, this.toComponentMap(capsuleList), {
-      ...linkingOptions,
-      legacyLink: false,
-    });
-    await symlinkOnCapsuleRoot(capsuleList, this.logger, capsulesDir);
-    await symlinkDependenciesToCapsules(capsulesWithModifiedPackageJson, capsuleList, this.logger);
-    // TODO: this is a hack to have access to the bit bin project in order to access core extensions from user extension
-    // TODO: remove this after exporting core extensions as components
-    await symlinkBitLegacyToCapsules(capsulesWithModifiedPackageJson, this.logger);
-    // await copyBitLegacyToCapsuleRoot(capsulesDir, this.logger);
-  }
-
-  private getCapsulesWithModifiedPackageJson(capsulesWithPackagesData: CapsulePackageJsonData[]) {
-    const capsulesWithModifiedPackageJson: Capsule[] = capsulesWithPackagesData
-      .filter((capsuleWithPackageData) => {
-        const packageJsonHasChanged = this.wereDependenciesInPackageJsonChanged(capsuleWithPackageData);
-        // @todo: when a component is tagged, it changes all package-json of its dependents, but it
-        // should not trigger any "npm install" because they dependencies are symlinked by us
-        return packageJsonHasChanged;
-      })
-      .map((capsuleWithPackageData) => capsuleWithPackageData.capsule);
-    return capsulesWithModifiedPackageJson;
-  }
-
-  private async writeComponentsInCapsules(components: Component[], capsuleList: CapsuleList, legacyScope?: Scope) {
-    const legacyComponents = components.map((component) => component.state._consumer.clone());
-    if (legacyScope) await importMultipleDistsArtifacts(legacyScope, legacyComponents);
-    const allIds = BitIds.fromArray(legacyComponents.map((c) => c.id));
-    await Promise.all(
-      components.map(async (component) => {
-        const capsule = capsuleList.getCapsule(component.id);
-        if (!capsule) return;
-        const params = this.getComponentWriteParams(component.state._consumer, allIds, legacyScope);
-        const componentWriter = new ComponentWriter(params);
-        await componentWriter.populateComponentsFilesToWrite();
-        await component.state._consumer.dataToPersist.persistAllToCapsule(capsule, { keepExistingCapsule: true });
-      })
-    );
-  }
-
-  private getPeersOnlyPolicy(): WorkspacePolicy {
-    const workspacePolicy = this.dependencyResolver.getWorkspacePolicy();
-    const peerOnlyPolicy = workspacePolicy.byLifecycleType('peer');
-    return peerOnlyPolicy;
-  }
-
-  private getComponentWriteParams(
-    component: ConsumerComponent,
-    ids: BitIds,
-    legacyScope?: Scope
-  ): ComponentWriterProps {
-    return {
-      component,
-      // @ts-ignore
-      bitMap: new BitMap(undefined, undefined, undefined, false),
-      writeToPath: '.',
-      origin: 'IMPORTED',
-      consumer: undefined,
-      scope: legacyScope,
-      override: false,
-      writePackageJson: true,
-      writeConfig: false,
-      ignoreBitDependencies: ids,
-      excludeRegistryPrefix: false,
-      isolated: true,
-    };
-  }
-
-  private toComponentMap(capsuleList: CapsuleList): ComponentMap<string> {
-    const tuples: [Component, string][] = capsuleList.map((capsule) => {
-      return [capsule.component, capsule.path];
-    });
-
-    return ComponentMap.create(tuples);
-  }
-
-  async list(workspacePath: string): Promise<ListResults> {
-    try {
-      const workspaceCapsuleFolder = this.getCapsulesRootDir(workspacePath);
-      const capsules = await fs.readdir(workspaceCapsuleFolder);
-      const capsuleFullPaths = capsules.map((c) => path.join(workspaceCapsuleFolder, c));
-      return {
-        workspace: workspacePath,
-        capsules: capsuleFullPaths,
-      };
-    } catch (e: any) {
-      if (e.code === 'ENOENT') {
-        return { workspace: workspacePath, capsules: [] };
-      }
-      throw e;
-    }
-  }
-
-  getCapsulesRootDir(baseDir: string, rootBaseDir?: string): PathOsBasedAbsolute {
-    const capsulesRootBaseDir =
-      rootBaseDir || this.globalConfig.getSync(CFG_CAPSULES_ROOT_BASE_DIR) || DEFAULT_CAPSULES_BASE_DIR;
-    return path.join(capsulesRootBaseDir, hash(baseDir));
-  }
-
-  private async createCapsulesFromComponents(
-    components: Component[],
-    baseDir: string,
-    opts: IsolateComponentsOptions
-  ): Promise<Capsule[]> {
-    const capsules: Capsule[] = await Promise.all(
-      components.map((component: Component) => {
-        return Capsule.createFromComponent(component, baseDir, opts);
-      })
-    );
-    return capsules;
-  }
-
-  private wereDependenciesInPackageJsonChanged(capsuleWithPackageData: CapsulePackageJsonData): boolean {
-    const { previousPackageJson, currentPackageJson } = capsuleWithPackageData;
-    if (!previousPackageJson) return true;
-    // @ts-ignore at this point, currentPackageJson is set
-    return DEPENDENCIES_FIELDS.some((field) => !equals(previousPackageJson[field], currentPackageJson[field]));
-  }
-
-  private async getCapsulesPreviousPackageJson(capsules: Capsule[]): Promise<CapsulePackageJsonData[]> {
-    return Promise.all(
-      capsules.map(async (capsule) => {
-        const packageJsonPath = path.join(capsule.path, 'package.json');
-        let previousPackageJson: any = null;
-        try {
-          const previousPackageJsonRaw = await capsule.fs.promises.readFile(packageJsonPath, { encoding: 'utf8' });
-          previousPackageJson = JSON.parse(previousPackageJsonRaw);
-        } catch (e: any) {
-          // package-json doesn't exist in the capsule, that's fine, it'll be considered as a cache miss
-        }
-        return {
-          capsule,
-          previousPackageJson,
-        };
-      })
-    );
-  }
-
-  private async updateWithCurrentPackageJsonData(
-    capsulesWithPackagesData: CapsulePackageJsonData[],
-    capsules: CapsuleList
-  ) {
-    const updateP = capsules.map(async (capsule) => {
-      const packageJson = await this.getCurrentPackageJson(capsule, capsules);
-      const found = capsulesWithPackagesData.find((c) => c.capsule.component.id.isEqual(capsule.component.id));
-      if (!found) throw new Error(`updateWithCurrentPackageJsonData unable to find ${capsule.component.id}`);
-      found.currentPackageJson = packageJson.packageJsonObject;
-    });
-    return Promise.all(updateP);
-  }
-
-  private async getCurrentPackageJson(capsule: Capsule, capsules: CapsuleList): Promise<PackageJsonFile> {
-    const component: Component = capsule.component;
-    const currentVersion = await this.getComponentPackageVersionWithCache(component);
-    // const newVersion = '0.0.1-new';
-    const getComponentDepsManifest = async (dependencies: DependencyList) => {
-      const manifest = {
-        dependencies: {},
-        devDependencies: {},
-      };
-      const compDeps = dependencies.toTypeArray<ComponentDependency>('component');
-      const promises = compDeps.map(async (dep) => {
-        const depCapsule = capsules.getCapsule(dep.componentId);
-        let version = dep.version;
-        if (depCapsule) {
-          version = await this.getComponentPackageVersionWithCache(depCapsule?.component);
-        }
-        const keyName = KEY_NAME_BY_LIFECYCLE_TYPE[dep.lifecycle];
-        const entry = dep.toManifest();
-        if (entry) {
-          manifest[keyName][entry.packageName] = version;
-        }
-      });
-      await Promise.all(promises);
-      return manifest;
-    };
-    const deps = await this.dependencyResolver.getDependencies(component);
-    const manifest = await getComponentDepsManifest(deps);
-
-    // unfortunately, component.packageJsonFile is not available here.
-    // the reason is that `writeComponentsToCapsules` clones the component before writing them
-    // also, don't use `PackageJsonFile.createFromComponent`, as it looses the intermediate changes
-    // such as postInstall scripts for custom-module-resolution.
-    const packageJson = PackageJsonFile.loadFromCapsuleSync(capsule.path);
-
-    const addDependencies = (packageJsonFile: PackageJsonFile) => {
-      packageJsonFile.addDependencies(manifest.dependencies);
-      packageJsonFile.addDevDependencies(manifest.devDependencies);
-    };
-    addDependencies(packageJson);
-    packageJson.addOrUpdateProperty('version', currentVersion);
-    return packageJson;
-  }
-
-  private async getComponentPackageVersionWithCache(component: Component): Promise<string> {
-    const idStr = component.id.toString();
-    if (this._componentsPackagesVersionCache[idStr]) {
-      return this._componentsPackagesVersionCache[idStr];
-    }
-    const version = await getComponentPackageVersion(component);
-    this._componentsPackagesVersionCache[idStr] = version;
-    return version;
-  }
-}
-
-IsolatorAspect.addRuntime(IsolatorMain);

package/network.ts

@@ -1,35 +0,0 @@
-import { ComponentID } from '@teambit/component';
-import { PathOsBasedAbsolute } from '@teambit/legacy/dist/utils/path';
-import CapsuleList from './capsule-list';
-
-export class Network {
-  constructor(
-    private _graphCapsules: CapsuleList,
-    private seedersIds: ComponentID[],
-    private _capsulesRootDir: string
-  ) {}
-
-  /**
-   * seeders capsules only without the entire graph. normally, this includes the capsules of one
-   * env.
-   */
-  get seedersCapsules(): CapsuleList {
-    const capsules = this.seedersIds.map((seederId) => {
-      const capsule = this.graphCapsules.getCapsule(seederId);
-      if (!capsule) throw new Error(`unable to find ${seederId.toString()} in the capsule list`);
-      return capsule;
-    });
-    return CapsuleList.fromArray(capsules);
-  }
-
-  /**
-   * all capsules, including the dependencies of the seeders. (even when they belong to another env)
-   */
-  get graphCapsules(): CapsuleList {
-    return this._graphCapsules;
-  }
-
-  get capsulesRootDir(): PathOsBasedAbsolute {
-    return this._capsulesRootDir;
-  }
-}

package/symlink-bit-legacy-to-capsules.ts

@@ -1,53 +0,0 @@
-import { Logger } from '@teambit/logger';
-import createSymlinkOrCopy from '@teambit/legacy/dist/utils/fs/create-symlink-or-copy';
-import fs from 'fs-extra';
-import path from 'path';
-
-import { Capsule } from './capsule';
-
-export async function symlinkBitLegacyToCapsules(capsules: Capsule[], logger: Logger) {
-  logger.debug(`symlink bit bin to capsules, ${capsules.length} capsules`);
-  const linksP = capsules.map(async (capsule) => linkBitLegacyInCapsule(capsule));
-  return Promise.all(linksP);
-}
-
-export async function copyBitLegacyToCapsuleRoot(root: string, logger: Logger) {
-  logger.debug(`symlink @teambit/legacy package to capsule root`);
-  const localBitLegacyPath = path.join(__dirname, '@teambit/legacy/dist/..');
-  const targetPath = path.join(root, './node_modules/@teambit/legacy');
-  await fs.copy(localBitLegacyPath, targetPath);
-}
-
-async function linkBitLegacyInCapsule(capsule: Capsule) {
-  const bitLegacyPath = path.join(capsule.wrkDir, './node_modules/@teambit/legacy');
-  const getLocalBitLegacyPath = () => {
-    const pathOutsideNodeModules = path.join(__dirname, '@teambit/legacy/dist/..');
-    const dirInIsolator = path.normalize('node_modules/@teambit/isolator/dist/@teambit/legacy');
-    if (pathOutsideNodeModules.includes(dirInIsolator)) {
-      return pathOutsideNodeModules.replace(dirInIsolator, '');
-    }
-    return pathOutsideNodeModules;
-    // if (pathOutsideNodeModules.endsWith(`${path.sep}dist`)) {
-    //   return pathOutsideNodeModules;
-    // }
-    // if (__dirname.includes('build-harmony')) {
-    //   // for @teambit/legacy development, the cli extension is installed as a package in build-harmony directory
-    //   return path.join(__dirname.split('build-harmony')[0], 'dist');
-    // }
-    // throw new Error('unable to link @teambit/legacy to the capsule, the location of @teambit/legacy is unknown');
-  };
-  const localBitLegacyPath = getLocalBitLegacyPath();
-  // if there are no deps, sometimes the node_modules folder is not created
-  // and we need it in order to perform the linking
-  try {
-    capsule.fs.mkdirSync('node_modules');
-  } catch (e: any) {
-    // fail silently - we only need to create it if it doesn't already exist
-  }
-
-  // we use fs directly here rather than the capsule.fs because there are some edge cases
-  // that the capsule fs does not deal with well (eg. identifying and deleting
-  // a symlink rather than the what the symlink links to)
-  await fs.remove(bitLegacyPath);
-  createSymlinkOrCopy(localBitLegacyPath, bitLegacyPath);
-}

package/symlink-dependencies-to-capsules.ts

@@ -1,58 +0,0 @@
-import { ComponentID } from '@teambit/component';
-import { Logger } from '@teambit/logger';
-import { BitId } from '@teambit/legacy-bit-id';
-import ConsumerComponent from '@teambit/legacy/dist/consumer/component';
-import Symlink from '@teambit/legacy/dist/links/symlink';
-import componentIdToPackageName from '@teambit/legacy/dist/utils/bit/component-id-to-package-name';
-import path from 'path';
-
-import { Capsule } from './capsule';
-import CapsuleList from './capsule-list';
-
-export async function symlinkDependenciesToCapsules(capsules: Capsule[], capsuleList: CapsuleList, logger: Logger) {
-  logger.debug(`symlinkDependenciesToCapsules, ${capsules.length} capsules`);
-  await Promise.all(
-    capsules.map((capsule) => {
-      return symlinkComponent(capsule.component.state._consumer, capsuleList, logger);
-    })
-  );
-}
-
-export async function symlinkOnCapsuleRoot(capsuleList: CapsuleList, logger: Logger, capsuleRoot: string) {
-  const modulesPath = path.join(capsuleRoot, 'node_modules');
-  const symlinks = capsuleList.map((capsule) => {
-    const packageName = componentIdToPackageName(capsule.component.state._consumer);
-    const dest = path.join(modulesPath, packageName);
-    const src = path.relative(path.resolve(dest, '..'), capsule.path);
-
-    return new Symlink(src, dest, capsule.component.id._legacy);
-  });
-
-  await Promise.all(symlinks.map((symlink) => symlink.write()));
-}
-
-async function symlinkComponent(component: ConsumerComponent, capsuleList: CapsuleList, logger: Logger) {
-  const componentCapsule = capsuleList.getCapsuleIgnoreScopeAndVersion(new ComponentID(component.id));
-  if (!componentCapsule) throw new Error(`unable to find the capsule for ${component.id.toString()}`);
-  const allDeps = component.getAllDependenciesIds();
-  const symlinks = allDeps.map((depId: BitId) => {
-    // TODO: this is dangerous - we might have 2 capsules for the same component with different version, then we might link to the wrong place
-    const devCapsule = capsuleList.getCapsuleIgnoreScopeAndVersion(new ComponentID(depId));
-    if (!devCapsule) {
-      // happens when a dependency is not in the workspace. (it gets installed via the package manager)
-      logger.debug(
-        `symlinkComponentToCapsule: unable to find the capsule for ${depId.toStringWithoutVersion()}. skipping`
-      );
-      return null;
-    }
-    const packageName = componentIdToPackageName(devCapsule.component.state._consumer);
-    const devCapsulePath = devCapsule.path;
-    // @todo: this is a hack, the capsule should be the one responsible to symlink, this works only for FS capsules.
-    const dest = path.join(componentCapsule.path, 'node_modules', packageName);
-    // use relative symlink in capsules to make it really isolated from the machine fs
-    const src = path.relative(path.resolve(dest, '..'), devCapsulePath);
-    return new Symlink(src, dest, component.id);
-  });
-
-  await Promise.all(symlinks.map((symlink) => symlink && symlink.write()));
-}

package/tsconfig.json

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

package/types/asset.d.ts

@@ -1,29 +0,0 @@
-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

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