@angular-wave/angular.ts 0.0.29 → 0.0.31

package/src/router/state/state-registry.js

@@ -12,13 +12,14 @@ import { ng1ViewsBuilder } from "./views";
  * This API is found at `$stateRegistry` ([[UIRouter.stateRegistry]])
  */
 export class StateRegistry {
-  constructor(urlMatcherFactory, urlServiceRules) {
+  constructor(urlService) {
     this.states = {};
-    this.urlServiceRules = urlServiceRules;
+    this.urlService = urlService;
+    this.urlServiceRules = urlService.rules;
     this.$injector = undefined;
     this.listeners = [];
     this.matcher = new StateMatcher(this.states);
-    this.builder = new StateBuilder(this.matcher, urlMatcherFactory);
+    this.builder = new StateBuilder(this.matcher, urlService);
     // Apply ng1 specific StateBuilder code for `views`, `resolve`, and `onExit/Retain/Enter` properties
     // TODO we can probably move this inside buildr
     this.builder.builder("views", ng1ViewsBuilder);
@@ -28,7 +29,7 @@ export class StateRegistry {
 
     this.stateQueue = new StateQueueManager(
       this,
-      urlServiceRules,
+      this.urlServiceRules,
       this.states,
       this.builder,
       this.listeners,
@@ -125,7 +126,7 @@ export class StateRegistry {
    * Gets the implicit root state
    *
    * Gets the root of the state tree.
-   * The root state is implicitly created by UI-Router.
+   * The root state is implicitly created by ng-router.
    * Note: this returns the internal [[StateObject]] representation, not a [[StateDeclaration]]
    *
    * @return the root [[StateObject]]

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

@@ -52,10 +52,9 @@ export class StateService {
     return this.globals.$current;
   }
 
-  // Needs access to urlRouter, stateRegistry
+  // Needs access to urlService, stateRegistry
   constructor(globals, transitionService) {
     this.stateRegistry = undefined;
-    this.urlRouter = undefined;
     this.urlService = undefined;
     this.globals = globals;
     this.transitionService = transitionService;
@@ -344,7 +343,7 @@ export class StateService {
       if (error instanceof Rejection) {
         const isLatest = this.globals.lastStartedTransitionId <= trans.$id;
         if (error.type === RejectType.IGNORED) {
-          isLatest && EventBus.publish("urlRouter.update");
+          isLatest && this.urlService.update();
           // Consider ignored `Transition.run()` as a successful `transitionTo`
           return services.$q.when(this.globals.current);
         }
@@ -360,7 +359,7 @@ export class StateService {
           return redirect.run().catch(rejectedTransitionHandler(redirect));
         }
         if (error.type === RejectType.ABORTED) {
-          isLatest && EventBus.publish("urlRouter.update");
+          isLatest && this.urlService.update();
           return services.$q.reject(error);
         }
       }
@@ -519,7 +518,7 @@ export class StateService {
     if (!nav || nav.url === undefined || nav.url === null) {
       return null;
     }
-    return this.urlRouter.href(nav.url, params, {
+    return this.urlService.href(nav.url, params, {
       absolute: options.absolute,
     });
   }

package/src/router/state/target-state.js

@@ -22,7 +22,7 @@ import { stringify } from "../../shared/strings";
  * 3) and transition options
  * 4) the registered state object (the [[StateDeclaration]])
  *
- * Many UI-Router APIs such as [[StateService.go]] take a [[StateOrName]] argument which can
+ * Many ng-router APIs such as [[StateService.go]] take a [[StateOrName]] argument which can
  * either be a *state object* (a [[StateDeclaration]] or [[StateObject]]) or a *state name* (a string).
  * The `TargetState` class normalizes those options.
  *

package/src/router/state/views.js

@@ -11,7 +11,7 @@ export function getNg1ViewConfigFactory() {
   let templateFactory = null;
   return (path, view) => {
     templateFactory =
-      templateFactory || services.$injector.get("$templateFactory");
+      templateFactory || services.$injector.get("$templateFactory"); // TODO: remove static injector
     return [new Ng1ViewConfig(path, view, templateFactory)];
   };
 }

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

@@ -18,14 +18,37 @@ export class UrlConfig {
     /** @type {ParamTypes} */
     this.paramTypes = new ParamTypes();
     /** @type {boolean} */
-    this._decodeParams = true;
-    /** @type {boolean} */
     this._isCaseInsensitive = false;
     /** @type {boolean} */
     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();
   }
+
   /**
    * Defines whether URL matching should be case sensitive (the default behavior), or not.
    *

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

@@ -39,7 +39,6 @@ const defaultConfig = {
   state: { params: {} },
   strict: true,
   caseInsensitive: true,
-  decodeParams: true,
 };
 /**
  * Matches URLs against patterns.
@@ -313,13 +312,6 @@ export class UrlMatcher {
   }
   _getDecodedParamValue(value, param) {
     if (isDefined(value)) {
-      if (this.config.decodeParams && !param.type.raw) {
-        if (Array.isArray(value)) {
-          value = value.map((paramValue) => decodeURIComponent(paramValue));
-        } else {
-          value = decodeURIComponent(value);
-        }
-      }
       value = param.type.decode(value);
     }
     return param.value(value);

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

@@ -1,9 +1,18 @@
-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";
 
 /**
  * API for URL management
@@ -14,8 +23,9 @@ export class UrlService {
    */
   constructor($locationProvider, urlRuleFactory, stateService) {
     this.stateService = stateService;
-
     this.$locationProvider = $locationProvider;
+    this.$location = undefined;
+    this.$browser = undefined;
 
     /** @type {boolean} */
     this.interceptDeferred = false;
@@ -34,6 +44,9 @@ export class UrlService {
      */
     this.config = new UrlConfig();
 
+    /** Creates a new [[Param]] for a given location (DefType) */
+    this.paramFactory = new ParamFactory(this.config);
+
     /**
      * Gets the path part of the current url
      *
@@ -213,9 +226,9 @@ export class UrlService {
    * Starts or stops listening for URL changes
    *
    * Call this sometime after calling [[deferIntercept]] to start monitoring the url.
-   * This causes UI-Router to start listening for changes to the URL, if it wasn't already listening.
+   * This causes ng-router to start listening for changes to the URL, if it wasn't already listening.
    *
-   * If called with `false`, UI-Router will stop listening (call listen(true) to start listening again).
+   * If called with `false`, ng-router will stop listening (call listen(true) to start listening again).
    *
    * #### Example:
    * ```js
@@ -243,15 +256,15 @@ export class UrlService {
   /**
    * Disables monitoring of the URL.
    *
-   * Call this method before UI-Router has bootstrapped.
-   * It will stop UI-Router from performing the initial url sync.
+   * Call this method before ng-router has bootstrapped.
+   * It will stop ng-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.
+   * Once the initialization is complete, call [[listen]] to tell ng-router to start watching and synchronizing the URL.
    *
    * #### Example:
    * ```js
-   * // Prevent UI-Router from automatically intercepting URL changes when it starts;
+   * // Prevent ng-router from automatically intercepting URL changes when it starts;
    * urlService.deferIntercept();
    *
    * fetch('/states.json').then(resp => resp.json()).then(data => {
@@ -312,4 +325,121 @@ export class UrlService {
       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

@@ -8,6 +8,7 @@ import {
 import { curry, prop } from "../../shared/hof";
 import { isString } from "../../shared/utils";
 import { trace } from "../common/trace";
+import { getNg1ViewConfigFactory } from "../state/views";
 /**
  * The View service
  *
@@ -45,6 +46,7 @@ export class ViewService {
         return () => removeFrom(this._listeners, listener);
       },
     };
+    this._pluginapi._viewConfigFactory("ng1", getNg1ViewConfigFactory());
   }
 
   /**
@@ -84,7 +86,7 @@ export class ViewService {
     if (relativeMatch.exec(ngViewContextAnchor)) {
       const anchorState = ngViewContextAnchor
         .split(".")
-        .reduce((anchor, x) => anchor.parent, context);
+        .reduce((anchor) => anchor.parent, context);
       ngViewContextAnchor = anchorState.name;
     } else if (ngViewContextAnchor === ".") {
       ngViewContextAnchor = context.name;

package/src/shared/common.js

@@ -1,5 +1,5 @@
 /**
- * Random utility functions used in the UI-Router code
+ * Random utility functions used in the ng-router code
  *
  * These functions are exported, but are subject to change without notice.
  *
@@ -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/test/router/services.spec.js

@@ -13,7 +13,7 @@ describe("router services", () => {
     module.config(
       (
         _$routerProvider_,
-        $urlMatcherFactoryProvider,
+        $urlServiceProvider,
         $stateRegistryProvider,
         $routerGlobalsProvider,
         $transitionsProvider,
@@ -23,7 +23,7 @@ describe("router services", () => {
         expect($routerProvider["router"]).toBe($routerProvider);
         providers = {
           $routerProvider,
-          $urlMatcherFactoryProvider,
+          $urlServiceProvider,
           $stateRegistryProvider,
           $routerGlobalsProvider,
           $transitionsProvider,
@@ -38,26 +38,17 @@ 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.$routerProvider).toBeDefined();
+    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);