@angular/compiler-cli 15.2.0 → 16.0.0-next.0

package/ngcc/src/entry_point_finder/tracing_entry_point_finder.d.ts

@@ -1,67 +0,0 @@
-/**
- * @license
- * Copyright Google LLC All Rights Reserved.
- *
- * Use of this source code is governed by an MIT-style license that can be
- * found in the LICENSE file at https://angular.io/license
- */
-import { AbsoluteFsPath, ReadonlyFileSystem } from '../../../src/ngtsc/file_system';
-import { Logger } from '../../../src/ngtsc/logging';
-import { EntryPointWithDependencies } from '../dependencies/dependency_host';
-import { DependencyResolver, SortedEntryPointsInfo } from '../dependencies/dependency_resolver';
-import { NgccConfiguration } from '../packages/configuration';
-import { PathMappings } from '../path_mappings';
-import { EntryPointFinder } from './interface';
-/**
- * An EntryPointFinder that starts from a set of initial files and only returns entry-points that
- * are dependencies of these files.
- *
- * This is faster than processing all entry-points in the entire file-system, and is used primarily
- * by the CLI integration.
- *
- * There are two concrete implementations of this class.
- *
- * * `TargetEntryPointFinder` - is given a single entry-point as the initial entry-point. This can
- *   be used in the synchronous CLI integration where the build tool has identified an external
- *   import to one of the source files being built.
- * * `ProgramBasedEntryPointFinder` - computes the initial entry-points from the source files
- *   computed from a `tsconfig.json` file. This can be used in the asynchronous CLI integration
- *   where the `tsconfig.json` to be used to do the build is known.
- */
-export declare abstract class TracingEntryPointFinder implements EntryPointFinder {
-    protected fs: ReadonlyFileSystem;
-    protected config: NgccConfiguration;
-    protected logger: Logger;
-    protected resolver: DependencyResolver;
-    protected basePath: AbsoluteFsPath;
-    protected pathMappings: PathMappings | undefined;
-    private basePaths;
-    constructor(fs: ReadonlyFileSystem, config: NgccConfiguration, logger: Logger, resolver: DependencyResolver, basePath: AbsoluteFsPath, pathMappings: PathMappings | undefined);
-    /**
-     * Search for Angular package entry-points.
-     */
-    findEntryPoints(): SortedEntryPointsInfo;
-    /**
-     * Return an array of entry-point paths from which to start the trace.
-     */
-    protected abstract getInitialEntryPointPaths(): AbsoluteFsPath[];
-    /**
-     * For the given `entryPointPath`, compute, or retrieve, the entry-point information, including
-     * paths to other entry-points that this entry-point depends upon.
-     *
-     * @param entryPointPath the path to the entry-point whose information and dependencies are to be
-     *     retrieved or computed.
-     *
-     * @returns the entry-point and its dependencies or `null` if the entry-point is not compiled by
-     *     Angular or cannot be determined.
-     */
-    protected abstract getEntryPointWithDeps(entryPointPath: AbsoluteFsPath): EntryPointWithDependencies | null;
-    /**
-     * Parse the path-mappings to compute the base-paths that need to be considered when finding
-     * entry-points.
-     *
-     * This processing can be time-consuming if the path-mappings are complex or extensive.
-     * So the result is cached locally once computed.
-     */
-    protected getBasePaths(): AbsoluteFsPath[];
-}

package/ngcc/src/entry_point_finder/utils.d.ts

