@teambit/builder 1.0.228 → 1.0.230

package/dist/builder.graphql.d.ts

@@ -0,0 +1,102 @@
+import { Component, ComponentID } from '@teambit/component';
+import { Logger } from '@teambit/logger';
+import { BuilderMain } from './builder.main.runtime';
+import { PipelineReport } from './build-pipeline-result-list';
+type ArtifactGQLFile = {
+    /**
+     * same as the path - used for GQL caching
+     */
+    id: string;
+    /**
+     * name of the artifact file
+     */
+    name: string;
+    /**
+     * path of the artifact file
+     */
+    path: string;
+    /**
+     * artifact file content (only for text files). Use /api/<component-id>/~aspect/builder/<extension-id>/~<path> to fetch binary file data
+     */
+    content?: string;
+    /**
+     * REST endpoint to fetch artifact data from. /api/<component-id>/~aspect/builder/<extension-id>/~<pat
+     */
+    downloadUrl?: string;
+    /**
+     * Remote storage url to resolve artifact file from
+     */
+    externalUrl?: string;
+    /**
+     * Size in bytes
+     */
+    size: number;
+};
+type ArtifactGQLData = {
+    name: string;
+    description?: string;
+    storage?: string;
+    generatedBy: string;
+    files: ArtifactGQLFile[];
+};
+type TaskReport = PipelineReport & {
+    artifact?: ArtifactGQLData;
+    componentId: ComponentID;
+};
+export declare function builderSchema(builder: BuilderMain, logger: Logger): {
+    typeDefs: import("graphql").DocumentNode;
+    resolvers: {
+        Component: {
+            pipelineReport: (component: Component, { taskId }: {
+                taskId?: string;
+            }) => Promise<{
+                id: string;
+                artifact: {
+                    id: string;
+                    name: string;
+                    description: string | undefined;
+                    task: import("./build-task").TaskDescriptor;
+                    storage: string;
+                    generatedBy: string;
+                    files: {
+                        id: string;
+                        name: string;
+                        path: string;
+                        content: string | undefined;
+                        downloadUrl: string;
+                        externalUrl: string | undefined;
+                        size: number;
+                    }[];
+                } | undefined;
+                taskId: string;
+                taskName: string;
+                taskDescription?: string | undefined;
+                startTime?: number | undefined;
+                endTime?: number | undefined; /**
+                 * artifact file content (only for text files). Use /api/<component-id>/~aspect/builder/<extension-id>/~<path> to fetch binary file data
+                 */
+                errors?: (string | Error)[] | undefined;
+                warnings?: string[] | undefined;
+            }[]>;
+        };
+        TaskReport: {
+            id: (taskReport: TaskReport & {
+                id?: string;
+            }) => string;
+            description: (taskReport: TaskReport) => string | undefined;
+            errors: (taskReport: TaskReport) => string[];
+            warnings: (taskReport: TaskReport) => string[];
+            artifact: (taskReport: TaskReport, { path: pathFilter }: {
+                path?: string;
+            }) => Promise<{
+                files: ArtifactGQLFile[];
+                name: string;
+                description?: string | undefined;
+                storage?: string | undefined;
+                generatedBy: string;
+                id: string;
+            } | undefined>;
+        };
+    };
+};
+export {};

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

