source: trip-planner-front/node_modules/@angular/router/esm2015/src/router_state.js@ 6a3a178

Last change on this file since 6a3a178 was 6a3a178, checked in by Ema <ema_spirova@…>, 3 years ago

initial commit

  • Property mode set to 100644
File size: 47.1 KB
Line 
1/**
2 * @license
3 * Copyright Google LLC All Rights Reserved.
4 *
5 * Use of this source code is governed by an MIT-style license that can be
6 * found in the LICENSE file at https://angular.io/license
7 */
8import { BehaviorSubject } from 'rxjs';
9import { map } from 'rxjs/operators';
10import { convertToParamMap, PRIMARY_OUTLET } from './shared';
11import { equalSegments, UrlSegment } from './url_tree';
12import { shallowEqual, shallowEqualArrays } from './utils/collection';
13import { Tree, TreeNode } from './utils/tree';
14/**
15 * Represents the state of the router as a tree of activated routes.
16 *
17 * @usageNotes
18 *
19 * Every node in the route tree is an `ActivatedRoute` instance
20 * that knows about the "consumed" URL segments, the extracted parameters,
21 * and the resolved data.
22 * Use the `ActivatedRoute` properties to traverse the tree from any node.
23 *
24 * The following fragment shows how a component gets the root node
25 * of the current state to establish its own route tree:
26 *
27 * ```
28 * @Component({templateUrl:'template.html'})
29 * class MyComponent {
30 * constructor(router: Router) {
31 * const state: RouterState = router.routerState;
32 * const root: ActivatedRoute = state.root;
33 * const child = root.firstChild;
34 * const id: Observable<string> = child.params.map(p => p.id);
35 * //...
36 * }
37 * }
38 * ```
39 *
40 * @see `ActivatedRoute`
41 * @see [Getting route information](guide/router#getting-route-information)
42 *
43 * @publicApi
44 */
45export class RouterState extends Tree {
46 /** @internal */
47 constructor(root,
48 /** The current snapshot of the router state */
49 snapshot) {
50 super(root);
51 this.snapshot = snapshot;
52 setRouterState(this, root);
53 }
54 toString() {
55 return this.snapshot.toString();
56 }
57}
58export function createEmptyState(urlTree, rootComponent) {
59 const snapshot = createEmptyStateSnapshot(urlTree, rootComponent);
60 const emptyUrl = new BehaviorSubject([new UrlSegment('', {})]);
61 const emptyParams = new BehaviorSubject({});
62 const emptyData = new BehaviorSubject({});
63 const emptyQueryParams = new BehaviorSubject({});
64 const fragment = new BehaviorSubject('');
65 const activated = new ActivatedRoute(emptyUrl, emptyParams, emptyQueryParams, fragment, emptyData, PRIMARY_OUTLET, rootComponent, snapshot.root);
66 activated.snapshot = snapshot.root;
67 return new RouterState(new TreeNode(activated, []), snapshot);
68}
69export function createEmptyStateSnapshot(urlTree, rootComponent) {
70 const emptyParams = {};
71 const emptyData = {};
72 const emptyQueryParams = {};
73 const fragment = '';
74 const activated = new ActivatedRouteSnapshot([], emptyParams, emptyQueryParams, fragment, emptyData, PRIMARY_OUTLET, rootComponent, null, urlTree.root, -1, {});
75 return new RouterStateSnapshot('', new TreeNode(activated, []));
76}
77/**
78 * Provides access to information about a route associated with a component
79 * that is loaded in an outlet.
80 * Use to traverse the `RouterState` tree and extract information from nodes.
81 *
82 * The following example shows how to construct a component using information from a
83 * currently activated route.
84 *
85 * Note: the observables in this class only emit when the current and previous values differ based
86 * on shallow equality. For example, changing deeply nested properties in resolved `data` will not
87 * cause the `ActivatedRoute.data` `Observable` to emit a new value.
88 *
89 * {@example router/activated-route/module.ts region="activated-route"
90 * header="activated-route.component.ts"}
91 *
92 * @see [Getting route information](guide/router#getting-route-information)
93 *
94 * @publicApi
95 */
96export class ActivatedRoute {
97 /** @internal */
98 constructor(
99 /** An observable of the URL segments matched by this route. */
100 url,
101 /** An observable of the matrix parameters scoped to this route. */
102 params,
103 /** An observable of the query parameters shared by all the routes. */
104 queryParams,
105 /** An observable of the URL fragment shared by all the routes. */
106 fragment,
107 /** An observable of the static and resolved data of this route. */
108 data,
109 /** The outlet name of the route, a constant. */
110 outlet,
111 /** The component of the route, a constant. */
112 // TODO(vsavkin): remove |string
113 component, futureSnapshot) {
114 this.url = url;
115 this.params = params;
116 this.queryParams = queryParams;
117 this.fragment = fragment;
118 this.data = data;
119 this.outlet = outlet;
120 this.component = component;
121 this._futureSnapshot = futureSnapshot;
122 }
123 /** The configuration used to match this route. */
124 get routeConfig() {
125 return this._futureSnapshot.routeConfig;
126 }
127 /** The root of the router state. */
128 get root() {
129 return this._routerState.root;
130 }
131 /** The parent of this route in the router state tree. */
132 get parent() {
133 return this._routerState.parent(this);
134 }
135 /** The first child of this route in the router state tree. */
136 get firstChild() {
137 return this._routerState.firstChild(this);
138 }
139 /** The children of this route in the router state tree. */
140 get children() {
141 return this._routerState.children(this);
142 }
143 /** The path from the root of the router state tree to this route. */
144 get pathFromRoot() {
145 return this._routerState.pathFromRoot(this);
146 }
147 /**
148 * An Observable that contains a map of the required and optional parameters
149 * specific to the route.
150 * The map supports retrieving single and multiple values from the same parameter.
151 */
152 get paramMap() {
153 if (!this._paramMap) {
154 this._paramMap = this.params.pipe(map((p) => convertToParamMap(p)));
155 }
156 return this._paramMap;
157 }
158 /**
159 * An Observable that contains a map of the query parameters available to all routes.
160 * The map supports retrieving single and multiple values from the query parameter.
161 */
162 get queryParamMap() {
163 if (!this._queryParamMap) {
164 this._queryParamMap =
165 this.queryParams.pipe(map((p) => convertToParamMap(p)));
166 }
167 return this._queryParamMap;
168 }
169 toString() {
170 return this.snapshot ? this.snapshot.toString() : `Future(${this._futureSnapshot})`;
171 }
172}
173/**
174 * Returns the inherited params, data, and resolve for a given route.
175 * By default, this only inherits values up to the nearest path-less or component-less route.
176 * @internal
177 */
178export function inheritedParamsDataResolve(route, paramsInheritanceStrategy = 'emptyOnly') {
179 const pathFromRoot = route.pathFromRoot;
180 let inheritingStartingFrom = 0;
181 if (paramsInheritanceStrategy !== 'always') {
182 inheritingStartingFrom = pathFromRoot.length - 1;
183 while (inheritingStartingFrom >= 1) {
184 const current = pathFromRoot[inheritingStartingFrom];
185 const parent = pathFromRoot[inheritingStartingFrom - 1];
186 // current route is an empty path => inherits its parent's params and data
187 if (current.routeConfig && current.routeConfig.path === '') {
188 inheritingStartingFrom--;
189 // parent is componentless => current route should inherit its params and data
190 }
191 else if (!parent.component) {
192 inheritingStartingFrom--;
193 }
194 else {
195 break;
196 }
197 }
198 }
199 return flattenInherited(pathFromRoot.slice(inheritingStartingFrom));
200}
201/** @internal */
202function flattenInherited(pathFromRoot) {
203 return pathFromRoot.reduce((res, curr) => {
204 const params = Object.assign(Object.assign({}, res.params), curr.params);
205 const data = Object.assign(Object.assign({}, res.data), curr.data);
206 const resolve = Object.assign(Object.assign({}, res.resolve), curr._resolvedData);
207 return { params, data, resolve };
208 }, { params: {}, data: {}, resolve: {} });
209}
210/**
211 * @description
212 *
213 * Contains the information about a route associated with a component loaded in an
214 * outlet at a particular moment in time. ActivatedRouteSnapshot can also be used to
215 * traverse the router state tree.
216 *
217 * The following example initializes a component with route information extracted
218 * from the snapshot of the root node at the time of creation.
219 *
220 * ```
221 * @Component({templateUrl:'./my-component.html'})
222 * class MyComponent {
223 * constructor(route: ActivatedRoute) {
224 * const id: string = route.snapshot.params.id;
225 * const url: string = route.snapshot.url.join('');
226 * const user = route.snapshot.data.user;
227 * }
228 * }
229 * ```
230 *
231 * @publicApi
232 */
233export class ActivatedRouteSnapshot {
234 /** @internal */
235 constructor(
236 /** The URL segments matched by this route */
237 url,
238 /**
239 * The matrix parameters scoped to this route.
240 *
241 * You can compute all params (or data) in the router state or to get params outside
242 * of an activated component by traversing the `RouterState` tree as in the following
243 * example:
244 * ```
245 * collectRouteParams(router: Router) {
246 * let params = {};
247 * let stack: ActivatedRouteSnapshot[] = [router.routerState.snapshot.root];
248 * while (stack.length > 0) {
249 * const route = stack.pop()!;
250 * params = {...params, ...route.params};
251 * stack.push(...route.children);
252 * }
253 * return params;
254 * }
255 * ```
256 */
257 params,
258 /** The query parameters shared by all the routes */
259 queryParams,
260 /** The URL fragment shared by all the routes */
261 fragment,
262 /** The static and resolved data of this route */
263 data,
264 /** The outlet name of the route */
265 outlet,
266 /** The component of the route */
267 component, routeConfig, urlSegment, lastPathIndex, resolve) {
268 this.url = url;
269 this.params = params;
270 this.queryParams = queryParams;
271 this.fragment = fragment;
272 this.data = data;
273 this.outlet = outlet;
274 this.component = component;
275 this.routeConfig = routeConfig;
276 this._urlSegment = urlSegment;
277 this._lastPathIndex = lastPathIndex;
278 this._resolve = resolve;
279 }
280 /** The root of the router state */
281 get root() {
282 return this._routerState.root;
283 }
284 /** The parent of this route in the router state tree */
285 get parent() {
286 return this._routerState.parent(this);
287 }
288 /** The first child of this route in the router state tree */
289 get firstChild() {
290 return this._routerState.firstChild(this);
291 }
292 /** The children of this route in the router state tree */
293 get children() {
294 return this._routerState.children(this);
295 }
296 /** The path from the root of the router state tree to this route */
297 get pathFromRoot() {
298 return this._routerState.pathFromRoot(this);
299 }
300 get paramMap() {
301 if (!this._paramMap) {
302 this._paramMap = convertToParamMap(this.params);
303 }
304 return this._paramMap;
305 }
306 get queryParamMap() {
307 if (!this._queryParamMap) {
308 this._queryParamMap = convertToParamMap(this.queryParams);
309 }
310 return this._queryParamMap;
311 }
312 toString() {
313 const url = this.url.map(segment => segment.toString()).join('/');
314 const matched = this.routeConfig ? this.routeConfig.path : '';
315 return `Route(url:'${url}', path:'${matched}')`;
316 }
317}
318/**
319 * @description
320 *
321 * Represents the state of the router at a moment in time.
322 *
323 * This is a tree of activated route snapshots. Every node in this tree knows about
324 * the "consumed" URL segments, the extracted parameters, and the resolved data.
325 *
326 * The following example shows how a component is initialized with information
327 * from the snapshot of the root node's state at the time of creation.
328 *
329 * ```
330 * @Component({templateUrl:'template.html'})
331 * class MyComponent {
332 * constructor(router: Router) {
333 * const state: RouterState = router.routerState;
334 * const snapshot: RouterStateSnapshot = state.snapshot;
335 * const root: ActivatedRouteSnapshot = snapshot.root;
336 * const child = root.firstChild;
337 * const id: Observable<string> = child.params.map(p => p.id);
338 * //...
339 * }
340 * }
341 * ```
342 *
343 * @publicApi
344 */
345export class RouterStateSnapshot extends Tree {
346 /** @internal */
347 constructor(
348 /** The url from which this snapshot was created */
349 url, root) {
350 super(root);
351 this.url = url;
352 setRouterState(this, root);
353 }
354 toString() {
355 return serializeNode(this._root);
356 }
357}
358function setRouterState(state, node) {
359 node.value._routerState = state;
360 node.children.forEach(c => setRouterState(state, c));
361}
362function serializeNode(node) {
363 const c = node.children.length > 0 ? ` { ${node.children.map(serializeNode).join(', ')} } ` : '';
364 return `${node.value}${c}`;
365}
366/**
367 * The expectation is that the activate route is created with the right set of parameters.
368 * So we push new values into the observables only when they are not the initial values.
369 * And we detect that by checking if the snapshot field is set.
370 */
371export function advanceActivatedRoute(route) {
372 if (route.snapshot) {
373 const currentSnapshot = route.snapshot;
374 const nextSnapshot = route._futureSnapshot;
375 route.snapshot = nextSnapshot;
376 if (!shallowEqual(currentSnapshot.queryParams, nextSnapshot.queryParams)) {
377 route.queryParams.next(nextSnapshot.queryParams);
378 }
379 if (currentSnapshot.fragment !== nextSnapshot.fragment) {
380 route.fragment.next(nextSnapshot.fragment);
381 }
382 if (!shallowEqual(currentSnapshot.params, nextSnapshot.params)) {
383 route.params.next(nextSnapshot.params);
384 }
385 if (!shallowEqualArrays(currentSnapshot.url, nextSnapshot.url)) {
386 route.url.next(nextSnapshot.url);
387 }
388 if (!shallowEqual(currentSnapshot.data, nextSnapshot.data)) {
389 route.data.next(nextSnapshot.data);
390 }
391 }
392 else {
393 route.snapshot = route._futureSnapshot;
394 // this is for resolved data
395 route.data.next(route._futureSnapshot.data);
396 }
397}
398export function equalParamsAndUrlSegments(a, b) {
399 const equalUrlParams = shallowEqual(a.params, b.params) && equalSegments(a.url, b.url);
400 const parentsMismatch = !a.parent !== !b.parent;
401 return equalUrlParams && !parentsMismatch &&
402 (!a.parent || equalParamsAndUrlSegments(a.parent, b.parent));
403}
404//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"router_state.js","sourceRoot":"","sources":["../../../../../../packages/router/src/router_state.ts"],"names":[],"mappings":"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","sourcesContent":["/**\n * @license\n * Copyright Google LLC All Rights Reserved.\n *\n * Use of this source code is governed by an MIT-style license that can be\n * found in the LICENSE file at https://angular.io/license\n */\n\nimport {Type} from '@angular/core';\nimport {BehaviorSubject, Observable} from 'rxjs';\nimport {map} from 'rxjs/operators';\n\nimport {Data, ResolveData, Route} from './config';\nimport {convertToParamMap, ParamMap, Params, PRIMARY_OUTLET} from './shared';\nimport {equalSegments, UrlSegment, UrlSegmentGroup, UrlTree} from './url_tree';\nimport {shallowEqual, shallowEqualArrays} from './utils/collection';\nimport {Tree, TreeNode} from './utils/tree';\n\n\n\n/**\n * Represents the state of the router as a tree of activated routes.\n *\n * @usageNotes\n *\n * Every node in the route tree is an `ActivatedRoute` instance\n * that knows about the \"consumed\" URL segments, the extracted parameters,\n * and the resolved data.\n * Use the `ActivatedRoute` properties to traverse the tree from any node.\n *\n * The following fragment shows how a component gets the root node\n * of the current state to establish its own route tree:\n *\n * ```\n * @Component({templateUrl:'template.html'})\n * class MyComponent {\n *   constructor(router: Router) {\n *     const state: RouterState = router.routerState;\n *     const root: ActivatedRoute = state.root;\n *     const child = root.firstChild;\n *     const id: Observable<string> = child.params.map(p => p.id);\n *     //...\n *   }\n * }\n * ```\n *\n * @see `ActivatedRoute`\n * @see [Getting route information](guide/router#getting-route-information)\n *\n * @publicApi\n */\nexport class RouterState extends Tree<ActivatedRoute> {\n  /** @internal */\n  constructor(\n      root: TreeNode<ActivatedRoute>,\n      /** The current snapshot of the router state */\n      public snapshot: RouterStateSnapshot) {\n    super(root);\n    setRouterState(<RouterState>this, root);\n  }\n\n  override toString(): string {\n    return this.snapshot.toString();\n  }\n}\n\nexport function createEmptyState(urlTree: UrlTree, rootComponent: Type<any>|null): RouterState {\n  const snapshot = createEmptyStateSnapshot(urlTree, rootComponent);\n  const emptyUrl = new BehaviorSubject([new UrlSegment('', {})]);\n  const emptyParams = new BehaviorSubject({});\n  const emptyData = new BehaviorSubject({});\n  const emptyQueryParams = new BehaviorSubject({});\n  const fragment = new BehaviorSubject('');\n  const activated = new ActivatedRoute(\n      emptyUrl, emptyParams, emptyQueryParams, fragment, emptyData, PRIMARY_OUTLET, rootComponent,\n      snapshot.root);\n  activated.snapshot = snapshot.root;\n  return new RouterState(new TreeNode<ActivatedRoute>(activated, []), snapshot);\n}\n\nexport function createEmptyStateSnapshot(\n    urlTree: UrlTree, rootComponent: Type<any>|null): RouterStateSnapshot {\n  const emptyParams = {};\n  const emptyData = {};\n  const emptyQueryParams = {};\n  const fragment = '';\n  const activated = new ActivatedRouteSnapshot(\n      [], emptyParams, emptyQueryParams, fragment, emptyData, PRIMARY_OUTLET, rootComponent, null,\n      urlTree.root, -1, {});\n  return new RouterStateSnapshot('', new TreeNode<ActivatedRouteSnapshot>(activated, []));\n}\n\n/**\n * Provides access to information about a route associated with a component\n * that is loaded in an outlet.\n * Use to traverse the `RouterState` tree and extract information from nodes.\n *\n * The following example shows how to construct a component using information from a\n * currently activated route.\n *\n * Note: the observables in this class only emit when the current and previous values differ based\n * on shallow equality. For example, changing deeply nested properties in resolved `data` will not\n * cause the `ActivatedRoute.data` `Observable` to emit a new value.\n *\n * {@example router/activated-route/module.ts region=\"activated-route\"\n *     header=\"activated-route.component.ts\"}\n *\n * @see [Getting route information](guide/router#getting-route-information)\n *\n * @publicApi\n */\nexport class ActivatedRoute {\n  /** The current snapshot of this route */\n  snapshot!: ActivatedRouteSnapshot;\n  /** @internal */\n  _futureSnapshot: ActivatedRouteSnapshot;\n  /** @internal */\n  _routerState!: RouterState;\n  /** @internal */\n  _paramMap!: Observable<ParamMap>;\n  /** @internal */\n  _queryParamMap!: Observable<ParamMap>;\n\n  /** @internal */\n  constructor(\n      /** An observable of the URL segments matched by this route. */\n      public url: Observable<UrlSegment[]>,\n      /** An observable of the matrix parameters scoped to this route. */\n      public params: Observable<Params>,\n      /** An observable of the query parameters shared by all the routes. */\n      public queryParams: Observable<Params>,\n      /** An observable of the URL fragment shared by all the routes. */\n      public fragment: Observable<string|null>,\n      /** An observable of the static and resolved data of this route. */\n      public data: Observable<Data>,\n      /** The outlet name of the route, a constant. */\n      public outlet: string,\n      /** The component of the route, a constant. */\n      // TODO(vsavkin): remove |string\n      public component: Type<any>|string|null, futureSnapshot: ActivatedRouteSnapshot) {\n    this._futureSnapshot = futureSnapshot;\n  }\n\n  /** The configuration used to match this route. */\n  get routeConfig(): Route|null {\n    return this._futureSnapshot.routeConfig;\n  }\n\n  /** The root of the router state. */\n  get root(): ActivatedRoute {\n    return this._routerState.root;\n  }\n\n  /** The parent of this route in the router state tree. */\n  get parent(): ActivatedRoute|null {\n    return this._routerState.parent(this);\n  }\n\n  /** The first child of this route in the router state tree. */\n  get firstChild(): ActivatedRoute|null {\n    return this._routerState.firstChild(this);\n  }\n\n  /** The children of this route in the router state tree. */\n  get children(): ActivatedRoute[] {\n    return this._routerState.children(this);\n  }\n\n  /** The path from the root of the router state tree to this route. */\n  get pathFromRoot(): ActivatedRoute[] {\n    return this._routerState.pathFromRoot(this);\n  }\n\n  /**\n   * An Observable that contains a map of the required and optional parameters\n   * specific to the route.\n   * The map supports retrieving single and multiple values from the same parameter.\n   */\n  get paramMap(): Observable<ParamMap> {\n    if (!this._paramMap) {\n      this._paramMap = this.params.pipe(map((p: Params): ParamMap => convertToParamMap(p)));\n    }\n    return this._paramMap;\n  }\n\n  /**\n   * An Observable that contains a map of the query parameters available to all routes.\n   * The map supports retrieving single and multiple values from the query parameter.\n   */\n  get queryParamMap(): Observable<ParamMap> {\n    if (!this._queryParamMap) {\n      this._queryParamMap =\n          this.queryParams.pipe(map((p: Params): ParamMap => convertToParamMap(p)));\n    }\n    return this._queryParamMap;\n  }\n\n  toString(): string {\n    return this.snapshot ? this.snapshot.toString() : `Future(${this._futureSnapshot})`;\n  }\n}\n\nexport type ParamsInheritanceStrategy = 'emptyOnly'|'always';\n\n/** @internal */\nexport type Inherited = {\n  params: Params,\n  data: Data,\n  resolve: Data,\n};\n\n/**\n * Returns the inherited params, data, and resolve for a given route.\n * By default, this only inherits values up to the nearest path-less or component-less route.\n * @internal\n */\nexport function inheritedParamsDataResolve(\n    route: ActivatedRouteSnapshot,\n    paramsInheritanceStrategy: ParamsInheritanceStrategy = 'emptyOnly'): Inherited {\n  const pathFromRoot = route.pathFromRoot;\n\n  let inheritingStartingFrom = 0;\n  if (paramsInheritanceStrategy !== 'always') {\n    inheritingStartingFrom = pathFromRoot.length - 1;\n\n    while (inheritingStartingFrom >= 1) {\n      const current = pathFromRoot[inheritingStartingFrom];\n      const parent = pathFromRoot[inheritingStartingFrom - 1];\n      // current route is an empty path => inherits its parent's params and data\n      if (current.routeConfig && current.routeConfig.path === '') {\n        inheritingStartingFrom--;\n\n        // parent is componentless => current route should inherit its params and data\n      } else if (!parent.component) {\n        inheritingStartingFrom--;\n\n      } else {\n        break;\n      }\n    }\n  }\n\n  return flattenInherited(pathFromRoot.slice(inheritingStartingFrom));\n}\n\n/** @internal */\nfunction flattenInherited(pathFromRoot: ActivatedRouteSnapshot[]): Inherited {\n  return pathFromRoot.reduce((res, curr) => {\n    const params = {...res.params, ...curr.params};\n    const data = {...res.data, ...curr.data};\n    const resolve = {...res.resolve, ...curr._resolvedData};\n    return {params, data, resolve};\n  }, <any>{params: {}, data: {}, resolve: {}});\n}\n\n/**\n * @description\n *\n * Contains the information about a route associated with a component loaded in an\n * outlet at a particular moment in time. ActivatedRouteSnapshot can also be used to\n * traverse the router state tree.\n *\n * The following example initializes a component with route information extracted\n * from the snapshot of the root node at the time of creation.\n *\n * ```\n * @Component({templateUrl:'./my-component.html'})\n * class MyComponent {\n *   constructor(route: ActivatedRoute) {\n *     const id: string = route.snapshot.params.id;\n *     const url: string = route.snapshot.url.join('');\n *     const user = route.snapshot.data.user;\n *   }\n * }\n * ```\n *\n * @publicApi\n */\nexport class ActivatedRouteSnapshot {\n  /** The configuration used to match this route **/\n  public readonly routeConfig: Route|null;\n  /** @internal **/\n  _urlSegment: UrlSegmentGroup;\n  /** @internal */\n  _lastPathIndex: number;\n  /** @internal */\n  _resolve: ResolveData;\n  /** @internal */\n  // TODO(issue/24571): remove '!'.\n  _resolvedData!: Data;\n  /** @internal */\n  // TODO(issue/24571): remove '!'.\n  _routerState!: RouterStateSnapshot;\n  /** @internal */\n  // TODO(issue/24571): remove '!'.\n  _paramMap!: ParamMap;\n  /** @internal */\n  // TODO(issue/24571): remove '!'.\n  _queryParamMap!: ParamMap;\n\n  /** @internal */\n  constructor(\n      /** The URL segments matched by this route */\n      public url: UrlSegment[],\n      /**\n       *  The matrix parameters scoped to this route.\n       *\n       *  You can compute all params (or data) in the router state or to get params outside\n       *  of an activated component by traversing the `RouterState` tree as in the following\n       *  example:\n       *  ```\n       *  collectRouteParams(router: Router) {\n       *    let params = {};\n       *    let stack: ActivatedRouteSnapshot[] = [router.routerState.snapshot.root];\n       *    while (stack.length > 0) {\n       *      const route = stack.pop()!;\n       *      params = {...params, ...route.params};\n       *      stack.push(...route.children);\n       *    }\n       *    return params;\n       *  }\n       *  ```\n       */\n      public params: Params,\n      /** The query parameters shared by all the routes */\n      public queryParams: Params,\n      /** The URL fragment shared by all the routes */\n      public fragment: string|null,\n      /** The static and resolved data of this route */\n      public data: Data,\n      /** The outlet name of the route */\n      public outlet: string,\n      /** The component of the route */\n      public component: Type<any>|string|null, routeConfig: Route|null, urlSegment: UrlSegmentGroup,\n      lastPathIndex: number, resolve: ResolveData) {\n    this.routeConfig = routeConfig;\n    this._urlSegment = urlSegment;\n    this._lastPathIndex = lastPathIndex;\n    this._resolve = resolve;\n  }\n\n  /** The root of the router state */\n  get root(): ActivatedRouteSnapshot {\n    return this._routerState.root;\n  }\n\n  /** The parent of this route in the router state tree */\n  get parent(): ActivatedRouteSnapshot|null {\n    return this._routerState.parent(this);\n  }\n\n  /** The first child of this route in the router state tree */\n  get firstChild(): ActivatedRouteSnapshot|null {\n    return this._routerState.firstChild(this);\n  }\n\n  /** The children of this route in the router state tree */\n  get children(): ActivatedRouteSnapshot[] {\n    return this._routerState.children(this);\n  }\n\n  /** The path from the root of the router state tree to this route */\n  get pathFromRoot(): ActivatedRouteSnapshot[] {\n    return this._routerState.pathFromRoot(this);\n  }\n\n  get paramMap(): ParamMap {\n    if (!this._paramMap) {\n      this._paramMap = convertToParamMap(this.params);\n    }\n    return this._paramMap;\n  }\n\n  get queryParamMap(): ParamMap {\n    if (!this._queryParamMap) {\n      this._queryParamMap = convertToParamMap(this.queryParams);\n    }\n    return this._queryParamMap;\n  }\n\n  toString(): string {\n    const url = this.url.map(segment => segment.toString()).join('/');\n    const matched = this.routeConfig ? this.routeConfig.path : '';\n    return `Route(url:'${url}', path:'${matched}')`;\n  }\n}\n\n/**\n * @description\n *\n * Represents the state of the router at a moment in time.\n *\n * This is a tree of activated route snapshots. Every node in this tree knows about\n * the \"consumed\" URL segments, the extracted parameters, and the resolved data.\n *\n * The following example shows how a component is initialized with information\n * from the snapshot of the root node's state at the time of creation.\n *\n * ```\n * @Component({templateUrl:'template.html'})\n * class MyComponent {\n *   constructor(router: Router) {\n *     const state: RouterState = router.routerState;\n *     const snapshot: RouterStateSnapshot = state.snapshot;\n *     const root: ActivatedRouteSnapshot = snapshot.root;\n *     const child = root.firstChild;\n *     const id: Observable<string> = child.params.map(p => p.id);\n *     //...\n *   }\n * }\n * ```\n *\n * @publicApi\n */\nexport class RouterStateSnapshot extends Tree<ActivatedRouteSnapshot> {\n  /** @internal */\n  constructor(\n      /** The url from which this snapshot was created */\n      public url: string, root: TreeNode<ActivatedRouteSnapshot>) {\n    super(root);\n    setRouterState(<RouterStateSnapshot>this, root);\n  }\n\n  override toString(): string {\n    return serializeNode(this._root);\n  }\n}\n\nfunction setRouterState<U, T extends {_routerState: U}>(state: U, node: TreeNode<T>): void {\n  node.value._routerState = state;\n  node.children.forEach(c => setRouterState(state, c));\n}\n\nfunction serializeNode(node: TreeNode<ActivatedRouteSnapshot>): string {\n  const c = node.children.length > 0 ? ` { ${node.children.map(serializeNode).join(', ')} } ` : '';\n  return `${node.value}${c}`;\n}\n\n/**\n * The expectation is that the activate route is created with the right set of parameters.\n * So we push new values into the observables only when they are not the initial values.\n * And we detect that by checking if the snapshot field is set.\n */\nexport function advanceActivatedRoute(route: ActivatedRoute): void {\n  if (route.snapshot) {\n    const currentSnapshot = route.snapshot;\n    const nextSnapshot = route._futureSnapshot;\n    route.snapshot = nextSnapshot;\n    if (!shallowEqual(currentSnapshot.queryParams, nextSnapshot.queryParams)) {\n      (<any>route.queryParams).next(nextSnapshot.queryParams);\n    }\n    if (currentSnapshot.fragment !== nextSnapshot.fragment) {\n      (<any>route.fragment).next(nextSnapshot.fragment);\n    }\n    if (!shallowEqual(currentSnapshot.params, nextSnapshot.params)) {\n      (<any>route.params).next(nextSnapshot.params);\n    }\n    if (!shallowEqualArrays(currentSnapshot.url, nextSnapshot.url)) {\n      (<any>route.url).next(nextSnapshot.url);\n    }\n    if (!shallowEqual(currentSnapshot.data, nextSnapshot.data)) {\n      (<any>route.data).next(nextSnapshot.data);\n    }\n  } else {\n    route.snapshot = route._futureSnapshot;\n\n    // this is for resolved data\n    (<any>route.data).next(route._futureSnapshot.data);\n  }\n}\n\n\nexport function equalParamsAndUrlSegments(\n    a: ActivatedRouteSnapshot, b: ActivatedRouteSnapshot): boolean {\n  const equalUrlParams = shallowEqual(a.params, b.params) && equalSegments(a.url, b.url);\n  const parentsMismatch = !a.parent !== !b.parent;\n\n  return equalUrlParams && !parentsMismatch &&\n      (!a.parent || equalParamsAndUrlSegments(a.parent, b.parent!));\n}\n"]}
Note: See TracBrowser for help on using the repository browser.