@@ -1,38 +0,0 @@
-/**
- * @license
- * Copyright Google LLC All Rights Reserved.
- *
- * Use of this source code is governed by an MIT-style license that can be
- * found in the LICENSE file at https://angular.io/license
- */
-import { AbsoluteFsPath } from '../../../src/ngtsc/file_system';
-import { Logger } from '../../../src/ngtsc/logging';
-import { PathMappings } from '../path_mappings';
-/**
- * Extract all the base-paths that we need to search for entry-points.
- *
- * This always contains the standard base-path (`sourceDirectory`).
- * But it also parses the `paths` mappings object to guess additional base-paths.
- *
- * For example:
- *
- * ```
- * getBasePaths('/node_modules', {baseUrl: '/dist', paths: {'*': ['lib/*', 'lib/generated/*']}})
- * > ['/node_modules', '/dist/lib']
- * ```
- *
- * Notice that `'/dist'` is not included as there is no `'*'` path,
- * and `'/dist/lib/generated'` is not included as it is covered by `'/dist/lib'`.
- *
- * @param sourceDirectory The standard base-path (e.g. node_modules).
- * @param pathMappings Path mapping configuration, from which to extract additional base-paths.
- */
-export declare function getBasePaths(logger: Logger, sourceDirectory: AbsoluteFsPath, pathMappings: PathMappings | undefined): AbsoluteFsPath[];
-/**
- * Run a task and track how long it takes.
- *
- * @param task The task whose duration we are tracking.
- * @param log The function to call with the duration of the task.
- * @returns The result of calling `task`.
- */
-export declare function trackDuration<T = void>(task: () => T extends Promise<unknown> ? never : T, log: (duration: number) => void): T;

package/ngcc/src/execution/analyze_entry_points.d.ts

@@ -1,9 +0,0 @@
-import { FileSystem } from '../../../src/ngtsc/file_system';
-import { Logger } from '../../../src/ngtsc/logging';
-import { EntryPointFinder } from '../entry_point_finder/interface';
-import { EntryPointJsonProperty } from '../packages/entry_point';
-import { AnalyzeEntryPointsFn } from './api';
-/**
- * Create the function for performing the analysis of the entry-points.
- */
-export declare function getAnalyzeEntryPointsFn(logger: Logger, finder: EntryPointFinder, fileSystem: FileSystem, supportedPropertiesToConsider: EntryPointJsonProperty[], typingsOnly: boolean, compileAllFormats: boolean, propertiesToConsider: string[], inParallel: boolean): AnalyzeEntryPointsFn;

package/ngcc/src/execution/api.d.ts

@@ -1,27 +0,0 @@
-/**
- * @license
- * Copyright Google LLC All Rights Reserved.
- *
- * Use of this source code is governed by an MIT-style license that can be
- * found in the LICENSE file at https://angular.io/license
- */
-import { FileToWrite } from '../rendering/utils';
-import { Task, TaskCompletedCallback, TaskQueue } from './tasks/api';
-/**
- * The type of the function that analyzes entry-points and creates the list of tasks.
- *
- * @return A list of tasks that need to be executed in order to process the necessary format
- *         properties for all entry-points.
- */
-export type AnalyzeEntryPointsFn = () => TaskQueue;
-/** The type of the function that can process/compile a task. */
-export type CompileFn<T> = (task: Task) => void | T;
-/** The type of the function that creates the `CompileFn` function used to process tasks. */
-export type CreateCompileFn = <T extends void | Promise<void>>(beforeWritingFiles: (transformedFiles: FileToWrite[]) => T, onTaskCompleted: TaskCompletedCallback) => CompileFn<T>;
-/**
- * A class that orchestrates and executes the required work (i.e. analyzes the entry-points,
- * processes the resulting tasks, does book-keeping and validates the final outcome).
- */
-export interface Executor {
-    execute(analyzeEntryPoints: AnalyzeEntryPointsFn, createCompileFn: CreateCompileFn): void | Promise<void>;
-}

package/ngcc/src/execution/cluster/api.d.ts

