@angular-wave/angular.ts 0.0.12 → 0.0.13

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@angular-wave/angular.ts",
   "license": "MIT",
-  "version": "0.0.12",
+  "version": "0.0.13",
   "type": "module",
   "main": "dist/angular-ts.esm.js",
   "browser": "dist/angular-ts.umd.js",

package/src/exts/messages.md

@@ -518,33 +518,33 @@ _ {@link module:ngMessages Click here} to learn more about`ngMessages`and`ngMess
     _ @param {string} ngMessageExp|whenExp an expression value corresponding to the message key.
     _/
 
-                                                                            /**
-                                                                            * @ngdoc directive
-                                                                            * @name ngMessageDefault
-                                                                            * @restrict AE
-                                                                            * @scope
-                                                                            *
-                                                                            * @description
-                                                                            * `ngMessageDefault` is a directive with the purpose to show and hide a default message for
-                                                                            * {@link directive:ngMessages}, when none of provided messages matches.
-                                                                            *
-                                                                            * More information about using `ngMessageDefault` can be found in the
-                                                                            * {@link module:ngMessages `ngMessages` module documentation}.
-                                                                            *
-                                                                            * @usage
-                                                                            * ```html
-                                                                            * <!-- using attribute directives -->
-                                                                            * <ANY ng-messages="expression" role="alert">
-                                                                            *   <ANY ng-message="stringValue">...</ANY>
-                                                                            *   <ANY ng-message="stringValue1, stringValue2, ...">...</ANY>
-                                                                            *   <ANY ng-message-default>...</ANY>
-                                                                            * </ANY>
-                                                                            *
-                                                                            * <!-- or by using element directives -->
-                                                                            * <ng-messages for="expression" role="alert">
-                                                                            *   <ng-message when="stringValue">...</ng-message>
-                                                                            *   <ng-message when="stringValue1, stringValue2, ...">...</ng-message>
-                                                                            *   <ng-message-default>...</ng-message-default>
-                                                                            * </ng-messages>
-                                                                            *
-                                                                            */
+                                                                                                /**
+                                                                                                * @ngdoc directive
+                                                                                                * @name ngMessageDefault
+                                                                                                * @restrict AE
+                                                                                                * @scope
+                                                                                                *
+                                                                                                * @description
+                                                                                                * `ngMessageDefault` is a directive with the purpose to show and hide a default message for
+                                                                                                * {@link directive:ngMessages}, when none of provided messages matches.
+                                                                                                *
+                                                                                                * More information about using `ngMessageDefault` can be found in the
+                                                                                                * {@link module:ngMessages `ngMessages` module documentation}.
+                                                                                                *
+                                                                                                * @usage
+                                                                                                * ```html
+                                                                                                * <!-- using attribute directives -->
+                                                                                                * <ANY ng-messages="expression" role="alert">
+                                                                                                *   <ANY ng-message="stringValue">...</ANY>
+                                                                                                *   <ANY ng-message="stringValue1, stringValue2, ...">...</ANY>
+                                                                                                *   <ANY ng-message-default>...</ANY>
+                                                                                                * </ANY>
+                                                                                                *
+                                                                                                * <!-- or by using element directives -->
+                                                                                                * <ng-messages for="expression" role="alert">
+                                                                                                *   <ng-message when="stringValue">...</ng-message>
+                                                                                                *   <ng-message when="stringValue1, stringValue2, ...">...</ng-message>
+                                                                                                *   <ng-message-default>...</ng-message-default>
+                                                                                                * </ng-messages>
+                                                                                                *
+                                                                                                */

package/src/index.js

@@ -5,6 +5,7 @@ import { publishExternalAPI } from "./public";
  * @type {angular.IAngularStatic}
  */
 window.angular = new Angular();
+console.log(window.angular);
 
 publishExternalAPI();
 

package/src/router/adapter/locationServices.js

@@ -32,7 +32,6 @@ export class Ng1LocationServices {
             .replace(/(~~|~2F)/g, (m) => ({ "~~": "~", "~2F": "/" })[m])
         : x;
   }
