@angular-wave/angular.ts 0.0.21 → 0.0.22

package/src/router/hooks/resolve.js

@@ -1,4 +1,3 @@
-import { noop } from "../../shared/common";
 import { ResolveContext } from "../resolve/resolveContext";
 import { val } from "../../shared/hof";
 export const RESOLVE_HOOK_PRIORITY = 1000;
@@ -14,7 +13,7 @@ export const RESOLVE_HOOK_PRIORITY = 1000;
 const eagerResolvePath = (trans) =>
   new ResolveContext(trans.treeChanges().to)
     .resolvePath("EAGER", trans)
-    .then(noop);
+    .then(() => {});
 export const registerEagerResolvePath = (transitionService) =>
   transitionService.onStart({}, eagerResolvePath, {
     priority: RESOLVE_HOOK_PRIORITY,
@@ -32,7 +31,7 @@ const lazyResolveState = (trans, state) =>
   new ResolveContext(trans.treeChanges().to)
     .subContext(state.$$state())
     .resolvePath("LAZY", trans)
-    .then(noop);
+    .then(() => {});
 export const registerLazyResolveState = (transitionService) =>
   transitionService.onEnter({ entering: val(true) }, lazyResolveState, {
     priority: RESOLVE_HOOK_PRIORITY,
@@ -50,7 +49,7 @@ export const registerLazyResolveState = (transitionService) =>
 const resolveRemaining = (trans) =>
   new ResolveContext(trans.treeChanges().to)
     .resolvePath("LAZY", trans)
-    .then(noop);
+    .then(() => {});
 export const registerResolveRemaining = (transitionService) =>
   transitionService.onFinish({}, resolveRemaining, {
     priority: RESOLVE_HOOK_PRIORITY,

package/src/router/hooks/views.js

@@ -1,4 +1,3 @@
-import { noop } from "../../shared/common";
 import { services } from "../common/coreservices";
 /**
  * A [[TransitionHookFn]] which waits for the views to load
@@ -12,7 +11,9 @@ const loadEnteringViews = (transition) => {
   const $q = services.$q;
   const enteringViews = transition.views("entering");
   if (!enteringViews.length) return;
-  return $q.all(enteringViews.map((view) => $q.when(view.load()))).then(noop);
+  return $q
+    .all(enteringViews.map((view) => $q.when(view.load())))
+    .then(() => {});
 };
 export const registerLoadEnteringViews = (transitionService) =>
   transitionService.onFinish({}, loadEnteringViews);

package/src/router/state/stateService.js

@@ -2,7 +2,6 @@ import {
   createProxyFunctions,
   defaults,
   inArray,
-  noop,
   removeFrom,
   silenceUncaughtInPromise,
   silentRejection,
@@ -86,7 +85,7 @@ export class StateService {
   }
 
   dispose() {
-    this.defaultErrorHandler(noop);
+    this.defaultErrorHandler(() => {});
     this.invalidCallbacks = [];
   }
   /**

package/src/router/transition/interface.js

@@ -1,14 +1,14 @@
-var TransitionHookPhase;
-(function (TransitionHookPhase) {
-  TransitionHookPhase[(TransitionHookPhase["CREATE"] = 0)] = "CREATE";
-  TransitionHookPhase[(TransitionHookPhase["BEFORE"] = 1)] = "BEFORE";
-  TransitionHookPhase[(TransitionHookPhase["RUN"] = 2)] = "RUN";
-  TransitionHookPhase[(TransitionHookPhase["SUCCESS"] = 3)] = "SUCCESS";
-  TransitionHookPhase[(TransitionHookPhase["ERROR"] = 4)] = "ERROR";
-})(TransitionHookPhase || (TransitionHookPhase = {}));
-var TransitionHookScope;
-(function (TransitionHookScope) {
-  TransitionHookScope[(TransitionHookScope["TRANSITION"] = 0)] = "TRANSITION";
-  TransitionHookScope[(TransitionHookScope["STATE"] = 1)] = "STATE";
-})(TransitionHookScope || (TransitionHookScope = {}));
-export { TransitionHookPhase, TransitionHookScope };
+/** An object for Transition Hook Phases */
+export const TransitionHookPhase = {
+  CREATE: 0,
+  BEFORE: 1,
+  RUN: 2,
+  SUCCESS: 3,
+  ERROR: 4,
+};
+
+/** An object for Transition Hook Scopes */
+export const TransitionHookScope = {
+  TRANSITION: 0,
+  STATE: 1,
+};

package/src/router/transition/rejectFactory.js

@@ -1,47 +1,56 @@
 import { silentRejection } from "../../shared/common";
 import { stringify } from "../../shared/strings";
 import { is } from "../../shared/hof";
-/** An enum for Transition Rejection reasons */
-var RejectType;
-(function (RejectType) {
+
+/**
+ * An object for Transition Rejection reasons.
+ * @enum {number}
+ */
+export const RejectType = {
   /**
    * A new transition superseded this one.
    *
    * While this transition was running, a new transition started.
-   * This transition is cancelled because it was superseded by new transition.
+   * This transition is cancelled because it was superseded by a new transition.
+   * @type {number}
    */
-  RejectType[(RejectType["SUPERSEDED"] = 2)] = "SUPERSEDED";
+  SUPERSEDED: 2,
+
   /**
-   * The transition was aborted
+   * The transition was aborted.
    *
-   * The transition was aborted by a hook which returned `false`
+   * The transition was aborted by a hook which returned `false`.
+   * @type {number}
    */
-  RejectType[(RejectType["ABORTED"] = 3)] = "ABORTED";
+  ABORTED: 3,
+
   /**
-   * The transition was invalid
+   * The transition was invalid.
    *
-   * The transition was never started because it was invalid
+   * The transition was never started because it was invalid.
+   * @type {number}
    */
-  RejectType[(RejectType["INVALID"] = 4)] = "INVALID";
+  INVALID: 4,
+
   /**
-   * The transition was ignored
+   * The transition was ignored.
    *
    * The transition was ignored because it would have no effect.
-   *
    * Either:
-   *
-   * - The transition is targeting the current state and parameter values
+   * - The transition is targeting the current state and parameter values.
    * - The transition is targeting the same state and parameter values as the currently running transition.
+   * @type {number}
    */
-  RejectType[(RejectType["IGNORED"] = 5)] = "IGNORED";
+  IGNORED: 5,
+
   /**
    * The transition errored.
    *
-   * This generally means a hook threw an error or returned a rejected promise
+   * This generally means a hook threw an error or returned a rejected promise.
+   * @type {number}
    */
-  RejectType[(RejectType["ERROR"] = 6)] = "ERROR";
-})(RejectType || (RejectType = {}));
-export { RejectType };
+  ERROR: 6,
+};
 
 let id = 0;
 export class Rejection {

package/src/router/transition/transitionHook.js

@@ -1,5 +1,5 @@
 import { TransitionHookPhase } from "./interface";
-import { defaults, noop, silentRejection } from "../../shared/common";
+import { defaults, silentRejection } from "../../shared/common";
 import { fnToString, maxLength } from "../../shared/strings";
 import { isPromise } from "../../shared/predicates";
 import { is, parse } from "../../shared/hof";
@@ -8,7 +8,7 @@ import { services } from "../common/coreservices";
 import { Rejection } from "./rejectFactory";
 import { TargetState } from "../state/targetState";
 const defaultOptions = {
-  current: noop,
+  current: () => {},
   transition: null,
   traceData: {},
   bind: null,
@@ -127,7 +127,7 @@ export class TransitionHook {
       // Wait for the promise, then reprocess with the resulting value
       return result.then((val) => this.handleHookResult(val));
     }
-    trace.traceHookResult(result, this.transition, this.options);
+    trace.traceHookResult(result, this.transition);
     // Hook returned false
     if (result === false) {
       // Abort this Transition
@@ -193,7 +193,7 @@ TransitionHook.LOG_REJECTED_RESULT = (hook) => (result) => {
  * Each HookType chooses a GetErrorHandler (See: [[TransitionService._defineCoreEvents]])
  */
 TransitionHook.LOG_ERROR = (hook) => (error) => hook.logError(error);
-TransitionHook.REJECT_ERROR = (hook) => (error) => silentRejection(error);
-TransitionHook.THROW_ERROR = (hook) => (error) => {
+TransitionHook.REJECT_ERROR = () => (error) => silentRejection(error);
+TransitionHook.THROW_ERROR = () => (error) => {
   throw error;
 };

package/src/router/url/urlMatcher.js

@@ -347,11 +347,10 @@ export class UrlMatcher {
    * @param path    The URL path to match, e.g. `$location.path()`.
    * @param search  URL search parameters, e.g. `$location.search()`.
    * @param hash    URL hash e.g. `$location.hash()`.
-   * @param options
    *
    * @returns The captured parameter values.
    */
-  exec(path, search = {}, hash, options = {}) {
+  exec(path, search = {}, hash) {
     const match = memoizeTo(this._cache, "pattern", () => {
       return new RegExp(
         [

package/src/router/url/urlRule.js

@@ -199,7 +199,7 @@ export class BaseUrlRule {
   constructor(match, handler) {
     this.match = match;
     this.type = "RAW";
-    this.matchPriority = (match) => 0 - this.$id;
+    this.matchPriority = () => 0 - this.$id;
     this.handler = handler || identity;
   }
 }

package/src/router/url/urlRules.js

@@ -73,7 +73,7 @@ export class UrlRules {
     this.urlRuleFactory = new UrlRuleFactory(router);
   }
 
-  dispose(router) {
+  dispose() {
     this._rules = [];
     delete this._otherwiseFn;
   }

package/src/shared/common.js

@@ -20,7 +20,6 @@ export const equals = _equals;
 export function identity(x) {
   return x;
 }
-export function noop() {}
 /**
  * Builds proxy functions on the `to` object which pass through to the `from` object.
  *

package/test/module-test.html

@@ -6,21 +6,53 @@
     <script>
       document.addEventListener("DOMContentLoaded", () => {
         var myApp = window.angular.module("test", ["ui.router"]);
-        myApp.config(function ($stateProvider) {
-          var helloState = {
-            name: "hello",
-            url: "/",
-            template: "<h3>hello world!</h3>",
-          };
-
-          $stateProvider.state(helloState);
-        });
+        myApp
+          .config(function ($stateProvider) {
+            $stateProvider
+              .state({ name: "top", url: "" })
+              .state({ name: "other", url: "/other/:id", template: "other" })
+              .state({
+                name: "other.detail",
+                url: "/detail",
+                template: "detail",
+              })
+              .state({
+                name: "contacts",
+                url: "/contacts",
+                template:
+                  '<a ui-sref=".item({ id: 5 })" class="item">Person</a> <ui-view></ui-view>',
+              })
+              .state({
+                name: "contacts.item",
+                url: "/{id:int}",
+                template:
+                  '<a ui-sref=".detail" class="item-detail">Detail</a> | <a ui-sref="^" class="item-parent">Parent</a> | <ui-view></ui-view>',
+              })
+              .state({
+                name: "contacts.item.detail",
+                url: "/{id}",
+                template:
+                  '<div class="title">Detail</div> | <a ui-sref="^" class="item-parent2">Item</a>',
+              });
+          })
+          .controller(
+            "TestController",
+            class {
+              constructor($q) {
+                const defer = $q.defer();
+                this.contact = defer.promise;
+                this.test = 1;
+                defer.resolve({ id: 6 });
+              }
+            },
+          );
       });
     </script>
   </head>
   <body ng-app="test">
-    {{ 2 + 2 }}
-    <a ui-sref="hello" ui-sref-active="active">Hello</a>
-    <ui-view></ui-view>
+    <div ng-controller="TestController as $ctrl">
+      {{$ctrl.test}}
+      <a ui-sref="contacts.item.detail({ id: contact.id })">Details</a>
+    </div>
   </body>
 </html>

package/test/router/services.spec.js

@@ -0,0 +1,71 @@
+import { Angular } from "../../src/loader";
+import { publishExternalAPI } from "../../src/public";
+
+describe("router services", () => {
+  let providers;
+  let $routerProvider;
+  let $injector;
+
+  beforeEach(() => {
+    window.angular = new Angular();
+    publishExternalAPI();
+    let module = window.angular.module("defaultModule", ["ui.router"]);
+    module.config(
+      (
+        _$routerProvider_,
+        $urlMatcherFactoryProvider,
+        $stateRegistryProvider,
+        $routerGlobalsProvider,
+        $transitionsProvider,
+        $stateProvider,
+      ) => {
+        debugger;
+        $routerProvider = _$routerProvider_;
+        expect($routerProvider["router"]).toBe($routerProvider);
+        providers = {
+          $routerProvider,
+          $urlMatcherFactoryProvider,
+          $stateRegistryProvider,
+          $routerGlobalsProvider,
+          $transitionsProvider,
+          $stateProvider,
+        };
+      },
+    );
+
+    $injector = window.angular.bootstrap(document.getElementById("dummy"), [
+      "defaultModule",
+    ]);
+  });
+
+  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);
+  });
+
+  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);
+    expect($injector.get("$transitions")).toBe($router.transitionService);
+    expect($injector.get("$state")).toBe($router.stateService);
+    expect($injector.get("$stateParams")).toBe($router.globals.params);
+    expect($injector.get("$view")).toBe($router.viewService);
+    expect($injector.get("$trace")).toBeDefined();
+  });
+});