@@ -1,51 +0,0 @@
-/**
- * @license
- * Copyright Google LLC All Rights Reserved.
- *
- * Use of this source code is governed by an MIT-style license that can be
- * found in the LICENSE file at https://angular.io/license
- */
-import { AbsoluteFsPath } from '../../../../src/ngtsc/file_system';
-import { JsonObject } from '../../utils';
-import { PackageJsonChange } from '../../writing/package_json_updater';
-import { Task, TaskProcessingOutcome } from '../tasks/api';
-/** A message reporting that the worker is ready for retrieving tasks. */
-export interface ReadyMessage extends JsonObject {
-    type: 'ready';
-}
-/** A message reporting that an unrecoverable error occurred. */
-export interface ErrorMessage extends JsonObject {
-    type: 'error';
-    error: string;
-}
-/** A message requesting the processing of a task. */
-export interface ProcessTaskMessage extends JsonObject {
-    type: 'process-task';
-    task: Task;
-}
-/**
- * A message reporting the result of processing the currently assigned task.
- *
- * NOTE: To avoid the communication overhead, the task is not included in the message. Instead, the
- *       master is responsible for keeping a mapping of workers to their currently assigned tasks.
- */
-export interface TaskCompletedMessage extends JsonObject {
-    type: 'task-completed';
-    outcome: TaskProcessingOutcome;
-    message: string | null;
-}
-/** A message listing the paths to transformed files about to be written to disk. */
-export interface TransformedFilesMessage extends JsonObject {
-    type: 'transformed-files';
-    files: AbsoluteFsPath[];
-}
-/** A message requesting the update of a `package.json` file. */
-export interface UpdatePackageJsonMessage extends JsonObject {
-    type: 'update-package-json';
-    packageJsonPath: AbsoluteFsPath;
-    changes: PackageJsonChange[];
-}
-/** The type of messages sent from cluster workers to the cluster master. */
-export type MessageFromWorker = ReadyMessage | ErrorMessage | TaskCompletedMessage | TransformedFilesMessage | UpdatePackageJsonMessage;
-/** The type of messages sent from the cluster master to cluster workers. */
-export type MessageToWorker = ProcessTaskMessage;

package/ngcc/src/execution/cluster/executor.d.ts

@@ -1,29 +0,0 @@
-/**
- * @license
- * Copyright Google LLC All Rights Reserved.
- *
- * Use of this source code is governed by an MIT-style license that can be
- * found in the LICENSE file at https://angular.io/license
- */
-import { PathManipulation } from '../../../../src/ngtsc/file_system';
-import { Logger } from '../../../../src/ngtsc/logging';
-import { AsyncLocker } from '../../locking/async_locker';
-import { FileWriter } from '../../writing/file_writer';
-import { PackageJsonUpdater } from '../../writing/package_json_updater';
-import { AnalyzeEntryPointsFn, CreateCompileFn, Executor } from '../api';
-import { CreateTaskCompletedCallback } from '../tasks/api';
-/**
- * An `Executor` that processes tasks in parallel (on multiple processes) and completes
- * asynchronously.
- */
-export declare class ClusterExecutor implements Executor {
-    private workerCount;
-    private fileSystem;
-    private logger;
-    private fileWriter;
-    private pkgJsonUpdater;
-    private lockFile;
-    private createTaskCompletedCallback;
-    constructor(workerCount: number, fileSystem: PathManipulation, logger: Logger, fileWriter: FileWriter, pkgJsonUpdater: PackageJsonUpdater, lockFile: AsyncLocker, createTaskCompletedCallback: CreateTaskCompletedCallback);
-    execute(analyzeEntryPoints: AnalyzeEntryPointsFn, _createCompileFn: CreateCompileFn): Promise<void>;
-}

package/ngcc/src/execution/cluster/master.d.ts

