{"ast":null,"code":"import { TransitionHookPhase } from './interface';\nimport { defaults, noop, silentRejection } from '../common/common';\nimport { fnToString, maxLength } from '../common/strings';\nimport { isPromise } from '../common/predicates';\nimport { is, parse } from '../common/hof';\nimport { trace } from '../common/trace';\nimport { services } from '../common/coreservices';\nimport { Rejection } from './rejectFactory';\nimport { TargetState } from '../state/targetState';\nvar defaultOptions = {\n  current: noop,\n  transition: null,\n  traceData: {},\n  bind: null\n};\n\nvar TransitionHook = function () {\n  function TransitionHook(transition, stateContext, registeredHook, options) {\n    var _this = this;\n\n    this.transition = transition;\n    this.stateContext = stateContext;\n    this.registeredHook = registeredHook;\n    this.options = options;\n\n    this.isSuperseded = function () {\n      return _this.type.hookPhase === TransitionHookPhase.RUN && !_this.options.transition.isActive();\n    };\n\n    this.options = defaults(options, defaultOptions);\n    this.type = registeredHook.eventType;\n  }\n  /**\n   * Chains together an array of TransitionHooks.\n   *\n   * Given a list of [[TransitionHook]] objects, chains them together.\n   * Each hook is invoked after the previous one completes.\n   *\n   * #### Example:\n   * ```js\n   * var hooks: TransitionHook[] = getHooks();\n   * let promise: Promise<any> = TransitionHook.chain(hooks);\n   *\n   * promise.then(handleSuccess, handleError);\n   * ```\n   *\n   * @param hooks the list of hooks to chain together\n   * @param waitFor if provided, the chain is `.then()`'ed off this promise\n   * @returns a `Promise` for sequentially invoking the hooks (in order)\n   */\n\n\n  TransitionHook.chain = function (hooks, waitFor) {\n    // Chain the next hook off the previous\n    var createHookChainR = function (prev, nextHook) {\n      return prev.then(function () {\n        return nextHook.invokeHook();\n      });\n    };\n\n    return hooks.reduce(createHookChainR, waitFor || services.$q.when());\n  };\n  /**\n   * Invokes all the provided TransitionHooks, in order.\n   * Each hook's return value is checked.\n   * If any hook returns a promise, then the rest of the hooks are chained off that promise, and the promise is returned.\n   * If no hook returns a promise, then all hooks are processed synchronously.\n   *\n   * @param hooks the list of TransitionHooks to invoke\n   * @param doneCallback a callback that is invoked after all the hooks have successfully completed\n   *\n   * @returns a promise for the async result, or the result of the callback\n   */\n\n\n  TransitionHook.invokeHooks = function (hooks, doneCallback) {\n    for (var idx = 0; idx < hooks.length; idx++) {\n      var hookResult = hooks[idx].invokeHook();\n\n      if (isPromise(hookResult)) {\n        var remainingHooks = hooks.slice(idx + 1);\n        return TransitionHook.chain(remainingHooks, hookResult).then(doneCallback);\n      }\n    }\n\n    return doneCallback();\n  };\n  /**\n   * Run all TransitionHooks, ignoring their return value.\n   */\n\n\n  TransitionHook.runAllHooks = function (hooks) {\n    hooks.forEach(function (hook) {\n      return hook.invokeHook();\n    });\n  };\n\n  TransitionHook.prototype.logError = function (err) {\n    this.transition.router.stateService.defaultErrorHandler()(err);\n  };\n\n  TransitionHook.prototype.invokeHook = function () {\n    var _this = this;\n\n    var hook = this.registeredHook;\n    if (hook._deregistered) return;\n    var notCurrent = this.getNotCurrentRejection();\n    if (notCurrent) return notCurrent;\n    var options = this.options;\n    trace.traceHookInvocation(this, this.transition, options);\n\n    var invokeCallback = function () {\n      return hook.callback.call(options.bind, _this.transition, _this.stateContext);\n    };\n\n    var normalizeErr = function (err) {\n      return Rejection.normalize(err).toPromise();\n    };\n\n    var handleError = function (err) {\n      return hook.eventType.getErrorHandler(_this)(err);\n    };\n\n    var handleResult = function (result) {\n      return hook.eventType.getResultHandler(_this)(result);\n    };\n\n    try {\n      var result = invokeCallback();\n\n      if (!this.type.synchronous && isPromise(result)) {\n        return result.catch(normalizeErr).then(handleResult, handleError);\n      } else {\n        return handleResult(result);\n      }\n    } catch (err) {\n      // If callback throws (synchronously)\n      return handleError(Rejection.normalize(err));\n    } finally {\n      if (hook.invokeLimit && ++hook.invokeCount >= hook.invokeLimit) {\n        hook.deregister();\n      }\n    }\n  };\n  /**\n   * This method handles the return value of a Transition Hook.\n   *\n   * A hook can return false (cancel), a TargetState (redirect),\n   * or a promise (which may later resolve to false or a redirect)\n   *\n   * This also handles \"transition superseded\" -- when a new transition\n   * was started while the hook was still running\n   */\n\n\n  TransitionHook.prototype.handleHookResult = function (result) {\n    var _this = this;\n\n    var notCurrent = this.getNotCurrentRejection();\n    if (notCurrent) return notCurrent; // Hook returned a promise\n\n    if (isPromise(result)) {\n      // Wait for the promise, then reprocess with the resulting value\n      return result.then(function (val) {\n        return _this.handleHookResult(val);\n      });\n    }\n\n    trace.traceHookResult(result, this.transition, this.options); // Hook returned false\n\n    if (result === false) {\n      // Abort this Transition\n      return Rejection.aborted('Hook aborted transition').toPromise();\n    }\n\n    var isTargetState = is(TargetState); // hook returned a TargetState\n\n    if (isTargetState(result)) {\n      // Halt the current Transition and redirect (a new Transition) to the TargetState.\n      return Rejection.redirected(result).toPromise();\n    }\n  };\n  /**\n   * Return a Rejection promise if the transition is no longer current due\n   * to a stopped router (disposed), or a new transition has started and superseded this one.\n   */\n\n\n  TransitionHook.prototype.getNotCurrentRejection = function () {\n    var router = this.transition.router; // The router is stopped\n\n    if (router._disposed) {\n      return Rejection.aborted(\"UIRouter instance #\" + router.$id + \" has been stopped (disposed)\").toPromise();\n    }\n\n    if (this.transition._aborted) {\n      return Rejection.aborted().toPromise();\n    } // This transition is no longer current.\n    // Another transition started while this hook was still running.\n\n\n    if (this.isSuperseded()) {\n      // Abort this transition\n      return Rejection.superseded(this.options.current()).toPromise();\n    }\n  };\n\n  TransitionHook.prototype.toString = function () {\n    var _a = this,\n        options = _a.options,\n        registeredHook = _a.registeredHook;\n\n    var event = parse('traceData.hookType')(options) || 'internal',\n        context = parse('traceData.context.state.name')(options) || parse('traceData.context')(options) || 'unknown',\n        name = fnToString(registeredHook.callback);\n    return event + \" context: \" + context + \", \" + maxLength(200, name);\n  };\n  /**\n   * These GetResultHandler(s) are used by [[invokeHook]] below\n   * Each HookType chooses a GetResultHandler (See: [[TransitionService._defineCoreEvents]])\n   */\n\n\n  TransitionHook.HANDLE_RESULT = function (hook) {\n    return function (result) {\n      return hook.handleHookResult(result);\n    };\n  };\n  /**\n   * If the result is a promise rejection, log it.\n   * Otherwise, ignore the result.\n   */\n\n\n  TransitionHook.LOG_REJECTED_RESULT = function (hook) {\n    return function (result) {\n      isPromise(result) && result.catch(function (err) {\n        return hook.logError(Rejection.normalize(err));\n      });\n      return undefined;\n    };\n  };\n  /**\n   * These GetErrorHandler(s) are used by [[invokeHook]] below\n   * Each HookType chooses a GetErrorHandler (See: [[TransitionService._defineCoreEvents]])\n   */\n\n\n  TransitionHook.LOG_ERROR = function (hook) {\n    return function (error) {\n      return hook.logError(error);\n    };\n  };\n\n  TransitionHook.REJECT_ERROR = function (hook) {\n    return function (error) {\n      return silentRejection(error);\n    };\n  };\n\n  TransitionHook.THROW_ERROR = function (hook) {\n    return function (error) {\n      throw error;\n    };\n  };\n\n  return TransitionHook;\n}();\n\nexport { TransitionHook };","map":{"version":3,"sources":["D:/Development/Work/CENOS/cenos-ui/node_modules/@uirouter/core/__ivy_ngcc__/lib-esm/transition/transitionHook.js"],"names":["TransitionHookPhase","defaults","noop","silentRejection","fnToString","maxLength","isPromise","is","parse","trace","services","Rejection","TargetState","defaultOptions","current","transition","traceData","bind","TransitionHook","stateContext","registeredHook","options","_this","isSuperseded","type","hookPhase","RUN","isActive","eventType","chain","hooks","waitFor","createHookChainR","prev","nextHook","then","invokeHook","reduce","$q","when","invokeHooks","doneCallback","idx","length","hookResult","remainingHooks","slice","runAllHooks","forEach","hook","prototype","logError","err","router","stateService","defaultErrorHandler","_deregistered","notCurrent","getNotCurrentRejection","traceHookInvocation","invokeCallback","callback","call","normalizeErr","normalize","toPromise","handleError","getErrorHandler","handleResult","result","getResultHandler","synchronous","catch","invokeLimit","invokeCount","deregister","handleHookResult","val","traceHookResult","aborted","isTargetState","redirected","_disposed","$id","_aborted","superseded","toString","_a","event","context","name","HANDLE_RESULT","LOG_REJECTED_RESULT","undefined","LOG_ERROR","error","REJECT_ERROR","THROW_ERROR"],"mappings":"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","sourcesContent":["import { TransitionHookPhase } from './interface';\nimport { defaults, noop, silentRejection } from '../common/common';\nimport { fnToString, maxLength } from '../common/strings';\nimport { isPromise } from '../common/predicates';\nimport { is, parse } from '../common/hof';\nimport { trace } from '../common/trace';\nimport { services } from '../common/coreservices';\nimport { Rejection } from './rejectFactory';\nimport { TargetState } from '../state/targetState';\nvar defaultOptions = {\n    current: noop,\n    transition: null,\n    traceData: {},\n    bind: null,\n};\nvar TransitionHook = /** @class */ (function () {\n    function TransitionHook(transition, stateContext, registeredHook, options) {\n        var _this = this;\n        this.transition = transition;\n        this.stateContext = stateContext;\n        this.registeredHook = registeredHook;\n        this.options = options;\n        this.isSuperseded = function () { return _this.type.hookPhase === TransitionHookPhase.RUN && !_this.options.transition.isActive(); };\n        this.options = defaults(options, defaultOptions);\n        this.type = registeredHook.eventType;\n    }\n    /**\n     * Chains together an array of TransitionHooks.\n     *\n     * Given a list of [[TransitionHook]] objects, chains them together.\n     * Each hook is invoked after the previous one completes.\n     *\n     * #### Example:\n     * ```js\n     * var hooks: TransitionHook[] = getHooks();\n     * let promise: Promise<any> = TransitionHook.chain(hooks);\n     *\n     * promise.then(handleSuccess, handleError);\n     * ```\n     *\n     * @param hooks the list of hooks to chain together\n     * @param waitFor if provided, the chain is `.then()`'ed off this promise\n     * @returns a `Promise` for sequentially invoking the hooks (in order)\n     */\n    TransitionHook.chain = function (hooks, waitFor) {\n        // Chain the next hook off the previous\n        var createHookChainR = function (prev, nextHook) { return prev.then(function () { return nextHook.invokeHook(); }); };\n        return hooks.reduce(createHookChainR, waitFor || services.$q.when());\n    };\n    /**\n     * Invokes all the provided TransitionHooks, in order.\n     * Each hook's return value is checked.\n     * If any hook returns a promise, then the rest of the hooks are chained off that promise, and the promise is returned.\n     * If no hook returns a promise, then all hooks are processed synchronously.\n     *\n     * @param hooks the list of TransitionHooks to invoke\n     * @param doneCallback a callback that is invoked after all the hooks have successfully completed\n     *\n     * @returns a promise for the async result, or the result of the callback\n     */\n    TransitionHook.invokeHooks = function (hooks, doneCallback) {\n        for (var idx = 0; idx < hooks.length; idx++) {\n            var hookResult = hooks[idx].invokeHook();\n            if (isPromise(hookResult)) {\n                var remainingHooks = hooks.slice(idx + 1);\n                return TransitionHook.chain(remainingHooks, hookResult).then(doneCallback);\n            }\n        }\n        return doneCallback();\n    };\n    /**\n     * Run all TransitionHooks, ignoring their return value.\n     */\n    TransitionHook.runAllHooks = function (hooks) {\n        hooks.forEach(function (hook) { return hook.invokeHook(); });\n    };\n    TransitionHook.prototype.logError = function (err) {\n        this.transition.router.stateService.defaultErrorHandler()(err);\n    };\n    TransitionHook.prototype.invokeHook = function () {\n        var _this = this;\n        var hook = this.registeredHook;\n        if (hook._deregistered)\n            return;\n        var notCurrent = this.getNotCurrentRejection();\n        if (notCurrent)\n            return notCurrent;\n        var options = this.options;\n        trace.traceHookInvocation(this, this.transition, options);\n        var invokeCallback = function () { return hook.callback.call(options.bind, _this.transition, _this.stateContext); };\n        var normalizeErr = function (err) { return Rejection.normalize(err).toPromise(); };\n        var handleError = function (err) { return hook.eventType.getErrorHandler(_this)(err); };\n        var handleResult = function (result) { return hook.eventType.getResultHandler(_this)(result); };\n        try {\n            var result = invokeCallback();\n            if (!this.type.synchronous && isPromise(result)) {\n                return result.catch(normalizeErr).then(handleResult, handleError);\n            }\n            else {\n                return handleResult(result);\n            }\n        }\n        catch (err) {\n            // If callback throws (synchronously)\n            return handleError(Rejection.normalize(err));\n        }\n        finally {\n            if (hook.invokeLimit && ++hook.invokeCount >= hook.invokeLimit) {\n                hook.deregister();\n            }\n        }\n    };\n    /**\n     * This method handles the return value of a Transition Hook.\n     *\n     * A hook can return false (cancel), a TargetState (redirect),\n     * or a promise (which may later resolve to false or a redirect)\n     *\n     * This also handles \"transition superseded\" -- when a new transition\n     * was started while the hook was still running\n     */\n    TransitionHook.prototype.handleHookResult = function (result) {\n        var _this = this;\n        var notCurrent = this.getNotCurrentRejection();\n        if (notCurrent)\n            return notCurrent;\n        // Hook returned a promise\n        if (isPromise(result)) {\n            // Wait for the promise, then reprocess with the resulting value\n            return result.then(function (val) { return _this.handleHookResult(val); });\n        }\n        trace.traceHookResult(result, this.transition, this.options);\n        // Hook returned false\n        if (result === false) {\n            // Abort this Transition\n            return Rejection.aborted('Hook aborted transition').toPromise();\n        }\n        var isTargetState = is(TargetState);\n        // hook returned a TargetState\n        if (isTargetState(result)) {\n            // Halt the current Transition and redirect (a new Transition) to the TargetState.\n            return Rejection.redirected(result).toPromise();\n        }\n    };\n    /**\n     * Return a Rejection promise if the transition is no longer current due\n     * to a stopped router (disposed), or a new transition has started and superseded this one.\n     */\n    TransitionHook.prototype.getNotCurrentRejection = function () {\n        var router = this.transition.router;\n        // The router is stopped\n        if (router._disposed) {\n            return Rejection.aborted(\"UIRouter instance #\" + router.$id + \" has been stopped (disposed)\").toPromise();\n        }\n        if (this.transition._aborted) {\n            return Rejection.aborted().toPromise();\n        }\n        // This transition is no longer current.\n        // Another transition started while this hook was still running.\n        if (this.isSuperseded()) {\n            // Abort this transition\n            return Rejection.superseded(this.options.current()).toPromise();\n        }\n    };\n    TransitionHook.prototype.toString = function () {\n        var _a = this, options = _a.options, registeredHook = _a.registeredHook;\n        var event = parse('traceData.hookType')(options) || 'internal', context = parse('traceData.context.state.name')(options) || parse('traceData.context')(options) || 'unknown', name = fnToString(registeredHook.callback);\n        return event + \" context: \" + context + \", \" + maxLength(200, name);\n    };\n    /**\n     * These GetResultHandler(s) are used by [[invokeHook]] below\n     * Each HookType chooses a GetResultHandler (See: [[TransitionService._defineCoreEvents]])\n     */\n    TransitionHook.HANDLE_RESULT = function (hook) { return function (result) {\n        return hook.handleHookResult(result);\n    }; };\n    /**\n     * If the result is a promise rejection, log it.\n     * Otherwise, ignore the result.\n     */\n    TransitionHook.LOG_REJECTED_RESULT = function (hook) { return function (result) {\n        isPromise(result) && result.catch(function (err) { return hook.logError(Rejection.normalize(err)); });\n        return undefined;\n    }; };\n    /**\n     * These GetErrorHandler(s) are used by [[invokeHook]] below\n     * Each HookType chooses a GetErrorHandler (See: [[TransitionService._defineCoreEvents]])\n     */\n    TransitionHook.LOG_ERROR = function (hook) { return function (error) { return hook.logError(error); }; };\n    TransitionHook.REJECT_ERROR = function (hook) { return function (error) { return silentRejection(error); }; };\n    TransitionHook.THROW_ERROR = function (hook) { return function (error) {\n        throw error;\n    }; };\n    return TransitionHook;\n}());\nexport { TransitionHook };\n"]},"metadata":{},"sourceType":"module"}