{"ast":null,"code":"import { find, tail, uniqR, unnestR, inArray } from '../common/common';\nimport { propEq, not } from '../common/hof';\nimport { trace } from '../common/trace';\nimport { services } from '../common/coreservices';\nimport { resolvePolicies } from './interface';\nimport { Resolvable } from './resolvable';\nimport { PathUtils } from '../path/pathUtils';\nimport { stringify } from '../common/strings';\nimport { isUndefined } from '../common';\nvar whens = resolvePolicies.when;\nvar ALL_WHENS = [whens.EAGER, whens.LAZY];\nvar EAGER_WHENS = [whens.EAGER]; // tslint:disable-next-line:no-inferrable-types\n\nexport var NATIVE_INJECTOR_TOKEN = 'Native Injector';\n/**\n * Encapsulates Dependency Injection for a path of nodes\n *\n * UI-Router states are organized as a tree.\n * A nested state has a path of ancestors to the root of the tree.\n * When a state is being activated, each element in the path is wrapped as a [[PathNode]].\n * A `PathNode` is a stateful object that holds things like parameters and resolvables for the state being activated.\n *\n * The ResolveContext closes over the [[PathNode]]s, and provides DI for the last node in the path.\n */\n\nvar ResolveContext = function () {\n  function ResolveContext(_path) {\n    this._path = _path;\n  }\n  /** Gets all the tokens found in the resolve context, de-duplicated */\n\n\n  ResolveContext.prototype.getTokens = function () {\n    return this._path.reduce(function (acc, node) {\n      return acc.concat(node.resolvables.map(function (r) {\n        return r.token;\n      }));\n    }, []).reduce(uniqR, []);\n  };\n  /**\n   * Gets the Resolvable that matches the token\n   *\n   * Gets the last Resolvable that matches the token in this context, or undefined.\n   * Throws an error if it doesn't exist in the ResolveContext\n   */\n\n\n  ResolveContext.prototype.getResolvable = function (token) {\n    var matching = this._path.map(function (node) {\n      return node.resolvables;\n    }).reduce(unnestR, []).filter(function (r) {\n      return r.token === token;\n    });\n\n    return tail(matching);\n  };\n  /** Returns the [[ResolvePolicy]] for the given [[Resolvable]] */\n\n\n  ResolveContext.prototype.getPolicy = function (resolvable) {\n    var node = this.findNode(resolvable);\n    return resolvable.getPolicy(node.state);\n  };\n  /**\n   * Returns a ResolveContext that includes a portion of this one\n   *\n   * Given a state, this method creates a new ResolveContext from this one.\n   * The new context starts at the first node (root) and stops at the node for the `state` parameter.\n   *\n   * #### Why\n   *\n   * When a transition is created, the nodes in the \"To Path\" are injected from a ResolveContext.\n   * A ResolveContext closes over a path of [[PathNode]]s and processes the resolvables.\n   * The \"To State\" can inject values from its own resolvables, as well as those from all its ancestor state's (node's).\n   * This method is used to create a narrower context when injecting ancestor nodes.\n   *\n   * @example\n   * `let ABCD = new ResolveContext([A, B, C, D]);`\n   *\n   * Given a path `[A, B, C, D]`, where `A`, `B`, `C` and `D` are nodes for states `a`, `b`, `c`, `d`:\n   * When injecting `D`, `D` should have access to all resolvables from `A`, `B`, `C`, `D`.\n   * However, `B` should only be able to access resolvables from `A`, `B`.\n   *\n   * When resolving for the `B` node, first take the full \"To Path\" Context `[A,B,C,D]` and limit to the subpath `[A,B]`.\n   * `let AB = ABCD.subcontext(a)`\n   */\n\n\n  ResolveContext.prototype.subContext = function (state) {\n    return new ResolveContext(PathUtils.subPath(this._path, function (node) {\n      return node.state === state;\n    }));\n  };\n  /**\n   * Adds Resolvables to the node that matches the state\n   *\n   * This adds a [[Resolvable]] (generally one created on the fly; not declared on a [[StateDeclaration.resolve]] block).\n   * The resolvable is added to the node matching the `state` parameter.\n   *\n   * These new resolvables are not automatically fetched.\n   * The calling code should either fetch them, fetch something that depends on them,\n   * or rely on [[resolvePath]] being called when some state is being entered.\n   *\n   * Note: each resolvable's [[ResolvePolicy]] is merged with the state's policy, and the global default.\n   *\n   * @param newResolvables the new Resolvables\n   * @param state Used to find the node to put the resolvable on\n   */\n\n\n  ResolveContext.prototype.addResolvables = function (newResolvables, state) {\n    var node = find(this._path, propEq('state', state));\n    var keys = newResolvables.map(function (r) {\n      return r.token;\n    });\n    node.resolvables = node.resolvables.filter(function (r) {\n      return keys.indexOf(r.token) === -1;\n    }).concat(newResolvables);\n  };\n  /**\n   * Returns a promise for an array of resolved path Element promises\n   *\n   * @param when\n   * @param trans\n   * @returns {Promise<any>|any}\n   */\n\n\n  ResolveContext.prototype.resolvePath = function (when, trans) {\n    var _this = this;\n\n    if (when === void 0) {\n      when = 'LAZY';\n    } // This option determines which 'when' policy Resolvables we are about to fetch.\n\n\n    var whenOption = inArray(ALL_WHENS, when) ? when : 'LAZY'; // If the caller specified EAGER, only the EAGER Resolvables are fetched.\n    // if the caller specified LAZY, both EAGER and LAZY Resolvables are fetched.`\n\n    var matchedWhens = whenOption === resolvePolicies.when.EAGER ? EAGER_WHENS : ALL_WHENS; // get the subpath to the state argument, if provided\n\n    trace.traceResolvePath(this._path, when, trans);\n\n    var matchesPolicy = function (acceptedVals, whenOrAsync) {\n      return function (resolvable) {\n        return inArray(acceptedVals, _this.getPolicy(resolvable)[whenOrAsync]);\n      };\n    }; // Trigger all the (matching) Resolvables in the path\n    // Reduce all the \"WAIT\" Resolvables into an array\n\n\n    var promises = this._path.reduce(function (acc, node) {\n      var nodeResolvables = node.resolvables.filter(matchesPolicy(matchedWhens, 'when'));\n      var nowait = nodeResolvables.filter(matchesPolicy(['NOWAIT'], 'async'));\n      var wait = nodeResolvables.filter(not(matchesPolicy(['NOWAIT'], 'async'))); // For the matching Resolvables, start their async fetch process.\n\n      var subContext = _this.subContext(node.state);\n\n      var getResult = function (r) {\n        return r.get(subContext, trans) // Return a tuple that includes the Resolvable's token\n        .then(function (value) {\n          return {\n            token: r.token,\n            value: value\n          };\n        });\n      };\n\n      nowait.forEach(getResult);\n      return acc.concat(wait.map(getResult));\n    }, []); // Wait for all the \"WAIT\" resolvables\n\n\n    return services.$q.all(promises);\n  };\n\n  ResolveContext.prototype.injector = function () {\n    return this._injector || (this._injector = new UIInjectorImpl(this));\n  };\n\n  ResolveContext.prototype.findNode = function (resolvable) {\n    return find(this._path, function (node) {\n      return inArray(node.resolvables, resolvable);\n    });\n  };\n  /**\n   * Gets the async dependencies of a Resolvable\n   *\n   * Given a Resolvable, returns its dependencies as a Resolvable[]\n   */\n\n\n  ResolveContext.prototype.getDependencies = function (resolvable) {\n    var _this = this;\n\n    var node = this.findNode(resolvable); // Find which other resolvables are \"visible\" to the `resolvable` argument\n    // subpath stopping at resolvable's node, or the whole path (if the resolvable isn't in the path)\n\n    var subPath = PathUtils.subPath(this._path, function (x) {\n      return x === node;\n    }) || this._path;\n\n    var availableResolvables = subPath.reduce(function (acc, _node) {\n      return acc.concat(_node.resolvables);\n    }, []) // all of subpath's resolvables\n    .filter(function (res) {\n      return res !== resolvable;\n    }); // filter out the `resolvable` argument\n\n    var getDependency = function (token) {\n      var matching = availableResolvables.filter(function (r) {\n        return r.token === token;\n      });\n      if (matching.length) return tail(matching);\n\n      var fromInjector = _this.injector().getNative(token);\n\n      if (isUndefined(fromInjector)) {\n        throw new Error('Could not find Dependency Injection token: ' + stringify(token));\n      }\n\n      return new Resolvable(token, function () {\n        return fromInjector;\n      }, [], fromInjector);\n    };\n\n    return resolvable.deps.map(getDependency);\n  };\n\n  return ResolveContext;\n}();\n\nexport { ResolveContext };\n/** @internal */\n\nvar UIInjectorImpl = function () {\n  function UIInjectorImpl(context) {\n    this.context = context;\n    this.native = this.get(NATIVE_INJECTOR_TOKEN) || services.$injector;\n  }\n\n  UIInjectorImpl.prototype.get = function (token) {\n    var resolvable = this.context.getResolvable(token);\n\n    if (resolvable) {\n      if (this.context.getPolicy(resolvable).async === 'NOWAIT') {\n        return resolvable.get(this.context);\n      }\n\n      if (!resolvable.resolved) {\n        throw new Error('Resolvable async .get() not complete:' + stringify(resolvable.token));\n      }\n\n      return resolvable.data;\n    }\n\n    return this.getNative(token);\n  };\n\n  UIInjectorImpl.prototype.getAsync = function (token) {\n    var resolvable = this.context.getResolvable(token);\n    if (resolvable) return resolvable.get(this.context);\n    return services.$q.when(this.native.get(token));\n  };\n\n  UIInjectorImpl.prototype.getNative = function (token) {\n    return this.native && this.native.get(token);\n  };\n\n  return UIInjectorImpl;\n}();","map":{"version":3,"sources":["D:/Development/Work/CENOS/cenos-ui/node_modules/@uirouter/core/__ivy_ngcc__/lib-esm/resolve/resolveContext.js"],"names":["find","tail","uniqR","unnestR","inArray","propEq","not","trace","services","resolvePolicies","Resolvable","PathUtils","stringify","isUndefined","whens","when","ALL_WHENS","EAGER","LAZY","EAGER_WHENS","NATIVE_INJECTOR_TOKEN","ResolveContext","_path","prototype","getTokens","reduce","acc","node","concat","resolvables","map","r","token","getResolvable","matching","filter","getPolicy","resolvable","findNode","state","subContext","subPath","addResolvables","newResolvables","keys","indexOf","resolvePath","trans","_this","whenOption","matchedWhens","traceResolvePath","matchesPolicy","acceptedVals","whenOrAsync","promises","nodeResolvables","nowait","wait","getResult","get","then","value","forEach","$q","all","injector","_injector","UIInjectorImpl","getDependencies","x","availableResolvables","_node","res","getDependency","length","fromInjector","getNative","Error","deps","context","native","$injector","async","resolved","data","getAsync"],"mappings":"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","sourcesContent":["import { find, tail, uniqR, unnestR, inArray } from '../common/common';\nimport { propEq, not } from '../common/hof';\nimport { trace } from '../common/trace';\nimport { services } from '../common/coreservices';\nimport { resolvePolicies } from './interface';\nimport { Resolvable } from './resolvable';\nimport { PathUtils } from '../path/pathUtils';\nimport { stringify } from '../common/strings';\nimport { isUndefined } from '../common';\nvar whens = resolvePolicies.when;\nvar ALL_WHENS = [whens.EAGER, whens.LAZY];\nvar EAGER_WHENS = [whens.EAGER];\n// tslint:disable-next-line:no-inferrable-types\nexport var NATIVE_INJECTOR_TOKEN = 'Native Injector';\n/**\n * Encapsulates Dependency Injection for a path of nodes\n *\n * UI-Router states are organized as a tree.\n * A nested state has a path of ancestors to the root of the tree.\n * When a state is being activated, each element in the path is wrapped as a [[PathNode]].\n * A `PathNode` is a stateful object that holds things like parameters and resolvables for the state being activated.\n *\n * The ResolveContext closes over the [[PathNode]]s, and provides DI for the last node in the path.\n */\nvar ResolveContext = /** @class */ (function () {\n    function ResolveContext(_path) {\n        this._path = _path;\n    }\n    /** Gets all the tokens found in the resolve context, de-duplicated */\n    ResolveContext.prototype.getTokens = function () {\n        return this._path.reduce(function (acc, node) { return acc.concat(node.resolvables.map(function (r) { return r.token; })); }, []).reduce(uniqR, []);\n    };\n    /**\n     * Gets the Resolvable that matches the token\n     *\n     * Gets the last Resolvable that matches the token in this context, or undefined.\n     * Throws an error if it doesn't exist in the ResolveContext\n     */\n    ResolveContext.prototype.getResolvable = function (token) {\n        var matching = this._path\n            .map(function (node) { return node.resolvables; })\n            .reduce(unnestR, [])\n            .filter(function (r) { return r.token === token; });\n        return tail(matching);\n    };\n    /** Returns the [[ResolvePolicy]] for the given [[Resolvable]] */\n    ResolveContext.prototype.getPolicy = function (resolvable) {\n        var node = this.findNode(resolvable);\n        return resolvable.getPolicy(node.state);\n    };\n    /**\n     * Returns a ResolveContext that includes a portion of this one\n     *\n     * Given a state, this method creates a new ResolveContext from this one.\n     * The new context starts at the first node (root) and stops at the node for the `state` parameter.\n     *\n     * #### Why\n     *\n     * When a transition is created, the nodes in the \"To Path\" are injected from a ResolveContext.\n     * A ResolveContext closes over a path of [[PathNode]]s and processes the resolvables.\n     * The \"To State\" can inject values from its own resolvables, as well as those from all its ancestor state's (node's).\n     * This method is used to create a narrower context when injecting ancestor nodes.\n     *\n     * @example\n     * `let ABCD = new ResolveContext([A, B, C, D]);`\n     *\n     * Given a path `[A, B, C, D]`, where `A`, `B`, `C` and `D` are nodes for states `a`, `b`, `c`, `d`:\n     * When injecting `D`, `D` should have access to all resolvables from `A`, `B`, `C`, `D`.\n     * However, `B` should only be able to access resolvables from `A`, `B`.\n     *\n     * When resolving for the `B` node, first take the full \"To Path\" Context `[A,B,C,D]` and limit to the subpath `[A,B]`.\n     * `let AB = ABCD.subcontext(a)`\n     */\n    ResolveContext.prototype.subContext = function (state) {\n        return new ResolveContext(PathUtils.subPath(this._path, function (node) { return node.state === state; }));\n    };\n    /**\n     * Adds Resolvables to the node that matches the state\n     *\n     * This adds a [[Resolvable]] (generally one created on the fly; not declared on a [[StateDeclaration.resolve]] block).\n     * The resolvable is added to the node matching the `state` parameter.\n     *\n     * These new resolvables are not automatically fetched.\n     * The calling code should either fetch them, fetch something that depends on them,\n     * or rely on [[resolvePath]] being called when some state is being entered.\n     *\n     * Note: each resolvable's [[ResolvePolicy]] is merged with the state's policy, and the global default.\n     *\n     * @param newResolvables the new Resolvables\n     * @param state Used to find the node to put the resolvable on\n     */\n    ResolveContext.prototype.addResolvables = function (newResolvables, state) {\n        var node = find(this._path, propEq('state', state));\n        var keys = newResolvables.map(function (r) { return r.token; });\n        node.resolvables = node.resolvables.filter(function (r) { return keys.indexOf(r.token) === -1; }).concat(newResolvables);\n    };\n    /**\n     * Returns a promise for an array of resolved path Element promises\n     *\n     * @param when\n     * @param trans\n     * @returns {Promise<any>|any}\n     */\n    ResolveContext.prototype.resolvePath = function (when, trans) {\n        var _this = this;\n        if (when === void 0) { when = 'LAZY'; }\n        // This option determines which 'when' policy Resolvables we are about to fetch.\n        var whenOption = inArray(ALL_WHENS, when) ? when : 'LAZY';\n        // If the caller specified EAGER, only the EAGER Resolvables are fetched.\n        // if the caller specified LAZY, both EAGER and LAZY Resolvables are fetched.`\n        var matchedWhens = whenOption === resolvePolicies.when.EAGER ? EAGER_WHENS : ALL_WHENS;\n        // get the subpath to the state argument, if provided\n        trace.traceResolvePath(this._path, when, trans);\n        var matchesPolicy = function (acceptedVals, whenOrAsync) { return function (resolvable) {\n            return inArray(acceptedVals, _this.getPolicy(resolvable)[whenOrAsync]);\n        }; };\n        // Trigger all the (matching) Resolvables in the path\n        // Reduce all the \"WAIT\" Resolvables into an array\n        var promises = this._path.reduce(function (acc, node) {\n            var nodeResolvables = node.resolvables.filter(matchesPolicy(matchedWhens, 'when'));\n            var nowait = nodeResolvables.filter(matchesPolicy(['NOWAIT'], 'async'));\n            var wait = nodeResolvables.filter(not(matchesPolicy(['NOWAIT'], 'async')));\n            // For the matching Resolvables, start their async fetch process.\n            var subContext = _this.subContext(node.state);\n            var getResult = function (r) {\n                return r\n                    .get(subContext, trans)\n                    // Return a tuple that includes the Resolvable's token\n                    .then(function (value) { return ({ token: r.token, value: value }); });\n            };\n            nowait.forEach(getResult);\n            return acc.concat(wait.map(getResult));\n        }, []);\n        // Wait for all the \"WAIT\" resolvables\n        return services.$q.all(promises);\n    };\n    ResolveContext.prototype.injector = function () {\n        return this._injector || (this._injector = new UIInjectorImpl(this));\n    };\n    ResolveContext.prototype.findNode = function (resolvable) {\n        return find(this._path, function (node) { return inArray(node.resolvables, resolvable); });\n    };\n    /**\n     * Gets the async dependencies of a Resolvable\n     *\n     * Given a Resolvable, returns its dependencies as a Resolvable[]\n     */\n    ResolveContext.prototype.getDependencies = function (resolvable) {\n        var _this = this;\n        var node = this.findNode(resolvable);\n        // Find which other resolvables are \"visible\" to the `resolvable` argument\n        // subpath stopping at resolvable's node, or the whole path (if the resolvable isn't in the path)\n        var subPath = PathUtils.subPath(this._path, function (x) { return x === node; }) || this._path;\n        var availableResolvables = subPath\n            .reduce(function (acc, _node) { return acc.concat(_node.resolvables); }, []) // all of subpath's resolvables\n            .filter(function (res) { return res !== resolvable; }); // filter out the `resolvable` argument\n        var getDependency = function (token) {\n            var matching = availableResolvables.filter(function (r) { return r.token === token; });\n            if (matching.length)\n                return tail(matching);\n            var fromInjector = _this.injector().getNative(token);\n            if (isUndefined(fromInjector)) {\n                throw new Error('Could not find Dependency Injection token: ' + stringify(token));\n            }\n            return new Resolvable(token, function () { return fromInjector; }, [], fromInjector);\n        };\n        return resolvable.deps.map(getDependency);\n    };\n    return ResolveContext;\n}());\nexport { ResolveContext };\n/** @internal */\nvar UIInjectorImpl = /** @class */ (function () {\n    function UIInjectorImpl(context) {\n        this.context = context;\n        this.native = this.get(NATIVE_INJECTOR_TOKEN) || services.$injector;\n    }\n    UIInjectorImpl.prototype.get = function (token) {\n        var resolvable = this.context.getResolvable(token);\n        if (resolvable) {\n            if (this.context.getPolicy(resolvable).async === 'NOWAIT') {\n                return resolvable.get(this.context);\n            }\n            if (!resolvable.resolved) {\n                throw new Error('Resolvable async .get() not complete:' + stringify(resolvable.token));\n            }\n            return resolvable.data;\n        }\n        return this.getNative(token);\n    };\n    UIInjectorImpl.prototype.getAsync = function (token) {\n        var resolvable = this.context.getResolvable(token);\n        if (resolvable)\n            return resolvable.get(this.context);\n        return services.$q.when(this.native.get(token));\n    };\n    UIInjectorImpl.prototype.getNative = function (token) {\n        return this.native && this.native.get(token);\n    };\n    return UIInjectorImpl;\n}());\n"]},"metadata":{},"sourceType":"module"}