@angular-wave/angular.ts 0.9.3 → 0.9.5

package/src/router/resolve/resolve-context.js

@@ -1,190 +0,0 @@
-import { find, tail, uniqR, unnestR } from "../../shared/common.js";
-import { propEq } from "../../shared/hof.js";
-import { trace } from "../common/trace.js";
-import { Resolvable } from "./resolvable.js";
-import { PathUtils } from "../path/path-utils.js";
-import { stringify } from "../../shared/strings.js";
-import { isUndefined } from "../../shared/utils.js";
-
-export const resolvePolicies = {
-  when: {
-    LAZY: "LAZY",
-    EAGER: "EAGER",
-  },
-  async: {
-    WAIT: "WAIT",
-    NOWAIT: "NOWAIT",
-  },
-};
-
-const ALL_WHENS = [resolvePolicies.when.EAGER, resolvePolicies.when.LAZY];
-const EAGER_WHENS = [resolvePolicies.when.EAGER];
-/**
- * Encapsulates Dependency Injection for a path of nodes
- *
- * ng-router states are organized as a tree.
- * A nested state has a path of ancestors to the root of the tree.
- * When a state is being activated, each element in the path is wrapped as a [[PathNode]].
- * A `PathNode` is a stateful object that holds things like parameters and resolvables for the state being activated.
- *
- * The ResolveContext closes over the [[PathNode]]s, and provides DI for the last node in the path.
- */
-export class ResolveContext {
-  constructor(_path) {
-    this._path = _path;
-  }
-  /** Gets all the tokens found in the resolve context, de-duplicated */
-  getTokens() {
-    return this._path
-      .reduce(
-        (acc, node) => acc.concat(node.resolvables.map((r) => r.token)),
-        [],
-      )
-      .reduce(uniqR, []);
-  }
-  /**
-   * Gets the Resolvable that matches the token
-   *
-   * Gets the last Resolvable that matches the token in this context, or undefined.
-   * Throws an error if it doesn't exist in the ResolveContext
-   */
-  getResolvable(token) {
-    const matching = this._path
-      .map((node) => node.resolvables)
-      .reduce(unnestR, [])
-      .filter((r) => r.token === token);
-    return tail(matching);
-  }
-
-  /** Returns the [[ResolvePolicy]] for the given [[Resolvable]] */
-  getPolicy(resolvable) {
-    const node = this.findNode(resolvable);
-    return resolvable.getPolicy(node);
-  }
-
-  /**
-   * Returns a ResolveContext that includes a portion of this one
-   *
-   * Given a state, this method creates a new ResolveContext from this one.
-   * The new context starts at the first node (root) and stops at the node for the `state` parameter.
-   *
-   * #### Why
-   *
-   * When a transition is created, the nodes in the "To Path" are injected from a ResolveContext.
-   * A ResolveContext closes over a path of [[PathNode]]s and processes the resolvables.
-   * The "To State" can inject values from its own resolvables, as well as those from all its ancestor state's (node's).
-   * This method is used to create a narrower context when injecting ancestor nodes.
-   *
-   * @example
-   * `let ABCD = new ResolveContext([A, B, C, D]);`
-   *
-   * Given a path `[A, B, C, D]`, where `A`, `B`, `C` and `D` are nodes for states `a`, `b`, `c`, `d`:
-   * When injecting `D`, `D` should have access to all resolvables from `A`, `B`, `C`, `D`.
-   * However, `B` should only be able to access resolvables from `A`, `B`.
-   *
-   * When resolving for the `B` node, first take the full "To Path" Context `[A,B,C,D]` and limit to the subpath `[A,B]`.
-   * `let AB = ABCD.subcontext(a)`
-   */
-  subContext(state) {
-    return new ResolveContext(
-      PathUtils.subPath(this._path, (node) => node.state === state),
-    );
-  }
-  /**
-   * Adds Resolvables to the node that matches the state
-   *
-   * This adds a [[Resolvable]] (generally one created on the fly; not declared on a [[StateDeclaration.resolve]] block).
-   * The resolvable is added to the node matching the `state` parameter.
-   *
-   * These new resolvables are not automatically fetched.
-   * The calling code should either fetch them, fetch something that depends on them,
-   * or rely on [[resolvePath]] being called when some state is being entered.
-   *
-   * Note: each resolvable's [[ResolvePolicy]] is merged with the state's policy, and the global default.
-   *
-   * @param {Resolvable[]} newResolvables the new Resolvables
-   * @param state Used to find the node to put the resolvable on
-   */
-  addResolvables(newResolvables, state) {
-    /** @type {import('../path/path-node').PathNode} */
-    const node = find(this._path, propEq("state", state));
-    const keys = newResolvables.map((r) => r.token);
-    node.resolvables = node.resolvables
-      .filter((r) => keys.indexOf(r.token) === -1)
-      .concat(newResolvables);
-  }
-  /**
-   * Returns a promise for an array of resolved path Element promises
-   *
-   * @param {string} when
-   * @param trans
-   * @returns {Promise<any>|any}
-   */
-  resolvePath(when = "LAZY", trans) {
-    // This option determines which 'when' policy Resolvables we are about to fetch.
-    const whenOption = ALL_WHENS.includes(when) ? when : "LAZY";
-    // If the caller specified EAGER, only the EAGER Resolvables are fetched.
-    // if the caller specified LAZY, both EAGER and LAZY Resolvables are fetched.`
-    const matchedWhens =
-      whenOption === resolvePolicies.when.EAGER ? EAGER_WHENS : ALL_WHENS;
-    // get the subpath to the state argument, if provided
-    trace.traceResolvePath(this._path, when, trans);
-    const matchesPolicy = (acceptedVals, whenOrAsync) => (resolvable) =>
-      acceptedVals.includes(this.getPolicy(resolvable)[whenOrAsync]);
-    // Trigger all the (matching) Resolvables in the path
-    // Reduce all the "WAIT" Resolvables into an array
-    const promises = this._path.reduce((acc, node) => {
-      const nodeResolvables = node.resolvables.filter(
-        matchesPolicy(matchedWhens, "when"),
-      );
-      const nowait = nodeResolvables.filter(matchesPolicy(["NOWAIT"], "async"));
-      const wait = nodeResolvables.filter(
-        (x) => !matchesPolicy(["NOWAIT"], "async")(x),
-      );
-      // For the matching Resolvables, start their async fetch process.
-      const subContext = this.subContext(node.state);
-      const getResult = (r) =>
-        r
-          .get(subContext, trans)
-          // Return a tuple that includes the Resolvable's token
-          .then((value) => ({ token: r.token, value: value }));
-      nowait.forEach(getResult);
-      return acc.concat(wait.map(getResult));
-    }, []);
-    // Wait for all the "WAIT" resolvables
-    return Promise.all(promises);
-  }
-
-  findNode(resolvable) {
-    return find(this._path, (node) => node.resolvables.includes(resolvable));
-  }
-
-  /**
-   * Gets the async dependencies of a Resolvable
-   *
-   * Given a Resolvable, returns its dependencies as a Resolvable[]
-   * @param {Resolvable} resolvable
-   * @returns {Resolvable[]}
-   */
-  getDependencies(resolvable) {
-    const node = this.findNode(resolvable);
-    // Find which other resolvables are "visible" to the `resolvable` argument
-    // subpath stopping at resolvable's node, or the whole path (if the resolvable isn't in the path)
-    const subPath =
-      PathUtils.subPath(this._path, (x) => x === node) || this._path;
-    const availableResolvables = subPath
-      .reduce((acc, _node) => acc.concat(_node.resolvables), []) // all of subpath's resolvables
-      .filter((res) => res !== resolvable); // filter out the `resolvable` argument
-    return resolvable.deps.map((token) => {
-      const matching = availableResolvables.filter((r) => r.token === token);
-      if (matching.length) return tail(matching);
-      const fromInjector = window["angular"].$injector.get(token);
-      if (isUndefined(fromInjector)) {
-        throw new Error(
-          "Could not find Dependency Injection token: " + stringify(token),
-        );
-      }
-      return new Resolvable(token, () => fromInjector, [], fromInjector);
-    });
-  }
-}

