@angular-wave/angular.ts 0.9.4 → 0.9.5

package/src/shared/hof.js

@@ -1,157 +0,0 @@
-/**
- * Returns a new function for [Partial Application](https://en.wikipedia.org/wiki/Partial_application) of the original function.
- *
- * Given a function with N parameters, returns a new function that supports partial application.
- * The new function accepts anywhere from 1 to N parameters.  When that function is called with M parameters,
- * where M is less than N, it returns a new function that accepts the remaining parameters.  It continues to
- * accept more parameters until all N parameters have been supplied.
- *
- *
- * This contrived example uses a partially applied function as an predicate, which returns true
- * if an object is found in both arrays.
- * @example
- * ```
- * // returns true if an object is in both of the two arrays
- * function inBoth(array1, array2, object) {
- *   return array1.indexOf(object) !== -1 &&
- *          array2.indexOf(object) !== 1;
- * }
- * let obj1, obj2, obj3, obj4, obj5, obj6, obj7
- * let foos = [obj1, obj3]
- * let bars = [obj3, obj4, obj5]
- *
- * // A curried "copy" of inBoth
- * let curriedInBoth = curry(inBoth);
- * // Partially apply both the array1 and array2
- * let inFoosAndBars = curriedInBoth(foos, bars);
- *
- * // Supply the final argument; since all arguments are
- * // supplied, the original inBoth function is then called.
- * let obj1InBoth = inFoosAndBars(obj1); // false
- *
- * // Use the inFoosAndBars as a predicate.
- * // Filter, on each iteration, supplies the final argument
- * let allObjs = [ obj1, obj2, obj3, obj4, obj5, obj6, obj7 ];
- * let foundInBoth = allObjs.filter(inFoosAndBars); // [ obj3 ]
- *
- * ```
- *
- * @param fn
- * @returns {*|function(): (*|any)}
- */
-export function curry(fn) {
-  return function curried() {
-    if (arguments.length >= fn.length) {
-      return fn.apply(this, arguments);
-    }
-    const args = Array.prototype.slice.call(arguments);
-    return curried.bind(this, ...args);
-  };
-}
-/**
- * Given a varargs list of functions, returns a function that composes the argument functions, right-to-left
- * given: f(x), g(x), h(x)
- * let composed = compose(f,g,h)
- * then, composed is: f(g(h(x)))
- */
-export function compose() {
-  const args = arguments;
-  const start = args.length - 1;
-  return function () {
-    let i = start,
-      result = args[start].apply(this, arguments);
-    while (i--) result = args[i].call(this, result);
-    return result;
-  };
-}
-
-/**
- * Given a property name and a value, returns a function that returns a boolean based on whether
- * the passed object has a property that matches the value
- * let obj = { foo: 1, name: "blarg" };
- * let getName = propEq("name", "blarg");
- * getName(obj) === true
- */
-export const propEq = curry((name, _val, obj) => obj && obj[name] === _val);
-/**
- * Given a dotted property name, returns a function that returns a nested property from an object, or undefined
- * let obj = { id: 1, nestedObj: { foo: 1, name: "blarg" }, };
- * let getName = prop("nestedObj.name");
- * getName(obj) === "blarg"
- * let propNotFound = prop("this.property.doesnt.exist");
- * propNotFound(obj) === undefined
- */
-export const parse = (path) => {
-  const parts = path.split(".");
-  return (obj) => parts.reduce((acc, key) => acc && acc[key], obj);
-};
-
-/**
- * Given a class constructor, returns a predicate function that checks
- * whether a given object is an instance of that class.
- *
- * @param {new (...args: any[]) => any} ctor - The class constructor to check against.
- * @returns {(obj: any) => boolean} A predicate function that returns true if the object is of the given class.
- */
-export function is(ctor) {
-  /**
-   * Checks if the provided object is an instance of the given constructor.
-   *
-   * @param {any} obj - The object to test.
-   * @returns {boolean} True if the object is an instance of the given class.
-   */
-  return function (obj) {
-    return (obj != null && obj.constructor === ctor) || obj instanceof ctor;
-  };
-}
-
-/** Given a value, returns a function which returns the value */
-export const val = (v) => () => v;
-
-/**
- * Sorta like Pattern Matching (a functional programming conditional construct)
- *
- * See http://c2.com/cgi/wiki?PatternMatching
- *
- * This is a conditional construct which allows a series of predicates and output functions
- * to be checked and then applied.  Each predicate receives the input.  If the predicate
- * returns truthy, then its matching output function (mapping function) is provided with
- * the input and, then the result is returned.
- *
- * Each combination (2-tuple) of predicate + output function should be placed in an array
- * of size 2: [ predicate, mapFn ]
- *
- * These 2-tuples should be put in an outer array.
- *
- * @example
- * ```
- *
- * // Here's a 2-tuple where the first element is the isString predicate
- * // and the second element is a function that returns a description of the input
- * let firstTuple = [ angular.isString, (input) => `Heres your string ${input}` ];
- *
- * // Second tuple: predicate "isNumber", mapfn returns a description
- * let secondTuple = [ angular.isNumber, (input) => `(${input}) That's a number!` ];
- *
- * let third = [ (input) => input === null,  (input) => `Oh, null...` ];
- *
- * let fourth = [ (input) => input === undefined,  (input) => `notdefined` ];
- *
- * let descriptionOf = pattern([ firstTuple, secondTuple, third, fourth ]);
- *
- * console.log(descriptionOf(undefined)); // 'notdefined'
- * console.log(descriptionOf(55)); // '(55) That's a number!'
- * console.log(descriptionOf("foo")); // 'Here's your string foo'
- * ```
- *
- * @param struct A 2D array.  Each element of the array should be an array, a 2-tuple,
- * with a Predicate and a mapping/output function
- * @returns {function(any): *}
- */
-export function pattern(struct) {
-  return function (x) {
-    for (let i = 0; i < struct.length; i++) {
-      if (struct[i][0](x)) return struct[i][1](x);
-    }
-  };
-}