-  // eslint-disable-next-line @typescript-eslint/no-empty-function
   dispose() {}
   constructor($locationProvider) {
     // .onChange() registry
@@ -48,7 +47,7 @@ export class Ng1LocationServices {
   html5Mode() {
     let html5Mode = this.$locationProvider.html5Mode();
     html5Mode = isObject(html5Mode) ? html5Mode.enabled : html5Mode;
-    return html5Mode && this.$sniffer.history;
+    return html5Mode && typeof history !== "undefined";
   }
   baseHref() {
     return (
@@ -63,11 +62,10 @@ export class Ng1LocationServices {
     if (state) this.$location.state(state);
     return this.$location.url();
   }
-  _runtimeServices($rootScope, $location, $sniffer, $browser, $window) {
+  _runtimeServices($rootScope, $location, $browser) {
     this.$location = $location;
-    this.$sniffer = $sniffer;
     this.$browser = $browser;
-    this.$window = $window;
+    this.$window = window;
     // Bind $locationChangeSuccess to the listeners registered in LocationService.onChange
     $rootScope.$on("$locationChangeSuccess", (evt) =>
       this._urlListeners.forEach((fn) => fn(evt)),

package/src/router/adapter/services.js

@@ -21,7 +21,6 @@ import {
 import { StateProvider } from "./stateProvider";
 import { getStateHookBuilder } from "./statebuilders/onEnterExitRetain";
 import { Ng1LocationServices } from "./locationServices";
-import { UrlRouterProvider } from "./urlRouterProvider";
 
 export let router = null;
 $uiRouterProvider.$inject = ["$locationProvider"];
@@ -52,15 +51,9 @@ export function $uiRouterProvider($locationProvider) {
   // backwards compat: also expose router instance as $uiRouterProvider.router
   router["router"] = router;
   router["$get"] = $get;
-  $get.$inject = ["$location", "$browser", "$window", "$sniffer", "$rootScope"];
-  function $get($location, $browser, $window, $sniffer, $rootScope) {
-    ng1LocationService._runtimeServices(
-      $rootScope,
-      $location,
-      $sniffer,
-      $browser,
-      $window,
-    );
+  $get.$inject = ["$location", "$browser", "$rootScope"];
+  function $get($location, $browser, $rootScope) {
+    ng1LocationService._runtimeServices($rootScope, $location, $browser);
     delete router["router"];
     delete router["$get"];
     return router;
@@ -69,7 +62,7 @@ export function $uiRouterProvider($locationProvider) {
 }
 export const getProviderFor = (serviceName) => [
   "$uiRouterProvider",
-  ($urp) => {
+  function UrlServiceProvider($urp) {
     const service = $urp.router[serviceName];
     service["$get"] = () => service;
     return service;
@@ -103,13 +96,14 @@ export function runBlock($injector, $q, $uiRouter) {
         )),
     );
 }
-// $urlRouter service and $urlRouterProvider
-export const getUrlRouterProvider = (uiRouter) =>
-  (uiRouter.urlRouterProvider = new UrlRouterProvider(uiRouter));
+
 // $state service and $stateProvider
 // $urlRouter service and $urlRouterProvider
-export const getStateProvider = () =>
-  extend(router.stateProvider, { $get: () => router.stateService });
+export function getStateProvider() {
+  debugger;
+  return extend(router.stateProvider, { $get: () => router.stateService });
+}
+
 watchDigests.$inject = ["$rootScope"];
 export function watchDigests($rootScope) {
   $rootScope.$watch(function () {

package/src/router/core/common/common.js

@@ -226,17 +226,7 @@ export function map(collection, callback, target) {
   forEach(collection, (item, i) => (target[i] = callback(item, i)));
   return target;
 }
-/**
- * Given an object, return its enumerable property values
- *
- * @example
- * ```
- *
- * let foo = { a: 1, b: 2, c: 3 }
- * let vals = values(foo); // [ 1, 2, 3 ]
- * ```
- */
-export const values = (obj) => Object.keys(obj).map((key) => obj[key]);
+
 /**
  * Reduce function that returns true if all of the values are truthy.
  *

package/src/router/core/hooks/coreResolvables.js

@@ -1,7 +1,7 @@
 import { Transition } from "../transition/transition";
 import { UIRouter } from "../router";
 import { Resolvable } from "../resolve/resolvable";
-import { inArray, uniqR, unnestR, values } from "../common/common";
+import { inArray, uniqR, unnestR } from "../common/common";
 function addCoreResolvables(trans) {
   trans.addResolvable(Resolvable.fromData(UIRouter, trans.router), "");
   trans.addResolvable(Resolvable.fromData(Transition, trans), "");
@@ -20,7 +20,7 @@ const isTransition = inArray(TRANSITION_TOKENS);
 // This function removes resolves for '$transition$' and `Transition` from the treeChanges.
 // Do not use this on current transitions, only on old ones.
 export const treeChangesCleanup = (trans) => {
-  const nodes = values(trans.treeChanges())
+  const nodes = Object.values(trans.treeChanges())
     .reduce(unnestR, [])
     .reduce(uniqR, []);
   // If the resolvable is a Transition, return a new resolvable with null data

package/src/router/core/path/pathUtils.js

@@ -5,7 +5,6 @@ import {
   omit,
   tail,
   mergeR,
-  values,
   unnestR,
   inArray,
   arrayTuples,
@@ -55,7 +54,7 @@ export class PathUtils {
     path
       .filter((node) => inArray(states, node.state))
       .forEach((node) => {
-        const viewDecls = values(node.state.views || {});
+        const viewDecls = Object.values(node.state.views || {});
         const subPath = PathUtils.subPath(path, (n) => n === node);
         const viewConfigs = viewDecls.map((view) =>
           $view.createViewConfig(subPath, view),

package/src/router/core/router.js

@@ -5,7 +5,7 @@ import { ViewService } from "./view/view";
 import { StateRegistry } from "./state/stateRegistry";
 import { StateService } from "./state/stateService";
 import { UIRouterGlobals } from "./globals";
-import { values, removeFrom } from "./common/common";
+import { removeFrom } from "./common/common";
 import { isFunction } from "./common/predicates";
 import { UrlService } from "./url/urlService";
 import { trace } from "./common/trace";
@@ -196,6 +196,8 @@ export class UIRouter {
     return (this._plugins[pluginInstance.name] = pluginInstance);
   }
   getPlugin(pluginName) {
-    return pluginName ? this._plugins[pluginName] : values(this._plugins);
+    return pluginName
+      ? this._plugins[pluginName]
+      : Object.values(this._plugins);
   }
 }

package/src/router/core/state/stateBuilder.js

@@ -7,7 +7,6 @@ import {
   noop,
   omit,
   tail,
-  values,
   copy,
 } from "../common/common";
 import { isArray, isDefined, isFunction, isString } from "../common/predicates";
@@ -75,7 +74,7 @@ const getParamsBuilder = (paramFactory) =>
       paramFactory.fromConfig(id, null, state.self);
     const urlParams =
       (state.url && state.url.parameters({ inherit: false })) || [];
-    const nonUrlParams = values(
+    const nonUrlParams = Object.values(
       mapObj(
         omit(state.params || {}, urlParams.map(prop("id"))),
         makeConfigParam,
@@ -292,7 +291,7 @@ export class StateBuilder {
       return null;
     }
     for (const key in builders) {
-      if (!builders.hasOwnProperty(key)) continue;
+      if (!Object.prototype.hasOwnProperty.call(builders, key)) continue;
       const chain = builders[key].reduce(
         (parentFn, step) => (_state) => step(_state, parentFn),
         noop,

package/src/router/core/state/stateMatcher.js

@@ -1,5 +1,4 @@
 import { isString } from "../common/predicates";
-import { values } from "../common/common";
 import { safeConsole } from "../common/safeConsole";
 export class StateMatcher {
   constructor(_states) {
@@ -22,7 +21,7 @@ export class StateMatcher {
     ) {
       return state;
     } else if (isStr && matchGlob) {
-      const _states = values(this._states);
+      const _states = Object.values(this._states);
       const matches = _states.filter(
         (_state) =>
           _state.__stateObjectCache.nameGlob &&

package/src/router/core/state/stateObject.js

@@ -1,4 +1,4 @@
-import { defaults, values, find, inherit } from "../common/common";
+import { defaults, find, inherit } from "../common/common";
 import { propEq } from "../common/hof";
 import { Glob } from "../common/glob";
 import { isObject, isFunction } from "../common/predicates";
@@ -83,10 +83,11 @@ export class StateObject {
     const inherited =
       (opts.inherit && this.parent && this.parent.parameters()) || [];
     return inherited
-      .concat(values(this.params))
+      .concat(Object.values(this.params))
       .filter(
         (param) =>
-          !opts.matchingKeys || opts.matchingKeys.hasOwnProperty(param.id),
+          !opts.matchingKeys ||
+          Object.prototype.hasOwnProperty.call(opts.matchingKeys, param.id),
       );
   }
   /**
@@ -99,7 +100,7 @@ export class StateObject {
   parameter(id, opts = {}) {
     return (
       (this.url && this.url.parameter(id, opts)) ||
-      find(values(this.params), propEq("id", id)) ||
+      find(Object.values(this.params), propEq("id", id)) ||
       (opts.inherit && this.parent && this.parent.parameter(id))
     );
   }

package/src/router/core/state/stateQueueManager.js

@@ -19,7 +19,7 @@ export class StateQueueManager {
     const name = state.name;
     if (!isString(name)) throw new Error("State must have a valid name");
     if (
-      this.states.hasOwnProperty(name) ||
+      Object.prototype.hasOwnProperty.call(this.states, name) ||
       inArray(queue.map(prop("name")), name)
     )
       throw new Error(`State '${name}' is already defined`);

package/src/router/core/transition/hookRegistry.js

@@ -1,11 +1,4 @@
-import {
-  extend,
-  removeFrom,
-  tail,
-  values,
-  identity,
-  mapObj,
-} from "../common/common";
+import { extend, removeFrom, tail, identity, mapObj } from "../common/common";
 import { isString, isFunction } from "../common/predicates";
 import { Glob } from "../common/glob";
 import {
@@ -125,7 +118,7 @@ export class RegisteredHook {
       this._getDefaultMatchCriteria(),
       this.matchCriteria,
     );
-    const paths = values(this.tranSvc._pluginapi._getPathTypes());
+    const paths = Object.values(this.tranSvc._pluginapi._getPathTypes());
     return paths.reduce((mn, pathtype) => {
       // STATE scope criteria matches against every node in the path.
       // TRANSITION scope criteria matches against only the last node in the path
@@ -149,7 +142,7 @@ export class RegisteredHook {
   matches(treeChanges, transition) {
     const matches = this._getMatchingNodes(treeChanges, transition);
     // Check if all the criteria matched the TreeChanges object
-    const allMatched = values(matches).every(identity);
+    const allMatched = Object.values(matches).every(identity);
     return allMatched ? matches : null;
   }
   deregister() {

package/src/router/core/transition/transitionService.js

@@ -26,7 +26,7 @@ import { registerLazyLoadHook } from "../hooks/lazyLoad";
 import { TransitionEventType } from "./transitionEventType";
 import { TransitionHook } from "./transitionHook";
 import { isDefined } from "../common/predicates";
-import { removeFrom, values, createProxyFunctions } from "../common/common";
+import { removeFrom, createProxyFunctions } from "../common/common";
 import { val } from "../common/hof";
 import { registerIgnoredTransitionHook } from "../hooks/ignoredTransition";
 import { registerInvalidTransitionHook } from "../hooks/invalidTransition";
@@ -148,7 +148,7 @@ export class TransitionService {
    * @internal
    */
   dispose(router) {
-    values(this._registeredHooks).forEach((hooksArray) =>
+    Object.values(this._registeredHooks).forEach((hooksArray) =>
       hooksArray.forEach((hook) => {
         hook._deregistered = true;
         removeFrom(hooksArray, hook);

package/src/router/router.js

@@ -1,6 +1,5 @@
 import {
   $uiRouterProvider,
-  getUrlRouterProvider,
   getProviderFor,
   getStateProvider,
   router,
@@ -14,12 +13,11 @@ export function initRouter() {
   window.angular.module("ui.router.angular1", []);
   const mod_init = window.angular.module("ui.router.init", ["ng"]);
   const mod_util = window.angular.module("ui.router.util", ["ui.router.init"]);
-  const mod_rtr = window.angular.module("ui.router.router", ["ui.router.util"]);
   const mod_state = window.angular.module("ui.router.state", [
-    "ui.router.router",
     "ui.router.util",
     "ui.router.angular1",
   ]);
+
   const mod_main = window.angular.module("ui.router", [
     "ui.router.init",
     "ui.router.state",
@@ -27,26 +25,34 @@ export function initRouter() {
   ]);
 
   mod_init.provider("$uiRouter", $uiRouterProvider);
-  mod_rtr.provider("$urlRouter", ["$uiRouterProvider", getUrlRouterProvider]);
   mod_util.provider("$urlService", getProviderFor("urlService"));
   mod_util.provider("$urlMatcherFactory", [
     "$uiRouterProvider",
-    () => router.urlMatcherFactory,
+    function RouterProvide() {
+      return router.urlMatcherFactory;
+    },
   ]);
-  mod_util.provider("$templateFactory", () => new TemplateFactory());
+  mod_util.provider("$templateFactory", function () {
+    return new TemplateFactory();
+  });
   mod_state.provider("$stateRegistry", getProviderFor("stateRegistry"));
   mod_state.provider("$uiRouterGlobals", getProviderFor("globals"));
   mod_state.provider("$transitions", getProviderFor("transitionService"));
   mod_state.provider("$state", ["$uiRouterProvider", getStateProvider]);
   mod_state.factory("$stateParams", [
     "$uiRouter",
-    ($uiRouter) => $uiRouter.globals.params,
+    function StateParamse($uiRouter) {
+      return $uiRouter.globals.params;
+    },
   ]);
-  mod_main.factory("$view", () => router.viewService);
-  mod_main.service("$trace", () => trace);
+  mod_main.factory("$view", function View() {
+    return router.viewService;
+  });
+  mod_main.service("$trace", function Trace() {
+    return trace;
+  });
   mod_main.run(watchDigests);
-  mod_util.run(["$urlMatcherFactory", function ($urlMatcherFactory) {}]);
-  mod_state.run(["$state", function ($state) {}]);
-  mod_rtr.run(["$urlRouter", function ($urlRouter) {}]);
+  mod_util.run(["$urlMatcherFactory", function MatcherFac() {}]);
+  mod_state.run(["$state", function State() {}]);
   mod_init.run(runBlock);
 }

package/test/module-test.html

@@ -1,10 +1,14 @@
 <!doctype html>
 <html>
   <head>
-    <script></script>
+    <script>
+      document.addEventListener("DOMContentLoaded", () => {
+        window.angular.module("test", ["ui.router"]);
+      });
+    </script>
     <script type="module" src="../src/index.js"></script>
   </head>
-  <body ng-app>
+  <body ng-app="test">
     <div ng-init='list = [{ name: "x" }, { name: "y" }, { name: "z" }]'>
       <label>Name:</label>
       <input type="text" ng-model="yourName" placeholder="Enter a name here" />

package/src/router/adapter/urlRouterProvider.js

@@ -1,196 +0,0 @@
-/** @publicapi @module url */ /** */
-
-import { BaseUrlRule } from "../core/url/urlRule";
-import { isString, isFunction, isArray, identity } from "../../core/utils";
-import { services } from "../core/common/coreservices";
-
-/**
- * Manages rules for client-side URL
- *
- * ### Deprecation warning:
- * This class is now considered to be an internal API
- * Use the [[UrlService]] instead.
- * For configuring URL rules, use the [[UrlRulesApi]] which can be found as [[UrlService.rules]].
- *
- * This class manages the router rules for what to do when the URL changes.
- *
- * This provider remains for backwards compatibility.
- *
- * @internalapi
- * @deprecated
- */
-export class UrlRouterProvider {
-  static injectableHandler(router, handler) {
-    return (match) =>
-      services.$injector.invoke(handler, null, {
-        $match: match,
-        $stateParams: router.globals.params,
-      });
-  }
-  /** @hidden */
-  constructor(/** @hidden */ router) {
-    this.router = router;
-  }
-  /** @hidden */
-  $get() {
-    const urlService = this.router.urlService;
-    this.router.urlRouter.update(true);
-    if (!urlService.interceptDeferred) urlService.listen();
-    return this.router.urlRouter;
-  }
-  /**
-   * Registers a url handler function.
-   *
-   * Registers a low level url handler (a `rule`).
-   * A rule detects specific URL patterns and returns a redirect, or performs some action.
-   *
-   * If a rule returns a string, the URL is replaced with the string, and all rules are fired again.
-   *
-   * #### Example:
-   * ```js
-   * var app = angular.module('app', ['ui.router.router']);
-   *
-   * app.config(function ($urlRouterProvider) {
-   *   // Here's an example of how you might allow case insensitive urls
-   *   $urlRouterProvider.rule(function ($injector, $location) {
-   *     var path = $location.path(),
-   *         normalized = path.toLowerCase();
-   *
-   *     if (path !== normalized) {
-   *       return normalized;
-   *     }
-   *   });
-   * });
-   * ```
-   *
-   * @param ruleFn
-   * Handler function that takes `$injector` and `$location` services as arguments.
-   * You can use them to detect a url and return a different url as a string.
-   *
-   * @return [[UrlRouterProvider]] (`this`)
-   */
-  rule(ruleFn) {
-    if (!isFunction(ruleFn)) throw new Error("'rule' must be a function");
-    const match = () => ruleFn(services.$injector, this.router.locationService);
-    const rule = new BaseUrlRule(match, identity);
-    this.router.urlService.rules.rule(rule);
-    return this;
-  }
-  /**
-   * Defines the path or behavior to use when no url can be matched.
-   *
-   * #### Example:
-   * ```js
-   * var app = angular.module('app', ['ui.router.router']);
-   *
-   * app.config(function ($urlRouterProvider) {
-   *   // if the path doesn't match any of the urls you configured
-   *   // otherwise will take care of routing the user to the
-   *   // specified url
-   *   $urlRouterProvider.otherwise('/index');
-   *
-   *   // Example of using function rule as param
-   *   $urlRouterProvider.otherwise(function ($injector, $location) {
-   *     return '/a/valid/url';
-   *   });
-   * });
-   * ```
-   *
-   * @param rule
-   * The url path you want to redirect to or a function rule that returns the url path or performs a `$state.go()`.
-   * The function version is passed two params: `$injector` and `$location` services, and should return a url string.
-   *
-   * @return {object} `$urlRouterProvider` - `$urlRouterProvider` instance
-   */
-  otherwise(rule) {
-    const urlRules = this.router.urlService.rules;
-    if (isString(rule)) {
-      urlRules.otherwise(rule);
-    } else if (isFunction(rule)) {
-      urlRules.otherwise(() =>
-        rule(services.$injector, this.router.locationService),
-      );
-    } else {
-      throw new Error("'rule' must be a string or function");
-    }
-    return this;
-  }
-  /**
-   * Registers a handler for a given url matching.
-   *
-   * If the handler is a string, it is
-   * treated as a redirect, and is interpolated according to the syntax of match
-   * (i.e. like `String.replace()` for `RegExp`, or like a `UrlMatcher` pattern otherwise).
-   *
-   * If the handler is a function, it is injectable.
-   * It gets invoked if `$location` matches.
-   * You have the option of inject the match object as `$match`.
-   *
-   * The handler can return
-   *
-   * - **falsy** to indicate that the rule didn't match after all, then `$urlRouter`
-   *   will continue trying to find another one that matches.
-   * - **string** which is treated as a redirect and passed to `$location.url()`
-   * - **void** or any **truthy** value tells `$urlRouter` that the url was handled.
-   *
-   * #### Example:
-   * ```js
-   * var app = angular.module('app', ['ui.router.router']);
-   *
-   * app.config(function ($urlRouterProvider) {
-   *   $urlRouterProvider.when($state.url, function ($match, $stateParams) {
-   *     if ($state.$current.navigable !== state ||
-   *         !equalForKeys($match, $stateParams) {
-   *      $state.transitionTo(state, $match, false);
-   *     }
-   *   });
-   * });
-   * ```
-   *
-   * @param what A pattern string to match, compiled as a [[UrlMatcher]].
-   * @param handler The path (or function that returns a path) that you want to redirect your user to.
-   * @param ruleCallback [optional] A callback that receives the `rule` registered with [[UrlMatcher.rule]]
-   *
-   * Note: the handler may also invoke arbitrary code, such as `$state.go()`
-   */
-  when(what, handler) {
-    if (isArray(handler) || isFunction(handler)) {
-      handler = UrlRouterProvider.injectableHandler(this.router, handler);
-    }
-    this.router.urlService.rules.when(what, handler);
-    return this;
-  }
-  /**
-   * Disables monitoring of the URL.
-   *
-   * Call this method before UI-Router has bootstrapped.
-   * It will stop UI-Router from performing the initial url sync.
-   *
-   * This can be useful to perform some asynchronous initialization before the router starts.
-   * Once the initialization is complete, call [[listen]] to tell UI-Router to start watching and synchronizing the URL.
-   *
-   * #### Example:
-   * ```js
-   * var app = angular.module('app', ['ui.router']);
-   *
-   * app.config(function ($urlRouterProvider) {
-   *   // Prevent $urlRouter from automatically intercepting URL changes;
-   *   $urlRouterProvider.deferIntercept();
-   * })
-   *
-   * app.run(function (MyService, $urlRouter, $http) {
-   *   $http.get("/stuff").then(function(resp) {
-   *     MyService.doStuff(resp.data);
-   *     $urlRouter.listen();
-   *     $urlRouter.sync();
-   *   });
-   * });
-   * ```
-   *
-   * @param defer Indicates whether to defer location change interception.
-   *        Passing no parameter is equivalent to `true`.
-   */
-  deferIntercept(defer) {
-    this.router.urlService.deferIntercept(defer);
-  }
-}