Creates a new Transition object.
Creates a new Transition object.
If the target state is not valid, an error is thrown.
The path of PathNodes from which the transition is leaving. The last node in the fromPath
encapsulates the "from state".
The target state and parameters being transitioned to (also, the transition options)
The UIRouter instance
This promise is resolved or rejected based on the outcome of the Transition.
When the transition is successful, the promise is resolved When the transition is unsuccessful, the promise is rejected with the [[TransitionRejection]] or javascript error
A reference to the UIRouter instance
This reference can be used to access the router services, such as the StateService
Dynamically adds a new Resolvable (resolve
) to this transition.
Dynamically adds a new Resolvable (resolve
) to this transition.
an Resolvable object
the state in the "to path" which should receive the new resolve (otherwise, the root state)
Returns true if the transition is dynamic.
Returns true if the transition is dynamic.
A transition is dynamic if no states are entered nor exited, but at least one dynamic parameter has changed.
true if the Transition is dynamic
Gets the states being entered.
Gets the states being entered.
an array of states that will be entered during this transition.
The reason the Transition is invalid
The reason the Transition is invalid
an error message explaining why the transition is invalid
Gets the states being exited.
Gets the states being exited.
an array of states that will be exited during this transition.
Returns the "from state"
Returns the "from state"
The state object for the Transition's "from state".
Gets all available resolve tokens (keys)
Gets all available resolve tokens (keys)
This method can be used in conjunction with [[getResolve]] to inspect the resolve values available to the Transition.
The returned tokens include those defined on StateDeclaration.resolve blocks, for the states in the Transition's TreeChanges.to path.
an array of resolve tokens (keys)
Gets resolved values
Gets resolved values
This method can be used in conjunction with getResolveTokens to inspect what resolve values are available to the Transition.
Given a token, returns the resolved data for that token. Given an array of tokens, returns an array of resolved data for those tokens.
If a resolvable hasn't yet been fetched, returns undefined
for that token
If a resolvable doesn't exist for the token, throws an error.
the token (or array of tokens)
an array of resolve tokens (keys)
Returns true if the transition is ignored.
Returns true if the transition is ignored.
A transition is ignored if no states are entered nor exited, and no parameter values have changed.
true if the Transition is ignored.
Creates a UIInjector Dependency Injector
Creates a UIInjector Dependency Injector
Returns a Dependency Injector for the Transition's target state (to state). The injector provides resolve values which the target state has access to.
The UIInjector
can also provide values from the native root/global injector (ng1/ng2).
If a state
is provided, the injector that is returned will be limited to resolve values that the provided state has access to.
Limits the resolves provided to only the resolves the provided state has access to.
Determines whether two transitions are equivalent.
Determines whether two transitions are equivalent.
Registers a TransitionHookFn, called before a transition starts.
Registers a TransitionHookFn, called before a transition starts.
Registers a transition lifecycle hook, which is invoked before a transition even begins. This hook can be useful to implement logic which prevents a transition from even starting, such as authentication, redirection
See TransitionHookFn for the signature of the function.
The HookMatchCriteria is used to determine which Transitions the hook should be invoked for.
onBefore
hooks are invoked before a Transition starts.
No resolves have been fetched yet.
Each onBefore
hook is invoked synchronously, in the same call stack as StateService.transitionTo.
The registered onBefore
hooks are invoked in priority order.
Note: during the onBefore
phase, additional hooks can be added to the specific Transition instance.
These "on-the-fly" hooks only affect the currently running transition..
The hook's return value can be used to pause, cancel, or redirect the current Transition. See HookResult for more information.
If any hook modifies the transition synchronously (by throwing, returning false
, or returning
a TargetState), the remainder of the hooks are skipped.
If a hook returns a promise, the remainder of the onBefore
hooks are still invoked synchronously.
All promises are resolved, and processed asynchronously before the onStart
phase of the Transition.
This example redirects any transition from 'home' to 'home.dashboard'. This is commonly referred to as a "default substate".
a function which deregisters the hook.
Registers a TransitionStateHookFn, called when a specific state is entered.
Registers a TransitionStateHookFn, called when a specific state is entered.
Registers a lifecycle hook, which is invoked (during a transition) when a specific state is being entered.
Since this hook is run only when the specific state is being entered, it can be useful for performing tasks when entering a submodule/feature area such as initializing a stateful service, or for guarding access to a submodule/feature area.
See TransitionStateHookFn for the signature of the function.
The HookMatchCriteria is used to determine which Transitions the hook should be invoked for.
onEnter
hooks generally specify { entering: 'somestate' }
.
The matchCriteria
is used to determine which Transitions the hook should be invoked during.
Note: for onEnter
hooks, the to
in the matchCriteria
matches the entering state, not the Transition "to state".
onEnter
hooks are invoked when the Transition is entering a state.
States are entered after the onRetain
phase is complete.
If more than one state is being entered, the parent state is entered first.
The registered onEnter
hooks for a state are invoked in priority order.
Note: A built-in onEnter
hook with high priority is used to fetch lazy resolve data for states being entered.
The hook's return value can be used to pause, cancel, or redirect the current Transition. See HookResult for more information.
Instead of registering onEnter
hooks using the TransitionService, you may define an onEnter
hook
directly on a state declaration (see: StateDeclaration.onEnter).
This example uses a service to log that a user has entered the admin section of an app. This assumes that there are substates of the "admin" state, such as "admin.users", "admin.pages", etc.
a function which deregisters the hook.
Registers a TransitionHookFn, called after a successful transition completed.
Registers a TransitionHookFn, called after a successful transition completed.
Registers a transition lifecycle hook, which is invoked after a transition successfully completes.
See TransitionHookFn for the signature of the function.
The HookMatchCriteria is used to determine which Transitions the hook should be invoked for.
onError
hooks are chained off the Transition's promise (see Transition.promise).
If the Transition fails and its promise is rejected, then the onError
hooks are invoked.
Since these hooks are run after the transition is over, their return value is ignored.
The onError
hooks are invoked in priority order.
Since the Transition is already completed, the hook's return value is ignored
a function which deregisters the hook.
Registers a TransitionStateHookFn, called when a specific state is exited.
Registers a TransitionStateHookFn, called when a specific state is exited.
Registers a lifecycle hook, which is invoked (during a transition) when a specific state is being exited.
Since this hook is run only when the specific state is being exited, it can be useful for performing tasks when leaving a submodule/feature area such as cleaning up a stateful service, or for preventing the user from leaving a state or submodule until some criteria is satisfied.
See TransitionStateHookFn for the signature of the function.
The HookMatchCriteria is used to determine which Transitions the hook should be invoked for.
onExit
hooks generally specify { exiting: 'somestate' }
.
onExit
hooks are invoked when the Transition is exiting a state.
States are exited after any onStart
phase is complete.
If more than one state is being exited, the child states are exited first.
The registered onExit
hooks for a state are invoked in priority order.
The hook's return value can be used to pause, cancel, or redirect the current Transition. See HookResult for more information.
Instead of registering onExit
hooks using the TransitionService, you may define an onExit
hook
directly on a state declaration (see: StateDeclaration.onExit).
a function which deregisters the hook.
Registers a TransitionHookFn, called just before a transition finishes.
Registers a TransitionHookFn, called just before a transition finishes.
Registers a transition lifecycle hook, which is invoked just before a transition finishes. This hook is a last chance to cancel or redirect a transition.
See TransitionHookFn for the signature of the function.
The HookMatchCriteria is used to determine which Transitions the hook should be invoked for.
onFinish
hooks are invoked asynchronously, in priority order, just before the Transition completes, after
all states are entered and exited.
onFinish
hooks are invoked after the onEnter
phase is complete.
These hooks are invoked just before the transition is "committed".
The registered onFinish
hooks are invoked in priority order.
The hook's return value can be used to pause, cancel, or redirect the current Transition. See HookResult for more information.
a function which deregisters the hook.
Registers a TransitionStateHookFn, called when a specific state is retained/kept.
Registers a TransitionStateHookFn, called when a specific state is retained/kept.
Registers a lifecycle hook, which is invoked (during a transition) for a specific state that was previously active and is not being entered nor exited.
Since this hook is invoked when a transition is when the state is kept, it means the transition is coming from a substate of the kept state to a substate of the kept state. This hook can be used to perform actions when the user moves from one substate to another, such as between steps in a wizard.
The matchCriteria
is used to determine which Transitions the hook should be invoked during.
onRetain
hooks generally specify { retained: 'somestate' }
.
onRetain
hooks are invoked after any onExit
hooks have been fired.
If more than one state is retained, the child states' onRetain
hooks are invoked first.
The registered onRetain
hooks for a state are invoked in priority order.
The hook's return value can be used to pause, cancel, or redirect the current Transition. See HookResult for more information.
Instead of registering onRetain
hooks using the TransitionService, you may define an onRetain
hook
directly on a state declaration (see: StateDeclaration.onRetain).
a function which deregisters the hook.
Registers a TransitionHookFn, called when a transition starts.
Registers a TransitionHookFn, called when a transition starts.
Registers a transition lifecycle hook, which is invoked as a transition starts running. This hook can be useful to perform some asynchronous action before completing a transition.
See TransitionHookFn for the signature of the function.
The HookMatchCriteria is used to determine which Transitions the hook should be invoked for.
onStart
hooks are invoked asynchronously when the Transition starts running.
This happens after the onBefore
phase is complete.
At this point, the Transition has not yet exited nor entered any states.
The registered onStart
hooks are invoked in priority order.
Note: A built-in onStart
hook with high priority is used to fetch any eager resolve data.
The hook's return value can be used to pause, cancel, or redirect the current Transition. See HookResult for more information.
This example intercepts any transition to a state which requires authentication, when the user is not currently authenticated. It allows the user to authenticate asynchronously, then resumes the transition. If the user did not authenticate successfully, it redirects to the "guest" state, which does not require authentication.
This example assumes:
'auth'
state.MyAuthService.isAuthenticated()
synchronously returns a boolean.MyAuthService.authenticate()
presents a login dialog, and returns a promise which is resolved
or rejected, whether or not the login attempt was successful.a function which deregisters the hook.
Registers a TransitionHookFn, called after a successful transition completed.
Registers a TransitionHookFn, called after a successful transition completed.
Registers a transition lifecycle hook, which is invoked after a transition successfully completes.
See TransitionHookFn for the signature of the function.
The HookMatchCriteria is used to determine which Transitions the hook should be invoked for.
onSuccess
hooks are chained off the Transition's promise (see Transition.promise).
If the Transition is successful and its promise is resolved, then the onSuccess
hooks are invoked.
Since these hooks are run after the transition is over, their return value is ignored.
The onSuccess
hooks are invoked in priority order.
Since the Transition is already completed, the hook's return value is ignored
a function which deregisters the hook.
Get the transition options
Get the transition options
the options for this Transition.
Gets transition parameter values
Gets transition parameter values
Pick which treeChanges path to get parameters for:
('to'
, 'from'
, 'entering'
, 'exiting'
, 'retained'
)
transition parameter values for the desired path.
Gets the previous transition, from which this transition was redirected.
Gets the previous transition, from which this transition was redirected.
The previous Transition, or null if this Transition is not the result of a redirection
Creates a new transition that is a redirection of the current one.
Creates a new transition that is a redirection of the current one.
This transition can be returned from a TransitionService hook to redirect a transition to a new state and/or set of parameters.
Returns a new Transition instance.
Gets the states being retained.
Gets the states being retained.
an array of states that are already entered from a previous Transition, that will not be exited during this Transition
Runs the transition
Runs the transition
This method is generally called from the StateService.transitionTo
a promise for a successful transition.
Returns the "to state"
Returns the "to state"
The state object for the Transition's target state ("to state").
A string representation of the Transition
A string representation of the Transition
A string representation of the Transition
Checks if the Transition is valid
Checks if the Transition is valid
true if the Transition is valid
Get the ViewConfigs associated with this Transition
Get the ViewConfigs associated with this Transition
Each state can define one or more views (template/controller), which are encapsulated as ViewConfig
objects.
This method fetches the ViewConfigs
for a given path in the Transition (e.g., "to" or "entering").
the name of the path to fetch views for:
('to'
, 'from'
, 'entering'
, 'exiting'
, 'retained'
)
If provided, only returns the ViewConfig
s for a single state in the path
a list of ViewConfig objects for the given path.
Generated using TypeDoc
Represents a transition between two states.
When navigating to a state, we are transitioning from the current state to the new state.
This object contains all contextual information about the to/from states, parameters, resolves. It has information about all states being entered and exited as a result of the transition.