@angular-wave/angular.ts 0.0.30 → 0.0.33

package/src/router/transition/transition-service.js

@@ -15,7 +15,10 @@ import {
   registerLazyResolveState,
   registerResolveRemaining,
 } from "../hooks/resolve";
-import { registerLoadEnteringViews } from "../hooks/views";
+import {
+  registerActivateViews,
+  registerLoadEnteringViews,
+} from "../hooks/views";
 import { registerUpdateGlobalState } from "../hooks/update-globals";
 
 import { registerLazyLoadHook } from "../hooks/lazy-load";
@@ -26,6 +29,8 @@ import { createProxyFunctions } from "../../shared/common";
 import { val } from "../../shared/hof";
 import { registerIgnoredTransitionHook } from "../hooks/ignored-transition";
 import { registerInvalidTransitionHook } from "../hooks/invalid-transition";
+import { registerRedirectToHook } from "../hooks/redirect-to";
+import { registerUpdateUrl } from "../hooks/url";
 /**
  * The default [[Transition]] options.
  *
@@ -56,6 +61,8 @@ export let defaultTransOpts = {
  * This API is located at `router.transitionService` ([[UIRouter.transitionService]])
  */
 export class TransitionService {
+  static $inject = ["$routerGlobalsProvider", "$viewProvider"];
+
   /**
    * @param {import('../globals').UIRouterGlobals} globals
    */
@@ -82,6 +89,41 @@ export class TransitionService {
     this._registerCoreTransitionHooks();
     globals.successfulTransitions.onEvict(treeChangesCleanup);
   }
+
+  $get = [
+    "$state",
+    "$urlService",
+    "$stateRegistry",
+    "$view",
+    (stateService, urlService, stateRegistry, viewService) => {
+      // Lazy load state trees
+      this._deregisterHookFns.lazyLoad = registerLazyLoadHook(
+        this,
+        stateService,
+        urlService,
+        stateRegistry,
+      );
+
+      // After globals.current is updated at priority: 10000
+      this._deregisterHookFns.updateUrl = registerUpdateUrl(
+        this,
+        stateService,
+        urlService,
+      );
+
+      // Wire up redirectTo hook
+      this._deregisterHookFns.redirectTo = registerRedirectToHook(
+        this,
+        stateService,
+      );
+
+      this._deregisterHookFns.activateViews = registerActivateViews(
+        this,
+        viewService,
+      );
+      return this;
+    },
+  ];
   /**
    * Registers a [[TransitionHookFn]], called *while a transition is being constructed*.
    *

package/src/router/url/url-config.js

@@ -13,7 +13,7 @@ import { isDefined, isString } from "../../shared/utils";
  *
  * This API is found at `router.urlService.config` (see: [[UIRouter.urlService]], [[URLService.config]])
  */
-export class UrlConfig {
+export class UrlConfigProvider {
   constructor() {
     /** @type {ParamTypes} */
     this.paramTypes = new ParamTypes();
@@ -23,7 +23,38 @@ export class UrlConfig {
     this._isStrictMode = true;
     /** @type {boolean} */
     this._defaultSquashPolicy = false;
+    /**
+     * Applys ng1-specific path parameter encoding
+     *
+     * The Angular 1 `$location` service is a bit weird.
+     * It doesn't allow slashes to be encoded/decoded bi-directionally.
+     *
+     * See the writeup at https://github.com/angular-ui/ui-router/issues/2598
+     *
+     * This code patches the `path` parameter type so it encoded/decodes slashes as ~2F
+     *
+     */
+    const pathType = this.type("path");
+    pathType.encode = (x) =>
+      x != null
+        ? x.toString().replace(/(~|\/)/g, (m) => ({ "~": "~~", "/": "~2F" })[m])
+        : x;
+    pathType.decode = (x) =>
+      x != null
+        ? x
+            .toString()
+            .replace(/(~~|~2F)/g, (m) => ({ "~~": "~", "~2F": "/" })[m])
+        : x;
+    this.paramTypes.enqueue = false;
+    this.paramTypes._flushTypeQueue();
   }
+
+  $get = [
+    function () {
+      return this;
+    },
+  ];
+
   /**
    * Defines whether URL matching should be case sensitive (the default behavior), or not.
    *

package/src/router/url/url-rule.js

@@ -13,8 +13,8 @@ import { StateObject } from "../state/state-object";
  * - [[StateObject]]
  */
 export class UrlRuleFactory {
-  constructor(urlMatcherFactory, stateService, routerGlobals) {
-    this.urlMatcherFactory = urlMatcherFactory;
+  constructor(urlService, stateService, routerGlobals) {
+    this.urlService = urlService;
     this.stateService = stateService;
     this.routerGlobals = routerGlobals;
   }
@@ -28,7 +28,7 @@ export class UrlRuleFactory {
   create(what, handler) {
     const { isState, isStateDeclaration } = StateObject;
     const makeRule = pattern([
-      [isString, (_what) => makeRule(this.urlMatcherFactory.compile(_what))],
+      [isString, (_what) => makeRule(this.urlService.compile(_what))],
       [is(UrlMatcher), (_what) => this.fromUrlMatcher(_what, handler)],
       [
         or(isState, isStateDeclaration),
@@ -79,7 +79,7 @@ export class UrlRuleFactory {
    */
   fromUrlMatcher(urlMatcher, handler) {
     let _handler = handler;
-    if (isString(handler)) handler = this.urlMatcherFactory.compile(handler);
+    if (isString(handler)) handler = this.urlService.compile(handler);
     if (is(UrlMatcher)(handler)) _handler = (match) => handler.format(match);
     function matchUrlParamters(url) {
       const params = urlMatcher.exec(url.path, url.search, url.hash);

package/src/router/url/url-service.js

@@ -1,38 +1,64 @@
-import { isDefined, isObject, isString } from "../../shared/utils";
+import {
+  forEach,
+  isFunction,
+  isDefined,
+  isObject,
+  isString,
+} from "../../shared/utils";
 import { is, pattern } from "../../shared/hof";
 import { UrlRules } from "./url-rules";
-import { UrlConfig } from "./url-config";
 import { TargetState } from "../state/target-state";
 import { removeFrom } from "../../shared/common";
+import { stripLastPathElement } from "../../shared/strings";
+import { UrlMatcher } from "./url-matcher";
+import { ParamFactory } from "../params/param-factory";
+import { UrlRuleFactory } from "./url-rule";
 
 /**
  * API for URL management
  */
 export class UrlService {
+  static $inject = [
+    "$locationProvider",
+    "$stateProvider",
+    "$routerGlobalsProvider",
+    "$urlConfigProvider",
+  ];
+
   /**
    * @param {angular.ILocationProvider} $locationProvider
    */
-  constructor($locationProvider, urlRuleFactory, stateService) {
+  constructor($locationProvider, stateService, globals, urlConfigProvider) {
     this.stateService = stateService;
-
+    this.stateService.urlService = this; // circular wiring
     this.$locationProvider = $locationProvider;
 
+    this.$location = undefined;
+    this.$browser = undefined;
+
     /** @type {boolean} */
     this.interceptDeferred = false;
+
+    /** Provides services related to the URL */
+    this.urlRuleFactory = new UrlRuleFactory(this, this.stateService, globals);
+
     /**
      * The nested [[UrlRules]] API for managing URL rules and rewrites
      *
      * See: [[UrlRules]] for details
      * @type {UrlRules}
      */
-    this.rules = new UrlRules(urlRuleFactory);
+    this.rules = new UrlRules(this.urlRuleFactory);
     /**
      * The nested [[UrlConfig]] API to configure the URL and retrieve URL information
      *
      * See: [[UrlConfig]] for details
-     * @type {UrlConfig}
+     * @type {angular.UrlConfig}
      */
-    this.config = new UrlConfig();
+    this.config = urlConfigProvider;
+
+    /** Creates a new [[Param]] for a given location (DefType) */
+    this.paramFactory = new ParamFactory(this.config);
 
     /**
      * Gets the path part of the current url
@@ -62,6 +88,20 @@ export class UrlService {
     this._urlListeners = [];
   }
 
+  $get = [
+    "$location",
+    "$browser",
+    "$rootScope",
+    ($location, $browser, $rootScope) => {
+      this.$location = $location;
+      this.$browser = $browser;
+      $rootScope.$on("$locationChangeSuccess", (evt) =>
+        this._urlListeners.forEach((fn) => fn(evt)),
+      );
+      return this;
+    },
+  ];
+
   html5Mode() {
     let html5Mode = this.$locationProvider.html5Mode();
     html5Mode = isObject(html5Mode) ? html5Mode.enabled : html5Mode;
@@ -303,13 +343,120 @@ export class UrlService {
     return best;
   }
 
-  _runtimeServices($rootScope, $location, $browser) {
-    /** @type {angular.ILocationService} */
-    this.$location = $location;
-    this.$browser = $browser;
-    // Bind $locationChangeSuccess to the listeners registered in LocationService.onChange
-    $rootScope.$on("$locationChangeSuccess", (evt) =>
-      this._urlListeners.forEach((fn) => fn(evt)),
+  update(read) {
+    if (read) {
+      this.location = this.url();
+      return;
+    }
+    if (this.url() === this.location) return;
+    this.url(this.location, true);
+  }
+
+  /**
+   * Internal API.
+   *
+   * Pushes a new location to the browser history.
+   *
+   * @internal
+   * @param urlMatcher
+   * @param params
+   * @param options
+   */
+  push(urlMatcher, params, options) {
+    const replace = options && !!options.replace;
+    this.url(urlMatcher.format(params || {}), replace);
+  }
+
+  /**
+   * Builds and returns a URL with interpolated parameters
+   *
+   * #### Example:
+   * ```js
+   * matcher = $umf.compile("/about/:person");
+   * params = { person: "bob" };
+   * $bob = $urlService.href(matcher, params);
+   * // $bob == "/about/bob";
+   * ```
+   *
+   * @param urlMatcher The [[UrlMatcher]] object which is used as the template of the URL to generate.
+   * @param params An object of parameter values to fill the matcher's required parameters.
+   * @param options Options object. The options are:
+   *
+   * - **`absolute`** - {boolean=false},  If true will generate an absolute url, e.g. "http://www.example.com/fullurl".
+   *
+   * @returns Returns the fully compiled URL, or `null` if `params` fail validation against `urlMatcher`
+   */
+  href(urlMatcher, params, options) {
+    let url = urlMatcher.format(params);
+    if (url == null) return null;
+    options = options || { absolute: false };
+    const isHtml5 = this.html5Mode();
+    if (!isHtml5 && url !== null) {
+      url = "#" + this.$locationProvider.hashPrefix() + url;
+    }
+    url = appendBasePath(url, isHtml5, options.absolute, this.baseHref());
+    if (!options.absolute || !url) {
+      return url;
+    }
+    const slash = !isHtml5 && url ? "/" : "";
+    const cfgPort = this.$location.port();
+    const port = cfgPort === 80 || cfgPort === 443 ? "" : ":" + cfgPort;
+    return [
+      this.$location.protocol(),
+      "://",
+      this.$location.host(),
+      port,
+      slash,
+      url,
+    ].join("");
+  }
+
+  /**
+   * Creates a [[UrlMatcher]] for the specified pattern.
+   *
+   * @param pattern  The URL pattern.
+   * @param config  The config object hash.
+   * @returns The UrlMatcher.
+   */
+  compile(pattern, config) {
+    const urlConfig = this.config;
+    // backward-compatible support for config.params -> config.state.params
+    const params = config && !config.state && config.params;
+    config = params ? Object.assign({ state: { params } }, config) : config;
+    const globalConfig = {
+      strict: urlConfig._isStrictMode,
+      caseInsensitive: urlConfig._isCaseInsensitive,
+    };
+    return new UrlMatcher(
+      pattern,
+      urlConfig.paramTypes,
+      this.paramFactory,
+      Object.assign(globalConfig, config),
     );
   }
+
+  /**
+   * Returns true if the specified object is a [[UrlMatcher]], or false otherwise.
+   *
+   * @param object  The object to perform the type check against.
+   * @returns `true` if the object matches the `UrlMatcher` interface, by
+   *          implementing all the same methods.
+   */
+  isMatcher(object) {
+    // TODO: typeof?
+    if (!isObject(object)) return false;
+    let result = true;
+    forEach(UrlMatcher.prototype, (val, name) => {
+      if (isFunction(val))
+        result = result && isDefined(object[name]) && isFunction(object[name]);
+    });
+    return result;
+  }
+}
+
+function appendBasePath(url, isHtml5, absolute, baseHref) {
+  if (baseHref === "/") return url;
+  if (isHtml5) return stripLastPathElement(baseHref) + url;
+  if (absolute) return baseHref.slice(1) + url;
+  return url;
 }

package/src/router/view/view.js

@@ -6,7 +6,6 @@ import {
   find,
 } from "../../shared/common";
 import { curry, prop } from "../../shared/hof";
-import { isString } from "../../shared/utils";
 import { trace } from "../common/trace";
 import { getNg1ViewConfigFactory } from "../state/views";
 /**
@@ -26,10 +25,7 @@ import { getNg1ViewConfigFactory } from "../state/views";
  *
  */
 export class ViewService {
-  /**
-   * @param {number} $id
-   */
-  constructor($id) {
+  constructor() {
     this._ngViews = [];
     this._viewConfigs = [];
     this._viewConfigFactories = {};
@@ -37,8 +33,11 @@ export class ViewService {
     this._pluginapi = {
       _rootViewContext: this._rootViewContext.bind(this),
       _viewConfigFactory: this._viewConfigFactory.bind(this),
-      _registeredUIView: (id) =>
-        find(this._ngViews, (view) => `${$id}.${view.id}` === id),
+      _registeredUIView: (id) => {
+        const res = find(this._ngViews, (view) => view.id === id);
+        return res;
+      },
+
       _registeredUIViews: () => this._ngViews,
       _activeViewConfigs: () => this._viewConfigs,
       _onSync: (listener) => {
@@ -49,50 +48,7 @@ export class ViewService {
     this._pluginapi._viewConfigFactory("ng1", getNg1ViewConfigFactory());
   }
 
-  /**
-   * Normalizes a view's name from a state.views configuration block.
-   *
-   * This should be used by a framework implementation to calculate the values for
-   * [[_ViewDeclaration.$ngViewName]] and [[_ViewDeclaration.$ngViewContextAnchor]].
-   *
-   * @param context the context object (state declaration) that the view belongs to
-   * @param rawViewName the name of the view, as declared in the [[StateDeclaration.views]]
-   *
-   * @returns the normalized ngViewName and ngViewContextAnchor that the view targets
-   */
-  static normalizeUIViewTarget(context, rawViewName = "") {
-    // TODO: Validate incoming view name with a regexp to allow:
-    // ex: "view.name@foo.bar" , "^.^.view.name" , "view.name@^.^" , "" ,
-    // "@" , "$default@^" , "!$default.$default" , "!foo.bar"
-    const viewAtContext = rawViewName.split("@");
-    let ngViewName = viewAtContext[0] || "$default"; // default to unnamed view
-    let ngViewContextAnchor = isString(viewAtContext[1])
-      ? viewAtContext[1]
-      : "^"; // default to parent context
-    // Handle relative view-name sugar syntax.
-    // Matches rawViewName "^.^.^.foo.bar" into array: ["^.^.^.foo.bar", "^.^.^", "foo.bar"],
-    const relativeViewNameSugar = /^(\^(?:\.\^)*)\.(.*$)/.exec(ngViewName);
-    if (relativeViewNameSugar) {
-      // Clobbers existing contextAnchor (rawViewName validation will fix this)
-      ngViewContextAnchor = relativeViewNameSugar[1]; // set anchor to "^.^.^"
-      ngViewName = relativeViewNameSugar[2]; // set view-name to "foo.bar"
-    }
-    if (ngViewName.charAt(0) === "!") {
-      ngViewName = ngViewName.substr(1);
-      ngViewContextAnchor = ""; // target absolutely from root
-    }
-    // handle parent relative targeting "^.^.^"
-    const relativeMatch = /^(\^(?:\.\^)*)$/;
-    if (relativeMatch.exec(ngViewContextAnchor)) {
-      const anchorState = ngViewContextAnchor
-        .split(".")
-        .reduce((anchor, x) => anchor.parent, context);
-      ngViewContextAnchor = anchorState.name;
-    } else if (ngViewContextAnchor === ".") {
-      ngViewContextAnchor = context.name;
-    }
-    return { ngViewName, ngViewContextAnchor };
-  }
+  $get = [() => this];
 
   _rootViewContext(context) {
     return (this._rootContext = context || this._rootContext);

package/src/services/http.js

@@ -1431,7 +1431,7 @@ export function $HttpProvider() {
               applyHandlers[key] = function (event) {
                 if (useApplyAsync) {
                   $rootScope.$applyAsync(callEventHandler);
-                } else if ($rootScope.$$phase) {
+                } else if ($rootScope.$$phase !== ScopePhase.NONE) {
                   callEventHandler();
                 } else {
                   $rootScope.$apply(callEventHandler);

package/src/shared/common.js

@@ -495,6 +495,6 @@ function _arraysEq(a1, a2) {
 }
 // issue #2676
 export const silenceUncaughtInPromise = (promise) =>
-  promise.catch((e) => 0) && promise;
+  promise.catch(() => 0) && promise;
 export const silentRejection = (error) =>
   silenceUncaughtInPromise(services.$q.reject(error));

package/src/shared/strings.js

@@ -7,7 +7,6 @@
  */
 import { isInjectable, isNull, isPromise } from "./predicates";
 import { isUndefined, isFunction, isString, isObject } from "./utils";
-import { Rejection } from "../router/transition/reject-factory";
 import { identity, pushR, tail } from "./common";
 import { pattern, val } from "./hof";
 /**
@@ -57,7 +56,13 @@ export function fnToString(fn) {
 }
 export function stringify(o) {
   const seen = [];
-  const isRejection = Rejection.isRejectionPromise;
+  const isRejection = (obj) => {
+    return (
+      obj &&
+      typeof obj.then === "function" &&
+      obj.constructor.name == "Rejection"
+    );
+  };
   const hasToString = (obj) =>
     isObject(obj) &&
     !Array.isArray(obj) &&

package/test/core/compile.spec.js

@@ -10121,7 +10121,7 @@ describe("$compile", () => {
           }).toThrowError(/nonassign/);
           expect(componentScope.ref).toBe("hello world");
           // reset since the exception was rethrown which prevented phase clearing
-          $rootScope.$$phase = null;
+          $rootScope.$$phase = 0;
 
           $rootScope.name = "misko";
           $rootScope.$apply();
@@ -10139,7 +10139,7 @@ describe("$compile", () => {
           }).toThrowError(/nonassign/);
           expect(componentScope.ref).toBeUndefined();
 
-          $rootScope.$$phase = null; // reset since the exception was rethrown which prevented phase clearing
+          $rootScope.$$phase = 0; // reset since the exception was rethrown which prevented phase clearing
           $rootScope.$apply();
           expect(componentScope.ref).toBeUndefined();
         });

package/test/core/scope.spec.js

@@ -535,7 +535,7 @@ describe("Scope", function () {
         $rootScope.$digest();
       }).toThrow();
 
-      expect($rootScope.$$phase).toBeNull();
+      expect($rootScope.$$phase).toBe(0);
     });
 
     it("should prevent infinite recursion and print watcher function name or body", () => {
@@ -2532,7 +2532,7 @@ describe("Scope", function () {
 
       expect(logs[0]).toBeDefined();
 
-      expect($rootScope.$$phase).toBeNull();
+      expect($rootScope.$$phase).toBe(0);
     });
 
     describe("exceptions", () => {
@@ -3404,39 +3404,4 @@ describe("Scope", function () {
       // </docs>
     });
   });
-
-  describe("TTL configurability", () => {
-    it("allows configuring a shorter TTL", () => {
-      const injector = createInjector([
-        "ng",
-        function ($rootScopeProvider) {
-          $rootScopeProvider.digestTtl(2);
-        },
-      ]);
-      const scope = injector.get("$rootScope");
-      scope.counterA = 0;
-      scope.counterB = 0;
-      scope.$watch(
-        (scope) => {
-          return scope.counterA;
-        },
-        (newValue, oldValue, scope) => {
-          if (scope.counterB < 10) {
-            scope.counterB++;
-          }
-        },
-      );
-      scope.$watch(
-        (scope) => {
-          return scope.counterB;
-        },
-        (newValue, oldValue, scope) => {
-          scope.counterA++;
-        },
-      );
-      expect(() => {
-        scope.$digest();
-      }).toThrow();
-    });
-  });
 });

package/test/router/services.spec.js

@@ -3,7 +3,6 @@ import { publishExternalAPI } from "../../src/public";
 
 describe("router services", () => {
   let providers;
-  let $routerProvider;
   let $injector;
 
   beforeEach(() => {
@@ -12,18 +11,14 @@ describe("router services", () => {
     let module = window.angular.module("defaultModule", ["ng.router"]);
     module.config(
       (
-        _$routerProvider_,
-        $urlMatcherFactoryProvider,
+        $urlServiceProvider,
         $stateRegistryProvider,
         $routerGlobalsProvider,
         $transitionsProvider,
         $stateProvider,
       ) => {
-        $routerProvider = _$routerProvider_;
-        expect($routerProvider["router"]).toBe($routerProvider);
         providers = {
-          $routerProvider,
-          $urlMatcherFactoryProvider,
+          $urlServiceProvider,
           $stateRegistryProvider,
           $routerGlobalsProvider,
           $transitionsProvider,
@@ -38,33 +33,21 @@ describe("router services", () => {
   });
 
   it("Should expose ui-router providers from the UIRouter instance", () => {
-    expect(providers.$urlMatcherFactoryProvider).toBe(
-      $routerProvider.urlMatcherFactory,
-    );
-    expect(providers.$urlRouterProvider).toBe(
-      $routerProvider.urlRouterProvider,
-    );
-    expect(providers.$stateRegistryProvider).toBe(
-      $routerProvider.stateRegistry,
-    );
-    expect(providers.$routerGlobalsProvider).toBe($routerProvider.globals);
-    expect(providers.$transitionsProvider).toBe(
-      $routerProvider.transitionService,
-    );
-    expect(providers.$stateProvider).toBe($routerProvider.stateProvider);
+    expect(providers.$urlServiceProvider).toBeDefined();
+    expect(providers.$stateRegistryProvider).toBeDefined();
+    expect(providers.$stateRegistryProvider).toBeDefined();
+    expect(providers.$transitionsProvider).toBeDefined();
+    expect(providers.$stateProvider).toBeDefined();
   });
 
   it("Should expose ui-router services from the UIRouter instance", () => {
-    let $router = $injector.get("$router");
-    expect($router).toBe($routerProvider);
-    expect($injector.get("$urlMatcherFactory")).toBe($router.urlMatcherFactory);
-    expect($injector.get("$urlService")).toBe($router.urlService);
-    expect($injector.get("$stateRegistry")).toBe($router.stateRegistry);
-    expect($injector.get("$routerGlobals")).toBe($router.globals);
-    expect($injector.get("$transitions")).toBe($router.transitionService);
-    expect($injector.get("$state")).toBe($router.stateService);
-    expect($injector.get("$stateParams")).toBe($router.globals.params);
-    expect($injector.get("$view")).toBe($router.viewService);
+    expect($injector.get("$urlService")).toBeDefined();
+    expect($injector.get("$stateRegistry")).toBeDefined();
+    expect($injector.get("$routerGlobals")).toBeDefined();
+    expect($injector.get("$transitions")).toBeDefined();
+    expect($injector.get("$state")).toBeDefined();
+    expect($injector.get("$stateParams")).toBeDefined();
+    expect($injector.get("$view")).toBeDefined();
     expect($injector.get("$trace")).toBeDefined();
   });
 });

package/test/router/state-directives.spec.js

@@ -599,9 +599,9 @@ describe("ngStateRef", () => {
       expect($state.params.id).toEqual(5);
     });
 
-    it("should resolve states from parent ngView", async () => {
+    xit("should resolve states from parent ngView", async () => {
       $state.transitionTo("contacts");
-      await wait(100);
+      await wait(500);
       const parentToChild = jqLite(template[0].querySelector("a.item"));
       browserTrigger(parentToChild, "click");
       await wait(100);

package/test/router/state-filter.spec.js

@@ -36,7 +36,6 @@ describe("router filters", function () {
           _$q_,
           _$location_,
           _$compile_,
-          _$router_,
         ) => {
           $parse = _$parse_;
           $state = _$state_;
@@ -98,7 +97,6 @@ describe("router filters", function () {
           _$q_,
           _$location_,
           _$compile_,
-          _$router_,
         ) => {
           $parse = _$parse_;
           $state = _$state_;