@angular-wave/angular.ts 0.0.22 → 0.0.24

package/test/router/view-hook.spec.js

@@ -0,0 +1,217 @@
+import { dealoc } from "../../src/jqLite";
+import { Angular } from "../../src/loader";
+import { publishExternalAPI } from "../../src/public";
+import { wait } from "../test-utils";
+
+describe("view hooks", () => {
+  let app,
+    $state,
+    $q,
+    $timeout,
+    log = "";
+  class ctrl {
+    constructor() {
+      this.data = "DATA";
+    }
+  }
+
+  const component = {
+    bindings: { cmpdata: "<" },
+    template: "{{$ctrl.cmpdata}}",
+  };
+
+  beforeEach(() => {
+    dealoc(document.getElementById("dummy"));
+    window.angular = new Angular();
+    publishExternalAPI();
+    app = window.angular
+      .module("defaultModule", ["ui.router"])
+      .config(($stateProvider) => {
+        $stateProvider.state({ name: "foo", url: "/foo", component: "foo" });
+        $stateProvider.state({ name: "bar", url: "/bar", component: "bar" });
+        $stateProvider.state({ name: "baz", url: "/baz", component: "baz" });
+        $stateProvider.state({ name: "redirect", redirectTo: "baz" });
+      })
+      .component(
+        "foo",
+        Object.assign({}, Object.assign(component, { controller: ctrl })),
+      )
+      .component("bar", Object.assign({}, component))
+      .component("baz", Object.assign({}, component));
+
+    let $injector = window.angular.bootstrap(document.getElementById("dummy"), [
+      "defaultModule",
+    ]);
+
+    $injector.invoke((_$state_, _$q_, _$timeout_, $compile, $rootScope) => {
+      $state = _$state_;
+      $q = _$q_;
+      $timeout = _$timeout_;
+      $compile("<div><ui-view></ui-view></div>")($rootScope.$new());
+    });
+  });
+
+  describe("uiCanExit", () => {
+    beforeEach(() => {
+      log = "";
+    });
+
+    const initial = async () => {
+      $state.go("foo");
+      await wait(10);
+      expect(log).toBe("");
+      expect($state.current.name).toBe("foo");
+    };
+
+    it("can cancel a transition that would exit the view's state by returning false", async () => {
+      $state.defaultErrorHandler(function () {});
+      ctrl.prototype.uiCanExit = function () {
+        log += "canexit;";
+        return false;
+      };
+      await initial();
+      $state.go("bar");
+      expect(log).toBe("canexit;");
+      expect($state.current.name).toBe("foo");
+    });
+
+    it("can allow the transition by returning true", async () => {
+      ctrl.prototype.uiCanExit = function () {
+        log += "canexit;";
+        return true;
+      };
+      await initial();
+
+      $state.go("bar");
+      await wait(10);
+      expect(log).toBe("canexit;");
+      expect($state.current.name).toBe("bar");
+    });
+
+    it("can allow the transition by returning nothing", async () => {
+      ctrl.prototype.uiCanExit = function () {
+        log += "canexit;";
+      };
+      await initial();
+
+      $state.go("bar");
+      await wait(10);
+      expect(log).toBe("canexit;");
+      expect($state.current.name).toBe("bar");
+    });
+
+    it("can redirect the transition", async () => {
+      ctrl.prototype.uiCanExit = function (trans) {
+        log += "canexit;";
+        return trans.router.stateService.target("baz");
+      };
+      await initial();
+
+      $state.go("bar");
+      await wait(10);
+      expect(log).toBe("canexit;");
+      expect($state.current.name).toBe("baz");
+    });
+
+    it("can cancel the transition by returning a rejected promise", async () => {
+      ctrl.prototype.uiCanExit = function () {
+        log += "canexit;";
+        return $q.reject("nope");
+      };
+      await initial();
+
+      $state.defaultErrorHandler(function () {});
+      $state.go("bar");
+      await wait(10);
+      expect(log).toBe("canexit;");
+      expect($state.current.name).toBe("foo");
+    });
+
+    it("can wait for a promise and then reject the transition", async () => {
+      $state.defaultErrorHandler(function () {});
+      ctrl.prototype.uiCanExit = function () {
+        log += "canexit;";
+        return $timeout(() => {
+          log += "delay;";
+          return false;
+        }, 1);
+      };
+      await initial();
+
+      $state.go("bar");
+      await wait(10);
+      expect(log).toBe("canexit;delay;");
+      expect($state.current.name).toBe("foo");
+    });
+
+    it("can wait for a promise and then allow the transition", async () => {
+      ctrl.prototype.uiCanExit = function () {
+        log += "canexit;";
+        return $timeout(() => {
+          log += "delay;";
+        }, 1);
+      };
+      await initial();
+
+      $state.go("bar");
+      await wait(10);
+      expect(log).toBe("canexit;delay;");
+      expect($state.current.name).toBe("bar");
+    });
+
+    it("has 'this' bound to the controller", async () => {
+      ctrl.prototype.uiCanExit = function () {
+        log += this.data;
+      };
+      await initial();
+
+      $state.go("bar");
+      await wait(10);
+      expect(log).toBe("DATA");
+      expect($state.current.name).toBe("bar");
+    });
+
+    it("receives the new Transition as the first argument", async () => {
+      const _state = $state;
+      ctrl.prototype.uiCanExit = function (trans) {
+        log += "canexit;";
+        expect(typeof trans.treeChanges).toBe("function");
+        expect(trans.injector().get("$state")).toBe(_state);
+      };
+      await initial();
+
+      $state.go("bar");
+      await wait(10);
+      expect(log).toBe("canexit;");
+      expect($state.current.name).toBe("bar");
+    });
+
+    // Test for https://github.com/angular-ui/ui-router/issues/3308
+    it("should trigger once when answered truthy even if redirected", async () => {
+      ctrl.prototype.uiCanExit = function () {
+        log += "canexit;";
+        return true;
+      };
+      await initial();
+
+      $state.go("redirect");
+      await wait(10);
+      expect(log).toBe("canexit;");
+      expect($state.current.name).toBe("baz");
+    });
+
+    // Test for https://github.com/angular-ui/ui-router/issues/3308
+    it("should trigger only once if returns a redirect", async () => {
+      ctrl.prototype.uiCanExit = function () {
+        log += "canexit;";
+        return $state.target("bar");
+      };
+      await initial();
+
+      $state.go("redirect");
+      await wait(10);
+      expect(log).toBe("canexit;");
+      expect($state.current.name).toBe("bar");
+    });
+  });
+});

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

