-
Notifications
You must be signed in to change notification settings - Fork 59
/
interface.ts
216 lines (206 loc) · 6.14 KB
/
interface.ts
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
/**
* # The Resolve subsystem
*
* This subsystem is an asynchronous, hierarchical Dependency Injection system.
*
* Typically, resolve is configured on a state using a [[StateDeclaration.resolve]] declaration.
*
* @publicapi @module resolve
*/ /** */
import { Resolvable } from './resolvable';
/**
* An interface which is similar to an Angular 2 `Provider`
*/
export interface ProviderLike {
provide: any;
useClass?: any;
useFactory?: Function;
useValue?: any;
useExisting?: any;
deps?: any[];
}
/**
* A plain object used to describe a [[Resolvable]]
*
* These objects may be used in the [[StateDeclaration.resolve]] array to declare
* async data that the state or substates require.
*
* #### Example:
* ```js
*
* var state = {
* name: 'main',
* resolve: [
* { token: 'myData', deps: [MyDataApi], resolveFn: (myDataApi) => myDataApi.getData() },
* ],
* }
* ```
*/
export interface ResolvableLiteral {
/**
* A Dependency Injection token
*
* This Resolvable's DI token.
* The Resolvable will be injectable elsewhere using the token.
*/
token: any;
/**
* A function which fetches the Resolvable's data
*
* A function which returns one of:
*
* - The resolved value (synchronously)
* - A promise for the resolved value
* - An Observable of the resolved value(s)
*
* This function will be provided the dependencies listed in [[deps]] as its arguments.
* The resolve system will asynchronously fetch the dependencies before invoking this function.
*/
resolveFn: Function;
/**
* Defines the Resolve Policy
*
* A policy that defines when to invoke the resolve,
* and whether to wait for async and unwrap the data
*/
policy?: ResolvePolicy;
/**
* The Dependency Injection tokens
*
* This is an array of Dependency Injection tokens for the dependencies of the [[resolveFn]].
*
* The DI tokens are references to other `Resolvables`, or to other
* services from the native DI system.
*/
deps?: any[];
/** Pre-resolved data. */
data?: any;
}
/**
* Defines how a resolve is processed during a transition
*
* This object is the [[StateDeclaration.resolvePolicy]] property.
*
* #### Example:
* ```js
* // Fetched when the resolve's state is being entered.
* // Wait for the promise to resolve.
* var policy1 = { when: "LAZY", async: "WAIT" }
*
* // Fetched when the Transition is starting.
* // Do not wait for the returned promise to resolve.
* // Inject the raw promise/value
* var policy2 = { when: "EAGER", async: "NOWAIT" }
* ```
*
* The policy for a given Resolvable is merged from three sources (highest priority first):
*
* - 1) Individual resolve definition
* - 2) State definition
* - 3) Global default
*
* #### Example:
* ```js
* // Wait for an Observable to emit one item.
* // Since `wait` is not specified, it uses the `wait`
* // policy defined on the state, or the global default
* // if no `wait` policy is defined on the state
* var myResolvablePolicy = { async: "RXWAIT" }
* ```
*/
export interface ResolvePolicy {
/**
* Defines when a Resolvable is resolved (fetched) during a transition
*
* - `LAZY` (default)
* - Resolved as the resolve's state is being entered
* - `EAGER`
* - Resolved as the transition is starting
*
* #### Example:
* Resolves for `main` and `main.home` are fetched when each state is entered.
* All of `main` resolves are processed before fetching `main.home` resolves.
* ```js
* var state = {
* name: 'main',
* resolve: mainResolves, // defined elsewhere
* resolvePolicy: { when: 'LAZY' }, // default
* }
*
* var state = {
* name: 'main.home',
* resolve: homeResolves, // defined elsewhere
* resolvePolicy: { when: 'LAZY' }, // default
* }
* ```
*
* #### Example:
* Resolves for `main` and `main.home` are fetched at the same time when the transition starts.
* This happens earlier in the lifecycle than when states are entered.
* All of the `main` and `main.home` resolves are fetched as soon as possible.
* ```js
* var mainState = {
* name: 'main',
* resolve: mainResolves, // defined elsewhere
* resolvePolicy: { when: 'EAGER' },
* }
*
* var homeState = {
* name: 'main.home',
* resolve: homeResolves, // defined elsewhere
* resolvePolicy: { when: 'EAGER' },
* }
* ```
*/
when?: PolicyWhen;
/**
* Determines the unwrapping behavior of asynchronous resolve values.
*
* - `WAIT` (default)
* - If a promise is returned from the resolveFn, wait for the promise before proceeding
* - The unwrapped value from the promise
* - `NOWAIT`
* - If a promise is returned from the resolve, do not wait for the promise.
* - Any other value returned is wrapped in a promise.
* - The promise will not be unwrapped.
* - The promise itself will be provided when the resolve is injected or bound elsewhere.
* - `RXWAIT`
* - When an Observable is returned from the resolveFn, wait until the Observable emits at least one item.
* - The Observable item will not be unwrapped.
* - The Observable stream itself will be provided when the resolve is injected or bound elsewhere.
*
* #### Example:
* The `Transition` will not wait for the resolve promise(s) from `main` to settle before continuing.
* Resolves for `main` will be provided to components wrapped in a `Promise`.
*
* The `Transition` will wait for the `main.home` resolve promises.
* Resolved values will be unwrapped before being provided to components.
* ```js
* var mainState = {
* name: 'main',
* resolve: mainResolves, // defined elsewhere
* resolvePolicy: { async: 'NOWAIT' },
* }
* var homeState = {
* name: 'main.home',
* resolve: homeResolves, // defined elsewhere
* resolvePolicy: { async: 'WAIT' }, // default
* }
* ```
*/
async?: PolicyAsync;
}
export type PolicyWhen = 'LAZY' | 'EAGER';
export type PolicyAsync = 'WAIT' | 'NOWAIT' | 'RXWAIT';
/** @internalapi */
export let resolvePolicies = {
when: {
LAZY: 'LAZY',
EAGER: 'EAGER',
},
async: {
WAIT: 'WAIT',
NOWAIT: 'NOWAIT',
RXWAIT: 'RXWAIT',
},
};