@angular-wave/angular.ts 0.9.3 → 0.9.5

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

@@ -1,95 +0,0 @@
-import { hasOwn, isString } from "../../shared/utils.js";
-import { StateObject } from "./state-object.js";
-
-export class StateQueueManager {
-  /**
-   * @param {import("./state-registry.js").StateRegistryProvider} stateRegistry
-   * @param {*} urlServiceRules
-   * @param {*} states
-   * @param {*} builder
-   * @param {*} listeners
-   */
-  constructor(stateRegistry, urlServiceRules, states, builder, listeners) {
-    this.stateRegistry = stateRegistry;
-    this.urlServiceRules = urlServiceRules;
-    this.states = states;
-    this.builder = builder;
-    this.listeners = listeners;
-    /**
-     * @type {Array<StateObject>}
-     */
-    this.queue = [];
-  }
-
-  register(stateDecl) {
-    const state = new StateObject(stateDecl);
-    if (!isString(name)) throw new Error("State must have a valid name");
-    if (
-      hasOwn(this.states, state.name) ||
-      this.queue.map((x) => x.name).includes(state.name)
-    )
-      throw new Error(`State '${state.name}' is already defined`);
-    this.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) => hasOwn(this.states, 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.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.urlServiceRules;
-    rulesApi.rule(rulesApi.urlRuleFactory.create(state));
-  }
-}

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

@@ -1,257 +0,0 @@
-import { StateMatcher } from "./state-matcher.js";
-import { StateBuilder } from "./state-builder.js";
-import { StateQueueManager } from "./state-queue-manager.js";
-import { applyPairs, removeFrom } from "../../shared/common.js";
-import { propEq } from "../../shared/hof.js";
-import { ResolveContext } from "../resolve/resolve-context.js";
-import { ng1ViewsBuilder } from "./views.js";
-import { isString } from "../../shared/utils.js";
-import { $injectTokens as $t, provider } from "../../injection-tokens.js";
-
-/** @typedef {import('../../interface.ts').ServiceProvider} ServiceProvider } */
-/**
- * A registry for all of the application's [[StateDeclaration]]s
- *
- * This API is found at `$stateRegistry` ([[UIRouter.stateRegistry]])
- *
- */
-export class StateRegistryProvider {
-  static $inject = provider([$t.$url, $t.$state, $t.$router, $t.$view]);
-
-  /**
-   * @param urlService
-   * @param stateService
-   * @param {import('../router.js').Router} globals
-   * @param viewService
-   */
-  constructor(urlService, stateService, globals, viewService) {
-    this.states = {};
-    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, 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);
-    this.builder.builder("onExit", this.getStateHookBuilder("onExit"));
-    this.builder.builder("onRetain", this.getStateHookBuilder("onRetain"));
-    this.builder.builder("onEnter", this.getStateHookBuilder("onEnter"));
-
-    this.stateQueue = new StateQueueManager(
-      this,
-      this.urlServiceRules,
-      this.states,
-      this.builder,
-      this.listeners,
-    );
-
-    this.registerRoot();
-
-    viewService.rootViewContext(this.root());
-    globals.$current = this.root();
-    globals.current = globals.$current.self;
-  }
-
-  $get = [
-    $t.$injector,
-    /**
-     * @param {import("../../core/di/internal-injector").InjectorService} $injector
-     * @returns {StateRegistryProvider}
-     */
-    ($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 [[StateDeclaration]].
-   *
-   * When the [[StateBuilder]] builds a [[StateObject]] object from a raw [[StateDeclaration]], this builder
-   * ensures that those hooks are injectable for @uirouter/angularjs (ng1).
-   *
-   * @internalapi
-   */
-  getStateHookBuilder(hookName) {
-    let that = this;
-    return function stateHookBuilder(stateObject) {
-      const hook = stateObject[hookName];
-      const pathname = hookName === "onExit" ? "from" : "to";
-      function decoratedNg1Hook(trans, state) {
-        const resolveContext = new ResolveContext(trans.treeChanges(pathname));
-        const subContext = resolveContext.subContext(state.$$state());
-        const locals = Object.assign(getLocals(subContext), {
-          $state$: state,
-          $transition$: trans,
-        });
-        return that.$injector.invoke(hook, this, locals);
-      }
-      return hook ? decoratedNg1Hook : undefined;
-    };
-  }
-
-  /**
-   * @private
-   */
-  registerRoot() {
-    const rootStateDef = {
-      name: "",
-      url: "^",
-      views: null,
-      params: {
-        "#": { value: null, type: "hash", dynamic: true },
-      },
-      abstract: true,
-    };
-    this._root = this.stateQueue.register(rootStateDef);
-    this._root.navigable = null;
-  }
-
-  /**
-   * 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 ng-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);
-  }
-
-  _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.urlServiceRules;
-      // 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 {import('./state-object').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);
-  }
-}
-
-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, {});
-};