@angular-devkit/core/src/utils/partially-ordered-set.js

"use strict";
/**
 * @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
 */
Object.defineProperty(exports, "__esModule", { value: true });
exports.PartiallyOrderedSet = exports.CircularDependencyFoundException = exports.DependencyNotFoundException = void 0;
const exception_1 = require("../exception");
class DependencyNotFoundException extends exception_1.BaseException {
    constructor() {
        super('One of the dependencies is not part of the set.');
    }
}
exports.DependencyNotFoundException = DependencyNotFoundException;
class CircularDependencyFoundException extends exception_1.BaseException {
    constructor() {
        super('Circular dependencies found.');
    }
}
exports.CircularDependencyFoundException = CircularDependencyFoundException;
class PartiallyOrderedSet {
    constructor() {
        this._items = new Map();
    }
    _checkCircularDependencies(item, deps) {
        if (deps.has(item)) {
            throw new CircularDependencyFoundException();
        }
        deps.forEach((dep) => this._checkCircularDependencies(item, this._items.get(dep) || new Set()));
    }
    clear() {
        this._items.clear();
    }
    has(item) {
        return this._items.has(item);
    }
    get size() {
        return this._items.size;
    }
    forEach(callbackfn, thisArg) {
        for (const x of this) {
            callbackfn.call(thisArg, x, x, this);
        }
    }
    /**
     * Returns an iterable of [v,v] pairs for every value `v` in the set.
     */
    *entries() {
        for (const item of this) {
            yield [item, item];
        }
    }
    /**
     * Despite its name, returns an iterable of the values in the set,
     */
    keys() {
        return this.values();
    }
    /**
     * Returns an iterable of values in the set.
     */
    values() {
        return this[Symbol.iterator]();
    }
    add(item, deps = new Set()) {
        if (Array.isArray(deps)) {
            deps = new Set(deps);
        }
        // Verify item is not already in the set.
        if (this._items.has(item)) {
            const itemDeps = this._items.get(item) || new Set();
            // If the dependency list is equal, just return, otherwise remove and keep going.
            let equal = true;
            for (const dep of deps) {
                if (!itemDeps.has(dep)) {
                    equal = false;
                    break;
                }
            }
            if (equal) {
                for (const dep of itemDeps) {
                    if (!deps.has(dep)) {
                        equal = false;
                        break;
                    }
                }
            }
            if (equal) {
                return this;
            }
            else {
                this._items.delete(item);
            }
        }
        // Verify all dependencies are part of the Set.
        for (const dep of deps) {
            if (!this._items.has(dep)) {
                throw new DependencyNotFoundException();
            }
        }
        // Verify there's no dependency cycle.
        this._checkCircularDependencies(item, deps);
        this._items.set(item, new Set(deps));
        return this;
    }
    delete(item) {
        if (!this._items.has(item)) {
            return false;
        }
        // Remove it from all dependencies if force == true.
        this._items.forEach((value) => value.delete(item));
        return this._items.delete(item);
    }
    *[Symbol.iterator]() {
        const copy = new Map(this._items);
        for (const [key, value] of copy.entries()) {
            copy.set(key, new Set(value));
        }
        while (copy.size > 0) {
            const run = [];
            // Take the first item without dependencies.
            for (const [item, deps] of copy.entries()) {
                if (deps.size == 0) {
                    run.push(item);
                }
            }
            for (const item of run) {
                copy.forEach((s) => s.delete(item));
                copy.delete(item);
                yield item;
            }
            if (run.length == 0) {
                // uh oh...
                throw new CircularDependencyFoundException();
            }
        }
    }
    get [Symbol.toStringTag]() {
        return 'Set';
    }
}
exports.PartiallyOrderedSet = PartiallyOrderedSet;
//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"partially-ordered-set.js","sourceRoot":"","sources":["../../../../../../../../packages/angular_devkit/core/src/utils/partially-ordered-set.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 */\n\nimport { BaseException } from '../exception';\n\nexport class DependencyNotFoundException extends BaseException {\n  constructor() {\n    super('One of the dependencies is not part of the set.');\n  }\n}\nexport class CircularDependencyFoundException extends BaseException {\n  constructor() {\n    super('Circular dependencies found.');\n  }\n}\n\nexport class PartiallyOrderedSet<T> implements Set<T> {\n  private _items = new Map<T, Set<T>>();\n\n  protected _checkCircularDependencies(item: T, deps: Set<T>) {\n    if (deps.has(item)) {\n      throw new CircularDependencyFoundException();\n    }\n\n    deps.forEach((dep) => this._checkCircularDependencies(item, this._items.get(dep) || new Set()));\n  }\n\n  clear() {\n    this._items.clear();\n  }\n  has(item: T) {\n    return this._items.has(item);\n  }\n  get size() {\n    return this._items.size;\n  }\n  forEach(\n    callbackfn: (value: T, value2: T, set: PartiallyOrderedSet<T>) => void,\n    thisArg?: any, // eslint-disable-line @typescript-eslint/no-explicit-any\n  ): void {\n    for (const x of this) {\n      callbackfn.call(thisArg, x, x, this);\n    }\n  }\n\n  /**\n   * Returns an iterable of [v,v] pairs for every value `v` in the set.\n   */\n  *entries(): IterableIterator<[T, T]> {\n    for (const item of this) {\n      yield [item, item];\n    }\n  }\n\n  /**\n   * Despite its name, returns an iterable of the values in the set,\n   */\n  keys(): IterableIterator<T> {\n    return this.values();\n  }\n\n  /**\n   * Returns an iterable of values in the set.\n   */\n  values(): IterableIterator<T> {\n    return this[Symbol.iterator]();\n  }\n\n  add(item: T, deps: Set<T> | T[] = new Set()) {\n    if (Array.isArray(deps)) {\n      deps = new Set(deps);\n    }\n\n    // Verify item is not already in the set.\n    if (this._items.has(item)) {\n      const itemDeps = this._items.get(item) || new Set<T>();\n\n      // If the dependency list is equal, just return, otherwise remove and keep going.\n      let equal = true;\n      for (const dep of deps) {\n        if (!itemDeps.has(dep)) {\n          equal = false;\n          break;\n        }\n      }\n      if (equal) {\n        for (const dep of itemDeps) {\n          if (!deps.has(dep)) {\n            equal = false;\n            break;\n          }\n        }\n      }\n\n      if (equal) {\n        return this;\n      } else {\n        this._items.delete(item);\n      }\n    }\n\n    // Verify all dependencies are part of the Set.\n    for (const dep of deps) {\n      if (!this._items.has(dep)) {\n        throw new DependencyNotFoundException();\n      }\n    }\n\n    // Verify there's no dependency cycle.\n    this._checkCircularDependencies(item, deps);\n\n    this._items.set(item, new Set(deps));\n\n    return this;\n  }\n\n  delete(item: T) {\n    if (!this._items.has(item)) {\n      return false;\n    }\n\n    // Remove it from all dependencies if force == true.\n    this._items.forEach((value) => value.delete(item));\n\n    return this._items.delete(item);\n  }\n\n  *[Symbol.iterator]() {\n    const copy: Map<T, Set<T>> = new Map(this._items);\n\n    for (const [key, value] of copy.entries()) {\n      copy.set(key, new Set(value));\n    }\n\n    while (copy.size > 0) {\n      const run: T[] = [];\n      // Take the first item without dependencies.\n      for (const [item, deps] of copy.entries()) {\n        if (deps.size == 0) {\n          run.push(item);\n        }\n      }\n\n      for (const item of run) {\n        copy.forEach((s) => s.delete(item));\n        copy.delete(item);\n        yield item;\n      }\n\n      if (run.length == 0) {\n        // uh oh...\n        throw new CircularDependencyFoundException();\n      }\n    }\n  }\n\n  get [Symbol.toStringTag](): 'Set' {\n    return 'Set';\n  }\n}\n"]}