@teambit/builder 0.0.555 → 0.0.559

package/build.cmd.ts

@@ -1,91 +0,0 @@
-import { Command, CommandOptions } from '@teambit/cli';
-import { Logger } from '@teambit/logger';
-import { Workspace } from '@teambit/workspace';
-import { ConsumerNotFound } from '@teambit/legacy/dist/consumer/exceptions';
-import chalk from 'chalk';
-import { BuilderMain } from './builder.main.runtime';
-
-type BuildOpts = {
-  rebuild: boolean;
-  install: boolean;
-  cachePackagesOnCapsulesRoot: boolean;
-  reuseCapsules: boolean;
-  tasks: string;
-  listTasks?: string;
-};
-
-export class BuilderCmd implements Command {
-  name = 'build [pattern]';
-  description = 'run set of tasks for build';
-  alias = '';
-  group = 'development';
-  options = [
-    ['', 'install', 'install core aspects in capsules'],
-    ['', 'reuse-capsules', 'avoid deleting the capsules root-dir before starting the build'],
-    [
-      '',
-      'tasks <string>',
-      `build the specified task(s) only. for multiple tasks, separate by a comma and wrap with quotes.
-specify the task-name (e.g. "TypescriptCompiler") or the task-aspect-id (e.g. teambit.compilation/compiler)`,
-    ],
-    ['', 'cache-packages-on-capsule-root', 'set the package-manager cache on the capsule root'],
-    [
-      '',
-      'list-tasks <string>',
-      'list tasks of an env or a component-id for each one of the pipelines: build, tag and snap',
-    ],
-  ] as CommandOptions;
-
-  constructor(private builder: BuilderMain, private workspace: Workspace, private logger: Logger) {}
-
-  async report(
-    [userPattern]: [string],
-    { install = false, cachePackagesOnCapsulesRoot = false, reuseCapsules = false, tasks, listTasks }: BuildOpts
-  ): Promise<string> {
-    if (!this.workspace) throw new ConsumerNotFound();
-    if (listTasks) {
-      return this.getListTasks(listTasks);
-    }
-    const longProcessLogger = this.logger.createLongProcessLogger('build');
-    const pattern = userPattern && userPattern.toString();
-    const components = pattern ? await this.workspace.byPattern(pattern) : await this.workspace.list();
-
-    const envsExecutionResults = await this.builder.build(
-      components,
-      {
-        installOptions: {
-          installTeambitBit: install,
-        },
-        linkingOptions: { linkTeambitBit: !install },
-        emptyRootDir: !reuseCapsules,
-        getExistingAsIs: reuseCapsules,
-        cachePackagesOnCapsulesRoot,
-      },
-      {
-        tasks: tasks ? tasks.split(',').map((task) => task.trim()) : [],
-      }
-    );
-    longProcessLogger.end();
-    envsExecutionResults.throwErrorsIfExist();
-    this.logger.consoleSuccess();
-    return chalk.green(`the build has been completed. total: ${envsExecutionResults.tasksQueue.length} tasks`);
-  }
-
-  private async getListTasks(componentIdStr: string): Promise<string> {
-    const compId = await this.workspace.resolveComponentId(componentIdStr);
-    const component = await this.workspace.get(compId);
-    const results = this.builder.listTasks(component);
-    return `${chalk.green('Tasks List')}
-id:    ${results.id.toString()}
-envId: ${results.envId}
-
-${chalk.bold('Build Pipeline Tasks:')}
-${results.buildTasks.join('\n')}
-
-${chalk.bold('Tag Pipeline Tasks:')}
-${results.tagTasks.join('\n')}
-
-${chalk.bold('Snap Pipeline Tasks:')}
-${results.snapTasks.join('\n') || '<N/A>'}`;
-  }
-}

package/builder.aspect.ts

@@ -1,5 +0,0 @@
-import { Aspect } from '@teambit/harmony';
-
-export const BuilderAspect = Aspect.create({
-  id: 'teambit.pipelines/builder',
-});