package/src/router/router-test-hashbang.html

@@ -1,45 +0,0 @@
-<!doctype html>
-<html>
-  <head>
-    <meta charset="utf-8" />
-    <title>AngularTS</title>
-    <link rel="shortcut icon" type="image/png" href="images/favicon.ico" />
-    <script type="module" src="../index.js"></script>
-    <script>
-      document.addEventListener("DOMContentLoaded", () => {
-        window.angular.module("router", []).config([
-          "$stateProvider",
-          "$locationProvider",
-          ($stateProvider, $locationProvider) => {
-            $locationProvider.html5ModeConf = {
-              enabled: false,
-            };
-            $stateProvider
-              .state({
-                name: "home",
-                url: "",
-                template: `
-                    <h1>Home</h1>
-                    <a ng-sref="page1">Page 1</a>
-                    <a ng-sref="page2">Page 2</a>
-                `,
-              })
-              .state({
-                name: "page1",
-                url: "/page1",
-                template: "<h3>Its the NG-Router hello world app!</h3>",
-              })
-              .state({
-                name: "page2",
-                url: "/page2",
-                template: "This is another template",
-              });
-          },
-        ]);
-      });
-    </script>
-  </head>
-  <body ng-app="router">
-    <ng-view></ng-view>
-  </body>
-</html>

