@teambit/builder 1.0.228 → 1.0.229

package/dist/artifact/artifact-definition.d.ts

@@ -0,0 +1,65 @@
+import { ArtifactStorageResolver } from '..';
+export type ArtifactDefinition = {
+    /**
+     * name of the artifact.
+     * e.g. a project might utilize two different artifacts for the same typescript compiler, one
+     * that generates ES5 files and another for ES6, this prop helps to distinguish between the two.
+     */
+    name: string;
+    /**
+     * aspect id that created the artifact. sometimes it's not the same as the task.id.
+     * e.g. teambit.compilation/compiler executes teambit.typescript/typescript code that generates dists artifacts
+     * the generatedBy in this case is the teambit.typescript/typescript while the task.id is
+     * teambit.compilation/compiler
+     */
+    generatedBy?: string;
+    /**
+     * description of the artifact.
+     */
+    description?: string;
+    /**
+     * glob patterns of files to include upon artifact creation.
+     * examples:
+     * ['*.ts', '!foo.ts'] - matches all ts files but ignores foo.ts.
+     * ['dist'] - matches all files recursively from dist dir. (similar to 'dist/**').
+     *
+     * the glob array are passed to [globby](https://www.npmjs.com/package/globby), which interprets the patterns
+     * according to [minimatch](https://github.com/isaacs/minimatch#usage).
+     */
+    globPatterns?: string[];
+    /**
+     * @deprecated use globPatterns instead.
+     *
+     * directories of files to include upon artifact creation. minimatch is used to match the patterns.
+     * e.g. ['/tmp'] will include all files from tmp dir
+     */
+    directories?: string[];
+    /**
+     * @deprecated use globPatterns instead.
+     *
+     * define the root directory for reading the artifacts from the capsule file system.
+     * the rootDir must be unique per artifacts, otherwise we risk overriding data between artifacts.
+     */
+    rootDir?: string;
+    /**
+     * @deprecated use globPatterns instead.
+     *
+     * adds a directory prefix for all artifact files.
+     */
+    dirPrefix?: string;
+    /**
+     * determine the context of the artifact.
+     * default artifact context is `component`.
+     * "env" is useful when the same file is generated for all components, for example, "preview"
+     * task may create the same webpack file for all components of that env.
+     */
+    context?: 'component' | 'env';
+    /**
+     * storage resolver. can be used to replace where artifacts are stored.
+     * default resolver persists artifacts on scope. (not recommended for large files!)
+     */
+    storageResolver?: ArtifactStorageResolver;
+};
+export type ArtifactModelDefinition = Omit<ArtifactDefinition, 'storageResolver'> & {
+    storageResolver?: string;
+};

package/dist/artifact/artifact-extractor.d.ts

@@ -0,0 +1,35 @@
+import { ComponentMain } from '@teambit/component';
+import { ComponentID } from '@teambit/component-id';
+import { BuilderMain } from '../builder.main.runtime';
+import { ArtifactsOpts } from './artifacts.cmd';
+export type ExtractorResult = {
+    id: ComponentID;
+    artifacts: ExtractorArtifactResult[];
+};
+export type ExtractorArtifactResult = {
+    artifactName: string;
+    aspectId: string;
+    taskName: string;
+    files: string[];
+};
+export type ExtractorResultGrouped = {
+    id: ComponentID;
+    artifacts: {
+        [aspectId: string]: ExtractorArtifactResult[];
+    };
+};
+export declare class ArtifactExtractor {
+    private componentMain;
+    private builder;
+    private pattern;
+    private options;
+    constructor(componentMain: ComponentMain, builder: BuilderMain, pattern: string, options: ArtifactsOpts);
+    list(): Promise<ExtractorResult[]>;
+    groupResultsByAspect(extractorResult: ExtractorResult[]): {
+        id: ComponentID;
+        artifacts: {};
+    }[];
+    private saveFilesInFileSystemIfAsked;
+    private artifactsObjectsToExtractorResults;
+    private filterByOptions;
+}

package/dist/artifact/artifact-factory.d.ts