@@ -1,57 +0,0 @@
-/**
- * @license
- * Copyright Google LLC All Rights Reserved.
- *
- * Use of this source code is governed by an MIT-style license that can be
- * found in the LICENSE file at https://angular.io/license
- */
-import { AbsoluteFsPath, PathManipulation } from '../../../../src/ngtsc/file_system';
-import { Logger } from '../../../../src/ngtsc/logging';
-import { FileWriter } from '../../writing/file_writer';
-import { PackageJsonUpdater } from '../../writing/package_json_updater';
-import { AnalyzeEntryPointsFn } from '../api';
-import { CreateTaskCompletedCallback } from '../tasks/api';
-/**
- * The cluster master is responsible for analyzing all entry-points, planning the work that needs to
- * be done, distributing it to worker-processes and collecting/post-processing the results.
- */
-export declare class ClusterMaster {
-    private maxWorkerCount;
-    private fileSystem;
-    private logger;
-    private fileWriter;
-    private pkgJsonUpdater;
-    private finishedDeferred;
-    private processingStartTime;
-    private taskAssignments;
-    private taskQueue;
-    private onTaskCompleted;
-    private remainingRespawnAttempts;
-    constructor(maxWorkerCount: number, fileSystem: PathManipulation, logger: Logger, fileWriter: FileWriter, pkgJsonUpdater: PackageJsonUpdater, analyzeEntryPoints: AnalyzeEntryPointsFn, createTaskCompletedCallback: CreateTaskCompletedCallback);
-    run(): Promise<void>;
-    /** Try to find available (idle) workers and assign them available (non-blocked) tasks. */
-    private maybeDistributeWork;
-    /** Handle a worker's exiting. (Might be intentional or not.) */
-    private onWorkerExit;
-    /** Handle a message from a worker. */
-    private onWorkerMessage;
-    /** Handle a worker's coming online and ready for retrieving IPC messages. */
-    private onWorkerReady;
-    /** Handle a worker's having completed their assigned task. */
-    private onWorkerTaskCompleted;
-    /** Handle a worker's message regarding the files transformed while processing its task. */
-    private onWorkerTransformedFiles;
-    /** Handle a worker's request to update a `package.json` file. */
-    private onWorkerUpdatePackageJson;
-    /** Stop all workers and stop listening on cluster events. */
-    private stopWorkers;
-    /**
-     * Wrap an event handler to ensure that `finishedDeferred` will be rejected on error (regardless
-     * if the handler completes synchronously or asynchronously).
-     */
-    private wrapEventHandler;
-}
-/** Wrapper for resolving the cluster worker script. Useful for test patching. */
-export declare class ClusterWorkerScriptResolver {
-    static resolve(fileSystem: PathManipulation): AbsoluteFsPath;
-}

package/ngcc/src/execution/cluster/ngcc_cluster_worker.d.ts

@@ -1,8 +0,0 @@
-/**
- * @license
- * Copyright Google LLC All Rights Reserved.
- *
- * Use of this source code is governed by an MIT-style license that can be
- * found in the LICENSE file at https://angular.io/license
- */
-export {};

package/ngcc/src/execution/cluster/package_json_updater.d.ts

@@ -1,22 +0,0 @@
-/**
- * @license
- * Copyright Google LLC All Rights Reserved.
- *
- * Use of this source code is governed by an MIT-style license that can be
- * found in the LICENSE file at https://angular.io/license
- */
-import { AbsoluteFsPath } from '../../../../src/ngtsc/file_system';
-import { JsonObject } from '../../utils';
-import { PackageJsonChange, PackageJsonUpdate, PackageJsonUpdater } from '../../writing/package_json_updater';
-/**
- * A `PackageJsonUpdater` for cluster workers that will send update changes to the master process so
- * that it can safely handle update operations on multiple processes.
- */
-export declare class ClusterWorkerPackageJsonUpdater implements PackageJsonUpdater {
-    constructor();
-    createUpdate(): PackageJsonUpdate;
-    /**
-     * Apply the changes in-memory (if necessary) and send a message to the master process.
-     */
-    writeChanges(changes: PackageJsonChange[], packageJsonPath: AbsoluteFsPath, preExistingParsedJson?: JsonObject): void;
-}

package/ngcc/src/execution/cluster/utils.d.ts

@@ -1,44 +0,0 @@
-/**
- * @license
- * Copyright Google LLC All Rights Reserved.
- *
- * Use of this source code is governed by an MIT-style license that can be
- * found in the LICENSE file at https://angular.io/license
- */
-import { MessageFromWorker, MessageToWorker } from './api';
-/** Expose a `Promise` instance as well as APIs for resolving/rejecting it. */
-export declare class Deferred<T> {
-    /**
-     * Resolve the associated promise with the specified value.
-     * If the value is a rejection (constructed with `Promise.reject()`), the promise will be rejected
-     * instead.
-     *
-     * @param value The value to resolve the promise with.
-     */
-    resolve: (value: T) => void;
-    /**
-     * Rejects the associated promise with the specified reason.
-     *
-     * @param reason The rejection reason.
-     */
-    reject: (reason: any) => void;
-    /** The `Promise` instance associated with this deferred. */
-    promise: Promise<T>;
-}
-/**
- * Send a message to the cluster master.
- * (This function should be invoked from cluster workers only.)
- *
- * @param msg The message to send to the cluster master.
- * @return A promise that is resolved once the message has been sent.
- */
-export declare const sendMessageToMaster: (msg: MessageFromWorker) => Promise<void>;
-/**
- * Send a message to a cluster worker.
- * (This function should be invoked from the cluster master only.)
- *
- * @param workerId The ID of the recipient worker.
- * @param msg The message to send to the worker.
- * @return A promise that is resolved once the message has been sent.
- */
-export declare const sendMessageToWorker: (workerId: number, msg: MessageToWorker) => Promise<void>;