@@ -0,0 +1,153 @@
+import { ArtifactVinyl } from '@teambit/legacy/dist/consumer/component/sources/artifact';
+import { ArtifactObject } from '@teambit/legacy/dist/consumer/component/sources/artifact-files';
+import { AspectLoaderMain } from '@teambit/aspect-loader';
+import { CLIMain } from '@teambit/cli';
+import { Component, ComponentMap, IComponent, ComponentMain, ComponentID } from '@teambit/component';
+import { EnvsMain } from '@teambit/envs';
+import { GraphqlMain } from '@teambit/graphql';
+import { SlotRegistry } from '@teambit/harmony';
+import { GlobalConfigMain } from '@teambit/global-config';
+import { Logger, LoggerMain } from '@teambit/logger';
+import { ScopeMain } from '@teambit/scope';
+import { Workspace } from '@teambit/workspace';
+import { IsolateComponentsOptions, IsolatorMain } from '@teambit/isolator';
+import { GeneratorMain } from '@teambit/generator';
+import { UiMain } from '@teambit/ui';
+import { Artifact, ArtifactList } from './artifact';
+import { BuilderService, BuilderServiceOptions } from './builder.service';
+import { BuildTask } from './build-task';
+import { TaskResults } from './build-pipe';
+import { TaskResultsList } from './task-results-list';
+import { AspectData, PipelineReport } from './build-pipeline-result-list';
+import { TaskMetadata } from './types';
+export type TaskSlot = SlotRegistry<BuildTask[]>;
+export type OnTagResults = {
+    builderDataMap: ComponentMap<RawBuilderData>;
+    pipeResults: TaskResultsList[];
+};
+export type OnTagOpts = {
+    disableTagAndSnapPipelines?: boolean;
+    throwOnError?: boolean;
+    forceDeploy?: boolean;
+    populateArtifactsFrom?: ComponentID[];
+    isSnap?: boolean;
+};
+export declare const FILE_PATH_PARAM_DELIM = "~";
+/**
+ * builder data format for the bit object store
+ */
+export type RawBuilderData = {
+    pipeline: PipelineReport[];
+    artifacts?: ArtifactObject[];
+    aspectsData: AspectData[];
+    bitVersion?: string;
+};
+/**
+ * builder data mapped to an ArtifactList instance
+ */
+export type BuilderData = Omit<RawBuilderData, 'artifacts'> & {
+    artifacts: ArtifactList<Artifact>;
+};
+export declare class BuilderMain {
+    private envs;
+    private workspace;
+    private buildService;
+    private tagService;
+    private snapService;
+    private scope;
+    private isolator;
+    private aspectLoader;
+    private componentAspect;
+    private globalConfig;
+    private buildTaskSlot;
+    private tagTaskSlot;
+    private snapTaskSlot;
+    private logger;
+    constructor(envs: EnvsMain, workspace: Workspace, buildService: BuilderService, tagService: BuilderService, snapService: BuilderService, scope: ScopeMain, isolator: IsolatorMain, aspectLoader: AspectLoaderMain, componentAspect: ComponentMain, globalConfig: GlobalConfigMain, buildTaskSlot: TaskSlot, tagTaskSlot: TaskSlot, snapTaskSlot: TaskSlot, logger: Logger);
+    private storeArtifacts;
+    pipelineResultsToBuilderData(components: Component[], buildPipelineResults: TaskResults[]): ComponentMap<RawBuilderData>;
+    tagListener(components: Component[], options?: OnTagOpts, isolateOptions?: IsolateComponentsOptions, builderOptions?: BuilderServiceOptions): Promise<OnTagResults>;
+    /**
+     * remove the onlyOverview from the preview data of the component if
+     * the env is in the workspace
+     * the env is not tagged with the component
+     * the last tagged env has onlyOverview undefined in preview data
+     *
+     * We don't want to do this but have no choice because,
+     * when we load components in workspace,
+     * we set the onlyOverview to true in the env's preview data
+     * which sets the onlyOverview to true in the component's preview data
+     * but if you don't tag the env with the component,
+     * the onlyOverview will be true in the component's preview data, since its env is in the workspace
+     * even though the env it is tagged with doesn't have onlyOverview in its preview data
+     * which will result in inconsistent preview data when exported to the scope
+     */
+    sanitizePreviewData(harmonyComps: Component[]): Promise<void>;
+    private validateBuilderDataMap;
+    private combineBuildDataFrom;
+    getArtifactsVinylByAspect(component: Component, aspectName: string): Promise<ArtifactVinyl[]>;
+    getArtifactsVinylByAspectAndName(component: Component, aspectName: string, name: string): Promise<ArtifactVinyl[]>;
+    getArtifactsVinylByAspectAndTaskName(component: Component, aspectName: string, name: string): Promise<ArtifactVinyl[]>;
+    getArtifactsByName(component: Component, name: string): ArtifactList<Artifact>;
+    getArtifactsByAspect(component: Component, aspectName: string): ArtifactList<Artifact>;
+    getArtifactsByAspectAndName(component: Component, aspectName: string, name: string): ArtifactList<Artifact>;
+    getArtifactsbyAspectAndTaskName(component: IComponent, aspectName: string, taskName: string): ArtifactList<Artifact>;
+    /**
+     * this is the aspect's data that was generated as "metadata" of the task component-result during the build process
+     * and saved by the builder aspect in the "aspectsData" property.
+     * (not to be confused with the data saved in the aspect itself, which is saved in the "data" property of the aspect).
+     */
+    getDataByAspect(component: IComponent, aspectName: string): TaskMetadata | undefined;
+    getArtifacts(component: IComponent): ArtifactList<Artifact>;
+    getBuilderData(component: IComponent): BuilderData | undefined;
+    build(components: Component[], isolateOptions?: IsolateComponentsOptions, builderOptions?: BuilderServiceOptions, extraOptions?: {
+        includeTag?: boolean;
+        includeSnap?: boolean;
+    }): Promise<TaskResultsList>;
+    runTagTasks(components: Component[], builderOptions: BuilderServiceOptions): Promise<TaskResultsList>;
+    runSnapTasks(components: Component[], builderOptions: BuilderServiceOptions): Promise<TaskResultsList>;
+    listTasks(component: Component): {
+        id: ComponentID;
+        envId: string;
+        buildTasks: string[];
+        tagTasks: string[];
+        snapTasks: string[];
+    };
+    /**
+     * 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;
+    /**
+     * @deprecated use registerTagTasks or registerSnapTasks
+     */
+    registerDeployTasks(tasks: BuildTask[]): 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;
+    /**
+     * 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;
+    getDownloadUrlForArtifact(componentId: ComponentID, taskId: string, path?: string): string;
+    static slots: ((registerFn: () => string) => SlotRegistry<BuildTask>)[];
+    static runtime: import("@teambit/harmony").RuntimeDefinition;
+    static dependencies: import("@teambit/harmony").Aspect[];
+    static provider([cli, envs, workspace, scope, isolator, loggerExt, aspectLoader, graphql, generator, component, ui, globalConfig]: [
+        CLIMain,
+        EnvsMain,
+        Workspace,
+        ScopeMain,
+        IsolatorMain,
+        LoggerMain,
+        AspectLoaderMain,
+        GraphqlMain,
+        GeneratorMain,
+        ComponentMain,
+        UiMain,
+        GlobalConfigMain
+    ], config: any, [buildTaskSlot, tagTaskSlot, snapTaskSlot]: [TaskSlot, TaskSlot, TaskSlot]): Promise<BuilderMain>;
+}

package/dist/builder.route.d.ts

@@ -0,0 +1,20 @@
+/// <reference types="express" />
+import { Request, Response, Route } from '@teambit/express';
+import { Logger } from '@teambit/logger';
+import { ScopeMain } from '@teambit/scope';
+import { BuilderMain } from './builder.main.runtime';
+export declare const routePath = "builder";
+export type BuilderUrlParams = {
+    aspectId?: string;
+    filePath?: string;
+};
+export declare const defaultExtension = ".tgz";
+export declare class BuilderRoute implements Route {
+    private builder;
+    private scope;
+    private logger;
+    constructor(builder: BuilderMain, scope: ScopeMain, logger: Logger);
+    route: string;
+    method: string;
+    middlewares: ((req: Request<BuilderUrlParams>, res: Response) => Promise<import("express").Response<any, Record<string, any>>>)[];
+}

package/dist/builder.service.d.ts

@@ -0,0 +1,105 @@
+import { EnvService, ExecutionContext, EnvDefinition, Env, EnvContext, ServiceTransformationMap } from '@teambit/envs';
+import { ScopeMain } from '@teambit/scope';
+import { GlobalConfigMain } from '@teambit/global-config';
+import { Logger } from '@teambit/logger';
+import { IsolatorMain } from '@teambit/isolator';
+import { Component, ComponentID } from '@teambit/component';
+import { TaskResults } from './build-pipe';
+import { TaskResultsList } from './task-results-list';
+import { TaskSlot } from './builder.main.runtime';
+import { BuildContext, BuildTask } from './build-task';
+import { ArtifactFactory } from './artifact';
+export type BuildServiceResults = {
+    id: string;
+    buildResults: TaskResultsList;
+    components: Component[];
+    errors?: [];
+};
+export type BuilderServiceOptions = {
+    seedersOnly?: boolean;
+    originalSeeders?: ComponentID[];
+    tasks?: string[];
+    skipTests?: boolean;
+    skipTasks?: string[];
+    previousTasksResults?: TaskResults[];
+    dev?: boolean;
+    exitOnFirstFailedTask?: boolean;
+    capsulesBaseDir?: string;
+};
+type BuilderTransformationMap = ServiceTransformationMap & {
+    getBuildPipe: () => BuildTask[];
+    getTagPipe: () => BuildTask[];
+    getSnapPipe: () => BuildTask[];
+};
+export type EnvsBuildContext = {
+    [envId: string]: BuildContext;
+};
+declare const pipeNames: {
+    getBuildPipe: string;
+    getTagPipe: string;
+    getSnapPipe: string;
+};
+export type PipeName = 'build' | 'tag' | 'snap';
+export type BuilderDescriptor = Array<{
+    pipeName: PipeName;
+    tasks: string[];
+}>;
+export type PipeFunctionNames = keyof typeof pipeNames;
+export declare class BuilderService implements EnvService<BuildServiceResults, string> {
+    /**
+     * isolator extension.
+     */
+    private isolator;
+    /**
+     * logger extension.
+     */
+    private logger;
+    /**
+     * task slot (e.g tasks registered by other extensions.).
+     */
+    private taskSlot;
+    /**
+     * a method with such name should be implemented on the env in order to run the pipe tasks.
+     */
+    private pipeNameOnEnv;
+    /**
+     * pipe name to display on the console during the execution
+     */
+    private displayPipeName;
+    private artifactFactory;
+    private scope;
+    private globalConfig;
+    name: string;
+    constructor(
+    /**
+     * isolator extension.
+     */
+    isolator: IsolatorMain, 
+    /**
+     * logger extension.
+     */
+    logger: Logger, 
+    /**
+     * task slot (e.g tasks registered by other extensions.).
+     */
+    taskSlot: TaskSlot, 
+    /**
+     * a method with such name should be implemented on the env in order to run the pipe tasks.
+     */
+    pipeNameOnEnv: PipeFunctionNames, 
+    /**
+     * pipe name to display on the console during the execution
+     */
+    displayPipeName: PipeName, artifactFactory: ArtifactFactory, scope: ScopeMain, globalConfig: GlobalConfigMain);
+    /**
+     * runs all tasks for all envs
+     */
+    runOnce(envsExecutionContext: ExecutionContext[], options: BuilderServiceOptions): Promise<TaskResultsList>;
+    getComponentsCapsulesBaseDir(): string | undefined;
+    render(): string;
+    transform(env: Env, envContext: EnvContext): BuilderTransformationMap | undefined;
+    getDescriptor(): string;
+    private getTasksNamesByPipeFunc;
+    getCurrentPipeTasks(env: EnvDefinition): string[];
+}
+export {};

