@angular-wave/angular.ts 0.8.0 → 0.8.1

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

@@ -19,14 +19,14 @@ export class StateRegistryProvider {
   /* @ignore */ static $inject = provider([
     $injectTokens.$url,
     $injectTokens.$state,
-    $injectTokens.$routerGlobals,
+    $injectTokens.$router,
     $injectTokens.$view,
   ]);
 
   /**
    * @param urlService
    * @param stateService
-   * @param {import('../globals.js').RouterGlobals} globals
+   * @param {import('../router.js').Router} globals
    * @param viewService
    */
   constructor(urlService, stateService, globals, viewService) {

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

@@ -30,7 +30,7 @@ export class StateProvider {
   /**
    * The latest successful state parameters
    *
-   * @deprecated This is a passthrough through to [[RouterGlobals.params]]
+   * @deprecated This is a passthrough through to [[Router.params]]
    */
   get params() {
     return this.globals.params;
@@ -38,7 +38,7 @@ export class StateProvider {
   /**
    * The current [[StateDeclaration]]
    *
-   * @deprecated This is a passthrough through to [[RouterGlobals.current]]
+   * @deprecated This is a passthrough through to [[Router.current]]
    */
   get current() {
     return this.globals.current;
@@ -46,21 +46,18 @@ export class StateProvider {
   /**
    * The current [[StateObject]] (an internal API)
    *
-   * @deprecated This is a passthrough through to [[RouterGlobals.$current]]
+   * @deprecated This is a passthrough through to [[Router.$current]]
    */
   get $current() {
     return this.globals.$current;
   }
 
-  /* @ignore */ static $inject = [
-    "$routerGlobalsProvider",
-    "$transitionsProvider",
-  ];
+  /* @ignore */ static $inject = ["$routerProvider", "$transitionsProvider"];
 
   // Needs access to urlService, stateRegistry
   /**
    *
-   * @param {import('../globals.js').RouterGlobals} globals
+   * @param {import('../router.js').Router} globals
    * @param {*} transitionService
    */
   constructor(globals, transitionService) {

package/src/router/template-factory.spec.js

@@ -78,9 +78,9 @@ describe("templateFactory", () => {
       ]);
       $injector.invoke(
         (_$templateFactory_, _$httpBackend_, _$sce_, $rootScope) => {
-          ($templateFactory = _$templateFactory_),
-            ($httpBackend = _$httpBackend_),
-            ($sce = _$sce_);
+          $templateFactory = _$templateFactory_;
+          $httpBackend = _$httpBackend_;
+          $sce = _$sce_;
           $scope = $rootScope;
         },
       );
@@ -119,9 +119,9 @@ describe("templateFactory", () => {
           _$state_,
           _$compile_,
         ) => {
-          ($templateFactory = _$templateFactory_),
-            ($httpBackend = _$httpBackend_),
-            ($sce = _$sce_);
+          $templateFactory = _$templateFactory_;
+          $httpBackend = _$httpBackend_;
+          $sce = _$sce_;
           $scope = $rootScope;
           $stateRegistry = _$stateRegistry_;
           $stateService = _$state_;

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

@@ -62,10 +62,10 @@ export let defaultTransOpts = {
  * This API is located at `router.transitionService` ([[UIRouter.transitionService]])
  */
 export class TransitionProvider {
-  /* @ignore */ static $inject = provider([$t.$routerGlobals, $t.$view]);
+  /* @ignore */ static $inject = provider([$t.$router, $t.$view]);
 
   /**
-   * @param {import('../globals.js').RouterGlobals} globals
+   * @param {import('../router.js').Router} globals
    * @param viewService
    */
   constructor(globals, viewService) {

package/src/router/transition/transition.js

@@ -44,11 +44,11 @@ export class Transition {
    *        encapsulates the "from state".
    * @param {import('../state/target-state.js').TargetState} targetState The target state and parameters being transitioned to (also, the transition options)
    * @param {import('../transition/transition-service.js').TransitionProvider} transitionService The [[TransitionService]] instance
-   * @param {import('../globals.js').RouterGlobals} globals
+   * @param {import('../router.js').Router} globals
    */
   constructor(fromPath, targetState, transitionService, globals) {
     /**
-     * @type {import('../globals.js').RouterGlobals}
+     * @type {import('../router.js').Router}
      */
     this.globals = globals;
     this.transitionService = transitionService;

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

@@ -93,13 +93,6 @@ const defaultConfig = {
  *
  */
 export class UrlMatcher {
-  static encodeDashes(str) {
-    // Replace dashes with encoded "\-"
-    return encodeURIComponent(str).replace(
-      /-/g,
-      (c) => `%5C%${c.charCodeAt(0).toString(16).toUpperCase()}`,
-    );
-  }
   /** @internal Given a matcher, return an array with the matcher's path segments and path params, in order */
   static pathSegmentsAndParams(matcher) {
     const staticSegments = matcher._segments;
@@ -310,9 +303,6 @@ export class UrlMatcher {
     return this.pattern;
   }
   _getDecodedParamValue(value, param) {
-    if (isDefined(value)) {
-      value = param.type.decode(value);
-    }
     return param.value(value);
   }
   /**
@@ -503,7 +493,7 @@ export class UrlMatcher {
       if (encoded == null) return acc;
       // If this parameter value is an array, encode the value using encodeDashes
       if (Array.isArray(encoded))
-        return acc + map(encoded, UrlMatcher.encodeDashes).join("-");
+        return acc + map(encoded, encodeDashes).join("-");
       // If the parameter type is "raw", then do not encodeURIComponent
       if (param.raw) return acc + encoded;
       // Encode the value
@@ -532,3 +522,11 @@ export class UrlMatcher {
 }
 
 UrlMatcher.nameValidator = /^\w+([-.]+\w+)*(?:\[\])?$/;
+
+function encodeDashes(str) {
+  // Replace dashes with encoded "\-"
+  return encodeURIComponent(str).replace(
+    /-/g,
+    (c) => `%5C%${c.charCodeAt(0).toString(16).toUpperCase()}`,
+  );
+}

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

@@ -6,7 +6,7 @@ import {
   isUndefined,
   assert,
 } from "../../shared/utils.js";
-import { is, or, pattern } from "../../shared/hof.js";
+import { is, pattern } from "../../shared/hof.js";
 import { StateObject } from "../state/state-object.js";
 /**
  * Creates a [[UrlRule]]
@@ -19,6 +19,11 @@ import { StateObject } from "../state/state-object.js";
  * - [[StateObject]]
  */
 export class UrlRuleFactory {
+  /**
+   * @param {import('../url/url-service.js').UrlService} urlService
+   * @param {import('../state/state-service.js').StateProvider} stateService
+   * @param {import('../router.js').Router} routerGlobals
+   */
   constructor(urlService, stateService, routerGlobals) {
     this.urlService = urlService;
     this.stateService = stateService;
@@ -37,7 +42,7 @@ export class UrlRuleFactory {
       [isString, (_what) => makeRule(this.urlService.compile(_what))],
       [is(UrlMatcher), (_what) => this.fromUrlMatcher(_what, handler)],
       [
-        or(isState, isStateDeclaration),
+        (...args) => isState(...args) || isStateDeclaration(...args),
         (_what) => this.fromState(_what, this.stateService, this.routerGlobals),
       ],
       [is(RegExp), (_what) => this.fromRegExp(_what, handler)],

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

@@ -22,7 +22,7 @@ export class UrlService {
   static $inject = provider([
     $t.$location,
     $t.$state,
-    $t.$routerGlobals,
+    $t.$router,
     $t.$urlConfig,
   ]);
 
@@ -32,7 +32,7 @@ export class UrlService {
   /**
    * @param {import("../../services/location/location").LocationProvider} $locationProvider
    * @param {import("../../router/state/state-service.js").StateProvider} stateService
-   * @param {import("../../router/globals.js").RouterGlobals} globals
+   * @param {import("../router.js").Router} globals
    * @param {import("../../router/url/url-config.js").UrlConfigProvider} urlConfigProvider
    */
   constructor($locationProvider, stateService, globals, urlConfigProvider) {
@@ -175,7 +175,10 @@ export class UrlService {
    * @return the url (after potentially being processed)
    */
   url(newUrl, state) {
-    if (isDefined(newUrl)) this.$location.setUrl(newUrl);
+    if (isDefined(newUrl)) {
+      const decodeUri = decodeURIComponent(newUrl);
+      this.$location.setUrl(decodeUri);
+    }
     if (state) this.$location.setState(state);
     return this.$location.getUrl();
   }

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

@@ -10,7 +10,12 @@ describe("UrlMatcher", () => {
   beforeEach(() => {
     dealoc(document.getElementById("app"));
     window.angular = new Angular();
-    window.angular.module("defaultModule", []);
+    window.angular
+      .module("defaultModule", [])
+      .config(
+        ($locationProvider) =>
+          ($locationProvider.html5ModeConf.enabled = false),
+      );
     $injector = window.angular.bootstrap(document.getElementById("app"), [
       "defaultModule",
     ]);
@@ -80,44 +85,6 @@ describe("UrlMatcher", () => {
     expect(matcher.format(array)).toBe("/?foo=bar&foo=baz");
   });
 
-  it("should encode and decode slashes in parameter values as ~2F", () => {
-    const matcher1 = $url.compile("/:foo");
-
-    expect(matcher1.format({ foo: "/" })).toBe("/~2F");
-    expect(matcher1.format({ foo: "//" })).toBe("/~2F~2F");
-
-    expect(matcher1.exec("/")).toBeTruthy();
-    expect(matcher1.exec("//")).not.toBeTruthy();
-
-    expect(matcher1.exec("/").foo).toBe("");
-    expect(matcher1.exec("/123").foo).toBe("123");
-    expect(matcher1.exec("/~2F").foo).toBe("/");
-    expect(matcher1.exec("/123~2F").foo).toBe("123/");
-
-    // param :foo should match between two slashes
-    const matcher2 = $url.compile("/:foo/");
-
-    expect(matcher2.exec("/")).not.toBeTruthy();
-    expect(matcher2.exec("//")).toBeTruthy();
-
-    expect(matcher2.exec("//").foo).toBe("");
-    expect(matcher2.exec("/123/").foo).toBe("123");
-    expect(matcher2.exec("/~2F/").foo).toBe("/");
-    expect(matcher2.exec("/123~2F/").foo).toBe("123/");
-  });
-
-  it("should encode and decode tildes in parameter values as ~~", () => {
-    const matcher1 = $url.compile("/:foo");
-
-    expect(matcher1.format({ foo: "abc" })).toBe("/abc");
-    expect(matcher1.format({ foo: "~abc" })).toBe("/~~abc");
-    expect(matcher1.format({ foo: "~2F" })).toBe("/~~2F");
-
-    expect(matcher1.exec("/abc").foo).toBe("abc");
-    expect(matcher1.exec("/~~abc").foo).toBe("~abc");
-    expect(matcher1.exec("/~~2F").foo).toBe("~2F");
-  });
-
   describe("snake-case parameters", () => {
     it("should match if properly formatted", () => {
       const matcher = $url.compile(

package/src/router/view-scroll.js

@@ -1,3 +1,5 @@
+import { $injectTokens as $t } from "../injection-tokens.js";
+
 export class ViewScrollProvider {
   constructor() {
     this.enabled = false;
@@ -8,7 +10,7 @@ export class ViewScrollProvider {
   }
 
   $get = [
-    "$anchorScroll",
+    $t.$anchorScroll,
     /**
      * @param {import('../services/anchor-scroll.js').AnchorScrollObject} $anchorScroll
      * @returns {import('../services/anchor-scroll.js').AnchorScrollObject|Function}

package/src/router/view-scroll.spec.js

@@ -4,7 +4,7 @@ import { wait } from "../shared/test-utils.js";
 
 describe("ngView", () => {
   describe("scrollIntoView", () => {
-    let elem, $anchorScroll, $ngViewScroll;
+    let elem, $anchorScroll, $viewScroll;
 
     beforeEach(() => {
       dealoc(document.getElementById("app"));
@@ -14,15 +14,15 @@ describe("ngView", () => {
         "defaultModule",
       ]);
 
-      $injector.invoke((_$ngViewScroll_, _$anchorScroll_) => {
+      $injector.invoke((_$viewScroll_, _$anchorScroll_) => {
         $anchorScroll = _$anchorScroll_;
-        $ngViewScroll = _$ngViewScroll_;
+        $viewScroll = _$viewScroll_;
       });
       elem = [{ scrollIntoView: jasmine.createSpy("scrollIntoView") }];
     });
 
     it("should scroll element into view after timeout", async () => {
-      $ngViewScroll(elem[0]);
+      $viewScroll(elem[0]);
       expect(elem[0].scrollIntoView).not.toHaveBeenCalled();
 
       await wait(100);
@@ -31,7 +31,7 @@ describe("ngView", () => {
 
     it("should return the promise from the timeout", async () => {
       dealoc(document.getElementById("app"));
-      const promise = $ngViewScroll(elem[0]);
+      const promise = $viewScroll(elem[0]);
 
       await wait(10);
       expect(elem[0].scrollIntoView).toHaveBeenCalled();
@@ -40,32 +40,32 @@ describe("ngView", () => {
   });
 
   describe("useAnchorScroll", () => {
-    let elem, $anchorScroll, $ngViewScroll;
+    let elem, $anchorScroll, $viewScroll;
 
     beforeEach(() => {
       dealoc(document.getElementById("app"));
       window.angular = new Angular();
       let module = window.angular.module("defaultModule", []);
-      module.config(($provide, $ngViewScrollProvider) => {
+      module.config(($provide, $viewScrollProvider) => {
         $provide.decorator("$anchorScroll", function ($delegate) {
           return jasmine.createSpy("$anchorScroll");
         });
-        $ngViewScrollProvider.useAnchorScroll();
+        $viewScrollProvider.useAnchorScroll();
       });
 
       let $injector = window.angular.bootstrap(document.getElementById("app"), [
         "defaultModule",
       ]);
 
-      $injector.invoke((_$ngViewScroll_, _$anchorScroll_) => {
+      $injector.invoke((_$viewScroll_, _$anchorScroll_) => {
         $anchorScroll = _$anchorScroll_;
-        $ngViewScroll = _$ngViewScroll_;
+        $viewScroll = _$viewScroll_;
       });
       elem = [{ scrollIntoView: jasmine.createSpy("scrollIntoView") }];
     });
 
     it("should call $anchorScroll", () => {
-      $ngViewScroll();
+      $viewScroll();
       expect($anchorScroll).toHaveBeenCalled();
     });
   });

package/src/services/location/location.js

@@ -92,8 +92,15 @@ export class Location {
    */
   setUrl(url) {
     const match = PATH_MATCH.exec(url);
-    if (match[1] || url === "") this.setPath(decodeURIComponent(match[1]));
-    if (match[2] || match[1] || url === "") this.setSearch(match[3] || "");
+
+    if (match[1] !== undefined || url === "") {
+      this.setPath(match[1] || "");
+    }
+
+    if (match[2] !== undefined || match[1] !== undefined || url === "") {
+      this.setSearch(match[3] || "");
+    }
+
     this.setHash(match[5] || "");
 
     return this;

package/src/services/location/location.spec.js

@@ -529,6 +529,12 @@ describe("$location", () => {
         locationUrl.setSearch({ "a+b": "c+d" });
         expect(locationUrl.getSearch()).toEqual({ "a+b": "c+d" });
       });
+
+      fit("should not drop encodings on already enconded params", () => {
+        const locationUrl = createLocationHtml5Url();
+        locationUrl.setUrl("/path/foo%2Fbar/baz%2Fqux");
+        expect(locationUrl.getPath()).toEqual("/path/foo%2Fbar/baz%2Fqux");
+      });
     });
   });
 

package/src/shared/common.js

@@ -1,5 +1,5 @@
 import { isDate, isFunction, isRegExp, isString } from "./utils.js";
-import { all, curry } from "./hof.js";
+import { curry } from "./hof.js";
 
 export function equals(o1, o2) {
   if (o1 === o2) return true;
@@ -9,10 +9,10 @@ export function equals(o1, o2) {
     t2 = typeof o2;
   if (t1 !== t2 || t1 !== "object") return false;
   const tup = [o1, o2];
-  if (all(Array.isArray)(tup)) return _arraysEq(o1, o2);
-  if (all(isDate)(tup)) return o1.getTime() === o2.getTime();
-  if (all(isRegExp)(tup)) return o1.toString() === o2.toString();
-  if (all(isFunction)(tup)) return true; // meh
+  if (tup.every(Array.isArray)) return _arraysEq(o1, o2);
+  if (tup.every(isDate)) return o1.getTime() === o2.getTime();
+  if (tup.every(isRegExp)) return o1.toString() === o2.toString();
+  if (tup.every(isFunction)) return true; // meh
   if ([isFunction, Array.isArray, isDate, isRegExp].some((fn) => !!fn(tup))) {
     return false;
   }

package/src/shared/hof.js

@@ -96,20 +96,6 @@ export const parse = (name) =>
     name.split(".").map((name) => (obj) => obj && obj[name]),
   );
 
-/**
- * Given two functions that return truthy or falsey values, returns a function that returns truthy
- * if at least one of the functions returns truthy for the given arguments
- */
-export function or(fn1, fn2) {
-  return (...args) => fn1.apply(null, args) || fn2.apply(null, args);
-}
-/**
- * Check if all the elements of an array match a predicate function
- *
- * @param fn1 a predicate function `fn1`
- * @returns a function which takes an array and returns true if `fn1` is true for all elements of the array
- */
-export const all = (fn1) => (arr) => arr.reduce((b, x) => b && !!fn1(x), true);
 /** Given a class, returns a Predicate function that returns true if the object is of that class */
 export const is = (ctor) => (obj) =>
   (obj != null && obj.constructor === ctor) || obj instanceof ctor;