@@ -0,0 +1,20 @@
+import { Component, ComponentMap } from '@teambit/component';
+import { ArtifactDefinition } from './artifact-definition';
+import { ArtifactList } from './artifact-list';
+import type { BuildContext, BuildTask } from '../build-task';
+import { FsArtifact } from './fs-artifact';
+export declare const DEFAULT_CONTEXT = "component";
+export type ArtifactMap = ComponentMap<ArtifactList<FsArtifact>>;
+export declare class ArtifactFactory {
+    resolvePaths(root: string, def: ArtifactDefinition): string[];
+    private getArtifactContextPath;
+    private getArtifactContext;
+    createFromComponent(context: BuildContext, component: Component, def: ArtifactDefinition, task: BuildTask): FsArtifact | undefined;
+    private getStorageResolver;
+    private toComponentMap;
+    getRootDir(rootDir: string, def: ArtifactDefinition): string;
+    /**
+     * generate artifacts from a build context according to the spec defined in the artifact definitions.
+     */
+    generate(context: BuildContext, defs: ArtifactDefinition[], task: BuildTask): ComponentMap<ArtifactList<FsArtifact>>;
+}

package/dist/artifact/artifact-list.d.ts

@@ -0,0 +1,52 @@
+import { Component } from '@teambit/component';
+import type { ArtifactObject } from '@teambit/legacy/dist/consumer/component/sources/artifact-files';
+import { ComponentID } from '@teambit/component-id';
+import { Scope } from '@teambit/legacy/dist/scope';
+import { ArtifactVinyl } from '@teambit/legacy/dist/consumer/component/sources/artifact';
+import { Artifact } from './artifact';
+export type ResolverMap<T extends Artifact> = {
+    [key: string]: T[];
+};
+export declare class ArtifactList<T extends Artifact> extends Array<T> {
+    byAspectNameAndName(aspectName?: string, name?: string): ArtifactList<T>;
+    byAspectNameAndTaskName(aspectName?: string, name?: string): ArtifactList<T>;
+    /**
+     * find by the artifact name. it's possible to have multiple artifacts with the same name, in which case it returns the first.
+     */
+    findByName(name: string): Artifact | undefined;
+    /**
+     * find by the task name. it's possible to have multiple tasks with the same name (different aspects), in which case it returns the first.
+     */
+    findByTaskName(name: string): Artifact | undefined;
+    isEmpty(): boolean;
+    /**
+     * group artifacts by the storage resolver.
+     */
+    groupByResolver(): ResolverMap<T>;
+    toObject(): ArtifactObject[];
+    groupByTaskId(): {
+        [key: string]: T;
+    };
+    getVinylsAndImportIfMissing(id: ComponentID, scope: Scope): Promise<ArtifactVinyl[]>;
+    /**
+     * store all artifacts using the configured storage resolvers.
+     */
+    store(component: Component): Promise<void[]>;
+    private storeArtifact;
+    /**
+     * Send the entire artifact to the resolver then get back the result for all files from the resolver
+     * @param storageResolver
+     * @param artifact
+     * @param component
+     */
+    private storeWholeArtifactByResolver;
+    /**
+     * Go over the artifact files and send them to the resolver one by one
+     * @param storageResolver
+     * @param artifact
+     * @param component
+     */
+    private storeArtifactFilesByResolver;
+    static fromArtifactObjects(artifactObjects: ArtifactObject[]): ArtifactList<Artifact>;
+    static fromArray<T extends Artifact>(artifacts: T[]): ArtifactList<T>;
+}

package/dist/artifact/artifact.d.ts