package/dist/exceptions/artifact-definition-no-glob.d.ts

@@ -0,0 +1,3 @@
+export declare class ArtifactDefinitionError extends Error {
+    constructor();
+}

package/dist/exceptions/artifact-storage-error.d.ts

@@ -0,0 +1,7 @@
+import { BitError } from '@teambit/bit-error';
+import { Component } from '@teambit/component';
+export declare class ArtifactStorageError extends BitError {
+    private originalError;
+    private component;
+    constructor(originalError: Error, component: Component);
+}

package/dist/exceptions/capsule-not-found.d.ts

@@ -0,0 +1,5 @@
+import { ComponentID } from '@teambit/component';
+export declare class CapsuleNotFound extends Error {
+    private id;
+    constructor(id: ComponentID);
+}

package/dist/exceptions/index.d.ts

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

package/dist/exceptions/invalid-task.d.ts

@@ -0,0 +1,5 @@
+import { BitError } from '@teambit/bit-error';
+export declare class InvalidTask extends BitError {
+    readonly taskAspectId: string;
+    constructor(taskAspectId: string, reason: string);
+}

package/dist/index.d.ts

@@ -0,0 +1,19 @@
+import { BuilderAspect } from './builder.aspect';
+export { ArtifactVinyl } from '@teambit/legacy/dist/consumer/component/sources/artifact';
+export { BuildPipe } from './build-pipe';
+export type { TaskResults } from './build-pipe';
+export type { ComponentResult, TaskMetadata } from './types';
+export type { BuildContext, BuildTask, BuiltTaskResult, TaskLocation } from './build-task';
+export { CAPSULE_ARTIFACTS_DIR } from './build-task';
+export type { PipeName } from './builder.service';
+export type { BuilderMain, RawBuilderData, BuilderData, OnTagOpts } from './builder.main.runtime';
+export type { TaskHandler } from './pipeline';
+export { Pipeline } from './pipeline';
+export type { PipelineReport } from './build-pipeline-result-list';
+export type { BuilderEnv } from './builder-env-type';
+export type { WholeArtifactStorageResolver, FileStorageResolver, ArtifactStorageResolver } from './storage';
+export type { ArtifactDefinition, ArtifactModelDefinition } from './artifact';
+export { Artifact, ArtifactList, ArtifactFactory } from './artifact';
+export type { Task } from './task';
+export { TaskResultsList } from './task-results-list';
+export { BuilderAspect, BuilderAspect as default };