package/src/shared/hof.spec.js

@@ -1,60 +0,0 @@
-import { curry } from "./hof.js";
-
-describe("curry", () => {
-  let original;
-
-  beforeEach(() => {
-    original = jasmine.createSpy("original", function (a, b, c) {});
-  });
-
-  it("should accept a function and return a new function", () => {
-    expect(typeof curry(original)).toBe("function");
-  });
-
-  it("should return a function that invokes original only when all arguments are supplied", () => {
-    const curried1 = curry(original);
-    curried1(1, 2, 3);
-    expect(original).toHaveBeenCalledTimes(1);
-    expect(original).toHaveBeenCalledWith(1, 2, 3);
-  });
-
-  it("should pass extra arguments through to original function", () => {
-    const curried1 = curry(original);
-    curried1(1, 2, 3, 4);
-    expect(original).toHaveBeenCalledTimes(1);
-    expect(original).toHaveBeenCalledWith(1, 2, 3, 4);
-  });
-
-  it("should keep returning functions that return functions if no arguments are supplied", () => {
-    const curried1 = curry(original);
-    expect(typeof curried1).toBe("function");
-
-    const curried2 = curried1();
-    expect(typeof curried2).toBe("function");
-
-    const curried3 = curried2();
-    expect(typeof curried3).toBe("function");
-
-    const curried4 = curried3();
-    expect(typeof curried4).toBe("function");
-
-    const curried5 = curried4();
-    expect(typeof curried5).toBe("function");
-
-    const curried6 = curried5();
-    expect(typeof curried6).toBe("function");
-
-    expect(original).toHaveBeenCalledTimes(0);
-  });
-
-  it("should keep returning functions that return functions until all arguments are supplied", () => {
-    const curried1 = curry(original);
-    const curried2 = curried1(1);
-    const curried3 = curried2(2);
-    const result = curried3(3);
-
-    expect(result).toBeUndefined();
-    expect(original).toHaveBeenCalledTimes(1);
-    expect(original).toHaveBeenCalledWith(1, 2, 3);
-  });
-});

package/src/shared/interface.ts

@@ -1,21 +0,0 @@
-export type Predicate<X> = (x?: X) => boolean;
-export type PredicateBinary<X, Y> = (x?: X, y?: Y) => boolean;
-
-/**
- * Error configuration object. May only contain the options that need to be updated.
- */
-export interface ErrorHandlingConfig {
-  /**
-   * The max depth for stringifying objects.
-   * Setting to a non-positive or non-numeric value removes the max depth limit.
-   * Default: 5.
-   */
-  objectMaxDepth?: number;
-
-  /**
-   * Specifies whether the generated error URL will contain the parameters
-   * of the thrown error. Default: true.
-   * When used without argument, it returns the current value.
-   */
-  urlErrorParamsEnabled?: boolean;
-}

package/src/shared/min-err.spec.js

