@teambit/isolator 1.0.228 → 1.0.229

package/dist/capsule/capsule.d.ts

@@ -0,0 +1,75 @@
+import { NodeFS } from '@teambit/any-fs';
+import { Capsule as CapsuleTemplate, Console, Exec, State } from '@teambit/capsule';
+import { Component } from '@teambit/component';
+import FsContainer, { BitExecOption } from './container';
+import ContainerExec from './container-exec';
+export default class Capsule extends CapsuleTemplate<Exec, NodeFS> {
+    /**
+     * 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;
+    /**
+     * capsule's state.
+     */
+    readonly state: State;
+    readonly component: Component;
+    private _wrkDir;
+    constructor(
+    /**
+     * container implementation the capsule is being executed within.
+     */
+    container: FsContainer, 
+    /**
+     * the capsule's file system.
+     */
+    fs: NodeFS, 
+    /**
+     * console for controlling process streams as stdout, stdin and stderr.
+     */
+    console: Console, 
+    /**
+     * capsule's state.
+     */
+    state: State, component: Component);
+    /**
+     * @deprecated please use `this.path`
+     */
+    get wrkDir(): string;
+    get path(): string;
+    start(): Promise<any>;
+    execNode(executable: string, args: any, exec: ContainerExec): Promise<ContainerExec>;
+    typedExec(opts: BitExecOption, exec?: ContainerExec): Promise<ContainerExec>;
+    outputFile(file: string, data: any, options?: any): Promise<any>;
+    removePath(dir: string): Promise<any>;
+    symlink(src: string, dest: string): Promise<any>;
+    execute(cmd: string, options?: Record<string, any> | null | undefined): Promise<unknown>;
+    /**
+     * @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?: string, options?: {
+        ignore?: string[];
+    }): any;
+    static getCapsuleDirName(component: Component, config?: {
+        alwaysNew?: boolean;
+        name?: string;
+    }): string;
+    static getCapsuleRootDir(component: Component, baseDir: string, config?: {
+        alwaysNew?: boolean;
+        name?: string;
+    }): string;
+    static createFromComponent(component: Component, baseDir: string, config?: {
+        alwaysNew?: boolean;
+    }): Promise<Capsule>;
+}

package/dist/capsule/container-exec.d.ts

@@ -0,0 +1,14 @@
+/// <reference types="node" />
+import { DuplexBufferStream, Exec, ExecStatus } from '@teambit/capsule';
+import { EventEmitter } from 'events';
+export default class ContainerExec extends EventEmitter implements Exec {
+    private _code;
+    constructor(_code?: number);
+    stdout: DuplexBufferStream;
+    stderr: DuplexBufferStream;
+    stdin: DuplexBufferStream;
+    setStatus(status: number): void;
+    get code(): number;
+    inspect(): Promise<ExecStatus>;
+    abort(): Promise<void>;
+}

package/dist/capsule/container.d.ts

@@ -0,0 +1,35 @@
+/// <reference types="node" />
+import { AnyFS, NodeFS } from '@teambit/any-fs';
+import { Container, ContainerFactoryOptions, ContainerStatus, Exec, ExecOptions } from '@teambit/capsule';
+import execa from 'execa';
+import { Stream } from 'stream';
+import ContainerExec from './container-exec';
+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> {
+    readonly wrkDir: string;
+    id: string;
+    fs: NodeFS;
+    constructor(wrkDir: string);
+    getPath(): string;
+    private composePath;
+    outputFile(file: any, data: any, options: any): Promise<void>;
+    removePath(dir: string): Promise<any>;
+    symlink(src: string, dest: string): Promise<any>;
+    exec(execOptions: BitExecOption, exec?: ContainerExec): Promise<ContainerExec>;
+    execP(execOptions: BitExecOption): Promise<string>;
+    terminal(): Promise<execa.ExecaReturnValue<string>>;
+    start(): Promise<void>;
+    inspect(): Promise<ContainerStatus>;
+    pause(): Promise<void>;
+    resume(): Promise<void>;
+    stop(ttl?: number | undefined): Promise<void>;
+    destroy(): Promise<void>;
+    log(): Promise<Exec>;
+    on(event: string, fn: (data: any) => void): void;
+}

package/dist/capsule/index.d.ts

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

package/dist/capsule-list.d.ts

@@ -0,0 +1,21 @@
+import type { Component } from '@teambit/component';
+import { DependencyResolverMain } from '@teambit/dependency-resolver';
+import { Graph } from '@teambit/graph.cleargraph';
+import { ComponentID } from '@teambit/component-id';
+import { Capsule } from './capsule';
+export default class CapsuleList extends Array<Capsule> {
+    getCapsule(id: ComponentID): Capsule | undefined;
+    getCapsuleByLegacyId(id: ComponentID): Capsule | undefined;
+    getCapsuleIgnoreVersion(id: ComponentID): Capsule | undefined;
+    getAllCapsuleDirs(): string[];
+    getIdByPathInCapsule(pathInCapsule: string): ComponentID | null;
+    getAllComponents(): Component[];
+    getGraphIds(): Graph<Component, string>;
+    toposort(depResolver: DependencyResolverMain): Promise<CapsuleList>;
+    static fromArray(capsules: Capsule[]): CapsuleList;
+    /**
+     * determines whether or not a capsule can theoretically use the dists saved in the last snap, rather than re-compile them.
+     * practically, this optimization is used for components that have typescript as their compiler.
+     */
+    static capsuleUsePreviouslySavedDists(component: Component): Promise<boolean>;
+}

