@angular-wave/angular.ts 0.0.30 → 0.0.33

package/src/router/injectables.js

@@ -259,56 +259,5 @@ let $urlServiceProvider;
  * ##### Note: This service can also be injected during the config phase as [[$urlServiceProvider]].
  */
 let $urlService;
-/**
- * The URL Router Provider
- *
- * ### Deprecation warning: This object is now considered internal. Use [[$urlServiceProvider]] instead.
- *
- * The [[UrlRouter]] singleton as a **Provider Object** (injectable during config time).
- *
- * #### Note: This object is also exposed as [[$urlRouter]] for injection during runtime.
- *
- * @deprecated
- */
-let $urlRouterProvider;
-/**
- * The Url Router
- *
- * ### Deprecation warning: This object is now considered internal. Use [[$urlService]] instead.
- *
- * The [[UrlRouter]] singleton as a **Service Object** (injectable during runtime).
- *
- * #### Note: This object is also exposed as [[$urlRouterProvider]] for injection during angular config time.
- *
- * @deprecated
- */
-let $urlRouter;
-/**
- * The URL Matcher Factory
- *
- * ### Deprecation warning: This object is now considered internal. Use [[$urlService]] instead.
- *
- * The [[UrlMatcherFactory]] singleton as a **Service Object** (injectable during runtime).
- *
- * This service is used to set url mapping options, define custom parameter types, and create [[UrlMatcher]] objects.
- *
- * #### Note: This object is also exposed as [[$urlMatcherFactoryProvider]] for injection during angular config time.
- *
- * @deprecated
- */
-let $urlMatcherFactory;
-/**
- * The URL Matcher Factory
- *
- * ### Deprecation warning: This object is now considered internal. Use [[$urlService]] instead.
- *
- * The [[UrlMatcherFactory]] singleton as a **Provider Object** (injectable during config time).
- *
- * This service is used to set url mapping options, define custom parameter types, and create [[UrlMatcher]] objects.
- *
- * #### Note: This object is also exposed as [[$urlMatcherFactory]] for injection during runtime.
- *
- * @deprecated
- */
-let $urlMatcherFactoryProvider;
+
 export {};

package/src/router/services.js

@@ -9,67 +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,
-  );
-
-  /**
-   * Applys ng1-specific path parameter encoding
-   *
-   * The Angular 1 `$location` service is a bit weird.
-   * It doesn't allow slashes to be encoded/decoded bi-directionally.
-   *
-   * See the writeup at https://github.com/angular-ui/ui-router/issues/2598
-   *
-   * This code patches the `path` parameter type so it encoded/decodes slashes as ~2F
-   *
-   */
-  const pathType = router.urlMatcherFactory.type("path");
-  pathType.encode = (x) =>
-    x != null
-      ? x.toString().replace(/(~|\/)/g, (m) => ({ "~": "~~", "/": "~2F" })[m])
-      : x;
-  pathType.decode = (x) =>
-    x != null
-      ? x.toString().replace(/(~~|~2F)/g, (m) => ({ "~~": "~", "~2F": "/" })[m])
-      : x;
-
-  // 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
@@ -82,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, [])
@@ -94,16 +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
-// $urlRouter service and $urlRouterProvider
-export function getStateProvider() {
-  return Object.assign(router.stateProvider, {
-    $get: () => router.stateService,
-  });
+  // Start listening for url changes
+  $urlService.listen();
 }
 
 watchDigests.$inject = ["$rootScope"];
@@ -112,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-builder.js

@@ -29,7 +29,7 @@ function dataBuilder(state) {
   }
   return state.data;
 }