package/builder.graphql.ts

@@ -1,38 +0,0 @@
-import { Component } from '@teambit/component';
-import gql from 'graphql-tag';
-
-import { BuilderMain } from './builder.main.runtime';
-
-// eslint-disable-next-line @typescript-eslint/no-unused-vars
-export function builderSchema(builder: BuilderMain) {
-  return {
-    typeDefs: gql`
-      type ExtensionDescriptor {
-        # extension ID.
-        id: String
-
-        # icon of the extension.
-        icon: String
-      }
-
-      type ExtensionArtifact {
-        # descriptor of the artifact's extension
-        extensionDescriptor: ExtensionDescriptor
-      }
-
-      extend type Component {
-        # list of extension artifacts.
-        getArtifacts(hash: String!): [ExtensionArtifact]
-      }
-    `,
-    resolvers: {
-      Component: {
-        // eslint-disable-next-line @typescript-eslint/no-unused-vars
-        getArtifacts: async (component: Component, { hash }: { hash: string }) => {
-          // const artifacts = await builder.getArtifacts(component.id, hash);
-          // return artifacts.map((artifact) => artifact.toObject());
-        },
-      },
-    },
-  };
-}

package/builder.main.runtime.ts

@@ -1,346 +0,0 @@
-import { flatten } from 'lodash';
-import { ArtifactVinyl } from '@teambit/legacy/dist/consumer/component/sources/artifact';
-import { AspectLoaderAspect, AspectLoaderMain } from '@teambit/aspect-loader';
-import { CLIAspect, CLIMain, MainRuntime } from '@teambit/cli';
-import { Component, ComponentAspect, ComponentMap } from '@teambit/component';
-import { EnvsAspect, EnvsMain } from '@teambit/envs';
-import { GraphqlAspect, GraphqlMain } from '@teambit/graphql';
-import { Slot, SlotRegistry } from '@teambit/harmony';
-import { LoggerAspect, LoggerMain } from '@teambit/logger';
-import { ScopeAspect, ScopeMain, OnTagResults } from '@teambit/scope';
-import { Workspace, WorkspaceAspect } from '@teambit/workspace';
-import { IsolateComponentsOptions, IsolatorAspect, IsolatorMain } from '@teambit/isolator';
-import { OnTagOpts } from '@teambit/legacy/dist/scope/scope';
-import { ArtifactObject } from '@teambit/legacy/dist/consumer/component/sources/artifact-files';
-import { ArtifactList } from './artifact';
-import { ArtifactFactory } from './artifact/artifact-factory'; // it gets undefined when importing it from './artifact'
-import { BuilderAspect } from './builder.aspect';
-import { builderSchema } from './builder.graphql';
-import { BuilderService, BuilderServiceOptions } from './builder.service';
-import { BuilderCmd } from './build.cmd';
-import { BuildTask } from './build-task';
-import { StorageResolver } from './storage';
-import { TaskResults } from './build-pipe';
-import { TaskResultsList } from './task-results-list';
-import { ArtifactStorageError } from './exceptions';
-import { BuildPipelineResultList, AspectData, PipelineReport } from './build-pipeline-result-list';
-import { Serializable } from './types';
-import { ArtifactsCmd } from './artifact/artifacts.cmd';
-
-export type TaskSlot = SlotRegistry<BuildTask[]>;
-
-export type StorageResolverSlot = SlotRegistry<StorageResolver>;
-
-export type BuilderData = {
-  pipeline: PipelineReport[];
-  artifacts: ArtifactObject[] | undefined;
-  aspectsData: AspectData[];
-};
-
-export class BuilderMain {
-  constructor(
-    private envs: EnvsMain,
-    private workspace: Workspace,
-    private buildService: BuilderService,
-    private tagService: BuilderService,
-    private snapService: BuilderService,
-    private scope: ScopeMain,
-    private isolator: IsolatorMain,
-    private aspectLoader: AspectLoaderMain,
-    private buildTaskSlot: TaskSlot,
-    private tagTaskSlot: TaskSlot,
-    private snapTaskSlot: TaskSlot,
-    private storageResolversSlot: StorageResolverSlot
-  ) {}
-
-  private async storeArtifacts(tasksResults: TaskResults[]) {
-    const artifacts = tasksResults.flatMap((t) => (t.artifacts ? [t.artifacts] : []));
-    const storeP = artifacts.map(async (artifactMap: ComponentMap<ArtifactList>) => {
-      return Promise.all(
-        artifactMap.toArray().map(async ([component, artifactList]) => {
-          try {
-            return await artifactList.store(component);
-          } catch (err: any) {
-            throw new ArtifactStorageError(err, component);
-          }
-        })
-      );
-    });
-    await Promise.all(storeP);
-  }
-
-  private pipelineResultsToBuilderData(
-    components: Component[],
-    buildPipelineResults: TaskResults[]
-  ): ComponentMap<BuilderData> {
-    const buildPipelineResultList = new BuildPipelineResultList(buildPipelineResults, components);
-    return ComponentMap.as<BuilderData>(components, (component) => {
-      const aspectsData = buildPipelineResultList.getDataOfComponent(component.id);
-      const pipelineReport = buildPipelineResultList.getPipelineReportOfComponent(component.id);
-      const artifactsData = buildPipelineResultList.getArtifactsDataOfComponent(component.id);
-      return { pipeline: pipelineReport, artifacts: artifactsData, aspectsData };
-    });
-  }
-
-  async tagListener(
-    components: Component[],
-    options: OnTagOpts = {},
-    isolateOptions: IsolateComponentsOptions = {}
-  ): Promise<OnTagResults> {
-    const pipeResults: TaskResultsList[] = [];
-    const { throwOnError, forceDeploy, disableTagAndSnapPipelines, isSnap } = options;
-    const envsExecutionResults = await this.build(
-      components,
-      { emptyRootDir: true, ...isolateOptions },
-      { skipTests: options.skipTests }
-    );
-    if (throwOnError && !forceDeploy) envsExecutionResults.throwErrorsIfExist();
-    const allTasksResults = [...envsExecutionResults.tasksResults];
-    pipeResults.push(envsExecutionResults);
-    if (forceDeploy || (!disableTagAndSnapPipelines && !envsExecutionResults.hasErrors())) {
-      const deployEnvsExecutionResults = isSnap
-        ? await this.runSnapTasks(components, isolateOptions)
-        : await this.runTagTasks(components, isolateOptions);
-      if (throwOnError) deployEnvsExecutionResults.throwErrorsIfExist();
-      allTasksResults.push(...deployEnvsExecutionResults.tasksResults);
-      pipeResults.push(deployEnvsExecutionResults);
-    }
-    await this.storeArtifacts(allTasksResults);
-    const builderDataMap = this.pipelineResultsToBuilderData(components, allTasksResults);
-    return { builderDataMap, pipeResults };
-  }
-
-  /**
-   * register a new storage resolver.
-   */
-  registerStorageResolver(storageResolver: StorageResolver) {
-    this.storageResolversSlot.register(storageResolver);
-    return this;
-  }
-
-  /**
-   * get storage resolver by name. otherwise, returns default.
-   */
-  getStorageResolver(name: string): StorageResolver | undefined {
-    return this.storageResolversSlot.values().find((storageResolver) => storageResolver.name === name);
-  }
-
-  // TODO: merge with getArtifactsVinylByExtensionAndName by getting aspect name and name as object with optional props
-  async getArtifactsVinylByExtension(component: Component, aspectName: string): Promise<ArtifactVinyl[]> {
-    const artifactsObjects = this.getArtifactsByExtension(component, aspectName);
-    const vinyls = await Promise.all(
-      (artifactsObjects || []).map((artifactObject) =>
-        artifactObject.files.getVinylsAndImportIfMissing(component.id.scope as string, this.scope.legacyScope)
-      )
-    );
-    return flatten(vinyls);
-  }
-
-  async getArtifactsVinylByExtensionAndName(
-    component: Component,
-    aspectName: string,
-    name: string
-  ): Promise<ArtifactVinyl[]> {
-    const artifactsObjects = this.getArtifactsByExtensionAndName(component, aspectName, name);
-    const vinyls = await Promise.all(
-      (artifactsObjects || []).map((artifactObject) =>
-        artifactObject.files.getVinylsAndImportIfMissing(component.id.scope as string, this.scope.legacyScope)
-      )
-    );
-    return flatten(vinyls);
-  }
-
-  getArtifactsByName(component: Component, name: string): ArtifactObject[] | undefined {
-    const artifacts = this.getArtifacts(component);
-    return artifacts?.filter((artifact) => artifact.name === name);
-  }
-
-  getArtifactsByExtension(component: Component, aspectName: string): ArtifactObject[] | undefined {
-    const artifacts = this.getArtifacts(component);
-    return artifacts?.filter((artifact) => artifact.task.id === aspectName);
-  }
-
-  getArtifactsByExtensionAndName(component: Component, aspectName: string, name: string): ArtifactObject[] | undefined {
-    const artifacts = this.getArtifacts(component);
-    return artifacts?.filter((artifact) => artifact.task.id === aspectName && artifact.name === name);
-  }
-
-  getDataByAspect(component: Component, aspectName: string): Serializable | undefined {
-    const aspectsData = this.getBuilderData(component)?.aspectsData;
-    const data = aspectsData?.find((aspectData) => aspectData.aspectId === aspectName);
-    return data?.data;
-  }
-
-  getArtifacts(component: Component): ArtifactObject[] | undefined {
-    return this.getBuilderData(component)?.artifacts;
-  }
-
-  getBuilderData(component: Component): BuilderData | undefined {
-    return component.state.aspects.get(BuilderAspect.id)?.data as BuilderData | undefined;
-  }
-
-  /**
-   * build given components for release.
-   * for each one of the envs it runs a series of tasks.
-   * in case of an error in a task, it stops the execution of that env and continue to the next
-   * env. at the end, the results contain the data and errors per env.
-   */
-  async build(
-    components: Component[],
-    isolateOptions?: IsolateComponentsOptions,
-    builderOptions?: BuilderServiceOptions
-  ): Promise<TaskResultsList> {
-    const ids = components.map((c) => c.id);
-    const network = await this.isolator.isolateComponents(ids, isolateOptions);
-    const envs = await this.envs.createEnvironment(network.graphCapsules.getAllComponents());
-    const builderServiceOptions = { seedersOnly: isolateOptions?.seedersOnly, ...(builderOptions || {}) };
-    const buildResult = await envs.runOnce(this.buildService, builderServiceOptions);
-    return buildResult;
-  }
-
-  async runTagTasks(components: Component[], isolateOptions?: IsolateComponentsOptions): Promise<TaskResultsList> {
-    const envs = await this.envs.createEnvironment(components);
-    const buildResult = await envs.runOnce(this.tagService, { seedersOnly: isolateOptions?.seedersOnly });
-
-    return buildResult;
-  }
-
-  async runSnapTasks(components: Component[], isolateOptions?: IsolateComponentsOptions): Promise<TaskResultsList> {
-    const envs = await this.envs.createEnvironment(components);
-    const buildResult = await envs.runOnce(this.snapService, { seedersOnly: isolateOptions?.seedersOnly });
-
-    return buildResult;
-  }
-
-  listTasks(component: Component) {
-    const compEnv = this.envs.getEnv(component);
-    const buildTasks = this.buildService.getCurrentPipeTasks(compEnv);
-    const tagTasks = this.tagService.getCurrentPipeTasks(compEnv);
-    const snapTasks = this.snapService.getCurrentPipeTasks(compEnv);
-    return { id: component.id, envId: compEnv.id, buildTasks, tagTasks, snapTasks };
-  }
-
-  /**
-   * register a build task to apply on all component build pipelines.
-   * build happens on `bit build` and as part of `bit tag --persist`.
-   */
-  registerBuildTasks(tasks: BuildTask[]) {
-    this.buildTaskSlot.register(tasks);
-    return this;
-  }
-
-  /**
-   * @deprecated use registerTagTasks or registerSnapTasks
-   */
-  registerDeployTasks(tasks: BuildTask[]) {
-    this.tagTaskSlot.register(tasks);
-    return this;
-  }
-
-  /**
-   * tag tasks that don't get executed on `bit build`, only on `bit tag'.
-   * this pipeline is running once the build-pipeline has completed.
-   */
-  registerTagTasks(tasks: BuildTask[]) {
-    this.tagTaskSlot.register(tasks);
-    return this;
-  }
-
-  /**
-   * tag tasks that don't get executed on `bit build`, only on `bit snap'.
-   * this pipeline is running once the build-pipeline has completed.
-   */
-  registerSnapTasks(tasks: BuildTask[]) {
-    this.snapTaskSlot.register(tasks);
-    return this;
-  }
-
-  static slots = [
-    Slot.withType<BuildTask>(),
-    Slot.withType<StorageResolver>(),
-    Slot.withType<BuildTask>(),
-    Slot.withType<BuildTask>(),
-  ];
-
-  static runtime = MainRuntime;
-  static dependencies = [
-    CLIAspect,
-    EnvsAspect,
-    WorkspaceAspect,
-    ScopeAspect,
-    IsolatorAspect,
-    LoggerAspect,
-    AspectLoaderAspect,
-    GraphqlAspect,
-    ComponentAspect,
-  ];
-
-  static async provider(
-    [cli, envs, workspace, scope, isolator, loggerExt, aspectLoader, graphql]: [
-      CLIMain,
-      EnvsMain,
-      Workspace,
-      ScopeMain,
-      IsolatorMain,
-      LoggerMain,
-      AspectLoaderMain,
-      GraphqlMain
-    ],
-    config,
-    [buildTaskSlot, storageResolversSlot, tagTaskSlot, snapTaskSlot]: [
-      TaskSlot,
-      StorageResolverSlot,
-      TaskSlot,
-      TaskSlot
-    ]
-  ) {
-    const artifactFactory = new ArtifactFactory(storageResolversSlot);
-    const logger = loggerExt.createLogger(BuilderAspect.id);
-    const buildService = new BuilderService(
-      isolator,
-      logger,
-      buildTaskSlot,
-      'getBuildPipe',
-      'build',
-      artifactFactory,
-      scope
-    );
-    envs.registerService(buildService);
-    const tagService = new BuilderService(isolator, logger, tagTaskSlot, 'getTagPipe', 'tag', artifactFactory, scope);
-    const snapService = new BuilderService(
-      isolator,
-      logger,
-      snapTaskSlot,
-      'getSnapPipe',
-      'snap',
-      artifactFactory,
-      scope
-    );
-    const builder = new BuilderMain(
-      envs,
-      workspace,
-      buildService,
-      tagService,
-      snapService,
-      scope,
-      isolator,
-      aspectLoader,
-      buildTaskSlot,
-      tagTaskSlot,
-      snapTaskSlot,
-      storageResolversSlot
-    );
-
-    graphql.register(builderSchema(builder));
-    const func = builder.tagListener.bind(builder);
-    if (scope) scope.onTag(func);
-    if (workspace && !workspace.consumer.isLegacy) {
-      const commands = [new BuilderCmd(builder, workspace, logger), new ArtifactsCmd(builder, scope)];
-      cli.unregister('build');
-      cli.register(...commands);
-    }
-    return builder;
-  }
-}
-
-BuilderAspect.addRuntime(BuilderMain);

