@angular-wave/angular.ts 0.0.31 → 0.0.34

package/src/router/services.js

@@ -9,46 +9,11 @@
  * @preferred @publicapi @module ng1
  */
 import { services } from "./common/coreservices";
-import { applyPairs, unnestR } from "../shared/common";
-import { isString } from "../shared/utils";
+import { unnestR } from "../shared/common";
 import { trace } from "./common/trace";
-import { UIRouter } from "./router";
-import { StateProvider } from "./state-provider";
 
-/** @type {angular.UIRouter}} */
-export let router = null;
-$routerProvider.$inject = ["$locationProvider"];
-/** This angular 1 provider instantiates a Router and exposes its services via the angular injector */
-export function $routerProvider($locationProvider) {
-  // Create a new instance of the Router when the $routerProvider is initialized
-  router = this.router = new UIRouter($locationProvider);
-  router.stateProvider = new StateProvider(
-    router.stateRegistry,
-    router.stateService,
-  );
-
-  // backwards compat: also expose router instance as $routerProvider.router
-  router["router"] = router;
-  router["$get"] = $get;
-  $get.$inject = ["$location", "$browser", "$rootScope", "$injector"];
-  function $get($location, $browser, $rootScope, $injector) {
-    router.stateRegistry.init($injector);
-    router.urlService._runtimeServices($rootScope, $location, $browser);
-    return router;
-  }
-  return router;
-}
-export const getProviderFor = (serviceName) => [
-  "$routerProvider",
-  function UrlServiceProvider($urp) {
-    const service = $urp.router[serviceName];
-    service["$get"] = () => service;
-    return service;
-  },
-];
-// This effectively calls $get() on `$routerProvider` to trigger init (when ng enters runtime)
-runBlock.$inject = ["$injector", "$q", "$router"];
-export function runBlock($injector, $q, $router) {
+runBlock.$inject = ["$injector", "$q", "$stateRegistry", "$urlService"];
+export function runBlock($injector, $q, $stateRegistry, $urlService) {
   services.$injector = $injector;
   services.$q = $q;
   // https://github.com/angular-ui/ui-router/issues/3678
@@ -61,7 +26,7 @@ export function runBlock($injector, $q, $router) {
   }
   // The $injector is now available.
   // Find any resolvables that had dependency annotation deferred
-  $router.stateRegistry
+  $stateRegistry
     .get()
     .map((x) => x.$$state().resolvables)
     .reduce(unnestR, [])
@@ -73,15 +38,8 @@ export function runBlock($injector, $q, $router) {
           $injector.strictDi,
         )),
     );
-  // TODO: Is this the best place for this?
-  $router.urlService.listen();
-}
-
-// $state service and $stateProvider
-export function getStateProvider() {
-  return Object.assign(router.stateProvider, {
-    $get: () => router.stateService,
-  });
+  // Start listening for url changes
+  $urlService.listen();
 }
 
 watchDigests.$inject = ["$rootScope"];
@@ -90,17 +48,3 @@ export function watchDigests($rootScope) {
     trace.approximateDigests++;
   });
 }
-
-/** @hidden TODO: find a place to move this */
-export const getLocals = (ctx) => {
-  const tokens = ctx.getTokens().filter(isString);
-  const tuples = tokens.map((key) => {
-    const resolvable = ctx.getResolvable(key);
-    const waitPolicy = ctx.getPolicy(resolvable).async;
-    return [
-      key,
-      waitPolicy === "NOWAIT" ? resolvable.promise : resolvable.data,
-    ];
-  });
-  return tuples.reduce(applyPairs, {});
-};

package/src/router/state/state-queue-manager.js

