@angular-wave/angular.ts 0.0.22 → 0.0.23

package/index.html

@@ -103,8 +103,12 @@
       <script type="module" src="test/router/state-directives.spec.js"></script>
       <script type="module" src="test/router/state-filter.spec.js"></script>
       <script type="module" src="test/router/state.spec.js"></script>
-      
-    
+      <script type="module" src="test/router/template-factory.spec.js"></script>
+      <script type="module" src="test/router/url-matcher-factory.spec.js"></script>
+      <script type="module" src="test/router/view-directive.spec.js"></script>
+      <script type="module" src="test/router/view-hook.spec.js"></script>
+      <script type="module" src="test/router/view-scroll.spec.js"></script>
+      <script type="module" src="test/router/view.spec.js"></script>
 
       <!-- Run asyncs last to prevent digest polution-->
       <script type="module" src="test/core/interval.spec.js"></script>

package/package.json

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

package/src/filters/order-by.js

@@ -12,7 +12,7 @@ orderByFilter.$inject = ["$parse"];
 
 /**
  *
- * @param {angular.IFilterOrderBy} $parse
+ * @param {angular.IParseService} $parse
  * @returns
  */
 export function orderByFilter($parse) {
@@ -90,12 +90,12 @@ export function orderByFilter($parse) {
           predicate = predicate.substring(1);
         }
         if (predicate !== "") {
-          get = $parse(predicate);
-          if (get.constant) {
-            const key = get();
-            get = function (value) {
-              return value[key];
-            };
+          let parsed = $parse(predicate);
+          if (parsed.constant) {
+            const key = parsed();
+            get = (value) => value[key];
+          } else {
+            get = parsed;
           }
         }
       }
@@ -130,7 +130,7 @@ export function orderByFilter($parse) {
   }
 
   function getPredicateValue(value, index) {
-    let type = typeof value;
+    /** @type {String} */ let type = typeof value;
     if (value === null) {
       type = "null";
     } else if (type === "object") {

package/src/router/directives/viewDirective.js

@@ -143,18 +143,10 @@ export let uiView = [
     function getRenderer() {
       return {
         enter: function (element, target, cb) {
-          // if (angular.version.minor > 2) {
-          //$animate.enter(element, null, target).then(cb);
-          // } else {
-          $animate.enter(element, null, target, cb);
-          // }
+          $animate.enter(element, null, target).then(cb);
         },
         leave: function (element, cb) {
-          // if (angular.version.minor > 2) {
-          //$animate.leave(element).then(cb);
-          // } else {
-          $animate.leave(element, cb);
-          // }
+          $animate.leave(element).then(cb);
         },
       };
     }
@@ -273,7 +265,7 @@ export let uiView = [
             const cloned = $transclude(newScope, function (clone) {
               clone.data("$uiViewAnim", $uiViewAnim);
               clone.data("$uiView", $uiViewData);
-              renderer.enter(clone, $element, function onUIViewEnter() {
+              renderer.enter(clone, $element, function () {
                 animEnter.resolve();
                 if (currentScope)
                   currentScope.$emit("$viewContentAnimationEnded");

package/src/router/stateProvider.js

@@ -5,14 +5,20 @@ import { createProxyFunctions } from "../shared/common";
 import { minErr } from "../shared/utils";
 
 const err = minErr("$stateProvider");
+// Right now this is a collection of all the properties we encounter in tests
 const validKeys = [
   "$$state",
   "__stateObjectCache",
+  "abstract",
+  "bindings",
   "controller",
+  "controllerAs",
   "controllerProvider",
   "component",
+  "componentProvider",
   "data",
   "includes",
+  "lazyLoad",
   "name",
   "navigable",
   "onEnter",
@@ -21,8 +27,10 @@ const validKeys = [
   "params",
   "parent",
   "path",
+  "redirectTo",
   "reloadOnSearch",
   "resolve",
+  "resolveAs",
   "resolvables",
   "self",
   "template",

package/src/router/templateFactory.js

@@ -10,15 +10,13 @@ import { kebobString } from "../shared/strings";
  */
 export class TemplateFactory {
   constructor() {
-    /** @hidden */ this.$get = [
+    this._useHttp = false;
+    this.$get = [
       "$http",
       "$templateCache",
-      "$injector",
-      ($http, $templateCache, $injector) => {
-        this.$templateRequest =
-          $injector.has &&
-          $injector.has("$templateRequest") &&
-          $injector.get("$templateRequest");
+      "$templateRequest",
+      ($http, $templateCache, $templateRequest) => {
+        this.$templateRequest = $templateRequest;
         this.$http = $http;
         this.$templateCache = $templateCache;
         return this;
@@ -26,6 +24,14 @@ export class TemplateFactory {
     ];
   }
 
+  /**
+   * Forces the provider to use $http service directly
+   * @param {boolean} value
+   */
+  useHttpService(value) {
+    this._useHttp = value;
+  }
+
   /**
    * Creates a template from a configuration object.
    *

package/src/router/transition/transition.js

@@ -358,7 +358,11 @@ export class Transition {
       : new Resolvable(resolvable);
     const stateName = typeof state === "string" ? state : state.name;
     const topath = this._treeChanges.to;
-    const targetNode = find(topath, (node) => node.state.name === stateName);
+    const targetNode = find(topath, (node) => {
+      return node.state.name === stateName;
+    });
+    console.assert(targetNode, `targetNode not found ${stateName}`);
+
     const resolveContext = new ResolveContext(topath);
     resolveContext.addResolvables([resolvable], targetNode.state);
   }

package/src/router/url/urlRule.js

@@ -20,6 +20,13 @@ export class UrlRuleFactory {
   compile(str) {
     return this.router.urlMatcherFactory.compile(str);
   }
+
+  /**
+   *
+   * @param {*} what
+   * @param {*} handler
+   * @returns {BaseUrlRule}
+   */
   create(what, handler) {
     const { isState, isStateDeclaration } = StateObject;
     const makeRule = pattern([
@@ -193,12 +200,13 @@ UrlRuleFactory.isUrlRule = (obj) =>
  * A base rule which calls `match`
  *
  * The value from the `match` function is passed through to the `handler`.
- * @internal
+ * @type {angular.BaseUrlRule}
  */
 export class BaseUrlRule {
   constructor(match, handler) {
     this.match = match;
     this.type = "RAW";
+    this.$id = -1;
     this.matchPriority = () => 0 - this.$id;
     this.handler = handler || identity;
   }

package/src/services/browser.js

@@ -5,18 +5,11 @@ import { forEach, isUndefined, equals } from "../shared/utils";
 // This variable should be used *only* inside the cacheState function.
 let lastCachedState = null;
 
-export function getHash(url) {
-  const index = url.indexOf("#");
-  return index === -1 ? "" : url.substr(index);
-}
-
 export function trimEmptyHash(url) {
   return url.replace(/#$/, "");
 }
 
 /**
- *
- *
  * @name $browser
  * @requires $log
  * @description
@@ -32,8 +25,6 @@ export function trimEmptyHash(url) {
  */
 export function Browser($log, $$taskTrackerFactory) {
   const self = this;
-  let { location } = window;
-  let { history } = window;
   const { setTimeout } = window;
   const { clearTimeout } = window;
   const pendingDeferIds = {};
@@ -56,10 +47,8 @@ export function Browser($log, $$taskTrackerFactory) {
 
   let cachedState;
   let lastHistoryState;
-  let lastBrowserUrl = location.href;
-  const baseElement = jqLite(
-    Array.from(window.document.getElementsByTagName("base")),
-  );
+  let lastBrowserUrl = window.location.href;
+  const baseElement = jqLite(Array.from(document.getElementsByTagName("base")));
   let pendingLocation = null;
   const getCurrentState = function getCurrentState() {
     return history.state;
@@ -96,10 +85,6 @@ export function Browser($log, $$taskTrackerFactory) {
       state = null;
     }
 
-    // Android Browser BFCache causes location, history reference to become stale.
-    if (location !== window.location) location = window.location;
-    if (history !== window.history) history = window.history;
-
     // setter
     if (url) {
       const sameState = lastHistoryState === state;
@@ -129,7 +114,7 @@ export function Browser($log, $$taskTrackerFactory) {
     // - pendingLocation is needed as browsers don't allow to read out
     //   the new location.href if a reload happened or if there is a bug like in iOS 9 (see
     //   https://openradar.appspot.com/22186109).
-    return trimEmptyHash(pendingLocation || location.href);
+    return trimEmptyHash(pendingLocation || window.location.href);
   };
 
   /**

package/test/router/ng-state-builder.spec.js

@@ -0,0 +1,81 @@
+import { StateBuilder } from "../../src/router/state/stateBuilder";
+
+describe("Ng1 StateBuilder", function () {
+  const parent = { name: "" };
+  let builder,
+    matcher,
+    urlMatcherFactoryProvider = {
+      compile: function () {},
+      isMatcher: function () {},
+    };
+
+  beforeEach(function () {
+    matcher = new StateBuilder({});
+    builder = new StateBuilder(matcher, urlMatcherFactoryProvider);
+    builder.builder("views", ng1ViewsBuilder);
+  });
+
+  it("should use the state object to build a default view, when no `views` property is found", function () {
+    const config = {
+      url: "/foo",
+      templateUrl: "/foo.html",
+      controller: "FooController",
+      parent: parent,
+    };
+    const built = builder.builder("views")(config);
+
+    expect(built.$default).not.toEqual(config);
+    expect(built.$default).toEqual(
+      expect.objectContaining({
+        templateUrl: "/foo.html",
+        controller: "FooController",
+        resolveAs: "$resolve",
+      }),
+    );
+  });
+
+  it("It should use the views object to build views, when defined", function () {
+    const config = { a: { foo: "bar", controller: "FooController" } };
+    const builtViews = builder.builder("views")({
+      parent: parent,
+      views: config,
+    });
+    expect(builtViews.a.foo).toEqual(config.a.foo);
+    expect(builtViews.a.controller).toEqual(config.a.controller);
+  });
+
+  it("should not allow a view config with both component and template keys", inject(function (
+    $injector,
+  ) {
+    const config = {
+      name: "foo",
+      url: "/foo",
+      template: "<h1>hey</h1>",
+      controller: "FooController",
+      parent: parent,
+    };
+    expect(() => builder.builder("views")(config)).not.toThrow();
+    expect(() =>
+      builder.builder("views")(
+        Object.assign({ component: "fooComponent" }, config),
+      ),
+    ).toThrow();
+    expect(() =>
+      builder.builder("views")(
+        Object.assign({ componentProvider: () => "fooComponent" }, config),
+      ),
+    ).toThrow();
+    expect(() =>
+      builder.builder("views")(Object.assign({ bindings: {} }, config)),
+    ).toThrow();
+  }));
+
+  it("should replace a resolve: string value with a function that injects the service of the same name", inject(function (
+    $injector,
+  ) {
+    const config = { resolve: { foo: "bar" } };
+    expect(builder.builder("resolvables")).toBeDefined();
+    const built = builder.builder("resolvables")(config);
+    expect(built[0].deps).toEqual(["bar"]);
+  }));
+});

package/test/router/services.spec.js

@@ -19,7 +19,6 @@ describe("router services", () => {
         $transitionsProvider,
         $stateProvider,
       ) => {
-        debugger;
         $routerProvider = _$routerProvider_;
         expect($routerProvider["router"]).toBe($routerProvider);
         providers = {