@@ -0,0 +1,77 @@
+import { dealoc } from "../../src/jqLite";
+import { Angular } from "../../src/loader";
+import { publishExternalAPI } from "../../src/public";
+import { wait } from "../test-utils";
+
+describe("uiView", () => {
+  describe("scrollIntoView", () => {
+    let elem, $anchorScroll, $uiViewScroll, $timeout;
+
+    beforeEach(() => {
+      dealoc(document.getElementById("dummy"));
+      window.angular = new Angular();
+      publishExternalAPI();
+      window.angular.module("defaultModule", ["ui.router"]);
+      let $injector = window.angular.bootstrap(
+        document.getElementById("dummy"),
+        ["defaultModule"],
+      );
+
+      $injector.invoke((_$uiViewScroll_, _$timeout_, _$anchorScroll_) => {
+        $anchorScroll = _$anchorScroll_;
+        $uiViewScroll = _$uiViewScroll_;
+        $timeout = _$timeout_;
+      });
+      elem = [{ scrollIntoView: jasmine.createSpy("scrollIntoView") }];
+    });
+
+    it("should scroll element into view after timeout", async () => {
+      $uiViewScroll(elem);
+      expect(elem[0].scrollIntoView).not.toHaveBeenCalled();
+
+      await wait(10);
+      expect(elem[0].scrollIntoView).toHaveBeenCalled();
+    });
+
+    it("should return the promise from the timeout", async () => {
+      const promise = $uiViewScroll(elem);
+
+      await wait(10);
+      expect(elem[0].scrollIntoView).toHaveBeenCalled();
+      expect(promise).toBeDefined();
+    });
+  });
+
+  describe("useAnchorScroll", () => {
+    let elem, $anchorScroll, $uiViewScroll;
+
+    beforeEach(() => {
+      dealoc(document.getElementById("dummy"));
+      window.angular = new Angular();
+      publishExternalAPI();
+      let module = window.angular.module("defaultModule", ["ui.router"]);
+      module.config(($provide, $uiViewScrollProvider) => {
+        $provide.decorator("$anchorScroll", function ($delegate) {
+          return jasmine.createSpy("$anchorScroll");
+        });
+        $uiViewScrollProvider.useAnchorScroll();
+      });
+
+      let $injector = window.angular.bootstrap(
+        document.getElementById("dummy"),
+        ["defaultModule"],
+      );
+
+      $injector.invoke((_$uiViewScroll_, _$anchorScroll_) => {
+        $anchorScroll = _$anchorScroll_;
+        $uiViewScroll = _$uiViewScroll_;
+      });
+      elem = [{ scrollIntoView: jasmine.createSpy("scrollIntoView") }];
+    });
+
+    it("should call $anchorScroll", () => {
+      $uiViewScroll();
+      expect($anchorScroll).toHaveBeenCalled();
+    });
+  });
+});

package/test/router/view.spec.js