package/dist/pipeline/index.d.ts

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

package/dist/pipeline/pipeline-results.d.ts

@@ -0,0 +1,2 @@
+export declare class PipelineResults {
+}

package/dist/pipeline.d.ts

@@ -0,0 +1,43 @@
+import { EnvContext, EnvHandler } from '@teambit/envs';
+import { Task } from './task';
+import { BuildTask } from './build-task';
+export type TaskHandler = {
+    handler: EnvHandler<Task>;
+    name: string;
+};
+/**
+ * create and maintain build pipelines for component
+ * dev environments.
+ */
+export declare class Pipeline {
+    private _tasks;
+    constructor(_tasks: TaskHandler[]);
+    /**
+     * list all tasks in the build pipeline.
+     */
+    get tasks(): TaskHandler[];
+    private initiateTasks;
+    /**
+     * add a build task to the pipeline.
+     */
+    add(tasks: TaskHandler[]): this;
+    /**
+     * remove a build task from the pipeline.
+     */
+    remove(taskNames: string[]): this;
+    /**
+     * replace a build task in the pipeline.
+     */
+    replace(tasks: TaskHandler[]): this;
+    /**
+     * return a new pipeline with the tasks from the pipeline args added.
+     * @param pipeline
+     * @returns
+     */
+    concat(pipeline: Pipeline): Pipeline;
+    /**
+     * compute the pipeline.
+     */
+    compute(context: EnvContext): BuildTask[];
+    static from(tasks: TaskHandler[]): Pipeline;
+}

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

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