package/ngcc/src/execution/cluster/worker.d.ts

@@ -1,10 +0,0 @@
-/**
- * @license
- * Copyright Google LLC All Rights Reserved.
- *
- * Use of this source code is governed by an MIT-style license that can be
- * found in the LICENSE file at https://angular.io/license
- */
-import { Logger } from '../../../../src/ngtsc/logging';
-import { CreateCompileFn } from '../api';
-export declare function startWorker(logger: Logger, createCompileFn: CreateCompileFn): Promise<void>;

package/ngcc/src/execution/create_compile_function.d.ts

@@ -1,10 +0,0 @@
-import { FileSystem } from '../../../src/ngtsc/file_system';
-import { Logger } from '../../../src/ngtsc/logging';
-import { ParsedConfiguration } from '../../../src/perform_compile';
-import { PathMappings } from '../path_mappings';
-import { FileWriter } from '../writing/file_writer';
-import { CreateCompileFn } from './api';
-/**
- * The function for creating the `compile()` function.
- */
-export declare function getCreateCompileFn(fileSystem: FileSystem, logger: Logger, fileWriter: FileWriter, enableI18nLegacyMessageIdFormat: boolean, tsConfig: ParsedConfiguration | null, pathMappings: PathMappings | undefined): CreateCompileFn;

package/ngcc/src/execution/single_process_executor.d.ts

@@ -1,34 +0,0 @@
-/**
- * @license
- * Copyright Google LLC All Rights Reserved.
- *
- * Use of this source code is governed by an MIT-style license that can be
- * found in the LICENSE file at https://angular.io/license
- */
-import { Logger } from '../../../src/ngtsc/logging';
-import { AsyncLocker } from '../locking/async_locker';
-import { SyncLocker } from '../locking/sync_locker';
-import { AnalyzeEntryPointsFn, CreateCompileFn, Executor } from './api';
-import { CreateTaskCompletedCallback } from './tasks/api';
-export declare abstract class SingleProcessorExecutorBase {
-    private logger;
-    private createTaskCompletedCallback;
-    constructor(logger: Logger, createTaskCompletedCallback: CreateTaskCompletedCallback);
-    doExecute(analyzeEntryPoints: AnalyzeEntryPointsFn, createCompileFn: CreateCompileFn): void | Promise<void>;
-}
-/**
- * An `Executor` that processes all tasks serially and completes synchronously.
- */
-export declare class SingleProcessExecutorSync extends SingleProcessorExecutorBase implements Executor {
-    private lockFile;
-    constructor(logger: Logger, lockFile: SyncLocker, createTaskCompletedCallback: CreateTaskCompletedCallback);
-    execute(analyzeEntryPoints: AnalyzeEntryPointsFn, createCompileFn: CreateCompileFn): void;
-}
-/**
- * An `Executor` that processes all tasks serially, but still completes asynchronously.
- */
-export declare class SingleProcessExecutorAsync extends SingleProcessorExecutorBase implements Executor {
-    private lockFile;
-    constructor(logger: Logger, lockFile: AsyncLocker, createTaskCompletedCallback: CreateTaskCompletedCallback);
-    execute(analyzeEntryPoints: AnalyzeEntryPointsFn, createCompileFn: CreateCompileFn): Promise<void>;
-}

package/ngcc/src/execution/tasks/api.d.ts