package/dist/index.d.ts

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

package/dist/isolator.aspect.d.ts

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

package/dist/isolator.composition.d.ts

@@ -0,0 +1 @@
+export declare const Logo: () => import("react/jsx-runtime").JSX.Element;

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

@@ -0,0 +1,264 @@
+import { CLIMain } from '@teambit/cli';
+import { AspectLoaderMain } from '@teambit/aspect-loader';
+import { Component } from '@teambit/component';
+import type { ComponentMain, ComponentFactory } from '@teambit/component';
+import { GraphMain } from '@teambit/graph';
+import { SlotRegistry } from '@teambit/harmony';
+import { DependencyResolverMain, LinkingOptions, NodeLinker } from '@teambit/dependency-resolver';
+import { Logger, LoggerMain } from '@teambit/logger';
+import { ComponentID, ComponentIdList } from '@teambit/component-id';
+import LegacyScope from '@teambit/legacy/dist/scope/scope';
+import { GlobalConfigMain } from '@teambit/global-config';
+import { PathOsBasedAbsolute } from '@teambit/legacy/dist/utils/path';
+import { Scope } from '@teambit/legacy/dist/scope';
+import DataToPersist from '@teambit/legacy/dist/consumer/component/sources/data-to-persist';
+import { Capsule } from './capsule';
+import { Network } from './network';
+export type ListResults = {
+    capsules: string[];
+};
+export type CapsuleTransferFn = (sourceDir: string, targetDir: string) => Promise<void>;
+export type CapsuleTransferSlot = SlotRegistry<CapsuleTransferFn>;
+/**
+ * Context for the isolation process
+ */
+export type IsolationContext = {
+    /**
+     * Whether the isolation done for aspects (as opposed to regular components)
+     */
+    aspects?: boolean;
+    /**
+     * Workspace name where the isolation starts from
+     */
+    workspaceName?: string;
+};
+export type IsolateComponentsInstallOptions = {
+    installPackages?: boolean;
+    dedupe?: boolean;
+    copyPeerToRuntimeOnComponents?: boolean;
+    copyPeerToRuntimeOnRoot?: boolean;
+    installPeersFromEnvs?: boolean;
+    installTeambitBit?: boolean;
+    packageManagerConfigRootDir?: string;
+    useNesting?: 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;
+    /**
+     * Whether to use hash function (of base dir) as capsules root dir name
+     */
+    useHash?: boolean;
+    /**
+     * create a new capsule with a random string attached to the path suffix
+     */
+    alwaysNew?: boolean;
+    /**
+     * If this is true -
+     * the isolator will check if there are missing capsules in the base dir
+     * if yes, it will create the capsule in a special dir inside a dir with the current date (without time)
+     * then inside that dir, it will create a dir with a random hash
+     * at the end of the process it will move missing capsules from the temp dir to the base dir so they can be used in
+     * the next iteration
+     */
+    useDatedDirs?: boolean;
+    /**
+     * If this is true -
+     * the isolator will do few things:
+     * 1. in the end of the process it will only move the lock file (pnpm-lock.yaml) into the capsule cache
+     * 2. in the beginning of the process it will check if there is a lock file in the capsule cache, if yes it will move
+     * it to the temp dated dir
+     * 3. it will write env's file into the dated dir (as it only contain the lock file)
+     * 4. it will run install in the dated dir (as there is no node_modules there yet)
+     */
+    cacheLockFileOnly?: boolean;
+    /**
+     * If set, along with useDatedDirs, then we will use the same hash dir for all capsules created with the same
+     * datedDirId
+     */
+    datedDirId?: string;
+    /**
+     * 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;
+    /**
+     * relevant for tagging from scope, where we tag an existing snap without any code-changes.
+     * the idea is to have all build artifacts from the previous snap and run deploy pipeline on top of it.
+     */
+    populateArtifactsFrom?: ComponentID[];
+    /**
+     * Force specific host to get the component from.
+     */
+    host?: ComponentFactory;
+    /**
+     * Use specific package manager for the isolation process (override the package manager from the dep resolver config)
+     */
+    packageManager?: string;
+    /**
+     * Use specific node linker for the isolation process (override the package manager from the dep resolver config)
+     */
+    nodeLinker?: NodeLinker;
+    /**
+     * Dir where to read the package manager config from
+     * usually used when running package manager in the capsules dir to use the config
+     * from the workspace dir
+     */
+    packageManagerConfigRootDir?: string;
+    context?: IsolationContext;
+    /**
+     * Root dir of capsulse cache (used mostly to copy lock file if used with cache lock file only option)
+     */
+    cacheCapsulesDir?: string;
+};
+type GetCapsuleDirOpts = Pick<IsolateComponentsOptions, 'datedDirId' | 'useHash' | 'rootBaseDir' | 'useDatedDirs' | 'cacheLockFileOnly'> & {
+    baseDir: string;
+};
+/**
+ * File name to indicate that the capsule is ready (all packages are installed and links are created)
+ */
+export declare const CAPSULE_READY_FILE = ".bit-capsule-ready";
+export declare class IsolatorMain {
+    private dependencyResolver;
+    private logger;
+    private componentAspect;
+    private graph;
+    private cli;
+    private globalConfig;
+    private aspectLoader;
+    private capsuleTransferSlot;
+    static runtime: import("@teambit/harmony").RuntimeDefinition;
+    static dependencies: import("@teambit/harmony").Aspect[];
+    static slots: ((registerFn: () => string) => SlotRegistry<CapsuleTransferFn>)[];
+    static defaultConfig: {};
+    _componentsPackagesVersionCache: {
+        [idStr: string]: string;
+    };
+    _datedHashForName: Map<string, string>;
+    _movedLockFiles: Set<unknown>;
+    static provider([dependencyResolver, loggerExtension, componentAspect, graphMain, globalConfig, aspectLoader, cli]: [
+        DependencyResolverMain,
+        LoggerMain,
+        ComponentMain,
+        GraphMain,
+        GlobalConfigMain,
+        AspectLoaderMain,
+        CLIMain
+    ], _config: any, [capsuleTransferSlot]: [CapsuleTransferSlot]): Promise<IsolatorMain>;
+    constructor(dependencyResolver: DependencyResolverMain, logger: Logger, componentAspect: ComponentMain, graph: GraphMain, cli: CLIMain, globalConfig: GlobalConfigMain, aspectLoader: AspectLoaderMain, capsuleTransferSlot: CapsuleTransferSlot);
+    isolateComponents(seeders: ComponentID[], opts: IsolateComponentsOptions, legacyScope?: LegacyScope): Promise<Network>;
+    private createGraph;
+    private registerMoveCapsuleOnProcessExit;
+    private getAllCapsulesDirsFromRoot;
+    private moveCapsulesLockFileToTargetDir;
+    private moveCapsulesToTargetDir;
+    /**
+     * The function moves a directory from a source location to a target location using a temporary directory.
+     * This is using temp dir because sometime the source dir and target dir might be in different FS
+     * (for example different mounts) which means the move might take a long time
+     * during the time of moving, another process will see that the capsule is not ready and will try to remove then
+     * move it again, which lead to the first process throwing an error
+     * @param sourceDir - The source directory from where the files or directories will be moved.
+     * @param targetDir - The target directory where the source directory will be moved to.
+     */
+    private moveWithTempName;
+    /**
+     * Re-create the core aspects links in the real capsule dir
+     * This is required mainly for the first time when that folder is empty
+     */
+    private relinkCoreAspectsInCapsuleDir;
+    private shouldUseDatedDirs;
+    /**
+     *
+     * @param originalCapsule the capsule that contains the original component
+     * @param newBaseDir relative path. (it will be saved inside `this.getRootDirOfAllCapsules()`. the final path of the capsule will be getRootDirOfAllCapsules() + newBaseDir + filenameify(component.id))
+     * @returns a new capsule with the same content of the original capsule but with a new baseDir and all packages
+     * installed in the newBaseDir.
+     */
+    cloneCapsule(originalCapsule: Capsule, newBaseDir: string): Promise<Capsule>;
+    /**
+     * 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 createCapsules;
+    private markCapsulesAsReady;
+    private markCapsuleAsReady;
+    private removeCapsuleReadyFileSync;
+    private writeCapsuleReadyFileSync;
+    private getCapsuleReadyFilePath;
+    private installInCapsules;
+    private linkInCapsules;
+    private linkInCapsulesRoot;
+    private toLocalLinks;
+    private linkDetailToLocalDepEntry;
+    private getCapsulesWithModifiedPackageJson;
+    private writeComponentsInCapsules;
+    private getWorkspacePeersOnlyPolicy;
+    private toComponentMap;
+    list(rootDir: string): Promise<ListResults>;
+    registerCapsuleTransferFn(fn: CapsuleTransferFn): void;
+    private getCapsuleTransferFn;
+    private getDefaultCapsuleTransferFn;
+    /** @deprecated use the new function signature with an object parameter instead */
+    getCapsulesRootDir(baseDir: string, rootBaseDir?: string, useHash?: boolean): PathOsBasedAbsolute;
+    getCapsulesRootDir(getCapsuleDirOpts: GetCapsuleDirOpts): PathOsBasedAbsolute;
+    deleteCapsules(rootDir?: string): Promise<string>;
+    private createCapsulesFromComponents;
+    private getRootDirOfAllCapsules;
+    private wereDependenciesInPackageJsonChanged;
+    private getCapsulesPreviousPackageJson;
+    private updateWithCurrentPackageJsonData;
+    private getCurrentPackageJson;
+    populateComponentsFilesToWriteForCapsule(component: Component, ids: ComponentIdList, legacyScope?: Scope, opts?: IsolateComponentsOptions): Promise<DataToPersist>;
+    private preparePackageJsonToWrite;
+    /**
+     * currently, it writes all artifacts.
+     * later, this responsibility might move to pkg extension, which could write only artifacts
+     * that are set in package.json.files[], to have a similar structure of a package.
+     */
+    private getArtifacts;
+}
+export {};

