@angular-wave/angular.ts 0.0.11 → 0.0.13

package/src/router/core/router.js

@@ -0,0 +1,203 @@
+import { UrlMatcherFactory } from "./url/urlMatcherFactory";
+import { UrlRouter } from "./url/urlRouter";
+import { TransitionService } from "./transition/transitionService";
+import { ViewService } from "./view/view";
+import { StateRegistry } from "./state/stateRegistry";
+import { StateService } from "./state/stateService";
+import { UIRouterGlobals } from "./globals";
+import { removeFrom } from "./common/common";
+import { isFunction } from "./common/predicates";
+import { UrlService } from "./url/urlService";
+import { trace } from "./common/trace";
+import { makeStub } from "./common/coreservices";
+
+/** @internal
+ * @type {number}
+ */
+let _routerInstance = 0;
+
+/** @internal
+ * @type {(keyof LocationServices)[]}
+ */
+const locSvcFns = ["url", "path", "search", "hash", "onChange"];
+/** @internal
+ * @type {(keyof LocationConfig)[]}
+ */
+const locCfgFns = [
+  "port",
+  "protocol",
+  "host",
+  "baseHref",
+  "html5Mode",
+  "hashPrefix",
+];
+/** @internal
+ * @type {any}
+ */
+const locationServiceStub = makeStub("LocationServices", locSvcFns);
+/** @internal
+ * @type {any}
+ */
+const locationConfigStub = makeStub("LocationConfig", locCfgFns);
+
+/**
+ * An instance of UI-Router.
+ *
+ * This object contains references to service APIs which define your application's routing behavior.
+ */
+export class UIRouter {
+  /**
+   * Creates a new `UIRouter` object
+   *
+   * @param locationService a [[LocationServices]] implementation
+   * @param locationConfig a [[LocationConfig]] implementation
+   * @internal
+   */
+  constructor(
+    locationService = locationServiceStub,
+    locationConfig = locationConfigStub,
+  ) {
+    this.locationService = locationService;
+    this.locationConfig = locationConfig;
+    /** @internal */ this.$id = _routerInstance++;
+    /** @internal */ this._disposed = false;
+    /** @internal */ this._disposables = [];
+    /** Enable/disable tracing to the javascript console */
+    this.trace = trace;
+    /** Provides services related to ui-view synchronization */
+    this.viewService = new ViewService(this);
+    /** An object that contains global router state, such as the current state and params */
+    this.globals = new UIRouterGlobals();
+    /** A service that exposes global Transition Hooks */
+    this.transitionService = new TransitionService(this);
+    /**
+     * Deprecated for public use. Use [[urlService]] instead.
+     * @deprecated Use [[urlService]] instead
+     */
+    this.urlMatcherFactory = new UrlMatcherFactory(this);
+    /**
+     * Deprecated for public use. Use [[urlService]] instead.
+     * @deprecated Use [[urlService]] instead
+     */
+    this.urlRouter = new UrlRouter(this);
+    /** Provides services related to the URL */
+    this.urlService = new UrlService(this);
+    /** Provides a registry for states, and related registration services */
+    this.stateRegistry = new StateRegistry(this);
+    /** Provides services related to states */
+    this.stateService = new StateService(this);
+    /** @internal plugin instances are registered here */
+    this._plugins = {};
+    this.viewService._pluginapi._rootViewContext(this.stateRegistry.root());
+    this.globals.$current = this.stateRegistry.root();
+    this.globals.current = this.globals.$current.self;
+    this.disposable(this.globals);
+    this.disposable(this.stateService);
+    this.disposable(this.stateRegistry);
+    this.disposable(this.transitionService);
+    this.disposable(this.urlService);
+    this.disposable(locationService);
+    this.disposable(locationConfig);
+  }
+
+  /**
+   * Registers an object to be notified when the router is disposed
+   * @param {Disposable} disposable
+   * @returns {void}
+   */
+  disposable(disposable) {
+    this._disposables.push(disposable);
+  }
+  /**
+   * Disposes this router instance
+   *
+   * When called, clears resources retained by the router by calling `dispose(this)` on all
+   * registered [[disposable]] objects.
+   *
+   * Or, if a `disposable` object is provided, calls `dispose(this)` on that object only.
+   *
+   * @internal
+   * @param disposable (optional) the disposable to dispose
+   */
+  dispose(disposable) {
+    if (disposable && isFunction(disposable.dispose)) {
+      disposable.dispose(this);
+      return undefined;
+    }
+    this._disposed = true;
+    this._disposables.slice().forEach((d) => {
+      try {
+        typeof d.dispose === "function" && d.dispose(this);
+        removeFrom(this._disposables, d);
+      } catch (ignored) {}
+    });
+  }
+
+  /**
+   * Adds a plugin to UI-Router
+   *
+   * This method adds a UI-Router Plugin.
+   * A plugin can enhance or change UI-Router behavior using any public API.
+   *
+   * #### Example:
+   * ```js
+   * import { MyCoolPlugin } from "ui-router-cool-plugin";
+   *
+   * var plugin = router.addPlugin(MyCoolPlugin);
+   * ```
+   *
+   * ### Plugin authoring
+   *
+   * A plugin is simply a class (or constructor function) which accepts a [[UIRouter]] instance and (optionally) an options object.
+   *
+   * The plugin can implement its functionality using any of the public APIs of [[UIRouter]].
+   * For example, it may configure router options or add a Transition Hook.
+   *
+   * The plugin can then be published as a separate module.
+   *
+   * #### Example:
+   * ```js
+   * export class MyAuthPlugin implements UIRouterPlugin {
+   *   constructor(router: UIRouter, options: any) {
+   *     this.name = "MyAuthPlugin";
+   *     let $transitions = router.transitionService;
+   *     let $state = router.stateService;
+   *
+   *     let authCriteria = {
+   *       to: (state) => state.data && state.data.requiresAuth
+   *     };
+   *
+   *     function authHook(transition: Transition) {
+   *       let authService = transition.injector().get('AuthService');
+   *       if (!authService.isAuthenticated()) {
+   *         return $state.target('login');
+   *       }
+   *     }
+   *
+   *     $transitions.onStart(authCriteria, authHook);
+   *   }
+   * }
+   * ```
+   *
+   * @param plugin one of:
+   *        - a plugin class which implements [[UIRouterPlugin]]
+   *        - a constructor function for a [[UIRouterPlugin]] which accepts a [[UIRouter]] instance
+   *        - a factory function which accepts a [[UIRouter]] instance and returns a [[UIRouterPlugin]] instance
+   * @param options options to pass to the plugin class/factory
+   * @returns the registered plugin instance
+   */
+  plugin(plugin, options = {}) {
+    const pluginInstance = new plugin(this, options);
+    if (!pluginInstance.name)
+      throw new Error(
+        "Required property `name` missing on plugin: " + pluginInstance,
+      );
+    this._disposables.push(pluginInstance);
+    return (this._plugins[pluginInstance.name] = pluginInstance);
+  }
+  getPlugin(pluginName) {
+    return pluginName
+      ? this._plugins[pluginName]
+      : Object.values(this._plugins);
+  }
+}