@@ -1,141 +0,0 @@
-/**
- * @license
- * Copyright Google LLC All Rights Reserved.
- *
- * Use of this source code is governed by an MIT-style license that can be
- * found in the LICENSE file at https://angular.io/license
- */
-import { EntryPoint, EntryPointJsonProperty } from '../../packages/entry_point';
-import { JsonObject, PartiallyOrderedList } from '../../utils';
-/**
- * Represents a unit of work to be undertaken by an `Executor`.
- *
- * A task consists of processing a specific format property of an entry-point.
- * This may or may not also include processing the typings for that entry-point, which only needs to
- * happen once across all the formats.
- */
-export interface Task extends JsonObject {
-    /** The `EntryPoint` which needs to be processed as part of the task. */
-    entryPoint: EntryPoint;
-    /**
-     * The `package.json` format property to process (i.e. the property which points to the file that
-     * is the program entry-point).
-     */
-    formatProperty: EntryPointJsonProperty;
-    /**
-     * The list of all format properties (including `task.formatProperty`) that should be marked as
-     * processed once the task has been completed, because they point to the format-path that will be
-     * processed as part of the task.
-     */
-    formatPropertiesToMarkAsProcessed: EntryPointJsonProperty[];
-    /**
-     * Whether to process typings for this entry-point as part of the task.
-     */
-    processDts: DtsProcessing;
-}
-/**
- * The options for processing Typescript typings (.d.ts) files.
- */
-export declare enum DtsProcessing {
-    /**
-     * Yes, process the typings for this entry point as part of the task.
-     */
-    Yes = 0,
-    /**
-     * No, do not process the typings as part of this task - they must have already been processed by
-     * another task or previous ngcc process.
-     */
-    No = 1,
-    /**
-     * Only process the typings for this entry-point; do not render any JavaScript files for the
-     * `formatProperty` of this task.
-     */
-    Only = 2
-}
-/**
- * Represents a partially ordered list of tasks.
- *
- * The ordering/precedence of tasks is determined by the inter-dependencies between their associated
- * entry-points. Specifically, the tasks' order/precedence is such that tasks associated to
- * dependent entry-points always come after tasks associated with their dependencies.
- *
- * As result of this ordering, it is guaranteed that - by processing tasks in the order in which
- * they appear in the list - a task's dependencies will always have been processed before processing
- * the task itself.
- *
- * See `DependencyResolver#sortEntryPointsByDependency()`.
- */
-export type PartiallyOrderedTasks = PartiallyOrderedList<Task>;
-/**
- * A mapping from Tasks to the Tasks that depend upon them (dependents).
- */
-export type TaskDependencies = Map<Task, Set<Task>>;
-export declare const TaskDependencies: MapConstructor;
-/**
- * A function to create a TaskCompletedCallback function.
- */
-export type CreateTaskCompletedCallback = (taskQueue: TaskQueue) => TaskCompletedCallback;
-/**
- * A function to be called once a task has been processed.
- */
-export type TaskCompletedCallback = (task: Task, outcome: TaskProcessingOutcome, message: string | null) => void;
-/**
- * Represents the outcome of processing a `Task`.
- */
-export declare const enum TaskProcessingOutcome {
-    /** Successfully processed the target format property. */
-    Processed = 0,
-    /** Failed to process the target format. */
-    Failed = 1
-}
-/**
- * A wrapper around a list of tasks and providing utility methods for getting the next task of
- * interest and determining when all tasks have been completed.
- *
- * (This allows different implementations to impose different constraints on when a task's
- * processing can start.)
- */
-export interface TaskQueue {
-    /** Whether all tasks have been completed. */
-    allTasksCompleted: boolean;
-    /**
-     * Get the next task whose processing can start (if any).
-     *
-     * This implicitly marks the task as in-progress.
-     * (This information is used to determine whether all tasks have been completed.)
-     *
-     * @return The next task available for processing or `null`, if no task can be processed at the
-     *         moment (including if there are no more unprocessed tasks).
-     */
-    getNextTask(): Task | null;
-    /**
-     * Mark a task as completed.
-     *
-     * This removes the task from the internal list of in-progress tasks.
-     * (This information is used to determine whether all tasks have been completed.)
-     *
-     * @param task The task to mark as completed.
-     */
-    markAsCompleted(task: Task): void;
-    /**
-     * Mark a task as failed.
-     *
-     * Do not process the tasks that depend upon the given task.
-     */
-    markAsFailed(task: Task): void;
-    /**
-     * Mark a task as not processed (i.e. add an in-progress task back to the queue).
-     *
-     * This removes the task from the internal list of in-progress tasks and adds it back to the list
-     * of pending tasks.
-     *
-     * @param task The task to mark as not processed.
-     */
-    markAsUnprocessed(task: Task): void;
-    /**
-     * Return a string representation of the task queue (for debugging purposes).
-     *
-     * @return A string representation of the task queue.
-     */
-    toString(): string;
-}

