# Class ResolveContext

Encapsulates Dependency Injection for a path of nodes

ng-router states are organized as a tree. A nested state has a path of ancestors to the root of the tree. When a state is being activated, each element in the path is wrapped as a [[PathNode]]. A `PathNode` is a stateful object that holds things like parameters and resolvables for the state being activated.

The ResolveContext closes over the [[PathNode]]s, and provides DI for the last node in the path.

- Defined in src/router/resolve/resolve-context.js:32

##### Index

### Constructors

constructor

### Properties

_injector
_path

### Methods

addResolvables
findNode
getDependencies
getPolicy
getResolvable
getTokens
injector
resolvePath
subContext

## Constructors

### constructor

- new ResolveContext(_path: any): ResolveContext

  #### Parameters

  - _path: any

  #### Returns ResolveContext

  - Defined in src/router/resolve/resolve-context.js:33

## Properties

### _injector

_injector: UIInjectorImpl

- Defined in src/router/resolve/resolve-context.js:159

### _path

_path: any

- Defined in src/router/resolve/resolve-context.js:34

## Methods

### addResolvables

- addResolvables(newResolvables: Resolvable[], state: any): void

  Adds Resolvables to the node that matches the state

  This adds a [[Resolvable]] (generally one created on the fly; not declared on a [[StateDeclaration.resolve]] block). The resolvable is added to the node matching the `state` parameter.

  These new resolvables are not automatically fetched. The calling code should either fetch them, fetch something that depends on them, or rely on [[resolvePath]] being called when some state is being entered.

  Note: each resolvable's [[ResolvePolicy]] is merged with the state's policy, and the global default.

  #### Parameters

  - newResolvables: Resolvable[]

    the new Resolvables

  - state: any

    Used to find the node to put the resolvable on

  #### Returns void

  - Defined in src/router/resolve/resolve-context.js:108

### findNode

- findNode(resolvable: any): undefined

  #### Parameters

  - resolvable: any

  #### Returns undefined

  - Defined in src/router/resolve/resolve-context.js:162

### getDependencies

- getDependencies(resolvable: Resolvable): Resolvable[]

  Gets the async dependencies of a Resolvable

  Given a Resolvable, returns its dependencies as a Resolvable[]

  #### Parameters

  - resolvable: Resolvable

  #### Returns Resolvable[]

  - Defined in src/router/resolve/resolve-context.js:173

### getPolicy

- getPolicy(resolvable: any): any

  Returns the [[ResolvePolicy]] for the given [[Resolvable]]

  #### Parameters

  - resolvable: any

  #### Returns any

  - Defined in src/router/resolve/resolve-context.js:60

### getResolvable

- getResolvable(token: any): any

  Gets the Resolvable that matches the token

  Gets the last Resolvable that matches the token in this context, or undefined. Throws an error if it doesn't exist in the ResolveContext

  #### Parameters

  - token: any

  #### Returns any

  - Defined in src/router/resolve/resolve-context.js:51

### getTokens

- getTokens(): any

  Gets all the tokens found in the resolve context, de-duplicated

  #### Returns any

  - Defined in src/router/resolve/resolve-context.js:37

### injector

- injector(): UIInjectorImpl

  #### Returns UIInjectorImpl

  - Defined in src/router/resolve/resolve-context.js:158

### resolvePath

- resolvePath(when?: string, trans: any): any

  Returns a promise for an array of resolved path Element promises

  #### Parameters

  - when: string = "LAZY"
  - trans: any

  #### Returns any

  - Defined in src/router/resolve/resolve-context.js:123

### subContext

- subContext(state: any): ResolveContext

  Returns a ResolveContext that includes a portion of this one

  Given a state, this method creates a new ResolveContext from this one. The new context starts at the first node (root) and stops at the node for the `state` parameter.

  #### Why

  When a transition is created, the nodes in the "To Path" are injected from a ResolveContext. A ResolveContext closes over a path of [[PathNode]]s and processes the resolvables. The "To State" can inject values from its own resolvables, as well as those from all its ancestor state's (node's). This method is used to create a narrower context when injecting ancestor nodes.

  #### Parameters

  - state: any

  #### Returns ResolveContext

  #### Example

      `let ABCD = new ResolveContext([A, B, C, D]);`

      Given a path `[A, B, C, D]`, where `A`, `B`, `C` and `D` are nodes for states `a`, `b`, `c`, `d`:
      When injecting `D`, `D` should have access to all resolvables from `A`, `B`, `C`, `D`.
      However, `B` should only be able to access resolvables from `A`, `B`.

      When resolving for the `B` node, first take the full "To Path" Context `[A,B,C,D]` and limit to the subpath `[A,B]`.
      `let AB = ABCD.subcontext(a)`

  - Defined in src/router/resolve/resolve-context.js:88