package/dist/network.d.ts

@@ -0,0 +1,122 @@
+import { ComponentID } from '@teambit/component';
+import { PathOsBasedAbsolute } from '@teambit/legacy/dist/utils/path';
+import CapsuleList from './capsule-list';
+/**
+ * collection of isolated components (capsules).
+ * normally, "seeders" are the components that this network was created for.
+ * "graphCapsules" is the graph created from the seeders and it includes also the dependencies.
+ *
+ * however, during "bit build"/"bit tag"/"bit snap", things are more complex because there is one more variable in the
+ * picture, which is the "env". the Network is created per env.
+ * in practice, for "build-task", a task is called per env, and the network passed to the task is relevant to that env.
+ * the "originalSeeders" are the ones the network was created for, but only for this env.
+ * the "seeders" are similar to the "graphCapsules" above, which contains also the dependencies, but only for this env.
+ * the "graphCapsules" is the entire graph, including capsules from other envs.
+ *
+ * for example:
+ * comp1 depends on comp2. comp1 env is "react". comp2 env is "aspect".
+ *
+ * when the user is running "bit build comp1", two `Network` instances will be created with the following:
+ * Network for "react" env:  originalSeeders: ['comp1'], seeders: ['comp1'], graphCapsules: ['comp1', 'comp2'].
+ * Network for "aspect" env: originalSeeders: [], seeders: ['comp2'], graphCapsules: ['comp2'].
+ *
+ * on the other hand, when the user is running "bit capsule create comp1", only one `Network` instance is created:
+ * Network: originalSeeders: ['comp1'], seeders: ['comp1'], graphCapsules: ['comp1', 'comp2'].
+ *
+ * (as a side note, another implementation was attempt to have the "seeders" as the original-seeders for build,
+ * however, it's failed. see https://github.com/teambit/bit/pull/5407 for more details).
+ *
+ *
+ * A more detailed explanation about the "seeders" vs "originalSeeders" vs "graphCapsules" is provided below:
+ * an example: comp1 -> comp2 -> comp3 (as in comp1 uses comp2, comp2 uses comp3).
+ * I changed only comp2.
+ * From comp2 perspective, comp1 is a “dependent”, comp3 is a “dependency”.
+ *
+ * When I run bit build with no args, it finds only one modified component: comp2, however, it doesn’t stop here. It also look for the dependents, in this case, comp1. So the seeders of this bit-build command are two: “comp1” and “comp2".
+ * The reason why the dependents are included is because you modified comp2, it’s possible you broke comp1. We want to build comp1 as well to make sure it’s still okay.
+ * (btw, bit test command also include dependents when it provided with no args).
+ *
+ * Keep in mind that also bit tag normally runs on the dependents as well (when it runs the build pipeline), because these are the “auto-tag”.
+ * With these two seeders it builds the graph. The graph calculates all the dependencies of the given seeders recursively. Eventually, it puts them in an instance of Network class.
+ * In our case, if all components use the same env, the Network consist of:
+ * seedersCapsules:          [comp1, comp2]
+ * originalSeedersCapsules:  [comp1, comp2]
+ * graphCapsules:            [comp1, comp2, comp3].
+ *
+ * It gets more complex when multiple envs involved.
+ * Imagine that comp1 uses env1, comp2 uses env2 and comp3 uses env3.
+ * Because bit build runs the tasks per env, it needs to create 3 networks. Each per env.
+ * The “seeders” refer to the seeders of the same env and includes only components from the same env.
+ * The “originalSeeders” refer to the ones that originally started the build command and are from the same env.
+ * Network1:
+ * seedersCapsules:          [comp1]
+ * originalSeedersCapsules:  [comp1]
+ * graphCapsules:            [comp1, comp2, comp3].
+ * Network2:
+ * seedersCapsules:          [comp2]
+ * originalSeedersCapsules:  [comp2]
+ * graphCapsules:            [comp2, comp3].
+ * Network3:
+ * seedersCapsules:          [comp3]
+ * originalSeedersCapsules:  []
+ * graphCapsules:            [comp3].
+ * As you can see, in network3, the originalSeeders is empty, because comp3 wasn’t part of the original seeders.
+ * These 3 networks are created for build-pipeline. This pipeline asks for all components in the graph and then create the network per env.
+ * Snap/Tag pipelines are different. They ask only for the components about to tag/snap, which are the original-seeders, and create the network per env. For them, we end up with 2 network instances only. network1 and network2. Also, the seedersCapsules and originalSeedersCapsules are the same because we create the network instances out of the seeders only, without the dependencies.
+ * A build-task provides context with a network instance to the execute() method. (it also provide Component[] which are the “seeders”. not “originalSeeders”).
+ *
+ * Each build-task can decide on what components to operate. It has 3 options:
+ * run on graphCapsules. If you do that, you risk running your task multiple times on the same components. In the example above, a task of build-pipeline, will run 3 times on comp3, because this component is part of the graphCapsules in each one of the network instance. So this is probably not recommended for most tasks.
+ * run on seedersCapsules. With this option you make sure that your task is running for each one of the capsules and it runs only once. This is good for example for the compiler task. It needs to make sure all capsules are built. Otherwise, if it’s running only on originalSeedersCapsules, the comp3 won’t be compiled, the dists will be missing and comp2 won’t be able to run its tests.
+ * run on originalSeedersCapsules . With this option you ensure that your task runs only on the ids you started with and you don’t run them on the dependencies. This is the option that most tasks probably need. An example is the test task, it should test only the seeders, no need to test the dependencies.
+ *
+ * Again, the distinction between seedersCapsules and originalSeedersCapsules is relevant for build-pipeline only. For tag-pipeline and snap-pipeline, these two are the same. You can see for example that Publisher task runs on seedersCapsules and that’s fine, it won’t be running on dependencies unexpectedly, only on the components it’s now tagging.
+ */
+export declare class Network {
+    private _graphCapsules;
+    private seedersIds;
+    private _capsulesRootDir;
+    _originalSeeders: ComponentID[] | undefined;
+    constructor(_graphCapsules: CapsuleList, seedersIds: ComponentID[], _capsulesRootDir: string);
+    /**
+     * for non build-tasks, this includes the original components the network was created for.
+     *
+     * for build-tasks (during bit build/tag/snap), this `Network` instance is created per env, and it depends on the pipeline.
+     * build-pipeline: includes the component graph (meaning include the dependencies) of the current env.
+     * snap/tag pipeline: it's the same as `this.originalSeedersCapsules`. it includes only the original to
+     * tag/snap/build of the current env.
+     *
+     * for example comp1 of env1 is using comp2 of env2. when running build/tag/snap on comp1 only, two networks are created
+     * for build pipeline:
+     * network1: seedersCapsules: [comp1], originalSeedersCapsules: [comp1], graphCapsules: [comp1, comp2]
+     * network2: seedersCapsules: [comp2], originalSeedersCapsules: [], graphCapsules: [comp2]
+     *
+     * for snap/tag pipeline, only network1 is created, and it includes only the originalSeedersCapsules.
+     *
+     * see the description of this Network class for more info.
+     */
+    get seedersCapsules(): CapsuleList;
+    /**
+     * for non build-tasks, this is the same as `this.seedersCapsules`, which includes the original components the
+     * network was created for.
+     *
+     * for build-tasks (during bit build/tag/snap), this includes the component to build/tag/snap of the current env.
+     * see the description of this Network class for more info.
+     */
+    get originalSeedersCapsules(): CapsuleList;
+    /**
+     * some of the capsules (non-modified) are written already with the dists files, so no need to re-compile them.
+     * this method helps optimizing compilers that are running on the capsules.
+     */
+    getCapsulesToCompile(): Promise<CapsuleList>;
+    /**
+     * originalSeeders are not always set (currently, only during build process), so if they're missing, just provide the
+     * seeders, which are probably the original-seeders
+     */
+    private getOriginalSeeders;
+    /**
+     * all capsules, including the dependencies of the seeders. (even when they belong to another env)
+     */
+    get graphCapsules(): CapsuleList;
+    get capsulesRootDir(): PathOsBasedAbsolute;
+}

