source: trip-planner-front/node_modules/@angular/compiler-cli/ngcc/src/execution/tasks/utils.js@ 6a3a178

(function (factory) {
    if (typeof module === "object" && typeof module.exports === "object") {
        var v = factory(require, exports);
        if (v !== undefined) module.exports = v;
    }
    else if (typeof define === "function" && define.amd) {
        define("@angular/compiler-cli/ngcc/src/execution/tasks/utils", ["require", "exports", "tslib", "@angular/compiler-cli/ngcc/src/execution/tasks/api"], factory);
    }
})(function (require, exports) {
    "use strict";
    Object.defineProperty(exports, "__esModule", { value: true });
    exports.sortTasksByPriority = exports.getBlockedTasks = exports.getDependentsSet = exports.computeTaskDependencies = exports.stringifyTask = void 0;
    var tslib_1 = require("tslib");
    var api_1 = require("@angular/compiler-cli/ngcc/src/execution/tasks/api");
    /** Stringify a task for debugging purposes. */
    var stringifyTask = function (task) {
        return "{entryPoint: " + task.entryPoint.name + ", formatProperty: " + task.formatProperty + ", " +
            ("processDts: " + api_1.DtsProcessing[task.processDts] + "}");
    };
    exports.stringifyTask = stringifyTask;
    /**
     * 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.
     */
    function computeTaskDependencies(tasks, graph) {
        var dependencies = new api_1.TaskDependencies();
        var candidateDependencies = new Map();
        tasks.forEach(function (task) {
            var e_1, _a;
            var entryPointPath = task.entryPoint.path;
            // Find the earlier tasks (`candidateDependencies`) that this task depends upon.
            var deps = graph.dependenciesOf(entryPointPath);
            var taskDependencies = deps.filter(function (dep) { return candidateDependencies.has(dep); })
                .map(function (dep) { return candidateDependencies.get(dep); });
            // If this task has dependencies, add it to the dependencies and dependents maps.
            if (taskDependencies.length > 0) {
                try {
                    for (var taskDependencies_1 = tslib_1.__values(taskDependencies), taskDependencies_1_1 = taskDependencies_1.next(); !taskDependencies_1_1.done; taskDependencies_1_1 = taskDependencies_1.next()) {
                        var dependency = taskDependencies_1_1.value;
                        var taskDependents = getDependentsSet(dependencies, dependency);
                        taskDependents.add(task);
                    }
                }
                catch (e_1_1) { e_1 = { error: e_1_1 }; }
                finally {
                    try {
                        if (taskDependencies_1_1 && !taskDependencies_1_1.done && (_a = taskDependencies_1.return)) _a.call(taskDependencies_1);
                    }
                    finally { if (e_1) throw e_1.error; }
                }
            }
            if (task.processDts !== api_1.DtsProcessing.No) {
                // SANITY CHECK:
                // There should only be one task per entry-point that generates typings (and thus can be a
                // dependency of other tasks), so the following should theoretically never happen, but check
                // just in case.
                if (candidateDependencies.has(entryPointPath)) {
                    var otherTask = candidateDependencies.get(entryPointPath);
                    throw new Error('Invariant violated: Multiple tasks are assigned generating typings for ' +
                        ("'" + entryPointPath + "':\n  - " + exports.stringifyTask(otherTask) + "\n  - " + exports.stringifyTask(task)));
                }
                // This task can potentially be a dependency (i.e. it generates typings), so add it to the
                // list of candidate dependencies for subsequent tasks.
                candidateDependencies.set(entryPointPath, task);
            }
            else {
                // This task is not generating typings so we need to add it to the dependents of the task that
                // does generate typings, if that exists
                if (candidateDependencies.has(entryPointPath)) {
                    var typingsTask = candidateDependencies.get(entryPointPath);
                    var typingsTaskDependents = getDependentsSet(dependencies, typingsTask);
                    typingsTaskDependents.add(task);
                }
            }
        });
        return dependencies;
    }
    exports.computeTaskDependencies = computeTaskDependencies;
    function getDependentsSet(map, task) {
        if (!map.has(task)) {
            map.set(task, new Set());
        }
        return map.get(task);
    }
    exports.getDependentsSet = getDependentsSet;
    /**
     * 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.
     */
    function getBlockedTasks(dependencies) {
        var e_2, _a, e_3, _b;
        var blockedTasks = new Map();
        try {
            for (var dependencies_1 = tslib_1.__values(dependencies), dependencies_1_1 = dependencies_1.next(); !dependencies_1_1.done; dependencies_1_1 = dependencies_1.next()) {
                var _c = tslib_1.__read(dependencies_1_1.value, 2), dependency = _c[0], dependents = _c[1];
                try {
                    for (var dependents_1 = (e_3 = void 0, tslib_1.__values(dependents)), dependents_1_1 = dependents_1.next(); !dependents_1_1.done; dependents_1_1 = dependents_1.next()) {
                        var dependent = dependents_1_1.value;
                        var dependentSet = getDependentsSet(blockedTasks, dependent);
                        dependentSet.add(dependency);
                    }
                }
                catch (e_3_1) { e_3 = { error: e_3_1 }; }
                finally {
                    try {
                        if (dependents_1_1 && !dependents_1_1.done && (_b = dependents_1.return)) _b.call(dependents_1);
                    }
                    finally { if (e_3) throw e_3.error; }
                }
            }
        }
        catch (e_2_1) { e_2 = { error: e_2_1 }; }
        finally {
            try {
                if (dependencies_1_1 && !dependencies_1_1.done && (_a = dependencies_1.return)) _a.call(dependencies_1);
            }
            finally { if (e_2) throw e_2.error; }
        }
        return blockedTasks;
    }
    exports.getBlockedTasks = getBlockedTasks;
    /**
     * 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.
     */
    function sortTasksByPriority(tasks, dependencies) {
        var priorityPerTask = new Map();
        var computePriority = function (task, idx) { return [dependencies.has(task) ? dependencies.get(task).size : 0, idx]; };
        tasks.forEach(function (task, i) { return priorityPerTask.set(task, computePriority(task, i)); });
        return tasks.slice().sort(function (task1, task2) {
            var _a = tslib_1.__read(priorityPerTask.get(task1), 2), p1 = _a[0], idx1 = _a[1];
            var _b = tslib_1.__read(priorityPerTask.get(task2), 2), p2 = _b[0], idx2 = _b[1];
            return (p2 - p1) || (idx1 - idx2);
        });
    }
    exports.sortTasksByPriority = sortTasksByPriority;
});
//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"utils.js","sourceRoot":"","sources":["../../../../../../../../../packages/compiler-cli/ngcc/src/execution/tasks/utils.ts"],"names":[],"mappings":"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","sourcesContent":["/**\n * @license\n * Copyright Google LLC All Rights Reserved.\n *\n * Use of this source code is governed by an MIT-style license that can be\n * found in the LICENSE file at https://angular.io/license\n */\nimport {DepGraph} from 'dependency-graph';\nimport {EntryPoint} from '../../packages/entry_point';\nimport {DtsProcessing, PartiallyOrderedTasks, Task, TaskDependencies} from './api';\n\n/** Stringify a task for debugging purposes. */\nexport const stringifyTask = (task: Task): string =>\n    `{entryPoint: ${task.entryPoint.name}, formatProperty: ${task.formatProperty}, ` +\n    `processDts: ${DtsProcessing[task.processDts]}}`;\n\n/**\n * Compute a mapping of tasks to the tasks that are dependent on them (if any).\n *\n * Task A can depend upon task B, if either:\n *\n * * A and B have the same entry-point _and_ B is generating the typings for that entry-point\n *   (i.e. has `processDts: true`).\n * * A's entry-point depends on B's entry-point _and_ B is also generating typings.\n *\n * NOTE: If a task is not generating typings, then it cannot affect anything which depends on its\n *       entry-point, regardless of the dependency graph. To put this another way, only the task\n *       which produces the typings for a dependency needs to have been completed.\n *\n * As a performance optimization, we take into account the fact that `tasks` are sorted in such a\n * way that a task can only depend on earlier tasks (i.e. dependencies always come before\n * dependents in the list of tasks).\n *\n * @param tasks A (partially ordered) list of tasks.\n * @param graph The dependency graph between entry-points.\n * @return A map from each task to those tasks directly dependent upon it.\n */\nexport function computeTaskDependencies(\n    tasks: PartiallyOrderedTasks, graph: DepGraph<EntryPoint>): TaskDependencies {\n  const dependencies = new TaskDependencies();\n  const candidateDependencies = new Map<string, Task>();\n\n  tasks.forEach(task => {\n    const entryPointPath = task.entryPoint.path;\n\n    // Find the earlier tasks (`candidateDependencies`) that this task depends upon.\n    const deps = graph.dependenciesOf(entryPointPath);\n    const taskDependencies = deps.filter(dep => candidateDependencies.has(dep))\n                                 .map(dep => candidateDependencies.get(dep)!);\n\n    // If this task has dependencies, add it to the dependencies and dependents maps.\n    if (taskDependencies.length > 0) {\n      for (const dependency of taskDependencies) {\n        const taskDependents = getDependentsSet(dependencies, dependency);\n        taskDependents.add(task);\n      }\n    }\n\n    if (task.processDts !== DtsProcessing.No) {\n      // SANITY CHECK:\n      // There should only be one task per entry-point that generates typings (and thus can be a\n      // dependency of other tasks), so the following should theoretically never happen, but check\n      // just in case.\n      if (candidateDependencies.has(entryPointPath)) {\n        const otherTask = candidateDependencies.get(entryPointPath)!;\n        throw new Error(\n            'Invariant violated: Multiple tasks are assigned generating typings for ' +\n            `'${entryPointPath}':\\n  - ${stringifyTask(otherTask)}\\n  - ${stringifyTask(task)}`);\n      }\n      // This task can potentially be a dependency (i.e. it generates typings), so add it to the\n      // list of candidate dependencies for subsequent tasks.\n      candidateDependencies.set(entryPointPath, task);\n    } else {\n      // This task is not generating typings so we need to add it to the dependents of the task that\n      // does generate typings, if that exists\n      if (candidateDependencies.has(entryPointPath)) {\n        const typingsTask = candidateDependencies.get(entryPointPath)!;\n        const typingsTaskDependents = getDependentsSet(dependencies, typingsTask);\n        typingsTaskDependents.add(task);\n      }\n    }\n  });\n\n  return dependencies;\n}\n\nexport function getDependentsSet(map: TaskDependencies, task: Task): Set<Task> {\n  if (!map.has(task)) {\n    map.set(task, new Set());\n  }\n  return map.get(task)!;\n}\n\n/**\n * Invert the given mapping of Task dependencies.\n *\n * @param dependencies The mapping of tasks to the tasks that depend upon them.\n * @returns A mapping of tasks to the tasks that they depend upon.\n */\nexport function getBlockedTasks(dependencies: TaskDependencies): Map<Task, Set<Task>> {\n  const blockedTasks = new Map<Task, Set<Task>>();\n  for (const [dependency, dependents] of dependencies) {\n    for (const dependent of dependents) {\n      const dependentSet = getDependentsSet(blockedTasks, dependent);\n      dependentSet.add(dependency);\n    }\n  }\n  return blockedTasks;\n}\n\n/**\n * Sort a list of tasks by priority.\n *\n * Priority is determined by the number of other tasks that a task is (transitively) blocking:\n * The more tasks a task is blocking the higher its priority is, because processing it will\n * potentially unblock more tasks.\n *\n * To keep the behavior predictable, if two tasks block the same number of other tasks, their\n * relative order in the original `tasks` lists is preserved.\n *\n * @param tasks A (partially ordered) list of tasks.\n * @param dependencies The mapping of tasks to the tasks that depend upon them.\n * @return The list of tasks sorted by priority.\n */\nexport function sortTasksByPriority(\n    tasks: PartiallyOrderedTasks, dependencies: TaskDependencies): PartiallyOrderedTasks {\n  const priorityPerTask = new Map<Task, [number, number]>();\n  const computePriority = (task: Task, idx: number):\n      [number, number] => [dependencies.has(task) ? dependencies.get(task)!.size : 0, idx];\n\n  tasks.forEach((task, i) => priorityPerTask.set(task, computePriority(task, i)));\n\n  return tasks.slice().sort((task1, task2) => {\n    const [p1, idx1] = priorityPerTask.get(task1)!;\n    const [p2, idx2] = priorityPerTask.get(task2)!;\n\n    return (p2 - p1) || (idx1 - idx2);\n  });\n}\n"]}