@angular-wave/angular.ts 0.0.11 → 0.0.13

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

@@ -0,0 +1,117 @@
+import { defaults, find, inherit } from "../common/common";
+import { propEq } from "../common/hof";
+import { Glob } from "../common/glob";
+import { isObject, isFunction } from "../common/predicates";
+/**
+ * Internal representation of a UI-Router state.
+ *
+ * Instances of this class are created when a [[StateDeclaration]] is registered with the [[StateRegistry]].
+ *
+ * A registered [[StateDeclaration]] is augmented with a getter ([[StateDeclaration.$$state]]) which returns the corresponding [[StateObject]] object.
+ *
+ * This class prototypally inherits from the corresponding [[StateDeclaration]].
+ * Each of its own properties (i.e., `hasOwnProperty`) are built using builders from the [[StateBuilder]].
+ */
+export class StateObject {
+  /**
+   * Create a state object to put the private/internal implementation details onto.
+   * The object's prototype chain looks like:
+   * (Internal State Object) -> (Copy of State.prototype) -> (State Declaration object) -> (State Declaration's prototype...)
+   *
+   * @param stateDecl the user-supplied State Declaration
+   * @returns {StateObject} an internal State object
+   */
+  static create(stateDecl) {
+    stateDecl = StateObject.isStateClass(stateDecl)
+      ? new stateDecl()
+      : stateDecl;
+    const state = inherit(inherit(stateDecl, StateObject.prototype));
+    stateDecl.$$state = () => state;
+    state.self = stateDecl;
+    state.__stateObjectCache = {
+      nameGlob: Glob.fromString(state.name), // might return null
+    };
+    return state;
+  }
+  /** @deprecated use State.create() */
+  constructor(config) {
+    return StateObject.create(config || {});
+  }
+  /**
+   * Returns true if the provided parameter is the same state.
+   *
+   * Compares the identity of the state against the passed value, which is either an object
+   * reference to the actual `State` instance, the original definition object passed to
+   * `$stateProvider.state()`, or the fully-qualified name.
+   *
+   * @param ref Can be one of (a) a `State` instance, (b) an object that was passed
+   *        into `$stateProvider.state()`, (c) the fully-qualified name of a state as a string.
+   * @returns Returns `true` if `ref` matches the current `State` instance.
+   */
+  is(ref) {
+    return this === ref || this.self === ref || this.fqn() === ref;
+  }
+  /**
+   * @deprecated this does not properly handle dot notation
+   * @returns Returns a dot-separated name of the state.
+   */
+  fqn() {
+    if (!this.parent || !(this.parent instanceof this.constructor))
+      return this.name;
+    const name = this.parent.fqn();
+    return name ? name + "." + this.name : this.name;
+  }
+  /**
+   * Returns the root node of this state's tree.
+   *
+   * @returns The root of this state's tree.
+   */
+  root() {
+    return (this.parent && this.parent.root()) || this;
+  }
+  /**
+   * Gets the state's `Param` objects
+   *
+   * Gets the list of [[Param]] objects owned by the state.
+   * If `opts.inherit` is true, it also includes the ancestor states' [[Param]] objects.
+   * If `opts.matchingKeys` exists, returns only `Param`s whose `id` is a key on the `matchingKeys` object
+   *
+   * @param opts options
+   */
+  parameters(opts) {
+    opts = defaults(opts, { inherit: true, matchingKeys: null });
+    const inherited =
+      (opts.inherit && this.parent && this.parent.parameters()) || [];
+    return inherited
+      .concat(Object.values(this.params))
+      .filter(
+        (param) =>
+          !opts.matchingKeys ||
+          Object.prototype.hasOwnProperty.call(opts.matchingKeys, param.id),
+      );
+  }
+  /**
+   * Returns a single [[Param]] that is owned by the state
+   *
+   * If `opts.inherit` is true, it also searches the ancestor states` [[Param]]s.
+   * @param id the name of the [[Param]] to return
+   * @param opts options
+   */
+  parameter(id, opts = {}) {
+    return (
+      (this.url && this.url.parameter(id, opts)) ||
+      find(Object.values(this.params), propEq("id", id)) ||
+      (opts.inherit && this.parent && this.parent.parameter(id))
+    );
+  }
+  toString() {
+    return this.fqn();
+  }
+}
+/** Predicate which returns true if the object is an class with @State() decorator */
+StateObject.isStateClass = (stateDecl) =>
+  isFunction(stateDecl) && stateDecl["__uiRouterState"] === true;
+/** Predicate which returns true if the object is a [[StateDeclaration]] object */
+StateObject.isStateDeclaration = (obj) => isFunction(obj["$$state"]);
+/** Predicate which returns true if the object is an internal [[StateObject]] object */
+StateObject.isState = (obj) => isObject(obj["__stateObjectCache"]);

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