@@ -0,0 +1,59 @@
+import type { ArtifactFiles, ArtifactObject } from '@teambit/legacy/dist/consumer/component/sources/artifact-files';
+import type { TaskDescriptor } from '../build-task';
+import type { ArtifactDefinition } from './artifact-definition';
+export declare class Artifact {
+    /**
+     * definition of the artifact.
+     */
+    readonly def: ArtifactDefinition;
+    readonly files: ArtifactFiles;
+    /**
+     * the declaring task.
+     */
+    readonly task: TaskDescriptor;
+    /**
+     * timestamp of the artifact creation.
+     */
+    readonly timestamp: number;
+    constructor(
+    /**
+     * definition of the artifact.
+     */
+    def: ArtifactDefinition, files: ArtifactFiles, 
+    /**
+     * the declaring task.
+     */
+    task: TaskDescriptor, 
+    /**
+     * timestamp of the artifact creation.
+     */
+    timestamp?: number);
+    get storage(): string;
+    get storageResolver(): import("..").ArtifactStorageResolver;
+    /**
+     * name of the artifact.
+     */
+    get name(): string;
+    /**
+     * description of the artifact.
+     */
+    get description(): string | undefined;
+    /**
+     * aspect id (string) that generated the artifact
+     */
+    get generatedBy(): string;
+    /**
+     * calculate what could possibly be the root directory of the artifact.
+     * in case the deprecated rootDir is set, use it.
+     * otherwise, get the common first directory of all files.
+     * if there is no common directory, or there are multiple directories return undefined.
+     */
+    get artifactDir(): string | undefined;
+    isEmpty(): boolean;
+    /**
+     * archive all artifact files into a tar.
+     */
+    tar(): void;
+    toObject(): ArtifactObject;
+    static fromArtifactObject(object: ArtifactObject): Artifact;
+}

package/dist/artifact/artifacts.cmd.d.ts

@@ -0,0 +1,26 @@
+import { Command, CommandOptions } from '@teambit/cli';
+import { ComponentMain } from '@teambit/component';
+import { BuilderMain } from '../builder.main.runtime';
+export type ArtifactsOpts = {
+    aspect?: string;
+    task?: string;
+    files?: string;
+    outDir?: string;
+};
+export declare class ArtifactsCmd implements Command {
+    private builder;
+    private componentMain;
+    name: string;
+    description: string;
+    extendedDescription: string;
+    arguments: {
+        name: string;
+        description: string;
+    }[];
+    alias: string;
+    group: string;
+    helpUrl: string;
+    options: CommandOptions;
+    constructor(builder: BuilderMain, componentMain: ComponentMain);
+    report([componentPattern]: [string], artifactsOpts: ArtifactsOpts): Promise<string>;
+}

package/dist/artifact/extension-artifact.d.ts

@@ -0,0 +1,10 @@
+import type { AspectDescriptor } from '@teambit/aspect-loader';
+import { AbstractVinyl } from '@teambit/legacy/dist/consumer/component/sources';
+export declare class ExtensionArtifact {
+    readonly files: AbstractVinyl[];
+    readonly extensionDescriptor: AspectDescriptor;
+    constructor(files: AbstractVinyl[], extensionDescriptor: AspectDescriptor);
+    toObject(): {
+        extensionDescriptor: AspectDescriptor;
+    };
+}

package/dist/artifact/fs-artifact.d.ts

@@ -0,0 +1,18 @@
+import type { ArtifactFiles } from '@teambit/legacy/dist/consumer/component/sources/artifact-files';
+import type { ArtifactDefinition } from './artifact-definition';
+import { Artifact } from './artifact';
+import { TaskDescriptor } from '../build-task';
+export declare class FsArtifact extends Artifact {
+    /**
+     * definition of the artifact.
+     */
+    readonly def: ArtifactDefinition;
+    readonly files: ArtifactFiles;
+    readonly task: TaskDescriptor;
+    readonly rootDir: string;
+    constructor(
+    /**
+     * definition of the artifact.
+     */
+    def: ArtifactDefinition, files: ArtifactFiles, task: TaskDescriptor, rootDir: string);
+}

package/dist/artifact/index.d.ts

@@ -0,0 +1,6 @@
+export { ArtifactDefinition, ArtifactModelDefinition } from './artifact-definition';
+export { ExtensionArtifact } from './extension-artifact';
+export { Artifact } from './artifact';
+export { ArtifactList } from './artifact-list';
+export { ArtifactFactory, ArtifactMap } from './artifact-factory';
+export { FsArtifact } from './fs-artifact';

package/dist/build-pipe.d.ts

