@angular-wave/angular.ts 0.0.30 → 0.0.31

package/package.json

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

package/src/router/hooks/url.js

@@ -1,7 +1,7 @@
 export const registerUpdateUrl = (
   transitionService,
   stateService,
-  urlRouter,
+  urlService,
 ) => {
   /**
    * A [[TransitionHookFn]] which updates the URL after a successful transition
@@ -11,7 +11,7 @@ export const registerUpdateUrl = (
   const updateUrl = (transition) => {
     const options = transition.options();
     const $state = stateService;
-    const $urlRouter = urlRouter;
+
     // Dont update the url in these situations:
     // The transition was triggered by a URL sync (options.source === 'url')
     // The user doesn't want the url to update (options.location === false)
@@ -22,13 +22,13 @@ export const registerUpdateUrl = (
       $state.$current.navigable
     ) {
       const urlOptions = { replace: options.location === "replace" };
-      $urlRouter.push(
+      urlService.push(
         $state.$current.navigable.url,
         $state.globals.params,
         urlOptions,
       );
     }
-    $urlRouter.update(true);
+    urlService.update(true);
   };
   transitionService.onSuccess({}, updateUrl, { priority: 9999 });
 };

package/src/router/index.js

@@ -22,12 +22,6 @@ export function initRouter() {
     .module("ng.router", ["ng"])
     .provider("$router", $routerProvider)
     .provider("$urlService", getProviderFor("urlService"))
-    .provider("$urlMatcherFactory", [
-      "$routerProvider",
-      function RouterProvide() {
-        return router.urlMatcherFactory;
-      },
-    ])
     .provider("$templateFactory", TemplateFactory)
     .provider("$stateRegistry", getProviderFor("stateRegistry"))
     .provider("$routerGlobals", getProviderFor("globals"))

package/src/router/injectables.js

@@ -259,56 +259,5 @@ let $urlServiceProvider;
  * ##### Note: This service can also be injected during the config phase as [[$urlServiceProvider]].
  */
 let $urlService;
-/**
- * The URL Router Provider
- *
- * ### Deprecation warning: This object is now considered internal. Use [[$urlServiceProvider]] instead.
- *
- * The [[UrlRouter]] singleton as a **Provider Object** (injectable during config time).
- *
- * #### Note: This object is also exposed as [[$urlRouter]] for injection during runtime.
- *
- * @deprecated
- */
-let $urlRouterProvider;
-/**
- * The Url Router
- *
- * ### Deprecation warning: This object is now considered internal. Use [[$urlService]] instead.
- *
- * The [[UrlRouter]] singleton as a **Service Object** (injectable during runtime).
- *
- * #### Note: This object is also exposed as [[$urlRouterProvider]] for injection during angular config time.
- *
- * @deprecated
- */
-let $urlRouter;
-/**
- * The URL Matcher Factory
- *
- * ### Deprecation warning: This object is now considered internal. Use [[$urlService]] instead.
- *
- * The [[UrlMatcherFactory]] singleton as a **Service Object** (injectable during runtime).
- *
- * This service is used to set url mapping options, define custom parameter types, and create [[UrlMatcher]] objects.
- *
- * #### Note: This object is also exposed as [[$urlMatcherFactoryProvider]] for injection during angular config time.
- *
- * @deprecated
- */
-let $urlMatcherFactory;
-/**
- * The URL Matcher Factory
- *
- * ### Deprecation warning: This object is now considered internal. Use [[$urlService]] instead.
- *
- * The [[UrlMatcherFactory]] singleton as a **Provider Object** (injectable during config time).
- *
- * This service is used to set url mapping options, define custom parameter types, and create [[UrlMatcher]] objects.
- *
- * #### Note: This object is also exposed as [[$urlMatcherFactory]] for injection during runtime.
- *
- * @deprecated
- */
-let $urlMatcherFactoryProvider;
+
 export {};

package/src/router/router.js

@@ -1,5 +1,3 @@
-import { UrlMatcherFactory } from "./url/url-matcher-factory";
-import { UrlRouter } from "./url/url-router";
 import { TransitionService } from "./transition/transition-service";
 import { ViewService } from "./view/view";
 import { StateRegistry } from "./state/state-registry";
@@ -70,31 +68,11 @@ export class UIRouter {
       this.stateService,
     );
 
-    /**
-     * Deprecated for public use. Use [[urlService]] instead.
-     * @deprecated Use [[urlService]] instead
-     */
-    this.urlMatcherFactory = new UrlMatcherFactory(this.urlService.config);
-
-    /**
-     * Deprecated for public use. Use [[urlService]] instead.
-     * @deprecated Use [[urlService]] instead
-     */
-    this.urlRouter = new UrlRouter(
-      this.urlService,
-      urlRuleFactory,
-      $locationProvider,
-    );
-
     /** Provides a registry for states, and related registration services */
-    this.stateRegistry = new StateRegistry(
-      this.urlMatcherFactory,
-      this.urlService.rules,
-    );
+    this.stateRegistry = new StateRegistry(this.urlService);
 
     // Manual wiring ideally we would want to do this at runtime
     this.stateService.stateRegistry = this.stateRegistry;
-    this.stateService.urlRouter = this.urlRouter;
     this.stateService.urlService = this.urlService; // <-- NOTE: circular dependency
 
     // Lazy load state trees
@@ -109,7 +87,7 @@ export class UIRouter {
     this.transitionService._deregisterHookFns.updateUrl = registerUpdateUrl(
       this.transitionService,
       this.stateService,
-      this.urlRouter,
+      this.urlService,
     );
 
     // Wire up redirectTo hook

package/src/router/services.js

@@ -27,27 +27,6 @@ export function $routerProvider($locationProvider) {
     router.stateService,
   );
 
-  /**
-   * 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 = router.urlMatcherFactory.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;
-
   // backwards compat: also expose router instance as $routerProvider.router
   router["router"] = router;
   router["$get"] = $get;
@@ -99,7 +78,6 @@ export function runBlock($injector, $q, $router) {
 }
 
 // $state service and $stateProvider
-// $urlRouter service and $urlRouterProvider
 export function getStateProvider() {
   return Object.assign(router.stateProvider, {
     $get: () => router.stateService,

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

@@ -29,7 +29,7 @@ function dataBuilder(state) {
   }
   return state.data;
 }
-const getUrlBuilder = ($urlMatcherFactoryProvider, root) =>
+const getUrlBuilder = ($urlService, root) =>
   function urlBuilder(stateObject) {
     let stateDec = stateObject.self;
     // For future states, i.e., states whose name ends with `.**`,
@@ -49,9 +49,9 @@ const getUrlBuilder = ($urlMatcherFactoryProvider, root) =>
     const parsed = parseUrl(stateDec.url);
     const url = !parsed
       ? stateDec.url
-      : $urlMatcherFactoryProvider.compile(parsed.val, { state: stateDec });
+      : $urlService.compile(parsed.val, { state: stateDec });
     if (!url) return null;
-    if (!$urlMatcherFactoryProvider.isMatcher(url))
+    if (!$urlService.isMatcher(url))
       throw new Error(`Invalid url '${url}' in state '${stateObject}'`);
     return parsed && parsed.root
       ? url
@@ -238,7 +238,7 @@ export function resolvablesBuilder(state) {
  * using the [[builder]] method.
  */
 export class StateBuilder {
-  constructor(matcher, urlMatcherFactory) {
+  constructor(matcher, urlService) {
     this.matcher = matcher;
     this.$injector = undefined;
     const self = this;
@@ -254,10 +254,11 @@ export class StateBuilder {
       parent: [parentBuilder],
       data: [dataBuilder],
       // Build a URLMatcher if necessary, either via a relative or absolute URL
-      url: [getUrlBuilder(urlMatcherFactory, root)],
+      url: [getUrlBuilder(urlService, root)],
       // Keep track of the closest ancestor state that has a URL (i.e. is navigable)
       navigable: [getNavigableBuilder(isRoot)],
-      params: [getParamsBuilder(urlMatcherFactory.paramFactory)],
+      // TODO
+      params: [getParamsBuilder(urlService.paramFactory)],
       // Each framework-specific ui-router implementation should define its own `views` builder
       // e.g., src/ng1/statebuilders/views.ts
       views: [],

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,

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/url/url-config.js

@@ -23,7 +23,32 @@ 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();
   }
+
   /**
    * Defines whether URL matching should be case sensitive (the default behavior), or not.
    *

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
      *
@@ -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

@@ -86,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

@@ -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);