@@ -0,0 +1,89 @@
+import { inArray } from "../common/common";
+import { prop } from "../common/hof";
+import { isString } from "../common/predicates";
+import { StateObject } from "./stateObject";
+export class StateQueueManager {
+  constructor(router, states, builder, listeners) {
+    this.router = router;
+    this.states = states;
+    this.builder = builder;
+    this.listeners = listeners;
+    this.queue = [];
+  }
+  dispose() {
+    this.queue = [];
+  }
+  register(stateDecl) {
+    const queue = this.queue;
+    const state = StateObject.create(stateDecl);
+    const name = state.name;
+    if (!isString(name)) throw new Error("State must have a valid name");
+    if (
+      Object.prototype.hasOwnProperty.call(this.states, name) ||
+      inArray(queue.map(prop("name")), name)
+    )
+      throw new Error(`State '${name}' is already defined`);
+    queue.push(state);
+    this.flush();
+    return state;
+  }
+  flush() {
+    const { queue, states, builder } = this;
+    const registered = [], // states that got registered
+      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];
+    const notifyListeners = () => {
+      if (registered.length) {
+        this.listeners.forEach((listener) =>
+          listener(
+            "registered",
+            registered.map((s) => s.self),
+          ),
+        );
+      }
+    };
+    while (queue.length > 0) {
+      const state = queue.shift();
+      const name = state.name;
+      const result = builder.build(state);
+      const orphanIdx = orphans.indexOf(state);
+      if (result) {
+        const existingState = getState(name);
+        if (existingState && existingState.name === name) {
+          throw new Error(`State '${name}' is already defined`);
+        }
+        const existingFutureState = getState(name + ".**");
+        if (existingFutureState) {
+          // Remove future state of the same name
+          this.router.stateRegistry.deregister(existingFutureState);
+        }
+        states[name] = state;
+        this.attachRoute(state);
+        if (orphanIdx >= 0) orphans.splice(orphanIdx, 1);
+        registered.push(state);
+        continue;
+      }
+      const prev = previousQueueLength[name];
+      previousQueueLength[name] = queue.length;
+      if (orphanIdx >= 0 && prev === queue.length) {
+        // Wait until two consecutive iterations where no additional states were dequeued successfully.
+        // throw new Error(`Cannot register orphaned state '${name}'`);
+        queue.push(state);
+        notifyListeners();
+        return states;
+      } else if (orphanIdx < 0) {
+        orphans.push(state);
+      }
+      queue.push(state);
+    }
+    notifyListeners();
+    return states;
+  }
+  attachRoute(state) {
+    if (state.abstract || !state.url) return;
+    const rulesApi = this.router.urlService.rules;
+    rulesApi.rule(rulesApi.urlRuleFactory.create(state));
+  }
+}

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