package/ngcc/src/execution/tasks/completion.d.ts

@@ -1,41 +0,0 @@
-/**
- * @license
- * Copyright Google LLC All Rights Reserved.
- *
- * Use of this source code is governed by an MIT-style license that can be
- * found in the LICENSE file at https://angular.io/license
- */
-import { PathManipulation, ReadonlyFileSystem } from '../../../../src/ngtsc/file_system';
-import { Logger } from '../../../../src/ngtsc/logging';
-import { PackageJsonUpdater } from '../../writing/package_json_updater';
-import { Task, TaskCompletedCallback, TaskProcessingOutcome, TaskQueue } from './api';
-/**
- * A function that can handle a specific outcome of a task completion.
- *
- * These functions can be composed using the `composeTaskCompletedCallbacks()`
- * to create a `TaskCompletedCallback` function that can be passed to an `Executor`.
- */
-export type TaskCompletedHandler = (task: Task, message: string | null) => void;
-/**
- * Compose a group of TaskCompletedHandlers into a single TaskCompletedCallback.
- *
- * The compose callback will receive an outcome and will delegate to the appropriate handler based
- * on this outcome.
- *
- * @param callbacks a map of outcomes to handlers.
- */
-export declare function composeTaskCompletedCallbacks(callbacks: Record<TaskProcessingOutcome, TaskCompletedHandler>): TaskCompletedCallback;
-/**
- * Create a handler that will mark the entry-points in a package as being processed.
- *
- * @param pkgJsonUpdater The service used to update the package.json
- */
-export declare function createMarkAsProcessedHandler(fs: PathManipulation, pkgJsonUpdater: PackageJsonUpdater): TaskCompletedHandler;
-/**
- * Create a handler that will throw an error.
- */
-export declare function createThrowErrorHandler(fs: ReadonlyFileSystem): TaskCompletedHandler;
-/**
- * Create a handler that logs an error and marks the task as failed.
- */
-export declare function createLogErrorHandler(logger: Logger, fs: ReadonlyFileSystem, taskQueue: TaskQueue): TaskCompletedHandler;

package/ngcc/src/execution/tasks/queues/base_task_queue.d.ts

@@ -1,38 +0,0 @@
-/**
- * @license
- * Copyright Google LLC All Rights Reserved.
- *
- * Use of this source code is governed by an MIT-style license that can be
- * found in the LICENSE file at https://angular.io/license
- */
-import { Logger } from '../../../../../src/ngtsc/logging';
-import { PartiallyOrderedTasks, Task, TaskDependencies, TaskQueue } from '../api';
-/**
- * A base `TaskQueue` implementation to be used as base for concrete implementations.
- */
-export declare abstract class BaseTaskQueue implements TaskQueue {
-    protected logger: Logger;
-    protected tasks: PartiallyOrderedTasks;
-    protected dependencies: TaskDependencies;
-    get allTasksCompleted(): boolean;
-    protected inProgressTasks: Set<Task>;
-    /**
-     * A map of tasks that should be skipped, mapped to the task that caused them to be skipped.
-     */
-    private tasksToSkip;
-    constructor(logger: Logger, tasks: PartiallyOrderedTasks, dependencies: TaskDependencies);
-    protected abstract computeNextTask(): Task | null;
-    getNextTask(): Task | null;
-    markAsCompleted(task: Task): void;
-    markAsFailed(task: Task): void;
-    markAsUnprocessed(task: Task): void;
-    toString(): string;
-    /**
-     * Mark the given `task` as to be skipped, then recursive skip all its dependents.
-     *
-     * @param task The task to skip
-     * @param failedTask The task that failed, causing this task to be skipped
-     */
-    protected skipDependentTasks(task: Task, failedTask: Task): void;
-    protected stringifyTasks(tasks: Task[], indentation: string): string;
-}