package/dist/storage/default-resolver.d.ts

@@ -0,0 +1,7 @@
+import { Component } from '@teambit/component';
+import { FsArtifact } from '../artifact';
+import { WholeArtifactStorageResolver } from './storage-resolver';
+export declare class DefaultResolver implements WholeArtifactStorageResolver {
+    name: string;
+    store(component: Component, artifact: FsArtifact): Promise<void>;
+}

package/dist/storage/index.d.ts

@@ -0,0 +1,2 @@
+export { WholeArtifactStorageResolver, ArtifactStorageResolver, FileStorageResolver } from './storage-resolver';
+export { DefaultResolver } from './default-resolver';

package/dist/storage/storage-resolver.d.ts

@@ -0,0 +1,26 @@
+import { Component } from '@teambit/component';
+import { ArtifactVinyl } from '@teambit/legacy/dist/consumer/component/sources/artifact';
+import { FsArtifact } from '../artifact';
+export type StoreResult = {
+    [path: string]: string;
+};
+interface BaseStorageResolver {
+    /**
+     * name of the storage resolver.
+     */
+    name: string;
+}
+export interface WholeArtifactStorageResolver extends BaseStorageResolver {
+    /**
+     * store artifacts in the storage.
+     */
+    store(component: Component, artifact: FsArtifact): Promise<StoreResult | undefined | void>;
+}
+export interface FileStorageResolver extends BaseStorageResolver {
+    /**
+     * store artifacts in the storage.
+     */
+    storeFile(component: Component, artifact: FsArtifact, file: ArtifactVinyl): Promise<string | undefined | void>;
+}
+export type ArtifactStorageResolver = FileStorageResolver | WholeArtifactStorageResolver;
+export {};