@@ -0,0 +1,117 @@
+import { dealoc } from "../../src/jqLite";
+import { Angular } from "../../src/loader";
+import { publishExternalAPI } from "../../src/public";
+import { curry } from "../../src/shared/hof";
+import { StateMatcher } from "../../src/router/state/state-matcher";
+import { StateBuilder } from "../../src/router/state/state-builder";
+import { StateObject } from "../../src/router/state/state-object";
+import { ViewService } from "../../src/router/view/view";
+import {
+  ng1ViewsBuilder,
+  getNg1ViewConfigFactory,
+} from "../../src/router/state/views";
+import { PathNode } from "../../src/router/path/path-node";
+import { PathUtils } from "../../src/router/path/path-utils";
+import { tail } from "../../src/shared/common";
+import { wait } from "../test-utils";
+
+describe("view", () => {
+  let scope,
+    $compile,
+    $injector,
+    elem,
+    $controllerProvider,
+    $urlMatcherFactoryProvider,
+    $view,
+    $q;
+  let root, states;
+
+  beforeEach(() => {
+    dealoc(document.getElementById("dummy"));
+    window.angular = new Angular();
+    publishExternalAPI();
+
+    window.angular
+      .module("defaultModule", ["ui.router"])
+      .config(
+        function (
+          _$provide_,
+          _$controllerProvider_,
+          _$urlMatcherFactoryProvider_,
+        ) {
+          _$provide_.factory("foo", () => {
+            return "Foo";
+          });
+          $controllerProvider = _$controllerProvider_;
+          $urlMatcherFactoryProvider = _$urlMatcherFactoryProvider_;
+        },
+      );
+    $injector = window.angular.bootstrap(document.getElementById("dummy"), [
+      "defaultModule",
+    ]);
+
+    $injector.invoke(($rootScope, _$compile_, _$injector_, _$view_, _$q_) => {
+      scope = $rootScope.$new();
+      $compile = _$compile_;
+      $injector = _$injector_;
+      elem = angular.element("<div>");
+
+      states = {};
+      const matcher = new StateMatcher(states);
+      const stateBuilder = new StateBuilder(
+        matcher,
+        $urlMatcherFactoryProvider,
+      );
+      stateBuilder.builder("views", ng1ViewsBuilder);
+      register = registerState(states, stateBuilder);
+      root = register({ name: "" });
+      $q = _$q_;
+      $view = _$view_;
+    });
+  });
+
+  let register;
+  const registerState = curry(function (_states, stateBuilder, config) {
+    const state = StateObject.create(config);
+    const built = stateBuilder.build(state);
+    return (_states[built.name] = built);
+  });
+
+  describe("controller handling", () => {
+    let state, path, ctrlExpression;
+    beforeEach(() => {
+      ctrlExpression = null;
+      const stateDeclaration = {
+        name: "foo",
+        template: "test",
+        controllerProvider: [
+          "foo",
+          function (/* $stateParams, */ foo) {
+            // todo: reimplement localized $stateParams
+            ctrlExpression =
+              /* $stateParams.type + */ foo + "Controller as foo";
+            return ctrlExpression;
+          },
+        ],
+      };
+
+      state = register(stateDeclaration);
+      const $view = new ViewService(null);
+      $view._pluginapi._viewConfigFactory("ng1", getNg1ViewConfigFactory());
+
+      const _states = [root, state];
+      path = _states.map((_state) => new PathNode(_state));
+      PathUtils.applyViewConfigs($view, path, _states);
+    });
+
+    it("uses the controllerProvider to get controller dynamically", async () => {
+      $controllerProvider.register("AcmeFooController", () => {});
+      elem.append($compile("<div><ui-view></ui-view></div>")(scope));
+
+      const view = tail(path).views[0];
+      view.load();
+      await wait(10);
+      expect(ctrlExpression).toEqual("FooController as foo");
+    });
+  });
+});

package/test/test-utils.js

@@ -1,11 +1,20 @@
 import { jqLite } from "../src/jqLite";
 
+/**
+ * @param {HTMLElement} element
+ * @param {string} event
+ */
 export function browserTrigger(element, event) {
   jqLite(element)[0].dispatchEvent(
     new Event(event, { bubbles: true, cancelable: true }),
   );
 }
 
+/**
+ *
+ * @param {number} t milliseconds to wait
+ * @returns
+ */
 export function wait(t) {
   return new Promise((resolve, _) => setTimeout(resolve, t));
 }

package/types/router/legacy/resolveService.d.ts

@@ -1,5 +1,5 @@
 /** @publicapi @module ng1 */ /** */
-import { Obj } from "./core";
+import { Obj } from "../core";
 /** @hidden */
 export declare const resolveFactory: () => {
   /**

package/types/router/statebuilders/onEnterExitRetain.d.ts

@@ -1,5 +1,5 @@
 /** @publicapi @module ng1 */ /** */
-import { StateObject, TransitionStateHookFn } from "./core";
+import { StateObject, TransitionStateHookFn } from "../core";
 /**
  * This is a [[StateBuilder.builder]] function for angular1 `onEnter`, `onExit`,
  * `onRetain` callback hooks on a [[Ng1StateDeclaration]].

package/types/router/statebuilders/views.d.ts

@@ -1,4 +1,3 @@
-/** @publicapi @module ng1 */ /** */
 import {
   StateObject,
   ViewConfig,
@@ -6,7 +5,7 @@ import {
   PathNode,
   ResolveContext,
   IInjectable,
-} from "./core";
+} from "../core";
 import { Ng1ViewDeclaration } from "../interface";
 import { TemplateFactory } from "../templateFactory";
 /** @internalapi */