-const getUrlBuilder = ($urlMatcherFactoryProvider, root) =>
+const getUrlBuilder = ($urlService, root) =>
   function urlBuilder(stateObject) {
     let stateDec = stateObject.self;
     // For future states, i.e., states whose name ends with `.**`,
@@ -49,9 +49,9 @@ const getUrlBuilder = ($urlMatcherFactoryProvider, root) =>
     const parsed = parseUrl(stateDec.url);
     const url = !parsed
       ? stateDec.url
-      : $urlMatcherFactoryProvider.compile(parsed.val, { state: stateDec });
+      : $urlService.compile(parsed.val, { state: stateDec });
     if (!url) return null;
-    if (!$urlMatcherFactoryProvider.isMatcher(url))
+    if (!$urlService.isMatcher(url))
       throw new Error(`Invalid url '${url}' in state '${stateObject}'`);
     return parsed && parsed.root
       ? url
@@ -238,7 +238,7 @@ export function resolvablesBuilder(state) {
  * using the [[builder]] method.
  */
 export class StateBuilder {
-  constructor(matcher, urlMatcherFactory) {
+  constructor(matcher, urlService) {
     this.matcher = matcher;
     this.$injector = undefined;
     const self = this;
@@ -254,10 +254,11 @@ export class StateBuilder {
       parent: [parentBuilder],
       data: [dataBuilder],
       // Build a URLMatcher if necessary, either via a relative or absolute URL
-      url: [getUrlBuilder(urlMatcherFactory, root)],
+      url: [getUrlBuilder(urlService, root)],
       // Keep track of the closest ancestor state that has a URL (i.e. is navigable)
       navigable: [getNavigableBuilder(isRoot)],
-      params: [getParamsBuilder(urlMatcherFactory.paramFactory)],
+      // TODO
+      params: [getParamsBuilder(urlService.paramFactory)],
       // Each framework-specific ui-router implementation should define its own `views` builder
       // e.g., src/ng1/statebuilders/views.ts
       views: [],

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,24 +1,32 @@
 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(urlMatcherFactory, urlServiceRules) {
+  static $inject = [
+    "$urlServiceProvider",
+    "$stateProvider",
+    "$routerGlobalsProvider",
+    "$viewProvider",
+  ];
+  constructor(urlService, stateService, globals, viewService) {
     this.states = {};
-    this.urlServiceRules = urlServiceRules;
+    stateService.stateRegistry = this; // <- circular wiring
+    this.urlService = urlService;
+    this.urlServiceRules = urlService.rules;
     this.$injector = undefined;
     this.listeners = [];
     this.matcher = new StateMatcher(this.states);
-    this.builder = new StateBuilder(this.matcher, urlMatcherFactory);
+    this.builder = new StateBuilder(this.matcher, urlService);
     // Apply ng1 specific StateBuilder code for `views`, `resolve`, and `onExit/Retain/Enter` properties
     // TODO we can probably move this inside buildr
     this.builder.builder("views", ng1ViewsBuilder);
@@ -28,22 +36,27 @@ export class StateRegistry {
 
     this.stateQueue = new StateQueueManager(
       this,
-      urlServiceRules,
+      this.urlServiceRules,
       this.states,
       this.builder,
       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]].
@@ -214,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,10 +88,11 @@ export class StateService {
     return this.globals.$current;
   }
 
-  // Needs access to urlRouter, stateRegistry
+  static $inject = ["$routerGlobalsProvider", "$transitionsProvider"];
+
+  // Needs access to urlService, stateRegistry
   constructor(globals, transitionService) {
     this.stateRegistry = undefined;
-    this.urlRouter = undefined;
     this.urlService = undefined;
     this.globals = globals;
     this.transitionService = transitionService;
@@ -86,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.
    *
@@ -344,7 +511,7 @@ export class StateService {
       if (error instanceof Rejection) {
         const isLatest = this.globals.lastStartedTransitionId <= trans.$id;
         if (error.type === RejectType.IGNORED) {
-          isLatest && EventBus.publish("urlRouter.update");
+          isLatest && this.urlService.update();
           // Consider ignored `Transition.run()` as a successful `transitionTo`
           return services.$q.when(this.globals.current);
         }
@@ -360,7 +527,7 @@ export class StateService {
           return redirect.run().catch(rejectedTransitionHandler(redirect));
         }
         if (error.type === RejectType.ABORTED) {
-          isLatest && EventBus.publish("urlRouter.update");
+          isLatest && this.urlService.update();
           return services.$q.reject(error);
         }
       }
@@ -519,7 +686,7 @@ export class StateService {
     if (!nav || nav.url === undefined || nav.url === null) {
       return null;
     }
-    return this.urlRouter.href(nav.url, params, {
+    return this.urlService.href(nav.url, params, {
       absolute: options.absolute,
     });
   }

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 =