@@ -1,178 +0,0 @@
-import {
-  minErr,
-  isDefined,
-  toDebugString,
-  errorHandlingConfig,
-} from "./utils.js";
-
-describe("errors", () => {
-  afterEach(() => {});
-
-  describe("minErr", () => {
-    const supportStackTraces = function () {
-      const e = new Error();
-      return isDefined(e.stack);
-    };
-    const emptyTestError = minErr("");
-    const testError = minErr("test");
-
-    it("should return an Error factory", () => {
-      const myError = testError("test", "Oops");
-      expect(myError instanceof Error).toBe(true);
-    });
-
-    it("should generate stack trace at the frame where the minErr instance was called", () => {
-      let myError;
-
-      function someFn() {
-        function nestedFn() {
-          myError = testError("fail", "I fail!");
-        }
-        nestedFn();
-      }
-
-      someFn();
-
-      // only Chrome, Firefox have stack
-      if (!supportStackTraces()) return;
-
-      expect(myError.stack).toMatch(/^[.\s\S]+nestedFn[.\s\S]+someFn.+/);
-    });
-
-    it("should interpolate string arguments without quotes", () => {
-      const myError = testError("1", 'This {0} is "{1}"', "foo", "bar");
-      expect(myError.message).toMatch(/^\[test:1] This foo is "bar"/);
-    });
-
-    it("should interpolate non-string arguments", () => {
-      const arr = [1, 2, 3];
-      const obj = { a: 123, b: "baar" };
-      const anonFn = function (something) {
-        return something;
-      };
-      const namedFn = function foo(something) {
-        return something;
-      };
-      let myError;
-
-      myError = testError(
-        "26",
-        "arr: {0}; obj: {1}; anonFn: {2}; namedFn: {3}",
-        arr,
-        obj,
-        anonFn,
-        namedFn,
-      );
-
-      expect(myError.message).toContain(
-        '[test:26] arr: [1,2,3]; obj: {"a":123,"b":"baar"};',
-      );
-      expect(myError.message).toContain("namedFn: function foo(something)");
-    });
-
-    it("should not suppress falsy objects", () => {
-      const myError = testError(
-        "26",
-        "false: {0}; zero: {1}; null: {2}; undefined: {3}; emptyStr: {4}",
-        false,
-        0,
-        null,
-        undefined,
-        "",
-      );
-      expect(myError.message).toMatch(
-        /^\[test:26] false: false; zero: 0; null: null; undefined: undefined; emptyStr: /,
-      );
-    });
-
-    it("should handle arguments that are objects with cyclic references", () => {
-      const a = { b: {} };
-      a.b.a = a;
-
-      const myError = testError("26", "a is {0}", a);
-      expect(myError.message).toMatch(/a is {"b":{"a":"..."}}/);
-    });
-
-    it("should handle arguments that are objects and ignore max depth when objectMaxDepth = $prop", () => {
-      [NaN, null, true, false, -1, 0].forEach((maxDepth) => {
-        const a = { b: { c: { d: { e: { f: { g: 1 } } } } } };
-
-        errorHandlingConfig({ objectMaxDepth: maxDepth });
-        const myError = testError("26", "a is {0}", a);
-        expect(myError.message).toMatch(
-          /a is {"b":{"c":{"d":{"e":{"f":{"g":1}}}}}}/,
-        );
-      });
-    });
-
-    it("should preserve interpolation markers when fewer arguments than needed are provided", () => {
-      // this way we can easily see if we are passing fewer args than needed
-
-      const foo = "Fooooo";
-      const myError = testError("26", "This {0} is {1} on {2}", foo);
-
-      expect(myError.message).toMatch(
-        /^\[test:26] This Fooooo is \{1\} on \{2\}/,
-      );
-    });
-
-    it("should pass through the message if no interpolation is needed", () => {
-      const myError = testError("26", "Something horrible happened!");
-      expect(myError.message).toMatch(
-        /^\[test:26] Something horrible happened!/,
-      );
-    });
-
-    it("should include a namespace in the message only if it is namespaced", () => {
-      const myError = emptyTestError("26", "This is a {0}", "Foo");
-      const myNamespacedError = testError("26", "That is a {0}", "Bar");
-      expect(myError.message).toMatch(/^\[26] This is a Foo/);
-      expect(myNamespacedError.message).toMatch(/^\[test:26] That is a Bar/);
-    });
-
-    // it("should strip error reference urls from the error message parameters", () => {
-    //   const firstError = testError("firstcode", "longer string and so on");
-
-    //   const error = testError(
-    //     "secondcode",
-    //     "description {0}, and {1}",
-    //     "a",
-    //     firstError.message,
-    //   );
-
-    //   expect(error.message).toBe(
-    //     "[test:secondcode] description a, and [test:firstcode] longer " +
-    //       'string and so on\n\nhttps://errors.angularjs.org/"NG_VERSION_FULL"/test/' +
-    //       "secondcode?p0=a&p1=%5Btest%3Afirstcode%5D%20longer%20string%20and%20so%20on%0Ahttps" +
-    //       "%3A%2F%2Ferrors.angularjs.org%2F%22NG_VERSION_FULL%22%2Ftest%2Ffirstcode",
-    //   );
-    // });
-
-    // it("should not generate URL query parameters when urlErrorParamsEnabled is  false", () => {
-    //   errorHandlingConfig({ urlErrorParamsEnabled: false });
-    //
-    //   expect(testError("acode", "aproblem", "a", "b", "c").message).toBe(
-    //     "[test:acode] aproblem\n" +
-    //       'https://errors.angularjs.org/"NG_VERSION_FULL"/test/acode',
-    //   );
-    // });
-  });
-});
-
-describe("toDebugString", () => {
-  it("should convert its argument to a string", () => {
-    expect(toDebugString("string")).toEqual("string");
-    expect(toDebugString(123)).toEqual("123");
-    expect(toDebugString({ a: { b: "c" } })).toEqual('{"a":{"b":"c"}}');
-    expect(
-      toDebugString(function fn() {
-        const a = 10;
-      }),
-    ).toEqual("function fn()");
-    expect(toDebugString()).toEqual("undefined");
-    const a = {};
-    a.a = a;
-    expect(toDebugString(a)).toEqual('{"a":"..."}');
-    expect(toDebugString([a, a])).toEqual('[{"a":"..."},"..."]');
-  });
-});