@@ -0,0 +1,75 @@
+import { EnvDefinition } from '@teambit/envs';
+import { ComponentMap } from '@teambit/component';
+import { Logger } from '@teambit/logger';
+import { ArtifactFactory, ArtifactList, FsArtifact } from './artifact';
+import { BuildTask } from './build-task';
+import { ComponentResult } from './types';
+import { TasksQueue } from './tasks-queue';
+import { EnvsBuildContext } from './builder.service';
+import { TaskResultsList } from './task-results-list';
+export type TaskResults = {
+    /**
+     * task itself. useful for getting its id/description later on.
+     */
+    task: BuildTask;
+    /**
+     * environment were the task was running
+     */
+    env: EnvDefinition;
+    /**
+     * component build results.
+     */
+    componentsResults: ComponentResult[];
+    /**
+     * artifacts generated by the build pipeline.
+     * in case the task finished with errors, this prop is undefined.
+     */
+    artifacts: ComponentMap<ArtifactList<FsArtifact>> | undefined;
+    /**
+     * timestamp of start initiation.
+     */
+    startTime: number;
+    /**
+     * timestamp of task completion.
+     */
+    endTime: number;
+};
+type PipeOptions = {
+    exitOnFirstFailedTask?: boolean;
+    showEnvNameInOutput?: boolean;
+    showEnvVersionInOutput?: boolean;
+};
+export declare class BuildPipe {
+    /**
+     * array of services to apply on the components.
+     */
+    readonly tasksQueue: TasksQueue;
+    readonly envsBuildContext: EnvsBuildContext;
+    readonly logger: Logger;
+    readonly artifactFactory: ArtifactFactory;
+    private previousTaskResults?;
+    private options?;
+    private failedTasks;
+    private failedDependencyTask;
+    private longProcessLogger;
+    private taskResults;
+    constructor(
+    /**
+     * array of services to apply on the components.
+     */
+    tasksQueue: TasksQueue, envsBuildContext: EnvsBuildContext, logger: Logger, artifactFactory: ArtifactFactory, previousTaskResults?: TaskResults[] | undefined, options?: PipeOptions | undefined);
+    get allTasksResults(): TaskResults[];
+    /**
+     * execute a pipeline of build tasks.
+     */
+    execute(): Promise<TaskResultsList>;
+    private executePreBuild;
+    private executeTask;
+    private getPrettyAspectName;
+    private getPrettyEnvName;
+    private executePostBuild;
+    private updateFailedDependencyTask;
+    private shouldSkipTask;
+    private getBuildContext;
+}
+export {};

package/dist/build-pipeline-order.d.ts

@@ -0,0 +1,35 @@
+import { EnvDefinition } from '@teambit/envs';
+import type { TaskSlot } from './builder.main.runtime';
+import { TasksQueue } from './tasks-queue';
+import { PipeFunctionNames } from './builder.service';
+/**
+ * there are two ways how to add tasks to build pipeline.
+ * 1. `getBuildPipe()` method of the env.
+ * 2. registering to the `builder.registerBuildTask()`.
+ *
+ * in the option #1, it's possible to determine the order. e.g. `getBuildPipe() { return [taskA, taskB, taskC]; }`
+ * in the option #2, the register happens once the extension is loaded, so there is no way to put
+ * one task before/after another task.
+ *
+ * To be able to determine the order, you can do the following
+ * 1. "task.location", it has two options "start" and "end". the rest are "middle".
+ * 2. "task.dependencies", the dependencies must be completed for all envs before this task starts.
+ * the dependencies are applicable inside a location and not across locations. see getLocation()
+ * or/and continue reading for more info about this.
+ *
+ * to determine the final order of the tasks, the following is done:
+ * 1. split all tasks to three groups: start, middle and end.
+ * 2. for each group define a dependencies graph for the tasks with "dependencies" prop and the pipeline.
+ * 3. start with the first group "start", toposort the dependencies graph and push the found tasks
+ * to a queue. once completed, iterate the pipeline and add all tasks to the queue.
+ * 4. do the same for the "middle" and "end" groups.
+ *
+ * the reason for splitting the tasks to the three groups and not using the "dependencies" field
+ * alone to determine the order is that the "start" and "end" groups are mostly core and "middle"
+ * is mostly the user entering tasks to the pipeline and we as the core don't know about the users
+ * tasks. For example, a core task "PublishComponent" must happen after the compiler, however, a
+ * user might have an env without a compiler. if we determine the order only by the dependencies
+ * field, the "PublishComponent" would have a dependency "compiler" and because in this case there
+ * is no compiler task, it would throw an error about missing dependencies.
+ */
+export declare function calculatePipelineOrder(taskSlot: TaskSlot, envs: EnvDefinition[], pipeNameOnEnv: PipeFunctionNames, tasks?: string[], skipTests?: boolean, skipTasks?: string[]): TasksQueue;