package/builder.service.tsx

@@ -1,163 +0,0 @@
-import { EnvDefinition, EnvService, ExecutionContext } from '@teambit/envs';
-import React from 'react';
-import { ScopeMain } from '@teambit/scope';
-import { Text, Newline } from 'ink';
-import { Logger } from '@teambit/logger';
-import { IsolatorMain } from '@teambit/isolator';
-import { Component } from '@teambit/component';
-import { BuildPipe } from './build-pipe';
-import { TaskResultsList } from './task-results-list';
-import { TaskSlot } from './builder.main.runtime';
-import { BuildContext, BuildTaskHelper } from './build-task';
-import { ArtifactFactory } from './artifact';
-import { calculatePipelineOrder } from './build-pipeline-order';
-import { BuilderAspect } from './builder.aspect';
-
-export type BuildServiceResults = {
-  id: string;
-  buildResults: TaskResultsList;
-  components: Component[];
-  errors?: [];
-};
-
-export type BuilderServiceOptions = { seedersOnly?: boolean; tasks?: string[]; skipTests?: boolean };
-
-export type EnvsBuildContext = { [envId: string]: BuildContext };
-
-const pipeNames = {
-  getBuildPipe: 'build',
-  getTagPipe: 'tag',
-  getSnapPipe: 'snap',
-};
-
-type PipeName = 'build' | 'tag' | 'snap';
-
-export type BuilderDescriptor = Array<{ pipeName: PipeName; tasks: string[] }>;
-
-type PipeFunctionNames = keyof typeof pipeNames;
-export class BuilderService implements EnvService<BuildServiceResults, BuilderDescriptor> {
-  name = 'builder';
-
-  constructor(
-    /**
-     * isolator extension.
-     */
-    private isolator: IsolatorMain,
-
-    /**
-     * logger extension.
-     */
-    private logger: Logger,
-
-    /**
-     * task slot (e.g tasks registered by other extensions.).
-     */
-    private taskSlot: TaskSlot,
-
-    /**
-     * a method with such name should be implemented on the env in order to run the pipe tasks.
-     */
-    private pipeNameOnEnv: PipeFunctionNames,
-
-    /**
-     * pipe name to display on the console during the execution
-     */
-    private displayPipeName: string,
-    private artifactFactory: ArtifactFactory,
-    private scope: ScopeMain
-  ) {}
-
-  /**
-   * runs all tasks for all envs
-   */
-  async runOnce(envsExecutionContext: ExecutionContext[], options: BuilderServiceOptions): Promise<TaskResultsList> {
-    const envs = envsExecutionContext.map((executionContext) => executionContext.envDefinition);
-    const tasksQueue = calculatePipelineOrder(
-      this.taskSlot,
-      envs,
-      this.pipeNameOnEnv,
-      options.tasks,
-      options.skipTests
-    );
-    tasksQueue.validate();
-    this.logger.info(`going to run tasks in the following order:\n${tasksQueue.toString()}`);
-    const title = `running ${this.displayPipeName} pipe for ${envs.length} environments, total ${tasksQueue.length} tasks`;
-    const longProcessLogger = this.logger.createLongProcessLogger(title);
-    this.logger.consoleTitle(title);
-    const envsBuildContext: EnvsBuildContext = {};
-    await Promise.all(
-      envsExecutionContext.map(async (executionContext) => {
-        const componentIds = executionContext.components.map((component) => component.id);
-        const capsuleNetwork = await this.isolator.isolateComponents(componentIds, {
-          getExistingAsIs: true,
-          seedersOnly: options.seedersOnly,
-        });
-        this.logger.console(
-          `generated graph for env "${executionContext.id}", seeders total: ${capsuleNetwork.seedersCapsules.length}, graph total: ${capsuleNetwork.graphCapsules.length}`
-        );
-        const buildContext = Object.assign(executionContext, {
-          capsuleNetwork,
-          previousTasksResults: [],
-        });
-        envsBuildContext[executionContext.id] = buildContext;
-      })
-    );
-    const buildPipe = BuildPipe.from(tasksQueue, envsBuildContext, this.logger, this.artifactFactory);
-    const buildResults = await buildPipe.execute();
-    longProcessLogger.end();
-    buildResults.hasErrors() ? this.logger.consoleFailure() : this.logger.consoleSuccess();
-
-    return buildResults;
-  }
-
-  render(env: EnvDefinition) {
-    const pipes = this.getDescriptor(env);
-
-    return (
-      <Text key={BuilderAspect.id}>{pipes.map(({ pipeName, tasks }) => this.renderOnePipe(pipeName, tasks))}</Text>
-    );
-  }
-
-  private renderOnePipe(pipeName, tasks) {
-    if (!tasks || !tasks.length) return null;
-    return (
-      <Text key={pipeName}>
-        <Text underline color="green">
-          {pipeName} pipe
-        </Text>
-        <Newline />
-        <Text color="cyan">total {tasks.length} tasks are configured to be executed in the following order</Text>
-        <Newline />
-        {tasks.map((task, index) => (
-          <Text key={index}>
-            <Text>
-              {index + 1}. {task}
-            </Text>
-            <Newline />
-          </Text>
-        ))}
-        <Newline />
-      </Text>
-    );
-  }
-
-  getDescriptor(env: EnvDefinition) {
-    // @ts-ignore
-    const tasks = Object.keys(pipeNames).map((pipeFuncName: PipeFunctionNames) => {
-      const tasksQueue = this.getTasksNamesByPipeFunc(env, pipeFuncName);
-      return { pipeName: pipeNames[pipeFuncName], tasks: tasksQueue };
-    });
-    return tasks as BuilderDescriptor;
-  }
-
-  private getTasksNamesByPipeFunc(env: EnvDefinition, pipeFuncName: PipeFunctionNames): string[] {
-    const tasksQueue = calculatePipelineOrder(this.taskSlot, [env], pipeFuncName).map(({ task }) =>
-      BuildTaskHelper.serializeId(task)
-    );
-    return tasksQueue;
-  }
-
-  getCurrentPipeTasks(env: EnvDefinition) {
-    return this.getTasksNamesByPipeFunc(env, this.pipeNameOnEnv);
-  }
-}