package/src/router/router-test.html

@@ -1,41 +0,0 @@
-<!doctype html>
-<html>
-  <head>
-    <meta charset="utf-8" />
-    <title>AngularTS</title>
-    <link rel="shortcut icon" type="image/png" href="images/favicon.ico" />
-    <script type="module" src="../index.js"></script>
-    <script>
-      document.addEventListener("DOMContentLoaded", () => {
-        window.angular.module("router", []).config([
-          "$stateProvider",
-          "$locationProvider",
-          ($stateProvider, $locationProvider) => {
-            $locationProvider.html5ModeConf = {
-              enabled: true,
-              requireBase: false,
-              rewriteLinks: false,
-            };
-            $stateProvider
-              .state({
-                name: "home",
-                url: "/src/router/router-test.html",
-                template: `
-                <h1>Home</h1>
-                <a ng-sref="page1">Page 1</a>
-              `,
-              })
-              .state({
-                name: "page1",
-                url: "/page1",
-                template: "<h3>Its the NG-Router hello world app!</h3>",
-              });
-          },
-        ]);
-      });
-    </script>
-  </head>
-  <body ng-app="router">
-    <ng-view></ng-view>
-  </body>
-</html>

package/src/router/router.html

@@ -1,22 +0,0 @@
-<!doctype html>
-<html>
-  <head>
-    <meta charset="utf-8" />
-    <title>AngularTS Test Runner</title>
-
-    <link rel="shortcut icon" type="image/png" href="/images/favicon.ico" />
-    <link rel="stylesheet" href="/jasmine/jasmine.css" />
-    <link rel="stylesheet" href="/public/jasmine-helper.css" />
-    <script src="/jasmine/jasmine.js"></script>
-    <script src="/jasmine/jasmine-html.js"></script>
-    <script src="/jasmine/boot0.js"></script>
-    <script src="/jasmine/boot1.js"></script>
-    <script type="module" src="/src/router/services.spec.js"></script>
-    <script type="module" src="/src/router/state-filter.spec.js"></script>
-    <script type="module" src="/src/router/view-hook.spec.js"></script>
-    <script type="module" src="/src/router/view-scroll.spec.js"></script>
-  </head>
-  <body>
-    <div id="app"></div>
-  </body>
-</html>

