source: trip-planner-front/node_modules/@angular/common/esm2015/upgrade/src/location_shim.js

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

initial commit

  • Property mode set to 100644
File size: 73.2 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 { ReplaySubject } from 'rxjs';
9import { deepEqual, isAnchor, isPromise } from './utils';
10const PATH_MATCH = /^([^?#]*)(\?([^#]*))?(#(.*))?$/;
11const DOUBLE_SLASH_REGEX = /^\s*[\\/]{2,}/;
12const IGNORE_URI_REGEXP = /^\s*(javascript|mailto):/i;
13const DEFAULT_PORTS = {
14 'http:': 80,
15 'https:': 443,
16 'ftp:': 21
17};
18/**
19 * Location service that provides a drop-in replacement for the $location service
20 * provided in AngularJS.
21 *
22 * @see [Using the Angular Unified Location Service](guide/upgrade#using-the-unified-angular-location-service)
23 *
24 * @publicApi
25 */
26export class $locationShim {
27 constructor($injector, location, platformLocation, urlCodec, locationStrategy) {
28 this.location = location;
29 this.platformLocation = platformLocation;
30 this.urlCodec = urlCodec;
31 this.locationStrategy = locationStrategy;
32 this.initalizing = true;
33 this.updateBrowser = false;
34 this.$$absUrl = '';
35 this.$$url = '';
36 this.$$host = '';
37 this.$$replace = false;
38 this.$$path = '';
39 this.$$search = '';
40 this.$$hash = '';
41 this.$$changeListeners = [];
42 this.cachedState = null;
43 this.urlChanges = new ReplaySubject(1);
44 this.lastBrowserUrl = '';
45 // This variable should be used *only* inside the cacheState function.
46 this.lastCachedState = null;
47 const initialUrl = this.browserUrl();
48 let parsedUrl = this.urlCodec.parse(initialUrl);
49 if (typeof parsedUrl === 'string') {
50 throw 'Invalid URL';
51 }
52 this.$$protocol = parsedUrl.protocol;
53 this.$$host = parsedUrl.hostname;
54 this.$$port = parseInt(parsedUrl.port) || DEFAULT_PORTS[parsedUrl.protocol] || null;
55 this.$$parseLinkUrl(initialUrl, initialUrl);
56 this.cacheState();
57 this.$$state = this.browserState();
58 this.location.onUrlChange((newUrl, newState) => {
59 this.urlChanges.next({ newUrl, newState });
60 });
61 if (isPromise($injector)) {
62 $injector.then($i => this.initialize($i));
63 }
64 else {
65 this.initialize($injector);
66 }
67 }
68 initialize($injector) {
69 const $rootScope = $injector.get('$rootScope');
70 const $rootElement = $injector.get('$rootElement');
71 $rootElement.on('click', (event) => {
72 if (event.ctrlKey || event.metaKey || event.shiftKey || event.which === 2 ||
73 event.button === 2) {
74 return;
75 }
76 let elm = event.target;
77 // traverse the DOM up to find first A tag
78 while (elm && elm.nodeName.toLowerCase() !== 'a') {
79 // ignore rewriting if no A tag (reached root element, or no parent - removed from document)
80 if (elm === $rootElement[0] || !(elm = elm.parentNode)) {
81 return;
82 }
83 }
84 if (!isAnchor(elm)) {
85 return;
86 }
87 const absHref = elm.href;
88 const relHref = elm.getAttribute('href');
89 // Ignore when url is started with javascript: or mailto:
90 if (IGNORE_URI_REGEXP.test(absHref)) {
91 return;
92 }
93 if (absHref && !elm.getAttribute('target') && !event.isDefaultPrevented()) {
94 if (this.$$parseLinkUrl(absHref, relHref)) {
95 // We do a preventDefault for all urls that are part of the AngularJS application,
96 // in html5mode and also without, so that we are able to abort navigation without
97 // getting double entries in the location history.
98 event.preventDefault();
99 // update location manually
100 if (this.absUrl() !== this.browserUrl()) {
101 $rootScope.$apply();
102 }
103 }
104 }
105 });
106 this.urlChanges.subscribe(({ newUrl, newState }) => {
107 const oldUrl = this.absUrl();
108 const oldState = this.$$state;
109 this.$$parse(newUrl);
110 newUrl = this.absUrl();
111 this.$$state = newState;
112 const defaultPrevented = $rootScope.$broadcast('$locationChangeStart', newUrl, oldUrl, newState, oldState)
113 .defaultPrevented;
114 // if the location was changed by a `$locationChangeStart` handler then stop
115 // processing this location change
116 if (this.absUrl() !== newUrl)
117 return;
118 // If default was prevented, set back to old state. This is the state that was locally
119 // cached in the $location service.
120 if (defaultPrevented) {
121 this.$$parse(oldUrl);
122 this.state(oldState);
123 this.setBrowserUrlWithFallback(oldUrl, false, oldState);
124 this.$$notifyChangeListeners(this.url(), this.$$state, oldUrl, oldState);
125 }
126 else {
127 this.initalizing = false;
128 $rootScope.$broadcast('$locationChangeSuccess', newUrl, oldUrl, newState, oldState);
129 this.resetBrowserUpdate();
130 }
131 if (!$rootScope.$$phase) {
132 $rootScope.$digest();
133 }
134 });
135 // update browser
136 $rootScope.$watch(() => {
137 if (this.initalizing || this.updateBrowser) {
138 this.updateBrowser = false;
139 const oldUrl = this.browserUrl();
140 const newUrl = this.absUrl();
141 const oldState = this.browserState();
142 let currentReplace = this.$$replace;
143 const urlOrStateChanged = !this.urlCodec.areEqual(oldUrl, newUrl) || oldState !== this.$$state;
144 // Fire location changes one time to on initialization. This must be done on the
145 // next tick (thus inside $evalAsync()) in order for listeners to be registered
146 // before the event fires. Mimicing behavior from $locationWatch:
147 // https://github.com/angular/angular.js/blob/master/src/ng/location.js#L983
148 if (this.initalizing || urlOrStateChanged) {
149 this.initalizing = false;
150 $rootScope.$evalAsync(() => {
151 // Get the new URL again since it could have changed due to async update
152 const newUrl = this.absUrl();
153 const defaultPrevented = $rootScope
154 .$broadcast('$locationChangeStart', newUrl, oldUrl, this.$$state, oldState)
155 .defaultPrevented;
156 // if the location was changed by a `$locationChangeStart` handler then stop
157 // processing this location change
158 if (this.absUrl() !== newUrl)
159 return;
160 if (defaultPrevented) {
161 this.$$parse(oldUrl);
162 this.$$state = oldState;
163 }
164 else {
165 // This block doesn't run when initalizing because it's going to perform the update to
166 // the URL which shouldn't be needed when initalizing.
167 if (urlOrStateChanged) {
168 this.setBrowserUrlWithFallback(newUrl, currentReplace, oldState === this.$$state ? null : this.$$state);
169 this.$$replace = false;
170 }
171 $rootScope.$broadcast('$locationChangeSuccess', newUrl, oldUrl, this.$$state, oldState);
172 if (urlOrStateChanged) {
173 this.$$notifyChangeListeners(this.url(), this.$$state, oldUrl, oldState);
174 }
175 }
176 });
177 }
178 }
179 this.$$replace = false;
180 });
181 }
182 resetBrowserUpdate() {
183 this.$$replace = false;
184 this.$$state = this.browserState();
185 this.updateBrowser = false;
186 this.lastBrowserUrl = this.browserUrl();
187 }
188 browserUrl(url, replace, state) {
189 // In modern browsers `history.state` is `null` by default; treating it separately
190 // from `undefined` would cause `$browser.url('/foo')` to change `history.state`
191 // to undefined via `pushState`. Instead, let's change `undefined` to `null` here.
192 if (typeof state === 'undefined') {
193 state = null;
194 }
195 // setter
196 if (url) {
197 let sameState = this.lastHistoryState === state;
198 // Normalize the inputted URL
199 url = this.urlCodec.parse(url).href;
200 // Don't change anything if previous and current URLs and states match.
201 if (this.lastBrowserUrl === url && sameState) {
202 return this;
203 }
204 this.lastBrowserUrl = url;
205 this.lastHistoryState = state;
206 // Remove server base from URL as the Angular APIs for updating URL require
207 // it to be the path+.
208 url = this.stripBaseUrl(this.getServerBase(), url) || url;
209 // Set the URL
210 if (replace) {
211 this.locationStrategy.replaceState(state, '', url, '');
212 }
213 else {
214 this.locationStrategy.pushState(state, '', url, '');
215 }
216 this.cacheState();
217 return this;
218 // getter
219 }
220 else {
221 return this.platformLocation.href;
222 }
223 }
224 cacheState() {
225 // This should be the only place in $browser where `history.state` is read.
226 this.cachedState = this.platformLocation.getState();
227 if (typeof this.cachedState === 'undefined') {
228 this.cachedState = null;
229 }
230 // Prevent callbacks fo fire twice if both hashchange & popstate were fired.
231 if (deepEqual(this.cachedState, this.lastCachedState)) {
232 this.cachedState = this.lastCachedState;
233 }
234 this.lastCachedState = this.cachedState;
235 this.lastHistoryState = this.cachedState;
236 }
237 /**
238 * This function emulates the $browser.state() function from AngularJS. It will cause
239 * history.state to be cached unless changed with deep equality check.
240 */
241 browserState() {
242 return this.cachedState;
243 }
244 stripBaseUrl(base, url) {
245 if (url.startsWith(base)) {
246 return url.substr(base.length);
247 }
248 return undefined;
249 }
250 getServerBase() {
251 const { protocol, hostname, port } = this.platformLocation;
252 const baseHref = this.locationStrategy.getBaseHref();
253 let url = `${protocol}//${hostname}${port ? ':' + port : ''}${baseHref || '/'}`;
254 return url.endsWith('/') ? url : url + '/';
255 }
256 parseAppUrl(url) {
257 if (DOUBLE_SLASH_REGEX.test(url)) {
258 throw new Error(`Bad Path - URL cannot start with double slashes: ${url}`);
259 }
260 let prefixed = (url.charAt(0) !== '/');
261 if (prefixed) {
262 url = '/' + url;
263 }
264 let match = this.urlCodec.parse(url, this.getServerBase());
265 if (typeof match === 'string') {
266 throw new Error(`Bad URL - Cannot parse URL: ${url}`);
267 }
268 let path = prefixed && match.pathname.charAt(0) === '/' ? match.pathname.substring(1) : match.pathname;
269 this.$$path = this.urlCodec.decodePath(path);
270 this.$$search = this.urlCodec.decodeSearch(match.search);
271 this.$$hash = this.urlCodec.decodeHash(match.hash);
272 // make sure path starts with '/';
273 if (this.$$path && this.$$path.charAt(0) !== '/') {
274 this.$$path = '/' + this.$$path;
275 }
276 }
277 /**
278 * Registers listeners for URL changes. This API is used to catch updates performed by the
279 * AngularJS framework. These changes are a subset of the `$locationChangeStart` and
280 * `$locationChangeSuccess` events which fire when AngularJS updates its internally-referenced
281 * version of the browser URL.
282 *
283 * It's possible for `$locationChange` events to happen, but for the browser URL
284 * (window.location) to remain unchanged. This `onChange` callback will fire only when AngularJS
285 * actually updates the browser URL (window.location).
286 *
287 * @param fn The callback function that is triggered for the listener when the URL changes.
288 * @param err The callback function that is triggered when an error occurs.
289 */
290 onChange(fn, err = (e) => { }) {
291 this.$$changeListeners.push([fn, err]);
292 }
293 /** @internal */
294 $$notifyChangeListeners(url = '', state, oldUrl = '', oldState) {
295 this.$$changeListeners.forEach(([fn, err]) => {
296 try {
297 fn(url, state, oldUrl, oldState);
298 }
299 catch (e) {
300 err(e);
301 }
302 });
303 }
304 /**
305 * Parses the provided URL, and sets the current URL to the parsed result.
306 *
307 * @param url The URL string.
308 */
309 $$parse(url) {
310 let pathUrl;
311 if (url.startsWith('/')) {
312 pathUrl = url;
313 }
314 else {
315 // Remove protocol & hostname if URL starts with it
316 pathUrl = this.stripBaseUrl(this.getServerBase(), url);
317 }
318 if (typeof pathUrl === 'undefined') {
319 throw new Error(`Invalid url "${url}", missing path prefix "${this.getServerBase()}".`);
320 }
321 this.parseAppUrl(pathUrl);
322 if (!this.$$path) {
323 this.$$path = '/';
324 }
325 this.composeUrls();
326 }
327 /**
328 * Parses the provided URL and its relative URL.
329 *
330 * @param url The full URL string.
331 * @param relHref A URL string relative to the full URL string.
332 */
333 $$parseLinkUrl(url, relHref) {
334 // When relHref is passed, it should be a hash and is handled separately
335 if (relHref && relHref[0] === '#') {
336 this.hash(relHref.slice(1));
337 return true;
338 }
339 let rewrittenUrl;
340 let appUrl = this.stripBaseUrl(this.getServerBase(), url);
341 if (typeof appUrl !== 'undefined') {
342 rewrittenUrl = this.getServerBase() + appUrl;
343 }
344 else if (this.getServerBase() === url + '/') {
345 rewrittenUrl = this.getServerBase();
346 }
347 // Set the URL
348 if (rewrittenUrl) {
349 this.$$parse(rewrittenUrl);
350 }
351 return !!rewrittenUrl;
352 }
353 setBrowserUrlWithFallback(url, replace, state) {
354 const oldUrl = this.url();
355 const oldState = this.$$state;
356 try {
357 this.browserUrl(url, replace, state);
358 // Make sure $location.state() returns referentially identical (not just deeply equal)
359 // state object; this makes possible quick checking if the state changed in the digest
360 // loop. Checking deep equality would be too expensive.
361 this.$$state = this.browserState();
362 }
363 catch (e) {
364 // Restore old values if pushState fails
365 this.url(oldUrl);
366 this.$$state = oldState;
367 throw e;
368 }
369 }
370 composeUrls() {
371 this.$$url = this.urlCodec.normalize(this.$$path, this.$$search, this.$$hash);
372 this.$$absUrl = this.getServerBase() + this.$$url.substr(1); // remove '/' from front of URL
373 this.updateBrowser = true;
374 }
375 /**
376 * Retrieves the full URL representation with all segments encoded according to
377 * rules specified in
378 * [RFC 3986](https://tools.ietf.org/html/rfc3986).
379 *
380 *
381 * ```js
382 * // given URL http://example.com/#/some/path?foo=bar&baz=xoxo
383 * let absUrl = $location.absUrl();
384 * // => "http://example.com/#/some/path?foo=bar&baz=xoxo"
385 * ```
386 */
387 absUrl() {
388 return this.$$absUrl;
389 }
390 url(url) {
391 if (typeof url === 'string') {
392 if (!url.length) {
393 url = '/';
394 }
395 const match = PATH_MATCH.exec(url);
396 if (!match)
397 return this;
398 if (match[1] || url === '')
399 this.path(this.urlCodec.decodePath(match[1]));
400 if (match[2] || match[1] || url === '')
401 this.search(match[3] || '');
402 this.hash(match[5] || '');
403 // Chainable method
404 return this;
405 }
406 return this.$$url;
407 }
408 /**
409 * Retrieves the protocol of the current URL.
410 *
411 * ```js
412 * // given URL http://example.com/#/some/path?foo=bar&baz=xoxo
413 * let protocol = $location.protocol();
414 * // => "http"
415 * ```
416 */
417 protocol() {
418 return this.$$protocol;
419 }
420 /**
421 * Retrieves the protocol of the current URL.
422 *
423 * In contrast to the non-AngularJS version `location.host` which returns `hostname:port`, this
424 * returns the `hostname` portion only.
425 *
426 *
427 * ```js
428 * // given URL http://example.com/#/some/path?foo=bar&baz=xoxo
429 * let host = $location.host();
430 * // => "example.com"
431 *
432 * // given URL http://user:password@example.com:8080/#/some/path?foo=bar&baz=xoxo
433 * host = $location.host();
434 * // => "example.com"
435 * host = location.host;
436 * // => "example.com:8080"
437 * ```
438 */
439 host() {
440 return this.$$host;
441 }
442 /**
443 * Retrieves the port of the current URL.
444 *
445 * ```js
446 * // given URL http://example.com/#/some/path?foo=bar&baz=xoxo
447 * let port = $location.port();
448 * // => 80
449 * ```
450 */
451 port() {
452 return this.$$port;
453 }
454 path(path) {
455 if (typeof path === 'undefined') {
456 return this.$$path;
457 }
458 // null path converts to empty string. Prepend with "/" if needed.
459 path = path !== null ? path.toString() : '';
460 path = path.charAt(0) === '/' ? path : '/' + path;
461 this.$$path = path;
462 this.composeUrls();
463 return this;
464 }
465 search(search, paramValue) {
466 switch (arguments.length) {
467 case 0:
468 return this.$$search;
469 case 1:
470 if (typeof search === 'string' || typeof search === 'number') {
471 this.$$search = this.urlCodec.decodeSearch(search.toString());
472 }
473 else if (typeof search === 'object' && search !== null) {
474 // Copy the object so it's never mutated
475 search = Object.assign({}, search);
476 // remove object undefined or null properties
477 for (const key in search) {
478 if (search[key] == null)
479 delete search[key];
480 }
481 this.$$search = search;
482 }
483 else {
484 throw new Error('LocationProvider.search(): First argument must be a string or an object.');
485 }
486 break;
487 default:
488 if (typeof search === 'string') {
489 const currentSearch = this.search();
490 if (typeof paramValue === 'undefined' || paramValue === null) {
491 delete currentSearch[search];
492 return this.search(currentSearch);
493 }
494 else {
495 currentSearch[search] = paramValue;
496 return this.search(currentSearch);
497 }
498 }
499 }
500 this.composeUrls();
501 return this;
502 }
503 hash(hash) {
504 if (typeof hash === 'undefined') {
505 return this.$$hash;
506 }
507 this.$$hash = hash !== null ? hash.toString() : '';
508 this.composeUrls();
509 return this;
510 }
511 /**
512 * Changes to `$location` during the current `$digest` will replace the current
513 * history record, instead of adding a new one.
514 */
515 replace() {
516 this.$$replace = true;
517 return this;
518 }
519 state(state) {
520 if (typeof state === 'undefined') {
521 return this.$$state;
522 }
523 this.$$state = state;
524 return this;
525 }
526}
527/**
528 * The factory function used to create an instance of the `$locationShim` in Angular,
529 * and provides an API-compatiable `$locationProvider` for AngularJS.
530 *
531 * @publicApi
532 */
533export class $locationShimProvider {
534 constructor(ngUpgrade, location, platformLocation, urlCodec, locationStrategy) {
535 this.ngUpgrade = ngUpgrade;
536 this.location = location;
537 this.platformLocation = platformLocation;
538 this.urlCodec = urlCodec;
539 this.locationStrategy = locationStrategy;
540 }
541 /**
542 * Factory method that returns an instance of the $locationShim
543 */
544 $get() {
545 return new $locationShim(this.ngUpgrade.$injector, this.location, this.platformLocation, this.urlCodec, this.locationStrategy);
546 }
547 /**
548 * Stub method used to keep API compatible with AngularJS. This setting is configured through
549 * the LocationUpgradeModule's `config` method in your Angular app.
550 */
551 hashPrefix(prefix) {
552 throw new Error('Configure LocationUpgrade through LocationUpgradeModule.config method.');
553 }
554 /**
555 * Stub method used to keep API compatible with AngularJS. This setting is configured through
556 * the LocationUpgradeModule's `config` method in your Angular app.
557 */
558 html5Mode(mode) {
559 throw new Error('Configure LocationUpgrade through LocationUpgradeModule.config method.');
560 }
561}
562//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"location_shim.js","sourceRoot":"","sources":["../../../../../../../packages/common/upgrade/src/location_shim.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 {Location, LocationStrategy, PlatformLocation} from '@angular/common';\nimport {UpgradeModule} from '@angular/upgrade/static';\nimport {ReplaySubject} from 'rxjs';\n\nimport {UrlCodec} from './params';\nimport {deepEqual, isAnchor, isPromise} from './utils';\n\nconst PATH_MATCH = /^([^?#]*)(\\?([^#]*))?(#(.*))?$/;\nconst DOUBLE_SLASH_REGEX = /^\\s*[\\\\/]{2,}/;\nconst IGNORE_URI_REGEXP = /^\\s*(javascript|mailto):/i;\nconst DEFAULT_PORTS: {[key: string]: number} = {\n  'http:': 80,\n  'https:': 443,\n  'ftp:': 21\n};\n\n/**\n * Location service that provides a drop-in replacement for the $location service\n * provided in AngularJS.\n *\n * @see [Using the Angular Unified Location Service](guide/upgrade#using-the-unified-angular-location-service)\n *\n * @publicApi\n */\nexport class $locationShim {\n  private initalizing = true;\n  private updateBrowser = false;\n  private $$absUrl: string = '';\n  private $$url: string = '';\n  private $$protocol: string;\n  private $$host: string = '';\n  private $$port: number|null;\n  private $$replace: boolean = false;\n  private $$path: string = '';\n  private $$search: any = '';\n  private $$hash: string = '';\n  private $$state: unknown;\n  private $$changeListeners: [\n    ((url: string, state: unknown, oldUrl: string, oldState: unknown, err?: (e: Error) => void) =>\n         void),\n    (e: Error) => void\n  ][] = [];\n\n  private cachedState: unknown = null;\n\n  private urlChanges = new ReplaySubject<{newUrl: string, newState: unknown}>(1);\n\n  constructor(\n      $injector: any, private location: Location, private platformLocation: PlatformLocation,\n      private urlCodec: UrlCodec, private locationStrategy: LocationStrategy) {\n    const initialUrl = this.browserUrl();\n\n    let parsedUrl = this.urlCodec.parse(initialUrl);\n\n    if (typeof parsedUrl === 'string') {\n      throw 'Invalid URL';\n    }\n\n    this.$$protocol = parsedUrl.protocol;\n    this.$$host = parsedUrl.hostname;\n    this.$$port = parseInt(parsedUrl.port) || DEFAULT_PORTS[parsedUrl.protocol] || null;\n\n    this.$$parseLinkUrl(initialUrl, initialUrl);\n    this.cacheState();\n    this.$$state = this.browserState();\n\n    this.location.onUrlChange((newUrl, newState) => {\n      this.urlChanges.next({newUrl, newState});\n    });\n\n    if (isPromise($injector)) {\n      $injector.then($i => this.initialize($i));\n    } else {\n      this.initialize($injector);\n    }\n  }\n\n  private initialize($injector: any) {\n    const $rootScope = $injector.get('$rootScope');\n    const $rootElement = $injector.get('$rootElement');\n\n    $rootElement.on('click', (event: any) => {\n      if (event.ctrlKey || event.metaKey || event.shiftKey || event.which === 2 ||\n          event.button === 2) {\n        return;\n      }\n\n      let elm: (Node&ParentNode)|null = event.target;\n\n      // traverse the DOM up to find first A tag\n      while (elm && elm.nodeName.toLowerCase() !== 'a') {\n        // ignore rewriting if no A tag (reached root element, or no parent - removed from document)\n        if (elm === $rootElement[0] || !(elm = elm.parentNode)) {\n          return;\n        }\n      }\n\n      if (!isAnchor(elm)) {\n        return;\n      }\n\n      const absHref = elm.href;\n      const relHref = elm.getAttribute('href');\n\n      // Ignore when url is started with javascript: or mailto:\n      if (IGNORE_URI_REGEXP.test(absHref)) {\n        return;\n      }\n\n      if (absHref && !elm.getAttribute('target') && !event.isDefaultPrevented()) {\n        if (this.$$parseLinkUrl(absHref, relHref)) {\n          // We do a preventDefault for all urls that are part of the AngularJS application,\n          // in html5mode and also without, so that we are able to abort navigation without\n          // getting double entries in the location history.\n          event.preventDefault();\n          // update location manually\n          if (this.absUrl() !== this.browserUrl()) {\n            $rootScope.$apply();\n          }\n        }\n      }\n    });\n\n    this.urlChanges.subscribe(({newUrl, newState}) => {\n      const oldUrl = this.absUrl();\n      const oldState = this.$$state;\n      this.$$parse(newUrl);\n      newUrl = this.absUrl();\n      this.$$state = newState;\n      const defaultPrevented =\n          $rootScope.$broadcast('$locationChangeStart', newUrl, oldUrl, newState, oldState)\n              .defaultPrevented;\n\n      // if the location was changed by a `$locationChangeStart` handler then stop\n      // processing this location change\n      if (this.absUrl() !== newUrl) return;\n\n      // If default was prevented, set back to old state. This is the state that was locally\n      // cached in the $location service.\n      if (defaultPrevented) {\n        this.$$parse(oldUrl);\n        this.state(oldState);\n        this.setBrowserUrlWithFallback(oldUrl, false, oldState);\n        this.$$notifyChangeListeners(this.url(), this.$$state, oldUrl, oldState);\n      } else {\n        this.initalizing = false;\n        $rootScope.$broadcast('$locationChangeSuccess', newUrl, oldUrl, newState, oldState);\n        this.resetBrowserUpdate();\n      }\n      if (!$rootScope.$$phase) {\n        $rootScope.$digest();\n      }\n    });\n\n    // update browser\n    $rootScope.$watch(() => {\n      if (this.initalizing || this.updateBrowser) {\n        this.updateBrowser = false;\n\n        const oldUrl = this.browserUrl();\n        const newUrl = this.absUrl();\n        const oldState = this.browserState();\n        let currentReplace = this.$$replace;\n\n        const urlOrStateChanged =\n            !this.urlCodec.areEqual(oldUrl, newUrl) || oldState !== this.$$state;\n\n        // Fire location changes one time to on initialization. This must be done on the\n        // next tick (thus inside $evalAsync()) in order for listeners to be registered\n        // before the event fires. Mimicing behavior from $locationWatch:\n        // https://github.com/angular/angular.js/blob/master/src/ng/location.js#L983\n        if (this.initalizing || urlOrStateChanged) {\n          this.initalizing = false;\n\n          $rootScope.$evalAsync(() => {\n            // Get the new URL again since it could have changed due to async update\n            const newUrl = this.absUrl();\n            const defaultPrevented =\n                $rootScope\n                    .$broadcast('$locationChangeStart', newUrl, oldUrl, this.$$state, oldState)\n                    .defaultPrevented;\n\n            // if the location was changed by a `$locationChangeStart` handler then stop\n            // processing this location change\n            if (this.absUrl() !== newUrl) return;\n\n            if (defaultPrevented) {\n              this.$$parse(oldUrl);\n              this.$$state = oldState;\n            } else {\n              // This block doesn't run when initalizing because it's going to perform the update to\n              // the URL which shouldn't be needed when initalizing.\n              if (urlOrStateChanged) {\n                this.setBrowserUrlWithFallback(\n                    newUrl, currentReplace, oldState === this.$$state ? null : this.$$state);\n                this.$$replace = false;\n              }\n              $rootScope.$broadcast(\n                  '$locationChangeSuccess', newUrl, oldUrl, this.$$state, oldState);\n              if (urlOrStateChanged) {\n                this.$$notifyChangeListeners(this.url(), this.$$state, oldUrl, oldState);\n              }\n            }\n          });\n        }\n      }\n      this.$$replace = false;\n    });\n  }\n\n  private resetBrowserUpdate() {\n    this.$$replace = false;\n    this.$$state = this.browserState();\n    this.updateBrowser = false;\n    this.lastBrowserUrl = this.browserUrl();\n  }\n\n  private lastHistoryState: unknown;\n  private lastBrowserUrl: string = '';\n  private browserUrl(): string;\n  private browserUrl(url: string, replace?: boolean, state?: unknown): this;\n  private browserUrl(url?: string, replace?: boolean, state?: unknown) {\n    // In modern browsers `history.state` is `null` by default; treating it separately\n    // from `undefined` would cause `$browser.url('/foo')` to change `history.state`\n    // to undefined via `pushState`. Instead, let's change `undefined` to `null` here.\n    if (typeof state === 'undefined') {\n      state = null;\n    }\n\n    // setter\n    if (url) {\n      let sameState = this.lastHistoryState === state;\n\n      // Normalize the inputted URL\n      url = this.urlCodec.parse(url).href;\n\n      // Don't change anything if previous and current URLs and states match.\n      if (this.lastBrowserUrl === url && sameState) {\n        return this;\n      }\n      this.lastBrowserUrl = url;\n      this.lastHistoryState = state;\n\n      // Remove server base from URL as the Angular APIs for updating URL require\n      // it to be the path+.\n      url = this.stripBaseUrl(this.getServerBase(), url) || url;\n\n      // Set the URL\n      if (replace) {\n        this.locationStrategy.replaceState(state, '', url, '');\n      } else {\n        this.locationStrategy.pushState(state, '', url, '');\n      }\n\n      this.cacheState();\n\n      return this;\n      // getter\n    } else {\n      return this.platformLocation.href;\n    }\n  }\n\n  // This variable should be used *only* inside the cacheState function.\n  private lastCachedState: unknown = null;\n  private cacheState() {\n    // This should be the only place in $browser where `history.state` is read.\n    this.cachedState = this.platformLocation.getState();\n    if (typeof this.cachedState === 'undefined') {\n      this.cachedState = null;\n    }\n\n    // Prevent callbacks fo fire twice if both hashchange & popstate were fired.\n    if (deepEqual(this.cachedState, this.lastCachedState)) {\n      this.cachedState = this.lastCachedState;\n    }\n\n    this.lastCachedState = this.cachedState;\n    this.lastHistoryState = this.cachedState;\n  }\n\n  /**\n   * This function emulates the $browser.state() function from AngularJS. It will cause\n   * history.state to be cached unless changed with deep equality check.\n   */\n  private browserState(): unknown {\n    return this.cachedState;\n  }\n\n  private stripBaseUrl(base: string, url: string) {\n    if (url.startsWith(base)) {\n      return url.substr(base.length);\n    }\n    return undefined;\n  }\n\n  private getServerBase() {\n    const {protocol, hostname, port} = this.platformLocation;\n    const baseHref = this.locationStrategy.getBaseHref();\n    let url = `${protocol}//${hostname}${port ? ':' + port : ''}${baseHref || '/'}`;\n    return url.endsWith('/') ? url : url + '/';\n  }\n\n  private parseAppUrl(url: string) {\n    if (DOUBLE_SLASH_REGEX.test(url)) {\n      throw new Error(`Bad Path - URL cannot start with double slashes: ${url}`);\n    }\n\n    let prefixed = (url.charAt(0) !== '/');\n    if (prefixed) {\n      url = '/' + url;\n    }\n    let match = this.urlCodec.parse(url, this.getServerBase());\n    if (typeof match === 'string') {\n      throw new Error(`Bad URL - Cannot parse URL: ${url}`);\n    }\n    let path =\n        prefixed && match.pathname.charAt(0) === '/' ? match.pathname.substring(1) : match.pathname;\n    this.$$path = this.urlCodec.decodePath(path);\n    this.$$search = this.urlCodec.decodeSearch(match.search);\n    this.$$hash = this.urlCodec.decodeHash(match.hash);\n\n    // make sure path starts with '/';\n    if (this.$$path && this.$$path.charAt(0) !== '/') {\n      this.$$path = '/' + this.$$path;\n    }\n  }\n\n  /**\n   * Registers listeners for URL changes. This API is used to catch updates performed by the\n   * AngularJS framework. These changes are a subset of the `$locationChangeStart` and\n   * `$locationChangeSuccess` events which fire when AngularJS updates its internally-referenced\n   * version of the browser URL.\n   *\n   * It's possible for `$locationChange` events to happen, but for the browser URL\n   * (window.location) to remain unchanged. This `onChange` callback will fire only when AngularJS\n   * actually updates the browser URL (window.location).\n   *\n   * @param fn The callback function that is triggered for the listener when the URL changes.\n   * @param err The callback function that is triggered when an error occurs.\n   */\n  onChange(\n      fn: (url: string, state: unknown, oldUrl: string, oldState: unknown) => void,\n      err: (e: Error) => void = (e: Error) => {}) {\n    this.$$changeListeners.push([fn, err]);\n  }\n\n  /** @internal */\n  $$notifyChangeListeners(\n      url: string = '', state: unknown, oldUrl: string = '', oldState: unknown) {\n    this.$$changeListeners.forEach(([fn, err]) => {\n      try {\n        fn(url, state, oldUrl, oldState);\n      } catch (e) {\n        err(e);\n      }\n    });\n  }\n\n  /**\n   * Parses the provided URL, and sets the current URL to the parsed result.\n   *\n   * @param url The URL string.\n   */\n  $$parse(url: string) {\n    let pathUrl: string|undefined;\n    if (url.startsWith('/')) {\n      pathUrl = url;\n    } else {\n      // Remove protocol & hostname if URL starts with it\n      pathUrl = this.stripBaseUrl(this.getServerBase(), url);\n    }\n    if (typeof pathUrl === 'undefined') {\n      throw new Error(`Invalid url \"${url}\", missing path prefix \"${this.getServerBase()}\".`);\n    }\n\n    this.parseAppUrl(pathUrl);\n\n    if (!this.$$path) {\n      this.$$path = '/';\n    }\n    this.composeUrls();\n  }\n\n  /**\n   * Parses the provided URL and its relative URL.\n   *\n   * @param url The full URL string.\n   * @param relHref A URL string relative to the full URL string.\n   */\n  $$parseLinkUrl(url: string, relHref?: string|null): boolean {\n    // When relHref is passed, it should be a hash and is handled separately\n    if (relHref && relHref[0] === '#') {\n      this.hash(relHref.slice(1));\n      return true;\n    }\n    let rewrittenUrl;\n    let appUrl = this.stripBaseUrl(this.getServerBase(), url);\n    if (typeof appUrl !== 'undefined') {\n      rewrittenUrl = this.getServerBase() + appUrl;\n    } else if (this.getServerBase() === url + '/') {\n      rewrittenUrl = this.getServerBase();\n    }\n    // Set the URL\n    if (rewrittenUrl) {\n      this.$$parse(rewrittenUrl);\n    }\n    return !!rewrittenUrl;\n  }\n\n  private setBrowserUrlWithFallback(url: string, replace: boolean, state: unknown) {\n    const oldUrl = this.url();\n    const oldState = this.$$state;\n    try {\n      this.browserUrl(url, replace, state);\n\n      // Make sure $location.state() returns referentially identical (not just deeply equal)\n      // state object; this makes possible quick checking if the state changed in the digest\n      // loop. Checking deep equality would be too expensive.\n      this.$$state = this.browserState();\n    } catch (e) {\n      // Restore old values if pushState fails\n      this.url(oldUrl);\n      this.$$state = oldState;\n\n      throw e;\n    }\n  }\n\n  private composeUrls() {\n    this.$$url = this.urlCodec.normalize(this.$$path, this.$$search, this.$$hash);\n    this.$$absUrl = this.getServerBase() + this.$$url.substr(1);  // remove '/' from front of URL\n    this.updateBrowser = true;\n  }\n\n  /**\n   * Retrieves the full URL representation with all segments encoded according to\n   * rules specified in\n   * [RFC 3986](https://tools.ietf.org/html/rfc3986).\n   *\n   *\n   * ```js\n   * // given URL http://example.com/#/some/path?foo=bar&baz=xoxo\n   * let absUrl = $location.absUrl();\n   * // => \"http://example.com/#/some/path?foo=bar&baz=xoxo\"\n   * ```\n   */\n  absUrl(): string {\n    return this.$$absUrl;\n  }\n\n  /**\n   * Retrieves the current URL, or sets a new URL. When setting a URL,\n   * changes the path, search, and hash, and returns a reference to its own instance.\n   *\n   * ```js\n   * // given URL http://example.com/#/some/path?foo=bar&baz=xoxo\n   * let url = $location.url();\n   * // => \"/some/path?foo=bar&baz=xoxo\"\n   * ```\n   */\n  url(): string;\n  url(url: string): this;\n  url(url?: string): string|this {\n    if (typeof url === 'string') {\n      if (!url.length) {\n        url = '/';\n      }\n\n      const match = PATH_MATCH.exec(url);\n      if (!match) return this;\n      if (match[1] || url === '') this.path(this.urlCodec.decodePath(match[1]));\n      if (match[2] || match[1] || url === '') this.search(match[3] || '');\n      this.hash(match[5] || '');\n\n      // Chainable method\n      return this;\n    }\n\n    return this.$$url;\n  }\n\n  /**\n   * Retrieves the protocol of the current URL.\n   *\n   * ```js\n   * // given URL http://example.com/#/some/path?foo=bar&baz=xoxo\n   * let protocol = $location.protocol();\n   * // => \"http\"\n   * ```\n   */\n  protocol(): string {\n    return this.$$protocol;\n  }\n\n  /**\n   * Retrieves the protocol of the current URL.\n   *\n   * In contrast to the non-AngularJS version `location.host` which returns `hostname:port`, this\n   * returns the `hostname` portion only.\n   *\n   *\n   * ```js\n   * // given URL http://example.com/#/some/path?foo=bar&baz=xoxo\n   * let host = $location.host();\n   * // => \"example.com\"\n   *\n   * // given URL http://user:password@example.com:8080/#/some/path?foo=bar&baz=xoxo\n   * host = $location.host();\n   * // => \"example.com\"\n   * host = location.host;\n   * // => \"example.com:8080\"\n   * ```\n   */\n  host(): string {\n    return this.$$host;\n  }\n\n  /**\n   * Retrieves the port of the current URL.\n   *\n   * ```js\n   * // given URL http://example.com/#/some/path?foo=bar&baz=xoxo\n   * let port = $location.port();\n   * // => 80\n   * ```\n   */\n  port(): number|null {\n    return this.$$port;\n  }\n\n  /**\n   * Retrieves the path of the current URL, or changes the path and returns a reference to its own\n   * instance.\n   *\n   * Paths should always begin with forward slash (/). This method adds the forward slash\n   * if it is missing.\n   *\n   * ```js\n   * // given URL http://example.com/#/some/path?foo=bar&baz=xoxo\n   * let path = $location.path();\n   * // => \"/some/path\"\n   * ```\n   */\n  path(): string;\n  path(path: string|number|null): this;\n  path(path?: string|number|null): string|this {\n    if (typeof path === 'undefined') {\n      return this.$$path;\n    }\n\n    // null path converts to empty string. Prepend with \"/\" if needed.\n    path = path !== null ? path.toString() : '';\n    path = path.charAt(0) === '/' ? path : '/' + path;\n\n    this.$$path = path;\n\n    this.composeUrls();\n    return this;\n  }\n\n  /**\n   * Retrieves a map of the search parameters of the current URL, or changes a search\n   * part and returns a reference to its own instance.\n   *\n   *\n   * ```js\n   * // given URL http://example.com/#/some/path?foo=bar&baz=xoxo\n   * let searchObject = $location.search();\n   * // => {foo: 'bar', baz: 'xoxo'}\n   *\n   * // set foo to 'yipee'\n   * $location.search('foo', 'yipee');\n   * // $location.search() => {foo: 'yipee', baz: 'xoxo'}\n   * ```\n   *\n   * @param {string|Object.<string>|Object.<Array.<string>>} search New search params - string or\n   * hash object.\n   *\n   * When called with a single argument the method acts as a setter, setting the `search` component\n   * of `$location` to the specified value.\n   *\n   * If the argument is a hash object containing an array of values, these values will be encoded\n   * as duplicate search parameters in the URL.\n   *\n   * @param {(string|Number|Array<string>|boolean)=} paramValue If `search` is a string or number,\n   *     then `paramValue`\n   * will override only a single search property.\n   *\n   * If `paramValue` is an array, it will override the property of the `search` component of\n   * `$location` specified via the first argument.\n   *\n   * If `paramValue` is `null`, the property specified via the first argument will be deleted.\n   *\n   * If `paramValue` is `true`, the property specified via the first argument will be added with no\n   * value nor trailing equal sign.\n   *\n   * @return {Object} The parsed `search` object of the current URL, or the changed `search` object.\n   */\n  search(): {[key: string]: unknown};\n  search(search: string|number|{[key: string]: unknown}): this;\n  search(\n      search: string|number|{[key: string]: unknown},\n      paramValue: null|undefined|string|number|boolean|string[]): this;\n  search(\n      search?: string|number|{[key: string]: unknown},\n      paramValue?: null|undefined|string|number|boolean|string[]): {[key: string]: unknown}|this {\n    switch (arguments.length) {\n      case 0:\n        return this.$$search;\n      case 1:\n        if (typeof search === 'string' || typeof search === 'number') {\n          this.$$search = this.urlCodec.decodeSearch(search.toString());\n        } else if (typeof search === 'object' && search !== null) {\n          // Copy the object so it's never mutated\n          search = {...search};\n          // remove object undefined or null properties\n          for (const key in search) {\n            if (search[key] == null) delete search[key];\n          }\n\n          this.$$search = search;\n        } else {\n          throw new Error(\n              'LocationProvider.search(): First argument must be a string or an object.');\n        }\n        break;\n      default:\n        if (typeof search === 'string') {\n          const currentSearch = this.search();\n          if (typeof paramValue === 'undefined' || paramValue === null) {\n            delete currentSearch[search];\n            return this.search(currentSearch);\n          } else {\n            currentSearch[search] = paramValue;\n            return this.search(currentSearch);\n          }\n        }\n    }\n    this.composeUrls();\n    return this;\n  }\n\n  /**\n   * Retrieves the current hash fragment, or changes the hash fragment and returns a reference to\n   * its own instance.\n   *\n   * ```js\n   * // given URL http://example.com/#/some/path?foo=bar&baz=xoxo#hashValue\n   * let hash = $location.hash();\n   * // => \"hashValue\"\n   * ```\n   */\n  hash(): string;\n  hash(hash: string|number|null): this;\n  hash(hash?: string|number|null): string|this {\n    if (typeof hash === 'undefined') {\n      return this.$$hash;\n    }\n\n    this.$$hash = hash !== null ? hash.toString() : '';\n\n    this.composeUrls();\n    return this;\n  }\n\n  /**\n   * Changes to `$location` during the current `$digest` will replace the current\n   * history record, instead of adding a new one.\n   */\n  replace(): this {\n    this.$$replace = true;\n    return this;\n  }\n\n  /**\n   * Retrieves the history state object when called without any parameter.\n   *\n   * Change the history state object when called with one parameter and return `$location`.\n   * The state object is later passed to `pushState` or `replaceState`.\n   *\n   * This method is supported only in HTML5 mode and only in browsers supporting\n   * the HTML5 History API methods such as `pushState` and `replaceState`. If you need to support\n   * older browsers (like Android < 4.0), don't use this method.\n   *\n   */\n  state(): unknown;\n  state(state: unknown): this;\n  state(state?: unknown): unknown|this {\n    if (typeof state === 'undefined') {\n      return this.$$state;\n    }\n\n    this.$$state = state;\n    return this;\n  }\n}\n\n/**\n * The factory function used to create an instance of the `$locationShim` in Angular,\n * and provides an API-compatiable `$locationProvider` for AngularJS.\n *\n * @publicApi\n */\nexport class $locationShimProvider {\n  constructor(\n      private ngUpgrade: UpgradeModule, private location: Location,\n      private platformLocation: PlatformLocation, private urlCodec: UrlCodec,\n      private locationStrategy: LocationStrategy) {}\n\n  /**\n   * Factory method that returns an instance of the $locationShim\n   */\n  $get() {\n    return new $locationShim(\n        this.ngUpgrade.$injector, this.location, this.platformLocation, this.urlCodec,\n        this.locationStrategy);\n  }\n\n  /**\n   * Stub method used to keep API compatible with AngularJS. This setting is configured through\n   * the LocationUpgradeModule's `config` method in your Angular app.\n   */\n  hashPrefix(prefix?: string) {\n    throw new Error('Configure LocationUpgrade through LocationUpgradeModule.config method.');\n  }\n\n  /**\n   * Stub method used to keep API compatible with AngularJS. This setting is configured through\n   * the LocationUpgradeModule's `config` method in your Angular app.\n   */\n  html5Mode(mode?: any) {\n    throw new Error('Configure LocationUpgrade through LocationUpgradeModule.config method.');\n  }\n}\n"]}
Note: See TracBrowser for help on using the repository browser.