package/exceptions/artifact-storage-error.ts

@@ -1,7 +0,0 @@
-import { Component } from '@teambit/component';
-
-export class ArtifactStorageError extends Error {
-  constructor(private originalError: Error, private component: Component) {
-    super(`failed to store artifacts for component ${component.id.toString()}`);
-  }
-}

package/exceptions/capsule-not-found.ts

@@ -1,7 +0,0 @@
-import { ComponentID } from '@teambit/component';
-
-export class CapsuleNotFound extends Error {
-  constructor(private id: ComponentID) {
-    super(`unable to find capsule for component ${id.toString()}`);
-  }
-}

package/exceptions/index.ts

@@ -1,3 +0,0 @@
-export { InvalidTask } from './invalid-task';
-export { CapsuleNotFound } from './capsule-not-found';
-export { ArtifactStorageError } from './artifact-storage-error';

package/exceptions/invalid-task.ts

@@ -1,7 +0,0 @@
-import { BitError } from '@teambit/bit-error';
-
-export class InvalidTask extends BitError {
-  constructor(readonly taskAspectId: string, reason: string) {
-    super(`task of ${taskAspectId} is invalid, ${reason}`);
-  }
-}

package/index.ts

@@ -1,9 +0,0 @@
-export { BuildPipe } from './build-pipe';
-export { ComponentResult, TaskMetadata } from './types';
-export { BuildContext, BuildTask, BuiltTaskResult, TaskLocation, BuildTaskHelper } from './build-task';
-export type { BuilderMain, BuilderData } from './builder.main.runtime';
-export type { PipelineReport } from './build-pipeline-result-list';
-export { BuilderAspect } from './builder.aspect';
-export { StorageResolver } from './storage';
-export { Artifact, ArtifactList, ArtifactFactory, ArtifactDefinition } from './artifact';
-export { TaskResultsList } from './task-results-list';

package/pipeline/index.ts

@@ -1 +0,0 @@
-export { PipelineResults } from './pipeline-results';