1 | "use strict";
|
2 | Object.defineProperty(exports, "__esModule", { value: true });
|
3 | exports.StateBuilder = exports.resolvablesBuilder = void 0;
|
4 | var common_1 = require("../common/common");
|
5 | var predicates_1 = require("../common/predicates");
|
6 | var strings_1 = require("../common/strings");
|
7 | var hof_1 = require("../common/hof");
|
8 | var resolvable_1 = require("../resolve/resolvable");
|
9 | var coreservices_1 = require("../common/coreservices");
|
10 | var parseUrl = function (url) {
|
11 | if (!predicates_1.isString(url))
|
12 | return false;
|
13 | var root = url.charAt(0) === '^';
|
14 | return { val: root ? url.substring(1) : url, root: root };
|
15 | };
|
16 | function nameBuilder(state) {
|
17 | return state.name;
|
18 | }
|
19 | function selfBuilder(state) {
|
20 | state.self.$$state = function () { return state; };
|
21 | return state.self;
|
22 | }
|
23 | function dataBuilder(state) {
|
24 | if (state.parent && state.parent.data) {
|
25 | state.data = state.self.data = common_1.inherit(state.parent.data, state.data);
|
26 | }
|
27 | return state.data;
|
28 | }
|
29 | var getUrlBuilder = function ($urlMatcherFactoryProvider, root) {
|
30 | return function urlBuilder(stateObject) {
|
31 | var stateDec = stateObject.self;
|
32 |
|
33 |
|
34 | if (stateDec && stateDec.url && stateDec.name && stateDec.name.match(/\.\*\*$/)) {
|
35 | var newStateDec = {};
|
36 | common_1.copy(stateDec, newStateDec);
|
37 | newStateDec.url += '{remainder:any}';
|
38 | stateDec = newStateDec;
|
39 | }
|
40 | var parent = stateObject.parent;
|
41 | var parsed = parseUrl(stateDec.url);
|
42 | var url = !parsed ? stateDec.url : $urlMatcherFactoryProvider.compile(parsed.val, { state: stateDec });
|
43 | if (!url)
|
44 | return null;
|
45 | if (!$urlMatcherFactoryProvider.isMatcher(url))
|
46 | throw new Error("Invalid url '" + url + "' in state '" + stateObject + "'");
|
47 | return parsed && parsed.root ? url : ((parent && parent.navigable) || root()).url.append(url);
|
48 | };
|
49 | };
|
50 | var getNavigableBuilder = function (isRoot) {
|
51 | return function navigableBuilder(state) {
|
52 | return !isRoot(state) && state.url ? state : state.parent ? state.parent.navigable : null;
|
53 | };
|
54 | };
|
55 | var getParamsBuilder = function (paramFactory) {
|
56 | return function paramsBuilder(state) {
|
57 | var makeConfigParam = function (config, id) { return paramFactory.fromConfig(id, null, state.self); };
|
58 | var urlParams = (state.url && state.url.parameters({ inherit: false })) || [];
|
59 | var nonUrlParams = common_1.values(common_1.mapObj(common_1.omit(state.params || {}, urlParams.map(hof_1.prop('id'))), makeConfigParam));
|
60 | return urlParams
|
61 | .concat(nonUrlParams)
|
62 | .map(function (p) { return [p.id, p]; })
|
63 | .reduce(common_1.applyPairs, {});
|
64 | };
|
65 | };
|
66 | function pathBuilder(state) {
|
67 | return state.parent ? state.parent.path.concat(state) : [state];
|
68 | }
|
69 | function includesBuilder(state) {
|
70 | var includes = state.parent ? common_1.extend({}, state.parent.includes) : {};
|
71 | includes[state.name] = true;
|
72 | return includes;
|
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 | function resolvablesBuilder(state) {
|
116 |
|
117 | var objects2Tuples = function (resolveObj, resolvePolicies) {
|
118 | return Object.keys(resolveObj || {}).map(function (token) { return ({
|
119 | token: token,
|
120 | val: resolveObj[token],
|
121 | deps: undefined,
|
122 | policy: resolvePolicies[token],
|
123 | }); });
|
124 | };
|
125 |
|
126 | var annotate = function (fn) {
|
127 | var $injector = coreservices_1.services.$injector;
|
128 |
|
129 |
|
130 |
|
131 | return fn['$inject'] || ($injector && $injector.annotate(fn, $injector.strictDi)) || 'deferred';
|
132 | };
|
133 |
|
134 | var isResolveLiteral = function (obj) { return !!(obj.token && obj.resolveFn); };
|
135 |
|
136 | var isLikeNg2Provider = function (obj) {
|
137 | return !!((obj.provide || obj.token) && (obj.useValue || obj.useFactory || obj.useExisting || obj.useClass));
|
138 | };
|
139 |
|
140 | var isTupleFromObj = function (obj) {
|
141 | return !!(obj && obj.val && (predicates_1.isString(obj.val) || predicates_1.isArray(obj.val) || predicates_1.isFunction(obj.val)));
|
142 | };
|
143 |
|
144 | var getToken = function (p) { return p.provide || p.token; };
|
145 |
|
146 | var literal2Resolvable = hof_1.pattern([
|
147 | [hof_1.prop('resolveFn'), function (p) { return new resolvable_1.Resolvable(getToken(p), p.resolveFn, p.deps, p.policy); }],
|
148 | [hof_1.prop('useFactory'), function (p) { return new resolvable_1.Resolvable(getToken(p), p.useFactory, p.deps || p.dependencies, p.policy); }],
|
149 | [hof_1.prop('useClass'), function (p) { return new resolvable_1.Resolvable(getToken(p), function () { return new p.useClass(); }, [], p.policy); }],
|
150 | [hof_1.prop('useValue'), function (p) { return new resolvable_1.Resolvable(getToken(p), function () { return p.useValue; }, [], p.policy, p.useValue); }],
|
151 | [hof_1.prop('useExisting'), function (p) { return new resolvable_1.Resolvable(getToken(p), common_1.identity, [p.useExisting], p.policy); }],
|
152 | ]);
|
153 |
|
154 | var tuple2Resolvable = hof_1.pattern([
|
155 | [hof_1.pipe(hof_1.prop('val'), predicates_1.isString), function (tuple) { return new resolvable_1.Resolvable(tuple.token, common_1.identity, [tuple.val], tuple.policy); }],
|
156 | [hof_1.pipe(hof_1.prop('val'), predicates_1.isArray), function (tuple) { return new resolvable_1.Resolvable(tuple.token, common_1.tail(tuple.val), tuple.val.slice(0, -1), tuple.policy); }],
|
157 | [hof_1.pipe(hof_1.prop('val'), predicates_1.isFunction), function (tuple) { return new resolvable_1.Resolvable(tuple.token, tuple.val, annotate(tuple.val), tuple.policy); }],
|
158 | ]);
|
159 |
|
160 | var item2Resolvable = hof_1.pattern([
|
161 | [hof_1.is(resolvable_1.Resolvable), function (r) { return r; }],
|
162 | [isResolveLiteral, literal2Resolvable],
|
163 | [isLikeNg2Provider, literal2Resolvable],
|
164 | [isTupleFromObj, tuple2Resolvable],
|
165 | [hof_1.val(true), function (obj) { throw new Error('Invalid resolve value: ' + strings_1.stringify(obj)); },],
|
166 | ]);
|
167 |
|
168 |
|
169 | var decl = state.resolve;
|
170 | var items = predicates_1.isArray(decl) ? decl : objects2Tuples(decl, state.resolvePolicy || {});
|
171 | return items.map(item2Resolvable);
|
172 | }
|
173 | exports.resolvablesBuilder = resolvablesBuilder;
|
174 |
|
175 |
|
176 |
|
177 |
|
178 |
|
179 |
|
180 |
|
181 |
|
182 |
|
183 |
|
184 |
|
185 |
|
186 | var StateBuilder = (function () {
|
187 | function StateBuilder(matcher, urlMatcherFactory) {
|
188 | this.matcher = matcher;
|
189 | var self = this;
|
190 | var root = function () { return matcher.find(''); };
|
191 | var isRoot = function (state) { return state.name === ''; };
|
192 | function parentBuilder(state) {
|
193 | if (isRoot(state))
|
194 | return null;
|
195 | return matcher.find(self.parentName(state)) || root();
|
196 | }
|
197 | this.builders = {
|
198 | name: [nameBuilder],
|
199 | self: [selfBuilder],
|
200 | parent: [parentBuilder],
|
201 | data: [dataBuilder],
|
202 |
|
203 | url: [getUrlBuilder(urlMatcherFactory, root)],
|
204 |
|
205 | navigable: [getNavigableBuilder(isRoot)],
|
206 | params: [getParamsBuilder(urlMatcherFactory.paramFactory)],
|
207 |
|
208 |
|
209 | views: [],
|
210 |
|
211 | path: [pathBuilder],
|
212 |
|
213 | includes: [includesBuilder],
|
214 | resolvables: [resolvablesBuilder],
|
215 | };
|
216 | }
|
217 | StateBuilder.prototype.builder = function (name, fn) {
|
218 | var builders = this.builders;
|
219 | var array = builders[name] || [];
|
220 |
|
221 | if (predicates_1.isString(name) && !predicates_1.isDefined(fn))
|
222 | return array.length > 1 ? array : array[0];
|
223 | if (!predicates_1.isString(name) || !predicates_1.isFunction(fn))
|
224 | return;
|
225 | builders[name] = array;
|
226 | builders[name].push(fn);
|
227 | return function () { return builders[name].splice(builders[name].indexOf(fn, 1)) && null; };
|
228 | };
|
229 | |
230 |
|
231 |
|
232 |
|
233 |
|
234 |
|
235 |
|
236 | StateBuilder.prototype.build = function (state) {
|
237 | var _a = this, matcher = _a.matcher, builders = _a.builders;
|
238 | var parent = this.parentName(state);
|
239 | if (parent && !matcher.find(parent, undefined, false)) {
|
240 | return null;
|
241 | }
|
242 | for (var key in builders) {
|
243 | if (!builders.hasOwnProperty(key))
|
244 | continue;
|
245 | var chain = builders[key].reduce(function (parentFn, step) { return function (_state) { return step(_state, parentFn); }; }, common_1.noop);
|
246 | state[key] = chain(state);
|
247 | }
|
248 | return state;
|
249 | };
|
250 | StateBuilder.prototype.parentName = function (state) {
|
251 |
|
252 | var name = state.name || '';
|
253 |
|
254 | var segments = name.split('.');
|
255 |
|
256 | var lastSegment = segments.pop();
|
257 |
|
258 | if (lastSegment === '**')
|
259 | segments.pop();
|
260 | if (segments.length) {
|
261 | if (state.parent) {
|
262 | throw new Error("States that specify the 'parent:' property should not have a '.' in their name (" + name + ")");
|
263 | }
|
264 |
|
265 | return segments.join('.');
|
266 | }
|
267 | if (!state.parent)
|
268 | return '';
|
269 | return predicates_1.isString(state.parent) ? state.parent : state.parent.name;
|
270 | };
|
271 | StateBuilder.prototype.name = function (state) {
|
272 | var name = state.name;
|
273 | if (name.indexOf('.') !== -1 || !state.parent)
|
274 | return name;
|
275 | var parentName = predicates_1.isString(state.parent) ? state.parent : state.parent.name;
|
276 | return parentName ? parentName + '.' + name : name;
|
277 | };
|
278 | return StateBuilder;
|
279 | }());
|
280 | exports.StateBuilder = StateBuilder;
|
281 |
|
\ | No newline at end of file |