package/dist/build-pipeline-result-list.d.ts

@@ -0,0 +1,34 @@
+import { ComponentID, Component } from '@teambit/component';
+import type { ArtifactObject } from '@teambit/legacy/dist/consumer/component/sources/artifact-files';
+import { TaskResults } from './build-pipe';
+import { TaskMetadata } from './types';
+export type PipelineReport = {
+    taskId: string;
+    taskName: string;
+    taskDescription?: string;
+    startTime?: number;
+    endTime?: number;
+    errors?: Array<Error | string>;
+    warnings?: string[];
+};
+export type AspectData = {
+    aspectId: string;
+    data: TaskMetadata;
+};
+/**
+ * Helper to get the data and artifacts from the TasksResultsList before saving during the tag
+ */
+export declare class BuildPipelineResultList {
+    private tasksResults;
+    private components;
+    private artifactListsMap;
+    constructor(tasksResults: TaskResults[], components: Component[]);
+    private getFlattenedArtifactListsMapFromAllTasks;
+    getMetadataFromTaskResults(componentId: ComponentID): {
+        [taskId: string]: TaskMetadata;
+    };
+    getPipelineReportOfComponent(componentId: ComponentID): PipelineReport[];
+    getDataOfComponent(componentId: ComponentID): AspectData[];
+    getArtifactsDataOfComponent(componentId: ComponentID): ArtifactObject[] | undefined;
+    private mergeDataIfPossible;
+}

package/dist/build-task.d.ts

@@ -0,0 +1,128 @@
+import type { Component } from '@teambit/component';
+import { LaneId } from '@teambit/lane-id';
+import { ExecutionContext } from '@teambit/envs';
+import type { Network } from '@teambit/isolator';
+import type { ComponentResult } from './types';
+import type { ArtifactDefinition } from './artifact';
+import { TaskResultsList } from './task-results-list';
+import { TaskResults } from './build-pipe';
+import { PipeName } from './builder.service';
+export type TaskLocation = 'start' | 'end';
+/**
+ * delimiter between task.aspectId and task.name
+ */
+export declare const TaskIdDelimiter = ":";
+/**
+ * A folder to write artifacts generated during a build task
+ * This folder is used in the core envs and excluded by default from the package tar file (the core envs is writing this into the npmignore file)
+ */
+export declare const CAPSULE_ARTIFACTS_DIR = "artifacts";
+export interface BuildContext extends ExecutionContext {
+    /**
+     * all components about to be built/tagged.
+     */
+    components: Component[];
+    /**
+     * network of capsules ready to be built.
+     */
+    capsuleNetwork: Network;
+    /**
+     * data generated by tasks that were running before this task
+     */
+    previousTasksResults: TaskResults[];
+    /**
+     * Run the build pipeline in dev mode
+     */
+    dev?: boolean;
+    /**
+     * pipe name such as "build", "tas", "snap".
+     * an example usage is "deploy" task which is running in snap and tag pipeline and has different needs in each one.
+     */
+    pipeName: PipeName;
+    /**
+     * current lane-id if exists. empty when on main.
+     */
+    laneId?: LaneId;
+}
+export interface TaskDescriptor {
+    aspectId: string;
+    name?: string;
+    description?: string;
+}
+export interface BuildTask {
+    /**
+     * aspect id serialized of the creator of the task.
+     * todo: automate this so then it won't be needed to pass manually.
+     */
+    aspectId: string;
+    /**
+     * name of the task. function as an identifier among other tasks of the same aspectId.
+     * spaces and special characters are not allowed. as a convention, use UpperCamelCase style.
+     * (e.g. TypescriptCompiler).
+     */
+    name: string;
+    /**
+     * description of what the task does.
+     * if available, the logger will log it show it in the status-line.
+     */
+    description?: string;
+    /**
+     * where to put the task, before the env pipeline or after
+     */
+    location?: TaskLocation;
+    /**
+     * execute a task in a build context
+     */
+    execute(context: BuildContext): Promise<BuiltTaskResult>;
+    /**
+     * run before the build pipeline has started. this is useful when some preparation are needed to
+     * be done on all envs before the build starts.
+     * e.g. typescript compiler needs to write the tsconfig file. doing it during the task, will
+     * cause dependencies from other envs to get this tsconfig written.
+     */
+    preBuild?(context: BuildContext): Promise<void>;
+    /**
+     * run after the build pipeline completed for all envs. useful for doing some cleanup on the
+     * capsules before the deployment starts.
+     */
+    postBuild?(context: BuildContext, tasksResults: TaskResultsList): Promise<void>;
+    /**
+     * needed if you want the task to be running only after the dependencies were completed
+     * for *all* envs.
+     * normally this is not needed because the build-pipeline runs the tasks in the same order
+     * they're located in the `getBuildPipe()` array and according to the task.location.
+     * the case where this is useful is when a task not only needs to be after another task, but also
+     * after all environments were running that task.
+     * a dependency is task.aspectId. if an aspect has multiple tasks, to be more specific, use
+     * "aspectId:name", e.g. "teambit.compilation/compiler:TypescriptCompiler".
+     */
+    dependencies?: string[];
+}
+export interface BuiltTaskResult {
+    /**
+     * build results for each of the components in the build context.
+     */
+    componentsResults: ComponentResult[];
+    /**
+     * array of artifact definitions to generate after a successful build.
+     */
+    artifacts?: ArtifactDefinition[];
+}
+export declare class BuildTaskHelper {
+    static serializeId({ aspectId, name }: {
+        aspectId: string;
+        name: string;
+    }): string;
+    static deserializeId(id: string): {
+        aspectId: string;
+        name: string;
+    };
+    /**
+     * don't throw an error when the id includes only the aspect-id without the task name.
+     * useful for task dependencies, when it's allowed to specify the aspect-id only.
+     */
+    static deserializeIdAllowEmptyName(id: string): {
+        aspectId: string;
+        name?: string;
+    };
+}