package/src/router/core/state/README.md

@@ -0,0 +1,21 @@
+/\*\*
+
+- # The state subsystem
+-
+- This subsystem implements the ui-router state tree
+-
+- - The [[StateService]] has state-related service methods such as:
+- - [[StateService.get]]: Get a registered [[StateDeclaration]] object
+- - [[StateService.go]]: Transition from the current state to a new state
+- - [[StateService.reload]]: Reload the current state
+- - [[StateService.target]]: Get a [[TargetState]] (useful when redirecting from a Transition Hook)
+- - [[StateService.onInvalid]]: Register a callback for when a transition to an invalid state is started
+- - [[StateService.defaultErrorHandler]]: Register a global callback for when a transition errors
+- - The [[StateDeclaration]] interface defines the shape of a state declaration
+- - The [[StateRegistry]] contains all the registered states
+- - States can be added/removed using the [[StateRegistry.register]] and [[StateRegistry.deregister]]
+-     - Note: Bootstrap state registration differs by front-end framework.
+- - Get notified of state registration/deregistration using [[StateRegistry.onStatesChanged]].
+-
+- @packageDocumentation
+  \*/

package/src/router/core/state/stateBuilder.js

@@ -0,0 +1,332 @@
+import {
+  applyPairs,
+  extend,
+  identity,
+  inherit,
+  mapObj,
+  noop,
+  omit,
+  tail,
+  copy,
+} from "../common/common";
+import { isArray, isDefined, isFunction, isString } from "../common/predicates";
+import { stringify } from "../common/strings";
+import { is, pattern, pipe, prop, val } from "../common/hof";
+import { Resolvable } from "../resolve/resolvable";
+import { services } from "../common/coreservices";
+const parseUrl = (url) => {
+  if (!isString(url)) return false;
+  const root = url.charAt(0) === "^";
+  return { val: root ? url.substring(1) : url, root };
+};
+function nameBuilder(state) {
+  return state.name;
+}
+function selfBuilder(state) {
+  state.self.$$state = () => state;
+  return state.self;
+}
+function dataBuilder(state) {
+  if (state.parent && state.parent.data) {
+    state.data = state.self.data = inherit(state.parent.data, state.data);
+  }
+  return state.data;
+}
+const getUrlBuilder = ($urlMatcherFactoryProvider, root) =>
+  function urlBuilder(stateObject) {
+    let stateDec = stateObject.self;
+    // For future states, i.e., states whose name ends with `.**`,
+    // match anything that starts with the url prefix
+    if (
+      stateDec &&
+      stateDec.url &&
+      stateDec.name &&
+      stateDec.name.match(/\.\*\*$/)
+    ) {
+      const newStateDec = {};
+      copy(stateDec, newStateDec);
+      newStateDec.url += "{remainder:any}"; // match any path (.*)
+      stateDec = newStateDec;
+    }
+    const parent = stateObject.parent;
+    const parsed = parseUrl(stateDec.url);
+    const url = !parsed
+      ? stateDec.url
+      : $urlMatcherFactoryProvider.compile(parsed.val, { state: stateDec });
+    if (!url) return null;
+    if (!$urlMatcherFactoryProvider.isMatcher(url))
+      throw new Error(`Invalid url '${url}' in state '${stateObject}'`);
+    return parsed && parsed.root
+      ? url
+      : ((parent && parent.navigable) || root()).url.append(url);
+  };
+const getNavigableBuilder = (isRoot) =>
+  function navigableBuilder(state) {
+    return !isRoot(state) && state.url
+      ? state
+      : state.parent
+        ? state.parent.navigable
+        : null;
+  };
+const getParamsBuilder = (paramFactory) =>
+  function paramsBuilder(state) {
+    const makeConfigParam = (config, id) =>
+      paramFactory.fromConfig(id, null, state.self);
+    const urlParams =
+      (state.url && state.url.parameters({ inherit: false })) || [];
+    const nonUrlParams = Object.values(
+      mapObj(
+        omit(state.params || {}, urlParams.map(prop("id"))),
+        makeConfigParam,
+      ),
+    );
+    return urlParams
+      .concat(nonUrlParams)
+      .map((p) => [p.id, p])
+      .reduce(applyPairs, {});
+  };
+function pathBuilder(state) {
+  return state.parent ? state.parent.path.concat(state) : /*root*/ [state];
+}
+function includesBuilder(state) {
+  const includes = state.parent ? extend({}, state.parent.includes) : {};
+  includes[state.name] = true;
+  return includes;
+}
+/**
+ * This is a [[StateBuilder.builder]] function for the `resolve:` block on a [[StateDeclaration]].
+ *
+ * When the [[StateBuilder]] builds a [[StateObject]] object from a raw [[StateDeclaration]], this builder
+ * validates the `resolve` property and converts it to a [[Resolvable]] array.
+ *
+ * resolve: input value can be:
+ *
+ * {
+ *   // analyzed but not injected
+ *   myFooResolve: function() { return "myFooData"; },
+ *
+ *   // function.toString() parsed, "DependencyName" dep as string (not min-safe)
+ *   myBarResolve: function(DependencyName) { return DependencyName.fetchSomethingAsPromise() },
+ *
+ *   // Array split; "DependencyName" dep as string
+ *   myBazResolve: [ "DependencyName", function(dep) { return dep.fetchSomethingAsPromise() },
+ *
+ *   // Array split; DependencyType dep as token (compared using ===)
+ *   myQuxResolve: [ DependencyType, function(dep) { return dep.fetchSometingAsPromise() },
+ *
+ *   // val.$inject used as deps
+ *   // where:
+ *   //     corgeResolve.$inject = ["DependencyName"];
+ *   //     function corgeResolve(dep) { dep.fetchSometingAsPromise() }
+ *   // then "DependencyName" dep as string
+ *   myCorgeResolve: corgeResolve,
+ *
+ *  // inject service by name
+ *  // When a string is found, desugar creating a resolve that injects the named service
+ *   myGraultResolve: "SomeService"
+ * }
+ *
+ * or:
+ *
+ * [
+ *   new Resolvable("myFooResolve", function() { return "myFooData" }),
+ *   new Resolvable("myBarResolve", function(dep) { return dep.fetchSomethingAsPromise() }, [ "DependencyName" ]),
+ *   { provide: "myBazResolve", useFactory: function(dep) { dep.fetchSomethingAsPromise() }, deps: [ "DependencyName" ] }
+ * ]
+ */
+export function resolvablesBuilder(state) {
+  /** convert resolve: {} and resolvePolicy: {} objects to an array of tuples */
+  const objects2Tuples = (resolveObj, resolvePolicies) =>
+    Object.keys(resolveObj || {}).map((token) => ({
+      token,
+      val: resolveObj[token],
+      deps: undefined,
+      policy: resolvePolicies[token],
+    }));
+  /** fetch DI annotations from a function or ng1-style array */
+  const annotate = (fn) => {
+    const $injector = services.$injector;
+    // ng1 doesn't have an $injector until runtime.
+    // If the $injector doesn't exist, use "deferred" literal as a
+    // marker indicating they should be annotated when runtime starts
+    return (
+      fn["$inject"] ||
+      ($injector && $injector.annotate(fn, $injector.strictDi)) ||
+      "deferred"
+    );
+  };
+  /** true if the object has both `token` and `resolveFn`, and is probably a [[ResolveLiteral]] */
+  const isResolveLiteral = (obj) => !!(obj.token && obj.resolveFn);
+  /** true if the object looks like a provide literal, or a ng2 Provider */
+  const isLikeNg2Provider = (obj) =>
+    !!(
+      (obj.provide || obj.token) &&
+      (obj.useValue || obj.useFactory || obj.useExisting || obj.useClass)
+    );
+  /** true if the object looks like a tuple from obj2Tuples */
+  const isTupleFromObj = (obj) =>
+    !!(
+      obj &&
+      obj.val &&
+      (isString(obj.val) || isArray(obj.val) || isFunction(obj.val))
+    );
+  /** extracts the token from a Provider or provide literal */
+  const getToken = (p) => p.provide || p.token;
+  // prettier-ignore: Given a literal resolve or provider object, returns a Resolvable
+  const literal2Resolvable = pattern([
+    [
+      prop("resolveFn"),
+      (p) => new Resolvable(getToken(p), p.resolveFn, p.deps, p.policy),
+    ],
+    [
+      prop("useFactory"),
+      (p) =>
+        new Resolvable(
+          getToken(p),
+          p.useFactory,
+          p.deps || p.dependencies,
+          p.policy,
+        ),
+    ],
+    [
+      prop("useClass"),
+      (p) => new Resolvable(getToken(p), () => new p.useClass(), [], p.policy),
+    ],
+    [
+      prop("useValue"),
+      (p) =>
+        new Resolvable(getToken(p), () => p.useValue, [], p.policy, p.useValue),
+    ],
+    [
+      prop("useExisting"),
+      (p) => new Resolvable(getToken(p), identity, [p.useExisting], p.policy),
+    ],
+  ]);
+  // prettier-ignore
+  const tuple2Resolvable = pattern([
+        [pipe(prop('val'), isString), (tuple) => new Resolvable(tuple.token, identity, [tuple.val], tuple.policy)],
+        [pipe(prop('val'), isArray), (tuple) => new Resolvable(tuple.token, tail(tuple.val), tuple.val.slice(0, -1), tuple.policy)],
+        [pipe(prop('val'), isFunction), (tuple) => new Resolvable(tuple.token, tuple.val, annotate(tuple.val), tuple.policy)],
+    ]);
+  // prettier-ignore
+  const item2Resolvable = pattern([
+        [is(Resolvable), (r) => r],
+        [isResolveLiteral, literal2Resolvable],
+        [isLikeNg2Provider, literal2Resolvable],
+        [isTupleFromObj, tuple2Resolvable],
+        [val(true), (obj) => { throw new Error('Invalid resolve value: ' + stringify(obj)); },],
+    ]);
+  // If resolveBlock is already an array, use it as-is.
+  // Otherwise, assume it's an object and convert to an Array of tuples
+  const decl = state.resolve;
+  const items = isArray(decl)
+    ? decl
+    : objects2Tuples(decl, state.resolvePolicy || {});
+  return items.map(item2Resolvable);
+}
+/**
+ * A internal global service
+ *
+ * StateBuilder is a factory for the internal [[StateObject]] objects.
+ *
+ * When you register a state with the [[StateRegistry]], you register a plain old javascript object which
+ * conforms to the [[StateDeclaration]] interface.  This factory takes that object and builds the corresponding
+ * [[StateObject]] object, which has an API and is used internally.
+ *
+ * Custom properties or API may be added to the internal [[StateObject]] object by registering a decorator function
+ * using the [[builder]] method.
+ */
+export class StateBuilder {
+  constructor(matcher, urlMatcherFactory) {
+    this.matcher = matcher;
+    const self = this;
+    const root = () => matcher.find("");
+    const isRoot = (state) => state.name === "";
+    function parentBuilder(state) {
+      if (isRoot(state)) return null;
+      return matcher.find(self.parentName(state)) || root();
+    }
+    this.builders = {
+      name: [nameBuilder],
+      self: [selfBuilder],
+      parent: [parentBuilder],
+      data: [dataBuilder],
+      // Build a URLMatcher if necessary, either via a relative or absolute URL
+      url: [getUrlBuilder(urlMatcherFactory, root)],
+      // Keep track of the closest ancestor state that has a URL (i.e. is navigable)
+      navigable: [getNavigableBuilder(isRoot)],
+      params: [getParamsBuilder(urlMatcherFactory.paramFactory)],
+      // Each framework-specific ui-router implementation should define its own `views` builder
+      // e.g., src/ng1/statebuilders/views.ts
+      views: [],
+      // Keep a full path from the root down to this state as this is needed for state activation.
+      path: [pathBuilder],
+      // Speed up $state.includes() as it's used a lot
+      includes: [includesBuilder],
+      resolvables: [resolvablesBuilder],
+    };
+  }
+  builder(name, fn) {
+    const builders = this.builders;
+    const array = builders[name] || [];
+    // Backwards compat: if only one builder exists, return it, else return whole arary.
+    if (isString(name) && !isDefined(fn))
+      return array.length > 1 ? array : array[0];
+    if (!isString(name) || !isFunction(fn)) return;
+    builders[name] = array;
+    builders[name].push(fn);
+    return () => builders[name].splice(builders[name].indexOf(fn, 1)) && null;
+  }
+  /**
+   * Builds all of the properties on an essentially blank State object, returning a State object which has all its
+   * properties and API built.
+   *
+   * @param state an uninitialized State object
+   * @returns the built State object
+   */
+  build(state) {
+    const { matcher, builders } = this;
+    const parent = this.parentName(state);
+    if (parent && !matcher.find(parent, undefined, false)) {
+      return null;
+    }
+    for (const key in builders) {
+      if (!Object.prototype.hasOwnProperty.call(builders, key)) continue;
+      const chain = builders[key].reduce(
+        (parentFn, step) => (_state) => step(_state, parentFn),
+        noop,
+      );
+      state[key] = chain(state);
+    }
+    return state;
+  }
+  parentName(state) {
+    // name = 'foo.bar.baz.**'
+    const name = state.name || "";
+    // segments = ['foo', 'bar', 'baz', '.**']
+    const segments = name.split(".");
+    // segments = ['foo', 'bar', 'baz']
+    const lastSegment = segments.pop();
+    // segments = ['foo', 'bar'] (ignore .** segment for future states)
+    if (lastSegment === "**") segments.pop();
+    if (segments.length) {
+      if (state.parent) {
+        throw new Error(
+          `States that specify the 'parent:' property should not have a '.' in their name (${name})`,
+        );
+      }
+      // 'foo.bar'
+      return segments.join(".");
+    }
+    if (!state.parent) return "";
+    return isString(state.parent) ? state.parent : state.parent.name;
+  }
+  name(state) {
+    const name = state.name;
+    if (name.indexOf(".") !== -1 || !state.parent) return name;
+    const parentName = isString(state.parent)
+      ? state.parent
+      : state.parent.name;
+    return parentName ? parentName + "." + name : name;
+  }
+}

