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

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

@@ -1,61 +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 { ParsedConfiguration } from '../../../src/perform_compile';
-import { EntryPointWithDependencies } from '../dependencies/dependency_host';
-import { DependencyResolver } from '../dependencies/dependency_resolver';
-import { NgccConfiguration } from '../packages/configuration';
-import { EntryPointManifest } from '../packages/entry_point_manifest';
-import { EntryPointCollector } from './entry_point_collector';
-import { TracingEntryPointFinder } from './tracing_entry_point_finder';
-/**
- * An EntryPointFinder that starts from the files in the program defined by the given tsconfig.json
- * and only returns entry-points that are dependencies of these files.
- *
- * This is faster than searching the entire file-system for all the entry-points,
- * and is used primarily by the CLI integration.
- */
-export declare class ProgramBasedEntryPointFinder extends TracingEntryPointFinder {
-    private entryPointCollector;
-    private entryPointManifest;
-    private tsConfig;
-    private entryPointsWithDependencies;
-    constructor(fs: ReadonlyFileSystem, config: NgccConfiguration, logger: Logger, resolver: DependencyResolver, entryPointCollector: EntryPointCollector, entryPointManifest: EntryPointManifest, basePath: AbsoluteFsPath, tsConfig: ParsedConfiguration, projectPath: AbsoluteFsPath);
-    /**
-     * Return an array containing the external import paths that were extracted from the source-files
-     * of the program defined by the tsconfig.json.
-     */
-    protected 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.
-     *
-     * In this entry-point finder, we use the `EntryPointManifest` to avoid computing each
-     * entry-point's dependencies in the case that this had been done previously.
-     *
-     * @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 getEntryPointWithDeps(entryPointPath: AbsoluteFsPath): EntryPointWithDependencies | null;
-    /**
-     * Walk the base paths looking for entry-points or load this information from an entry-point
-     * manifest, if available.
-     */
-    private findOrLoadEntryPoints;
-    /**
-     * Search the `basePath` for possible Angular packages and entry-points.
-     *
-     * @param basePath The path at which to start the search.
-     * @returns an array of `EntryPoint`s that were found within `basePath`.
-     */
-    walkBasePathForPackages(basePath: AbsoluteFsPath): EntryPointWithDependencies[];
-}

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

@@ -1,95 +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 { EntryPointJsonProperty } from '../packages/entry_point';
-import { PathMappings } from '../path_mappings';
-import { TracingEntryPointFinder } from './tracing_entry_point_finder';
-/**
- * An EntryPointFinder that starts from a target entry-point and only finds
- * entry-points that are dependencies of the target.
- *
- * This is faster than searching the entire file-system for all the entry-points,
- * and is used primarily by the CLI integration.
- */
-export declare class TargetedEntryPointFinder extends TracingEntryPointFinder {
-    private targetPath;
-    constructor(fs: ReadonlyFileSystem, config: NgccConfiguration, logger: Logger, resolver: DependencyResolver, basePath: AbsoluteFsPath, pathMappings: PathMappings | undefined, targetPath: AbsoluteFsPath);
-    /**
-     * Search for Angular entry-points that can be reached from the entry-point specified by the given
-     * `targetPath`.
-     */
-    findEntryPoints(): SortedEntryPointsInfo;
-    /**
-     * Determine whether the entry-point at the given `targetPath` needs to be processed.
-     *
-     * @param propertiesToConsider the package.json properties that should be considered for
-     *     processing.
-     * @param compileAllFormats true if all formats need to be processed, or false if it is enough for
-     *     one of the formats covered by the `propertiesToConsider` is processed.
-     */
-    targetNeedsProcessingOrCleaning(propertiesToConsider: EntryPointJsonProperty[], compileAllFormats: boolean): boolean;
-    /**
-     * Return an array containing the `targetPath` from which to start the trace.
-     */
-    protected 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 getEntryPointWithDeps(entryPointPath: AbsoluteFsPath): EntryPointWithDependencies | null;
-    /**
-     * Compute the path to the package that contains the given entry-point.
-     *
-     * In this entry-point finder it is not trivial to find the containing package, since it is
-     * possible that this entry-point is not directly below the directory containing the package.
-     * Moreover, the import path could be affected by path-mapping.
-     *
-     * @param entryPointPath the path to the entry-point, whose package path we want to compute.
-     */
-    private computePackagePath;
-    /**
-     * Compute whether the `test` path is contained within the `base` path.
-     *
-     * Note that this doesn't use a simple `startsWith()` since that would result in a false positive
-     * for `test` paths such as `a/b/c-x` when the `base` path is `a/b/c`.
-     *
-     * Since `fs.relative()` can be quite expensive we check the fast possibilities first.
-     */
-    private isPathContainedBy;
-    /**
-     * Search down to the `entryPointPath` from the `containingPath` for the first `package.json` that
-     * we come to. This is the path to the entry-point's containing package. For example if
-     * `containingPath` is `/a/b/c` and `entryPointPath` is `/a/b/c/d/e` and there exists
-     * `/a/b/c/d/package.json` and `/a/b/c/d/e/package.json`, then we will return `/a/b/c/d`.
-     *
-     * To account for nested `node_modules` we actually start the search at the last `node_modules` in
-     * the `entryPointPath` that is below the `containingPath`. E.g. if `containingPath` is `/a/b/c`
-     * and `entryPointPath` is `/a/b/c/d/node_modules/x/y/z`, we start the search at
-     * `/a/b/c/d/node_modules`.
-     */
-    private computePackagePathFromContainingPath;
-    /**
-     * Search up the directory tree from the `entryPointPath` looking for a `node_modules` directory
-     * that we can use as a potential starting point for computing the package path.
-     */
-    private computePackagePathFromNearestNodeModules;
-    /**
-     * Split the given `path` into path segments using an FS independent algorithm.
-     */
-    private splitPath;
-}

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>;
-}