package/src/shared/noderef.js

@@ -1,225 +0,0 @@
-import { assertArg, isString } from "./utils.js";
-import { createElementFromHTML } from "./dom.js";
-
-/**
- * A type-safe wrapper around a DOM Node, HTMLElement, HTML string, NodeList, or an array of Nodes.
- * Provides guarantees around presence and access.
- */
-export class NodeRef {
-  /**
-   * @param {Node | Element | string | NodeList | Node[]} element - The DOM node(s) or HTML string to wrap.
-   * @throws {Error} If the argument is invalid or cannot be wrapped properly.
-   */
-  constructor(element) {
-    assertArg(element, "element");
-    this.initial = null;
-
-    /** @private @type {Node | ChildNode | null} */
-    this._node = null;
-
-    /** @private @type {Element | undefined} */
-    this._element = undefined;
-
-    /** @private @type {Array<Node>} a stable list on nodes */
-    this._nodes = undefined;
-
-    /** @type {boolean} */
-    this.linked = false;
-
-    /** @type {boolean} */
-    this.isList = false;
-
-    // Handle HTML string
-    if (isString(element)) {
-      this.initial = element;
-      let res = createElementFromHTML(/** @type {string} */ (element));
-      switch (true) {
-        case res instanceof Element:
-          this.element = res;
-          break;
-        case res instanceof Node:
-          this.node = res;
-          break;
-      }
-    }
-
-    // Handle NodeList
-    else if (element instanceof NodeList) {
-      this.initial = Array.from(element).map((e) => e.cloneNode(true));
-      if (element.length == 1) {
-        this.node = element[0];
-      } else {
-        this._nodes = Array.from(element);
-        this.isList = true;
-      }
-    }
-
-    // Handle single Element
-    else if (element instanceof Element) {
-      this.initial = element.cloneNode(true);
-      this.element = /** @type {Element} */ element;
-    }
-
-    // Handle single Node
-    else if (element instanceof Node) {
-      this.initial = element.cloneNode(true);
-      this._node = element;
-    }
-
-    // Handle array of elements
-    else if (element instanceof Array) {
-      if (element.length == 1) {
-        this.initial = element[0].cloneNode(true);
-        this.node = element[0];
-      } else {
-        this.initial = Array.from(element).map((e) => e.cloneNode(true));
-        this.nodes = element;
-      }
-    } else {
-      throw new Error("Invalid element passed to NodeRef");
-    }
-  }
-
-  /** @returns {Element} */
-  get element() {
-    assertArg(this._element, "element");
-    return this._element;
-  }
-
-  /** @param {Element} el */
-  set element(el) {
-    assertArg(el instanceof Element, "element");
-    this._element = el;
-    this._nodes = undefined;
-    this.isList = false;
-  }
-
-  /** @returns {Node | ChildNode} */
-  get node() {
-    assertArg(this._node || this._element, "node");
-    return this._node || this._element;
-  }
-
-  /** @param {Node | ChildNode} node */
-  set node(node) {
-    assertArg(node instanceof Node, "node");
-    this._node = node;
-    if (node.nodeType === Node.ELEMENT_NODE) {
-      this._element = /** @type {Element} */ (node);
-    } else {
-      this._element = undefined;
-    }
-  }
-
-  /** @param {Array<Node>} nodes */
-  set nodes(nodes) {
-    assertArg(
-      Array.isArray(nodes) && nodes.every((n) => n instanceof Node),
-      "nodes",
-    );
-    this._nodes = nodes;
-    this.isList = true;
-  }
-
-  /** @returns {Array<Node>} */
-  get nodes() {
-    assertArg(this._nodes, "nodes");
-    return this._nodes;
-  }
-
-  /** @returns {NodeList|Node[]} */
-  get nodelist() {
-    assertArg(this.isList, "nodes");
-    if (this._nodes.length === 0) {
-      return this._nodes;
-    }
-    if (this._nodes[0].parentElement) {
-      return this._nodes[0].parentElement.childNodes;
-    } else {
-      const fragment = document.createDocumentFragment();
-      this._nodes.forEach((el) => {
-        fragment.appendChild(el);
-      });
-      return fragment.childNodes;
-    }
-  }
-
-  /** @returns {Element | Node | ChildNode | NodeList | Node[]} */
-  get dom() {
-    if (this.isList) return this.nodelist;
-    else return this.node;
-  }
-
-  /** @returns {number} */
-  get size() {
-    return this.isList ? this._nodes.length : 1;
-  }
-
-  /** @returns {Element | Node | ChildNode} */
-  getAny() {
-    if (this.isList) {
-      return this._nodes[0];
-    } else {
-      return this._element || this._node;
-    }
-  }
-
-  /** @returns {Element | Array<Node> | Node | ChildNode} */
-  getAll() {
-    if (this.isList) {
-      return this._nodes;
-    } else {
-      return this._element || this._node;
-    }
-  }
-
-  /** @returns {Array<Element> | Array<Node>} */
-  collection() {
-    if (this.isList) {
-      return Array.from(this._nodes);
-    } else {
-      return [this._element || this._node];
-    }
-  }
-
-  /**
-   * @param {number} index
-   * @returns {Element | Node | ChildNode}
-   */
-  getIndex(index) {
-    if (this.isList) {
-      return this._nodes[index];
-    } else {
-      return this.node;
-    }
-  }
-
-  /**
-   * @param {number} index
-   * @param {Element | Node | ChildNode} node
-   */
-  setIndex(index, node) {
-    assertArg(index !== null, "index");
-    assertArg(node, "node");
-    if (this.isList) {
-      this._nodes[index] = node;
-    } else {
-      this.node = node;
-    }
-  }
-
-  /**
-   * @returns {NodeRef}
-   */
-  clone() {
-    const cloned = this.isList
-      ? this.nodes.map((el) => el.cloneNode(true))
-      : this.node.cloneNode(true);
-
-    return new NodeRef(cloned);
-  }
-
-  isElement() {
-    return this._element !== undefined;
-  }
-}

package/src/shared/predicates.js

@@ -1,34 +0,0 @@
-import { isFunction, isString } from "./utils.js";
-
-/**
- * Predicate which checks if a value is injectable
- *
- * A value is "injectable" if it is a function, or if it is an ng1 array-notation-style array
- * where all the elements in the array are Strings, except the last one, which is a Function
- * @param {*} val
- * @returns {boolean}
- */
-export function isInjectable(val) {
-  if (Array.isArray(val) && val.length) {
-    const head = val.slice(0, -1),
-      tail = val.slice(-1);
-
-    return !(
-      head.filter((x) => !isString(x)).length ||
-      tail.filter((x) => !isFunction(x)).length
-    );
-  }
-  return isFunction(val);
-}
-/**
- * Predicate which checks if a value looks like a Promise
- *
- * It is probably a Promise if it's an object, and it has a `then` property which is a Function
- * @param {any} obj
- * @returns {boolean}
- */
-export function isPromise(obj) {
-  return (
-    obj !== null && typeof obj === "object" && typeof obj.then === "function"
-  );
-}