package/dist/task-results-list.d.ts

@@ -0,0 +1,22 @@
+import { TasksQueue } from './tasks-queue';
+import { TaskResults } from './build-pipe';
+export declare class TaskResultsList {
+    tasksQueue: TasksQueue;
+    /**
+     * results of all tasks executed in the build pipeline.
+     */
+    tasksResults: TaskResults[];
+    capsuleRootDir: string;
+    constructor(tasksQueue: TasksQueue, 
+    /**
+     * results of all tasks executed in the build pipeline.
+     */
+    tasksResults: TaskResults[], capsuleRootDir: string);
+    hasErrors(): boolean;
+    throwErrorsIfExist(): void;
+    /**
+     * group errors from all tasks and show them nicely to the user
+     */
+    getErrorMessageFormatted(): string | null;
+    private aggregateTaskErrorsToOneString;
+}

package/dist/task.d.ts

@@ -0,0 +1,44 @@
+import { BuildContext, BuiltTaskResult } from './build-task';
+import { TaskResultsList } from './task-results-list';
+/**
+ * this is the external interface for task. please make
+ * sure to use only this interface outside of this builder
+ * aspect.
+ */
+export interface Task {
+    /**
+     * names ideally with dashes 'typescript'
+     */
+    name: string;
+    /**
+     * description of what the task does.
+     */
+    description?: string;
+    /**
+     * 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[];
+}

package/dist/tasks-queue.d.ts

@@ -0,0 +1,16 @@
+import { EnvDefinition } from '@teambit/envs';
+import { BuildTask } from './build-task';
+type EnvTask = {
+    env: EnvDefinition;
+    task: BuildTask;
+};
+export declare class TasksQueue extends Array<EnvTask> {
+    toString(): string;
+    /**
+     * make sure tasks names are valid and there are no duplications
+     */
+    validate(): void;
+    private validateTaskName;
+    private validateDuplications;
+}
+export {};

package/dist/templates/build-task/files/index-file.d.ts

@@ -0,0 +1,2 @@
+import { ComponentContext } from '@teambit/generator';
+export declare function indexFile({ namePascalCase, name }: ComponentContext): string;

package/dist/templates/build-task/files/task-file.d.ts

@@ -0,0 +1,2 @@
+import { ComponentContext } from '@teambit/generator';
+export declare function taskFile({ namePascalCase }: ComponentContext): string;

package/dist/templates/build-task/index.d.ts

@@ -0,0 +1,2 @@
+import { ComponentTemplate } from '@teambit/generator';
+export declare const buildTaskTemplate: ComponentTemplate;