package/src/router/router.js

@@ -1,54 +0,0 @@
-import { StateParams } from "./params/state-params.js";
-import { Queue } from "../shared/queue.js";
-
-/** @typedef {import('../interface.ts').ServiceProvider} ServiceProvider } */
-
-/**
- * Global router state
- *
- * This is where we hold the global mutable state such as current state, current
- * params, current transition, etc.
- */
-export class Router {
-  constructor() {
-    /**
-     * Current parameter values
-     *
-     * The parameter values from the latest successful transition
-     * @type {StateParams}
-     */
-    this.params = new StateParams();
-
-    /**
-     * @type {number}
-     */
-    this.lastStartedTransitionId = -1;
-
-    /**
-     * @type {Queue<import("./transition/transition.js").Transition>}
-     */
-    this.transitionHistory = new Queue([], 1);
-
-    /**
-     * @type {Queue<import("./transition/transition.js").Transition>}
-     */
-    this.successfulTransitions = new Queue([], 1);
-
-    /**
-     * @type {import("./state/interface.ts").StateDeclaration|undefined}
-     */
-    this.current = undefined;
-
-    /**
-     * @type {import("./state/state-object.js").StateObject|undefined}
-     */
-    this.$current = undefined;
-
-    /**
-     * @type {import("./transition/transition.js").Transition|undefined}
-     */
-    this.transition = undefined;
-  }
-
-  $get = () => this;
-}

package/src/router/router.test.js

@@ -1,12 +0,0 @@
-import { test, expect } from "@playwright/test";
-
-const TEST_URL = "src/router/router.html?random=false";
-
-test("unit tests contain no errors", async ({ page }) => {
-  await page.goto(TEST_URL);
-  await page.content();
-  await page.waitForTimeout(4000);
-  await expect(page.locator(".jasmine-overall-result")).toHaveText(
-    / 0 failures/,
-  );
-});

package/src/router/services.spec.js

@@ -1,52 +0,0 @@
-import { Angular } from "../angular.js";
-import { dealoc } from "../shared/dom.js";
-
-describe("router services", () => {
-  let providers;
-  let $injector;
-
-  beforeEach(() => {
-    dealoc(document.getElementById("app"));
-    window["angular"] = new Angular();
-    let module = window["angular"].module("defaultModule", []);
-    module.config(
-      (
-        $urlProvider,
-        $stateRegistryProvider,
-        $routerProvider,
-        $transitionsProvider,
-        $stateProvider,
-      ) => {
-        providers = {
-          $urlProvider,
-          $stateRegistryProvider,
-          $routerProvider,
-          $transitionsProvider,
-          $stateProvider,
-        };
-      },
-    );
-
-    $injector = window["angular"].bootstrap(document.getElementById("app"), [
-      "defaultModule",
-    ]);
-  });
-
-  it("Should expose ng-router providers from the UIRouter instance", () => {
-    expect(providers.$urlProvider).toBeDefined();
-    expect(providers.$stateRegistryProvider).toBeDefined();
-    expect(providers.$stateRegistryProvider).toBeDefined();
-    expect(providers.$transitionsProvider).toBeDefined();
-    expect(providers.$stateProvider).toBeDefined();
-  });
-
-  it("Should expose ng-router services from the UIRouter instance", () => {
-    expect($injector.get("$url")).toBeDefined();
-    expect($injector.get("$stateRegistry")).toBeDefined();
-    expect($injector.get("$router")).toBeDefined();
-    expect($injector.get("$transitions")).toBeDefined();
-    expect($injector.get("$state")).toBeDefined();
-    expect($injector.get("$view")).toBeDefined();
-    expect($injector.get("$trace")).toBeDefined();
-  });
-});

package/src/router/state/README.md

@@ -1,21 +0,0 @@
-/\*\*
-
-- # The state subsystem
--
-- This subsystem implements the ng-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
-  \*/