package/dist/{preview-1712805335812.js → preview-1712822929999.js}

@@ -1,5 +1,5 @@
-import * as compositions_0 from '/home/circleci/Library/Caches/Bit/capsules/8891be5ad3d35bfc38b9cd90c0e05b598a5a55af/teambit.component_isolator@1.0.228/dist/isolator.composition.js';
-import * as overview_0 from '/home/circleci/Library/Caches/Bit/capsules/8891be5ad3d35bfc38b9cd90c0e05b598a5a55af/teambit.component_isolator@1.0.228/dist/isolator.docs.md';
+import * as compositions_0 from '/home/circleci/Library/Caches/Bit/capsules/8891be5ad3d35bfc38b9cd90c0e05b598a5a55af/teambit.component_isolator@1.0.229/dist/isolator.composition.js';
+import * as overview_0 from '/home/circleci/Library/Caches/Bit/capsules/8891be5ad3d35bfc38b9cd90c0e05b598a5a55af/teambit.component_isolator@1.0.229/dist/isolator.docs.md';
 
 export const compositions = [compositions_0];
 export const overview = [overview_0];

package/dist/symlink-dependencies-to-capsules.d.ts

@@ -0,0 +1,6 @@
+import { LinkDetail } from '@teambit/dependency-resolver';
+import { Logger } from '@teambit/logger';
+import { Capsule } from './capsule';
+import CapsuleList from './capsule-list';
+export declare function symlinkDependenciesToCapsules(capsules: Capsule[], capsuleList: CapsuleList, logger: Logger): Promise<Record<string, Record<string, string>>>;
+export declare function symlinkOnCapsuleRoot(capsuleList: CapsuleList, logger: Logger, capsuleRoot: string): Promise<LinkDetail[]>;