@@ -32,7 +32,8 @@ export class StateQueueManager {
       orphans = [], // states that don't yet have a parent registered
       previousQueueLength = {}; // keep track of how long the queue when an orphan was first encountered
     const getState = (name) =>
-      this.states.hasOwnProperty(name) && this.states[name];
+      Object.prototype.hasOwnProperty.call(this.states, name) &&
+      this.states[name];
     const notifyListeners = () => {
       if (registered.length) {
         this.listeners.forEach((listener) =>

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

@@ -1,19 +1,26 @@
 import { StateMatcher } from "./state-matcher";
 import { StateBuilder } from "./state-builder";
 import { StateQueueManager } from "./state-queue-manager";
-import { removeFrom } from "../../shared/common";
+import { applyPairs, removeFrom } from "../../shared/common";
 import { propEq } from "../../shared/hof";
 import { ResolveContext } from "../resolve/resolve-context";
-import { getLocals } from "../services";
 import { ng1ViewsBuilder } from "./views";
+import { isString } from "../../shared/utils";
 /**
  * A registry for all of the application's [[StateDeclaration]]s
  *
  * This API is found at `$stateRegistry` ([[UIRouter.stateRegistry]])
  */
 export class StateRegistry {
-  constructor(urlService) {
+  static $inject = [
+    "$urlServiceProvider",
+    "$stateProvider",
+    "$routerGlobalsProvider",
+    "$viewProvider",
+  ];
+  constructor(urlService, stateService, globals, viewService) {
     this.states = {};
+    stateService.stateRegistry = this; // <- circular wiring
     this.urlService = urlService;
     this.urlServiceRules = urlService.rules;
     this.$injector = undefined;
@@ -35,16 +42,21 @@ export class StateRegistry {
       this.listeners,
     );
     this._registerRoot();
-  }
 
-  /**
-   * @param {angular.$InjectorLike} $injector
-   */
-  init($injector) {
-    this.$injector = $injector;
-    this.builder.$injector = $injector;
+    viewService._pluginapi._rootViewContext(this.root());
+    globals.$current = this.root();
+    globals.current = globals.$current.self;
   }
 
+  $get = [
+    "$injector",
+    ($injector) => {
+      this.$injector = $injector;
+      this.builder.$injector = $injector;
+      return this;
+    },
+  ];
+
   /**
    * This is a [[StateBuilder.builder]] function for angular1 `onEnter`, `onExit`,
    * `onRetain` callback hooks on a [[Ng1StateDeclaration]].
@@ -215,12 +227,17 @@ export class StateRegistry {
   decorator(property, builderFunction) {
     return this.builder.builder(property, builderFunction);
   }
-
-  $get = [
-    "$injector",
-    function ($injector) {
-      this.init($injector);
-      return this;
-    },
-  ];
 }
+
+export const getLocals = (ctx) => {
+  const tokens = ctx.getTokens().filter(isString);
+  const tuples = tokens.map((key) => {
+    const resolvable = ctx.getResolvable(key);
+    const waitPolicy = ctx.getPolicy(resolvable).async;
+    return [
+      key,
+      waitPolicy === "NOWAIT" ? resolvable.promise : resolvable.data,
+    ];
+  });
+  return tuples.reduce(applyPairs, {});
+};

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

@@ -6,7 +6,7 @@ import {
   silenceUncaughtInPromise,
   silentRejection,
 } from "../../shared/common";
-import { isDefined, isObject, isString } from "../../shared/utils";
+import { isDefined, isObject, isString, minErr } from "../../shared/utils";
 import { Queue } from "../common/queue";
 import { services } from "../common/coreservices";
 import { PathUtils } from "../path/path-utils";
@@ -21,6 +21,42 @@ import { lazyLoadState } from "../hooks/lazy-load";
 import { not, val } from "../../shared/hof";
 import { EventBus } from "../../core/pubsub";
 
+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",
+  "onExit",
+  "onRetain",
+  "params",
+  "parent",
+  "path",
+  "redirectTo",
+  "reloadOnSearch",
+  "resolve",
+  "resolveAs",
+  "resolvables",
+  "self",
+  "template",
+  "templateProvider",
+  "templateUrl",
+  "url",
+  "views",
+];
+
 /**
  * Provides services related to ui-router states.
  *
@@ -52,6 +88,8 @@ export class StateService {
     return this.globals.$current;
   }
 
+  static $inject = ["$routerGlobalsProvider", "$transitionsProvider"];
+
   // Needs access to urlService, stateRegistry
   constructor(globals, transitionService) {
     this.stateRegistry = undefined;
@@ -85,6 +123,136 @@ export class StateService {
     );
   }
 
+  $get = [
+    () => {
+      return this;
+    },
+  ];
+
+  /**
+   * Decorates states when they are registered
+   *
+   * Allows you to extend (carefully) or override (at your own peril) the
+   * `stateBuilder` object used internally by [[StateRegistry]].
+   * This can be used to add custom functionality to ui-router,
+   * for example inferring templateUrl based on the state name.
+   *
+   * When passing only a name, it returns the current (original or decorated) builder
+   * function that matches `name`.
+   *
+   * The builder functions that can be decorated are listed below. Though not all
+   * necessarily have a good use case for decoration, that is up to you to decide.
+   *
+   * In addition, users can attach custom decorators, which will generate new
+   * properties within the state's internal definition. There is currently no clear
+   * use-case for this beyond accessing internal states (i.e. $state.$current),
+   * however, expect this to become increasingly relevant as we introduce additional
+   * meta-programming features.
+   *
+   * **Warning**: Decorators should not be interdependent because the order of
+   * execution of the builder functions in non-deterministic. Builder functions
+   * should only be dependent on the state definition object and super function.
+   *
+   *
+   * Existing builder functions and current return values:
+   *
+   * - **parent** `{object}` - returns the parent state object.
+   * - **data** `{object}` - returns state data, including any inherited data that is not
+   *   overridden by own values (if any).
+   * - **url** `{object}` - returns a {@link ui.router.util.type:UrlMatcher UrlMatcher}
+   *   or `null`.
+   * - **navigable** `{object}` - returns closest ancestor state that has a URL (aka is
+   *   navigable).
+   * - **params** `{object}` - returns an array of state params that are ensured to
+   *   be a super-set of parent's params.
+   * - **views** `{object}` - returns a views object where each key is an absolute view
+   *   name (i.e. "viewName@stateName") and each value is the config object
+   *   (template, controller) for the view. Even when you don't use the views object
+   *   explicitly on a state config, one is still created for you internally.
+   *   So by decorating this builder function you have access to decorating template
+   *   and controller properties.
+   * - **ownParams** `{object}` - returns an array of params that belong to the state,
+   *   not including any params defined by ancestor states.
+   * - **path** `{string}` - returns the full path from the root down to this state.
+   *   Needed for state activation.
+   * - **includes** `{object}` - returns an object that includes every state that
+   *   would pass a `$state.includes()` test.
+   *
+   * #### Example:
+   * Override the internal 'views' builder with a function that takes the state
+   * definition, and a reference to the internal function being overridden:
+   * ```js
+   * $stateProvider.decorator('views', function (state, parent) {
+   *   let result = {},
+   *       views = parent(state);
+   *
+   *   angular.forEach(views, function (config, name) {
+   *     let autoName = (state.name + '.' + name).replace('.', '/');
+   *     config.templateUrl = config.templateUrl || '/partials/' + autoName + '.html';
+   *     result[name] = config;
+   *   });
+   *   return result;
+   * });
+   *
+   * $stateProvider.state('home', {
+   *   views: {
+   *     'contact.list': { controller: 'ListController' },
+   *     'contact.item': { controller: 'ItemController' }
+   *   }
+   * });
+   * ```
+   *
+   *
+   * ```js
+   * // Auto-populates list and item views with /partials/home/contact/list.html,
+   * // and /partials/home/contact/item.html, respectively.
+   * $state.go('home');
+   * ```
+   *
+   * @param {string} name The name of the builder function to decorate.
+   * @param {object} func A function that is responsible for decorating the original
+   * builder function. The function receives two parameters:
+   *
+   *   - `{object}` - state - The state config object.
+   *   - `{object}` - super - The original builder function.
+   *
+   * @return {object} $stateProvider - $stateProvider instance
+   */
+  decorator(name, func) {
+    return this.stateRegistry.decorator(name, func) || this;
+  }
+
+  /**
+   *
+   * @param {angular.Ng1StateDeclaration} definition
+   */
+  state(definition) {
+    if (!definition.name) {
+      throw err("stateinvalid", `'name' required`);
+    }
+
+    const hasInvalidKeys = Object.keys(definition).filter(
+      (key) => !validKeys.includes(key),
+    );
+    if (hasInvalidKeys.length) {
+      throw err("stateinvalid", `Invalid key(s): ${hasInvalidKeys.join(", ")}`);
+    }
+    try {
+      this.stateRegistry.register(definition);
+    } catch (e) {
+      throw err("stateinvalid", e.message);
+    }
+    return this;
+  }
+  /**
+   * Registers an invalid state handler
+   *
+   * This is a passthrough to [[StateService.onInvalid]] for ng1.
+   */
+  onInvalid(callback) {
+    return this.onInvalid(callback);
+  }
+
   /**
    * Handler for when [[transitionTo]] is called with an invalid state.
    *

package/src/router/state/views.js

@@ -3,7 +3,6 @@ import { isDefined, isString } from "../../shared/utils";
 import { isInjectable } from "../../shared/predicates";
 import { services } from "../common/coreservices";
 import { trace } from "../common/trace";
-import { ViewService } from "../view/view";
 import { ResolveContext } from "../resolve/resolve-context";
 import { Resolvable } from "../resolve/resolvable";
 
@@ -77,7 +76,7 @@ export function ng1ViewsBuilder(state) {
     config.$type = "ng1";
     config.$context = state;
     config.$name = name;
-    const normalized = ViewService.normalizeUIViewTarget(
+    const normalized = Ng1ViewConfig.normalizeUIViewTarget(
       config.$context,
       config.$name,
     );
@@ -144,4 +143,49 @@ export class Ng1ViewConfig {
     const resolvable = new Resolvable("", providerFn, deps);
     return resolvable.get(context);
   }
+
+  /**
+   * Normalizes a view's name from a state.views configuration block.
+   *
+   * This should be used by a framework implementation to calculate the values for
+   * [[_ViewDeclaration.$ngViewName]] and [[_ViewDeclaration.$ngViewContextAnchor]].
+   *
+   * @param context the context object (state declaration) that the view belongs to
+   * @param rawViewName the name of the view, as declared in the [[StateDeclaration.views]]
+   *
+   * @returns the normalized ngViewName and ngViewContextAnchor that the view targets
+   */
+  static normalizeUIViewTarget(context, rawViewName = "") {
+    // TODO: Validate incoming view name with a regexp to allow:
+    // ex: "view.name@foo.bar" , "^.^.view.name" , "view.name@^.^" , "" ,
+    // "@" , "$default@^" , "!$default.$default" , "!foo.bar"
+    const viewAtContext = rawViewName.split("@");
+    let ngViewName = viewAtContext[0] || "$default"; // default to unnamed view
+    let ngViewContextAnchor = isString(viewAtContext[1])
+      ? viewAtContext[1]
+      : "^"; // default to parent context
+    // Handle relative view-name sugar syntax.
+    // Matches rawViewName "^.^.^.foo.bar" into array: ["^.^.^.foo.bar", "^.^.^", "foo.bar"],
+    const relativeViewNameSugar = /^(\^(?:\.\^)*)\.(.*$)/.exec(ngViewName);
+    if (relativeViewNameSugar) {
+      // Clobbers existing contextAnchor (rawViewName validation will fix this)
+      ngViewContextAnchor = relativeViewNameSugar[1]; // set anchor to "^.^.^"
+      ngViewName = relativeViewNameSugar[2]; // set view-name to "foo.bar"
+    }
+    if (ngViewName.charAt(0) === "!") {
+      ngViewName = ngViewName.substr(1);
+      ngViewContextAnchor = ""; // target absolutely from root
+    }
+    // handle parent relative targeting "^.^.^"
+    const relativeMatch = /^(\^(?:\.\^)*)$/;
+    if (relativeMatch.exec(ngViewContextAnchor)) {
+      const anchorState = ngViewContextAnchor
+        .split(".")
+        .reduce((anchor) => anchor.parent, context);
+      ngViewContextAnchor = anchorState.name;
+    } else if (ngViewContextAnchor === ".") {
+      ngViewContextAnchor = context.name;
+    }
+    return { ngViewName, ngViewContextAnchor };
+  }
 }

package/src/router/transition/reject-factory.js

@@ -54,14 +54,6 @@ export const RejectType = {
 
 let id = 0;
 export class Rejection {
-  /** Returns true if the obj is a rejected promise created from the `asPromise` factory */
-  static isRejectionPromise(obj) {
-    return (
-      obj &&
-      typeof obj.then === "function" &&
-      is(Rejection)(obj._transitionRejection)
-    );
-  }
   /** Returns a Rejection due to transition superseded */
   static superseded(detail, options) {
     const message =

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

@@ -15,7 +15,10 @@ import {
   registerLazyResolveState,
   registerResolveRemaining,
 } from "../hooks/resolve";
-import { registerLoadEnteringViews } from "../hooks/views";
+import {
+  registerActivateViews,
+  registerLoadEnteringViews,
+} from "../hooks/views";
 import { registerUpdateGlobalState } from "../hooks/update-globals";
 
 import { registerLazyLoadHook } from "../hooks/lazy-load";
@@ -26,6 +29,8 @@ import { createProxyFunctions } from "../../shared/common";
 import { val } from "../../shared/hof";
 import { registerIgnoredTransitionHook } from "../hooks/ignored-transition";
 import { registerInvalidTransitionHook } from "../hooks/invalid-transition";
+import { registerRedirectToHook } from "../hooks/redirect-to";
+import { registerUpdateUrl } from "../hooks/url";
 /**
  * The default [[Transition]] options.
  *
@@ -56,6 +61,8 @@ export let defaultTransOpts = {
  * This API is located at `router.transitionService` ([[UIRouter.transitionService]])
  */
 export class TransitionService {
+  static $inject = ["$routerGlobalsProvider", "$viewProvider"];
+
   /**
    * @param {import('../globals').UIRouterGlobals} globals
    */
@@ -82,6 +89,41 @@ export class TransitionService {
     this._registerCoreTransitionHooks();
     globals.successfulTransitions.onEvict(treeChangesCleanup);
   }
+
+  $get = [
+    "$state",
+    "$urlService",
+    "$stateRegistry",
+    "$view",
+    (stateService, urlService, stateRegistry, viewService) => {
+      // Lazy load state trees
+      this._deregisterHookFns.lazyLoad = registerLazyLoadHook(
+        this,
+        stateService,
+        urlService,
+        stateRegistry,
+      );
+
+      // After globals.current is updated at priority: 10000
+      this._deregisterHookFns.updateUrl = registerUpdateUrl(
+        this,
+        stateService,
+        urlService,
+      );
+
+      // Wire up redirectTo hook
+      this._deregisterHookFns.redirectTo = registerRedirectToHook(
+        this,
+        stateService,
+      );
+
+      this._deregisterHookFns.activateViews = registerActivateViews(
+        this,
+        viewService,
+      );
+      return this;
+    },
+  ];
   /**
    * Registers a [[TransitionHookFn]], called *while a transition is being constructed*.
    *

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

@@ -13,7 +13,7 @@ import { isDefined, isString } from "../../shared/utils";
  *
  * This API is found at `router.urlService.config` (see: [[UIRouter.urlService]], [[URLService.config]])
  */
-export class UrlConfig {
+export class UrlConfigProvider {
   constructor() {
     /** @type {ParamTypes} */
     this.paramTypes = new ParamTypes();
@@ -49,6 +49,12 @@ export class UrlConfig {
     this.paramTypes._flushTypeQueue();
   }
 
+  $get = [
+    function () {
+      return this;
+    },
+  ];
+
   /**
    * Defines whether URL matching should be case sensitive (the default behavior), or not.
    *

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

@@ -13,8 +13,8 @@ import { StateObject } from "../state/state-object";
  * - [[StateObject]]
  */
 export class UrlRuleFactory {
-  constructor(urlMatcherFactory, stateService, routerGlobals) {
-    this.urlMatcherFactory = urlMatcherFactory;
+  constructor(urlService, stateService, routerGlobals) {
+    this.urlService = urlService;
     this.stateService = stateService;
     this.routerGlobals = routerGlobals;
   }
@@ -28,7 +28,7 @@ export class UrlRuleFactory {
   create(what, handler) {
     const { isState, isStateDeclaration } = StateObject;
     const makeRule = pattern([
-      [isString, (_what) => makeRule(this.urlMatcherFactory.compile(_what))],
+      [isString, (_what) => makeRule(this.urlService.compile(_what))],
       [is(UrlMatcher), (_what) => this.fromUrlMatcher(_what, handler)],
       [
         or(isState, isStateDeclaration),
@@ -79,7 +79,7 @@ export class UrlRuleFactory {
    */
   fromUrlMatcher(urlMatcher, handler) {
     let _handler = handler;
-    if (isString(handler)) handler = this.urlMatcherFactory.compile(handler);
+    if (isString(handler)) handler = this.urlService.compile(handler);
     if (is(UrlMatcher)(handler)) _handler = (match) => handler.format(match);
     function matchUrlParamters(url) {
       const params = urlMatcher.exec(url.path, url.search, url.hash);

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

@@ -7,42 +7,55 @@ import {
 } 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";
+import { UrlRuleFactory } from "./url-rule";
 
 /**
  * API for URL management
  */
 export class UrlService {
+  static $inject = [
+    "$locationProvider",
+    "$stateProvider",
+    "$routerGlobalsProvider",
+    "$urlConfigProvider",
+  ];
+
   /**
    * @param {angular.ILocationProvider} $locationProvider
    */
-  constructor($locationProvider, urlRuleFactory, stateService) {
+  constructor($locationProvider, stateService, globals, urlConfigProvider) {
     this.stateService = stateService;
+    this.stateService.urlService = this; // circular wiring
     this.$locationProvider = $locationProvider;
+
     this.$location = undefined;
     this.$browser = undefined;
 
     /** @type {boolean} */
     this.interceptDeferred = false;
+
+    /** Provides services related to the URL */
+    this.urlRuleFactory = new UrlRuleFactory(this, this.stateService, globals);
+
     /**
      * The nested [[UrlRules]] API for managing URL rules and rewrites
      *
      * See: [[UrlRules]] for details
      * @type {UrlRules}
      */
-    this.rules = new UrlRules(urlRuleFactory);
+    this.rules = new UrlRules(this.urlRuleFactory);
     /**
      * The nested [[UrlConfig]] API to configure the URL and retrieve URL information
      *
      * See: [[UrlConfig]] for details
-     * @type {UrlConfig}
+     * @type {angular.UrlConfig}
      */
-    this.config = new UrlConfig();
+    this.config = urlConfigProvider;
 
     /** Creates a new [[Param]] for a given location (DefType) */
     this.paramFactory = new ParamFactory(this.config);
@@ -75,6 +88,20 @@ export class UrlService {
     this._urlListeners = [];
   }
 
+  $get = [
+    "$location",
+    "$browser",
+    "$rootScope",
+    ($location, $browser, $rootScope) => {
+      this.$location = $location;
+      this.$browser = $browser;
+      $rootScope.$on("$locationChangeSuccess", (evt) =>
+        this._urlListeners.forEach((fn) => fn(evt)),
+      );
+      return this;
+    },
+  ];
+
   html5Mode() {
     let html5Mode = this.$locationProvider.html5Mode();
     html5Mode = isObject(html5Mode) ? html5Mode.enabled : html5Mode;
@@ -316,16 +343,6 @@ export class UrlService {
     return best;
   }
 
-  _runtimeServices($rootScope, $location, $browser) {
-    /** @type {angular.ILocationService} */
-    this.$location = $location;
-    this.$browser = $browser;
-    // Bind $locationChangeSuccess to the listeners registered in LocationService.onChange
-    $rootScope.$on("$locationChangeSuccess", (evt) =>
-      this._urlListeners.forEach((fn) => fn(evt)),
-    );
-  }
-
   update(read) {
     if (read) {
       this.location = this.url();