@@ -0,0 +1,175 @@
+import { StateMatcher } from "./stateMatcher";
+import { StateBuilder } from "./stateBuilder";
+import { StateQueueManager } from "./stateQueueManager";
+import { removeFrom } from "../common/common";
+import { propEq } from "../common/hof";
+/**
+ * A registry for all of the application's [[StateDeclaration]]s
+ *
+ * This API is found at `router.stateRegistry` ([[UIRouter.stateRegistry]])
+ */
+export class StateRegistry {
+  /** @internal */
+  constructor(router) {
+    this.router = router;
+    this.states = {};
+    /** @internal */
+    this.listeners = [];
+    this.matcher = new StateMatcher(this.states);
+    this.builder = new StateBuilder(this.matcher, router.urlMatcherFactory);
+    this.stateQueue = new StateQueueManager(
+      router,
+      this.states,
+      this.builder,
+      this.listeners,
+    );
+    this._registerRoot();
+  }
+  /** @internal */
+  _registerRoot() {
+    const rootStateDef = {
+      name: "",
+      url: "^",
+      views: null,
+      params: {
+        "#": { value: null, type: "hash", dynamic: true },
+      },
+      abstract: true,
+    };
+    const _root = (this._root = this.stateQueue.register(rootStateDef));
+    _root.navigable = null;
+  }
+  /** @internal */
+  dispose() {
+    this.stateQueue.dispose();
+    this.listeners = [];
+    this.get().forEach((state) => this.get(state) && this.deregister(state));
+  }
+  /**
+   * Listen for a State Registry events
+   *
+   * Adds a callback that is invoked when states are registered or deregistered with the StateRegistry.
+   *
+   * #### Example:
+   * ```js
+   * let allStates = registry.get();
+   *
+   * // Later, invoke deregisterFn() to remove the listener
+   * let deregisterFn = registry.onStatesChanged((event, states) => {
+   *   switch(event) {
+   *     case: 'registered':
+   *       states.forEach(state => allStates.push(state));
+   *       break;
+   *     case: 'deregistered':
+   *       states.forEach(state => {
+   *         let idx = allStates.indexOf(state);
+   *         if (idx !== -1) allStates.splice(idx, 1);
+   *       });
+   *       break;
+   *   }
+   * });
+   * ```
+   *
+   * @param listener a callback function invoked when the registered states changes.
+   *        The function receives two parameters, `event` and `state`.
+   *        See [[StateRegistryListener]]
+   * @return a function that deregisters the listener
+   */
+  onStatesChanged(listener) {
+    this.listeners.push(listener);
+    return function deregisterListener() {
+      removeFrom(this.listeners)(listener);
+    }.bind(this);
+  }
+  /**
+   * Gets the implicit root state
+   *
+   * Gets the root of the state tree.
+   * The root state is implicitly created by UI-Router.
+   * Note: this returns the internal [[StateObject]] representation, not a [[StateDeclaration]]
+   *
+   * @return the root [[StateObject]]
+   */
+  root() {
+    return this._root;
+  }
+  /**
+   * Adds a state to the registry
+   *
+   * Registers a [[StateDeclaration]] or queues it for registration.
+   *
+   * Note: a state will be queued if the state's parent isn't yet registered.
+   *
+   * @param stateDefinition the definition of the state to register.
+   * @returns the internal [[StateObject]] object.
+   *          If the state was successfully registered, then the object is fully built (See: [[StateBuilder]]).
+   *          If the state was only queued, then the object is not fully built.
+   */
+  register(stateDefinition) {
+    return this.stateQueue.register(stateDefinition);
+  }
+  /** @internal */
+  _deregisterTree(state) {
+    const all = this.get().map((s) => s.$$state());
+    const getChildren = (states) => {
+      const _children = all.filter((s) => states.indexOf(s.parent) !== -1);
+      return _children.length === 0
+        ? _children
+        : _children.concat(getChildren(_children));
+    };
+    const children = getChildren([state]);
+    const deregistered = [state].concat(children).reverse();
+    deregistered.forEach((_state) => {
+      const rulesApi = this.router.urlService.rules;
+      // Remove URL rule
+      rulesApi
+        .rules()
+        .filter(propEq("state", _state))
+        .forEach((rule) => rulesApi.removeRule(rule));
+      // Remove state from registry
+      delete this.states[_state.name];
+    });
+    return deregistered;
+  }
+  /**
+   * Removes a state from the registry
+   *
+   * This removes a state from the registry.
+   * If the state has children, they are are also removed from the registry.
+   *
+   * @param stateOrName the state's name or object representation
+   * @returns {StateObject[]} a list of removed states
+   */
+  deregister(stateOrName) {
+    const _state = this.get(stateOrName);
+    if (!_state)
+      throw new Error("Can't deregister state; not found: " + stateOrName);
+    const deregisteredStates = this._deregisterTree(_state.$$state());
+    this.listeners.forEach((listener) =>
+      listener(
+        "deregistered",
+        deregisteredStates.map((s) => s.self),
+      ),
+    );
+    return deregisteredStates;
+  }
+  get(stateOrName, base) {
+    if (arguments.length === 0)
+      return Object.keys(this.states).map((name) => this.states[name].self);
+    const found = this.matcher.find(stateOrName, base);
+    return (found && found.self) || null;
+  }
+  /**
+   * Registers a [[BuilderFunction]] for a specific [[StateObject]] property (e.g., `parent`, `url`, or `path`).
+   * More than one BuilderFunction can be registered for a given property.
+   *
+   * The BuilderFunction(s) will be used to define the property on any subsequently built [[StateObject]] objects.
+   *
+   * @param property The name of the State property being registered for.
+   * @param builderFunction The BuilderFunction which will be used to build the State property
+   * @returns a function which deregisters the BuilderFunction
+   */
+  decorator(property, builderFunction) {
+    return this.builder.builder(property, builderFunction);
+  }
+}