@angular-wave/angular.ts 0.9.3 → 0.9.5

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

@@ -1,376 +0,0 @@
-import {
-  applyPairs,
-  inherit,
-  omit,
-  tail,
-  copy,
-  map,
-} from "../../shared/common.js";
-import { hasOwn, isDefined, isFunction, isString } from "../../shared/utils.js";
-import { stringify } from "../../shared/strings.js";
-import { is, pattern, pipe, val } from "../../shared/hof.js";
-import { Resolvable } from "../resolve/resolvable.js";
-import { annotate } from "../../core/di/injector.js";
-
-function parseUrl(url) {
-  if (!isString(url)) return false;
-  const root = url.charAt(0) === "^";
-  return { val: root ? url.substring(1) : url, root };
-}
-
-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;
-}
-
-function getUrlBuilder($url, root) {
-  return function (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
-      : $url.compile(parsed.val, { state: stateDec });
-    if (!url) return null;
-    if (!$url.isMatcher(url))
-      throw new Error(`Invalid url '${url}' in state '${stateObject}'`);
-    return parsed && parsed.root
-      ? url
-      : ((parent && parent.navigable) || root()).url.append(url);
-  };
-}
-
-function getNavigableBuilder(isRoot) {
-  return function (state) {
-    return !isRoot(state) && state.url
-      ? state
-      : state.parent
-        ? state.parent.navigable
-        : null;
-  };
-}
-
-/**
- * @param {import("../params/param-factory.js").ParamFactory} paramFactory
- */
-function getParamsBuilder(paramFactory) {
-  return function (state) {
-    const makeConfigParam = (_config, id) =>
-      paramFactory.fromConfig(id, null, state.self);
-    const urlParams =
-      (state.url && state.url.parameters({ inherit: false })) || [];
-    const nonUrlParams = Object.values(
-      map(
-        omit(
-          state.params || {},
-          urlParams.map((x) => x.id),
-        ),
-        makeConfigParam,
-      ),
-    );
-    return urlParams
-      .concat(nonUrlParams)
-      .map((p) => [p.id, p])
-      .reduce(applyPairs, {});
-  };
-}
-
-function pathBuilder(state) {
-  return state.parent ? state.parent.path.concat(state) : [state];
-}
-
-function includesBuilder(state) {
-  const includes = state.parent ? Object.assign({}, 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 annotateFn = (fn) => {
-    const $injector = window["angular"].$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 && 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 tuple from obj2Tuples */
-  const isTupleFromObj = (obj) =>
-    !!(
-      obj &&
-      obj.val &&
-      (isString(obj.val) || Array.isArray(obj.val) || isFunction(obj.val))
-    );
-
-  // Given a literal resolve or provider object, returns a Resolvable
-  const literal2Resolvable = pattern([
-    [
-      (x) => x.resolveFn,
-      (p) => new Resolvable(getToken(p), p.resolveFn, p.deps, p.policy),
-    ],
-    [
-      (x) => x.useFactory,
-      (p) =>
-        new Resolvable(
-          getToken(p),
-          p.useFactory,
-          p.deps || p.dependencies,
-          p.policy,
-        ),
-    ],
-    [
-      (x) => x.useClass,
-      (p) => new Resolvable(getToken(p), () => new p.useClass(), [], p.policy),
-    ],
-    [
-      (x) => x.useValue,
-      (p) =>
-        new Resolvable(getToken(p), () => p.useValue, [], p.policy, p.useValue),
-    ],
-    [
-      (x) => x.useExisting,
-      (p) => new Resolvable(getToken(p), (x) => x, [p.useExisting], p.policy),
-    ],
-  ]);
-  const tuple2Resolvable = pattern([
-    [
-      pipe((x) => x.val, isString),
-      (tuple) =>
-        new Resolvable(tuple.token, (x) => x, [tuple.val], tuple.policy),
-    ],
-    [
-      pipe((x) => x.val, Array.isArray),
-      (tuple) =>
-        new Resolvable(
-          tuple.token,
-          tail(tuple.val),
-          tuple.val.slice(0, -1),
-          tuple.policy,
-        ),
-    ],
-    [
-      pipe((x) => x.val, isFunction),
-      (tuple) =>
-        new Resolvable(
-          tuple.token,
-          tuple.val,
-          annotateFn(tuple.val),
-          tuple.policy,
-        ),
-    ],
-  ]);
-  const item2Resolvable = pattern([
-    [is(Resolvable), (r) => r],
-    [isResolveLiteral, 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 = Array.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 {
-  /**
-   * @param {import('./state-matcher.js').StateMatcher} matcher
-   * @param urlService
-   */
-  constructor(matcher, urlService) {
-    this.matcher = matcher;
-    this.$injector = undefined;
-    const self = this;
-    const root = () => matcher.find("");
-    function parentBuilder(state) {
-      if (isRoot(state)) return null;
-      return matcher.find(self.parentName(state)) || root();
-    }
-    this.builders = {
-      name: [(state) => state.name],
-      self: [selfBuilder],
-      parent: [parentBuilder],
-      data: [dataBuilder],
-      // Build a URLMatcher if necessary, either via a relative or absolute URL
-      url: [getUrlBuilder(urlService, root)],
-      // Keep track of the closest ancestor state that has a URL (i.e. is navigable)
-      navigable: [getNavigableBuilder(isRoot)],
-      // TODO
-      params: [getParamsBuilder(urlService.paramFactory)],
-      // Each framework-specific ng-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 (!hasOwn(builders, key)) continue;
-      const chain = builders[key].reduce(
-        (parentFn, step) => (_state) => step(_state, parentFn),
-        () => {},
-      );
-      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;
-  }
-}
-
-function isRoot(state) {
-  return state.name === "";
-}
-
-/** extracts the token from a Provider or provide literal */
-function getToken(p) {
-  return p.provide || p.token;
-}

package/src/router/state/state-builder.spec.js

@@ -1,86 +0,0 @@
-import { StateBuilder } from "./state-builder.js";
-import { Angular } from "../../angular.js";
-import { dealoc } from "../../shared/dom.js";
-
-// TODO refactor this to url service as it is using the provider right now
-describe("StateBuilder", function () {
-  const parent = { name: "" };
-  let builder;
-  let $stateRegistry;
-
-  beforeEach(function () {
-    dealoc(document.getElementById("app"));
-    window.angular = new Angular();
-    window.angular.module("default", []);
-    let $injector = window.angular.bootstrap(document.getElementById("app"), [
-      "default",
-    ]);
-    $stateRegistry = $injector.get("$stateRegistry");
-    builder = $stateRegistry.builder;
-  });
-
-  it("expect it to be configured by state registry", () => {
-    expect($stateRegistry).toBeDefined();
-    expect($stateRegistry.builder).toBeDefined();
-  });
-
-  it("should use the state object to build a default view, when no `views` property is found", function () {
-    const config = {
-      url: "/foo",
-      templateUrl: "/foo.html",
-      controller: "FooController",
-      parent: parent,
-    };
-    const built = builder.builder("views")(config);
-
-    expect(built.$default).not.toEqual(config);
-    expect(built.$default).toEqual(
-      jasmine.objectContaining({
-        templateUrl: "/foo.html",
-        controller: "FooController",
-        resolveAs: "$resolve",
-      }),
-    );
-  });
-
-  it("It should use the views object to build views, when defined", function () {
-    const config = { a: { foo: "bar", controller: "FooController" } };
-    const builtViews = builder.builder("views")({
-      parent: parent,
-      views: config,
-    });
-    expect(builtViews.a.foo).toEqual(config.a.foo);
-    expect(builtViews.a.controller).toEqual(config.a.controller);
-  });
-
-  it("should not allow a view config with both component and template keys", function () {
-    const config = {
-      name: "foo",
-      url: "/foo",
-      template: "<h1>hey</h1>",
-      controller: "FooController",
-      parent: parent,
-    };
-    expect(() => builder.builder("views")(config)).not.toThrow();
-    expect(() =>
-      builder.builder("views")(
-        Object.assign({ component: "fooComponent" }, config),
-      ),
-    ).toThrow();
-    expect(() =>
-      builder.builder("views")(
-        Object.assign({ componentProvider: () => "fooComponent" }, config),
-      ),
-    ).toThrow();
-    expect(() =>
-      builder.builder("views")(Object.assign({ bindings: {} }, config)),
-    ).toThrow();
-  });
-
-  it("should replace a resolve: string value with a function that injects the service of the same name", function () {
-    const config = { resolve: { foo: "bar" } };
-    expect(builder.builder("resolvables")).toBeDefined();
-    const built = builder.builder("resolvables")(config);
-    expect(built[0].deps).toEqual(["bar"]);
-  });
-});

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

@@ -1,64 +0,0 @@
-import { isString } from "../../shared/utils.js";
-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) {
-        console.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;
-  }
-}

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

@@ -1,118 +0,0 @@
-import { defaults, find } from "../../shared/common.js";
-import { propEq } from "../../shared/hof.js";
-import { Glob } from "../glob/glob.js";
-import { hasOwn, isFunction, isObject } from "../../shared/utils.js";
-
-/** @typedef {import('./interface.js').StateDeclaration} StateDeclaration */
-
-/**
- * Internal representation of a ng-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]].
- * @implements {StateDeclaration}
- */
-export class StateObject {
-  name = undefined;
-  navigable = undefined;
-  /** @type {?StateObject} */
-  parent = undefined;
-  params = undefined;
-  url = undefined;
-  includes = undefined;
-
-  /**
-   * @param {import('./interface.js').StateDeclaration} config
-   */
-  constructor(config) {
-    Object.assign(this, config);
-    this.$$state = () => {
-      return this;
-    };
-    /**
-     * @type {import('./interface.js').StateDeclaration}
-     */
-    this.self = config;
-    /**
-     * @type {?Glob}
-     */
-    const nameGlob = this.name ? Glob.fromString(this.name) : null;
-    this.__stateObjectCache = { nameGlob };
-  }
-  /**
-   * 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 || hasOwn(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 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"]);