package/dist/build.cmd.d.ts

@@ -0,0 +1,39 @@
+import { Command, CommandOptions } from '@teambit/cli';
+import { Logger } from '@teambit/logger';
+import { Workspace } from '@teambit/workspace';
+import { BuilderMain } from './builder.main.runtime';
+type BuildOpts = {
+    all: boolean;
+    unmodified?: boolean;
+    dev: boolean;
+    rebuild: boolean;
+    install: boolean;
+    cachePackagesOnCapsulesRoot: boolean;
+    reuseCapsules: boolean;
+    tasks: string;
+    listTasks?: string;
+    skipTests?: boolean;
+    failFast?: boolean;
+    includeSnap?: boolean;
+    includeTag?: boolean;
+};
+export declare class BuilderCmd implements Command {
+    private builder;
+    private workspace;
+    private logger;
+    name: string;
+    description: string;
+    extendedDescription: string;
+    arguments: {
+        name: string;
+        description: string;
+    }[];
+    helpUrl: string;
+    alias: string;
+    group: string;
+    options: CommandOptions;
+    constructor(builder: BuilderMain, workspace: Workspace, logger: Logger);
+    report([pattern]: [string], { all, unmodified, dev, install, cachePackagesOnCapsulesRoot, reuseCapsules, tasks, listTasks, skipTests, failFast, includeSnap, includeTag, }: BuildOpts): Promise<string>;
+    private getListTasks;
+}
+export {};

package/dist/builder-env-type.d.ts

@@ -0,0 +1,15 @@
+import { Pipeline } from './pipeline';
+export interface BuilderEnv {
+    /**
+     * return a build pipeline instance.
+     */
+    build(): Pipeline;
+    /**
+     * return a snap pipeline instance.
+     */
+    snap(): Pipeline;
+    /**
+     * return a tag pipeline instance.
+     */
+    tag(): Pipeline;
+}

package/dist/builder.aspect.d.ts

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

package/dist/builder.composition.d.ts

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