package/package.json

@@ -1,12 +1,12 @@
 {
   "name": "@teambit/isolator",
-  "version": "1.0.228",
+  "version": "1.0.229",
   "homepage": "https://bit.cloud/teambit/component/isolator",
   "main": "dist/index.js",
   "componentId": {
     "scope": "teambit.component",
     "name": "isolator",
-    "version": "1.0.228"
+    "version": "1.0.229"
   },
   "dependencies": {
     "chalk": "2.4.2",
@@ -26,15 +26,15 @@
     "@teambit/component-id": "1.2.0",
     "@teambit/graph.cleargraph": "0.0.8",
     "@teambit/harmony": "0.4.6",
-    "@teambit/component": "1.0.228",
-    "@teambit/dependency-resolver": "1.0.228",
-    "@teambit/aspect-loader": "1.0.228",
-    "@teambit/cli": "0.0.861",
+    "@teambit/component": "1.0.229",
+    "@teambit/dependency-resolver": "1.0.229",
+    "@teambit/aspect-loader": "1.0.229",
+    "@teambit/cli": "0.0.862",
     "@teambit/component-package-version": "0.0.433",
     "@teambit/dependencies.fs.linked-dependencies": "0.0.9",
-    "@teambit/global-config": "0.0.864",
-    "@teambit/graph": "1.0.228",
-    "@teambit/logger": "0.0.954",
+    "@teambit/global-config": "0.0.865",
+    "@teambit/graph": "1.0.229",
+    "@teambit/logger": "0.0.955",
     "@teambit/workspace.modules.node-modules-linker": "0.0.167"
   },
   "devDependencies": {
@@ -45,7 +45,7 @@
     "@types/uuid": "8.3.4",
     "@types/mocha": "9.1.0",
     "chai": "4.3.0",
-    "@teambit/harmony.envs.core-aspect-env": "0.0.30"
+    "@teambit/harmony.envs.core-aspect-env": "0.0.33"
   },
   "peerDependencies": {
     "react": "^17.0.0 || ^18.0.0",

package/tsconfig.json

@@ -20,8 +20,7 @@
     "emitDeclarationOnly": true,
     "strict": true,
     "strictPropertyInitialization": false,
-    "noImplicitAny": false,
-    "composite": true
+    "noImplicitAny": false
   },
   "exclude": [
     "artifacts",
@@ -36,25 +35,5 @@
   "include": [
     "**/*",
     "**/*.json"
-  ],
-  "references": [
-    {
-      "path": "/home/circleci/Library/Caches/Bit/capsules/8891be5ad3d35bfc38b9cd90c0e05b598a5a55af/teambit.component_component@1.0.228"
-    },
-    {
-      "path": "/home/circleci/Library/Caches/Bit/capsules/8891be5ad3d35bfc38b9cd90c0e05b598a5a55af/teambit.harmony_aspect-loader@1.0.228"
-    },
-    {
-      "path": "/home/circleci/Library/Caches/Bit/capsules/8891be5ad3d35bfc38b9cd90c0e05b598a5a55af/teambit.harmony_cli@0.0.861"
-    },
-    {
-      "path": "/home/circleci/Library/Caches/Bit/capsules/8891be5ad3d35bfc38b9cd90c0e05b598a5a55af/teambit.harmony_global-config@0.0.864"
-    },
-    {
-      "path": "/home/circleci/Library/Caches/Bit/capsules/8891be5ad3d35bfc38b9cd90c0e05b598a5a55af/teambit.component_graph@1.0.228"
-    },
-    {
-      "path": "/home/circleci/Library/Caches/Bit/capsules/8891be5ad3d35bfc38b9cd90c0e05b598a5a55af/teambit.harmony_logger@0.0.954"
-    }
   ]
 }