@angular/compiler-cli 15.2.1 → 16.0.0-next.1

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

package/ngcc/src/execution/tasks/queues/parallel_task_queue.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 { Logger } from '../../../../../src/ngtsc/logging';
-import { PartiallyOrderedTasks, Task, TaskDependencies } from '../api';
-import { BaseTaskQueue } from './base_task_queue';
-/**
- * A `TaskQueue` implementation that assumes tasks are processed in parallel, thus has to ensure a
- * task's dependencies have been processed before processing the task.
- */
-export declare class ParallelTaskQueue extends BaseTaskQueue {
-    /**
-     * A map from Tasks to the Tasks that it depends upon.
-     *
-     * This is the reverse mapping of `TaskDependencies`.
-     */
-    private blockedTasks;
-    constructor(logger: Logger, tasks: PartiallyOrderedTasks, dependencies: TaskDependencies);
-    computeNextTask(): Task | null;
-    markAsCompleted(task: Task): void;
-    toString(): string;
-    private stringifyBlockedTasks;
-}

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

@@ -1,16 +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 { Task } from '../api';
-import { BaseTaskQueue } from './base_task_queue';
-/**
- * A `TaskQueue` implementation that assumes tasks are processed serially and each one is completed
- * before requesting the next one.
- */
-export declare class SerialTaskQueue extends BaseTaskQueue {
-    computeNextTask(): Task | null;
-}

package/ngcc/src/execution/tasks/utils.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 { DepGraph } from 'dependency-graph';
-import { EntryPoint } from '../../packages/entry_point';
-import { PartiallyOrderedTasks, Task, TaskDependencies } from './api';
-/** Stringify a task for debugging purposes. */
-export declare const stringifyTask: (task: Task) => string;
-/**
- * Compute a mapping of tasks to the tasks that are dependent on them (if any).
- *
- * Task A can depend upon task B, if either:
- *
- * * A and B have the same entry-point _and_ B is generating the typings for that entry-point
- *   (i.e. has `processDts: true`).
- * * A's entry-point depends on B's entry-point _and_ B is also generating typings.
- *
- * NOTE: If a task is not generating typings, then it cannot affect anything which depends on its
- *       entry-point, regardless of the dependency graph. To put this another way, only the task
- *       which produces the typings for a dependency needs to have been completed.
- *
- * As a performance optimization, we take into account the fact that `tasks` are sorted in such a
- * way that a task can only depend on earlier tasks (i.e. dependencies always come before
- * dependents in the list of tasks).
- *
- * @param tasks A (partially ordered) list of tasks.
- * @param graph The dependency graph between entry-points.
- * @return A map from each task to those tasks directly dependent upon it.
- */
-export declare function computeTaskDependencies(tasks: PartiallyOrderedTasks, graph: DepGraph<EntryPoint>): TaskDependencies;
-export declare function getDependentsSet(map: TaskDependencies, task: Task): Set<Task>;
-/**
- * Invert the given mapping of Task dependencies.
- *
- * @param dependencies The mapping of tasks to the tasks that depend upon them.
- * @returns A mapping of tasks to the tasks that they depend upon.
- */
-export declare function getBlockedTasks(dependencies: TaskDependencies): Map<Task, Set<Task>>;
-/**
- * Sort a list of tasks by priority.
- *
- * Priority is determined by the number of other tasks that a task is (transitively) blocking:
- * The more tasks a task is blocking the higher its priority is, because processing it will
- * potentially unblock more tasks.
- *
- * To keep the behavior predictable, if two tasks block the same number of other tasks, their
- * relative order in the original `tasks` lists is preserved.
- *
- * @param tasks A (partially ordered) list of tasks.
- * @param dependencies The mapping of tasks to the tasks that depend upon them.
- * @return The list of tasks sorted by priority.
- */
-export declare function sortTasksByPriority(tasks: PartiallyOrderedTasks, dependencies: TaskDependencies): PartiallyOrderedTasks;