package/src/router/core/state/stateMatcher.js

@@ -0,0 +1,65 @@
+import { isString } from "../common/predicates";
+import { safeConsole } from "../common/safeConsole";
+export class StateMatcher {
+  constructor(_states) {
+    this._states = _states;
+  }
+  isRelative(stateName) {
+    stateName = stateName || "";
+    return stateName.indexOf(".") === 0 || stateName.indexOf("^") === 0;
+  }
+  find(stateOrName, base, matchGlob = true) {
+    if (!stateOrName && stateOrName !== "") return undefined;
+    const isStr = isString(stateOrName);
+    let name = isStr ? stateOrName : stateOrName.name;
+    if (this.isRelative(name)) name = this.resolvePath(name, base);
+    const state = this._states[name];
+    if (
+      state &&
+      (isStr ||
+        (!isStr && (state === stateOrName || state.self === stateOrName)))
+    ) {
+      return state;
+    } else if (isStr && matchGlob) {
+      const _states = Object.values(this._states);
+      const matches = _states.filter(
+        (_state) =>
+          _state.__stateObjectCache.nameGlob &&
+          _state.__stateObjectCache.nameGlob.matches(name),
+      );
+      if (matches.length > 1) {
+        safeConsole.error(
+          `stateMatcher.find: Found multiple matches for ${name} using glob: `,
+          matches.map((match) => match.name),
+        );
+      }
+      return matches[0];
+    }
+    return undefined;
+  }
+  resolvePath(name, base) {
+    if (!base) throw new Error(`No reference point given for path '${name}'`);
+    const baseState = this.find(base);
+    const splitName = name.split(".");
+    const pathLength = splitName.length;
+    let i = 0,
+      current = baseState;
+    for (; i < pathLength; i++) {
+      if (splitName[i] === "" && i === 0) {
+        current = baseState;
+        continue;
+      }
+      if (splitName[i] === "^") {
+        if (!current.parent)
+          throw new Error(
+            `Path '${name}' not valid for state '${baseState.name}'`,
+          );
+        current = current.parent;
+        continue;
+      }
+      break;
+    }
+    const relName = splitName.slice(i).join(".");
+    return current.name + (current.name && relName ? "." : "") + relName;
+  }
+}