@angular-wave/angular.ts 0.9.4 → 0.9.6

package/src/shared/common.spec.js

@@ -1,294 +0,0 @@
-import { defaults, filter, map, pick, tail } from "./common.js";
-import { is, pattern, val } from "./hof.js";
-import { isInjectable } from "./predicates.js";
-import { Queue } from "./queue.js";
-
-describe("common", function () {
-  describe("filter", function () {
-    it("should filter arrays", function () {
-      const input = [1, 2, 3, 4, 5];
-      const filtered = filter(input, function (int) {
-        return int > 2;
-      });
-      expect(filtered.length).toBe(3);
-      expect(filtered).toEqual([3, 4, 5]);
-    });
-
-    it("should properly compact arrays", function () {
-      expect(
-        filter([0, 1, 0, 2, 0, 3, 4], function (v) {
-          return !!v;
-        }),
-      ).toEqual([1, 2, 3, 4]);
-    });
-
-    it("should filter objects", function () {
-      const input = { foo: 1, bar: 2, baz: 3, qux: 4 };
-      const filtered = filter(input, function (value, _key) {
-        return value > 2;
-      });
-      expect(Object.keys(filtered).length).toBe(2);
-      expect(filtered).toEqual({ baz: 3, qux: 4 });
-    });
-  });
-
-  describe("defaults", function () {
-    it("should do left-associative object merge", function () {
-      const options = { param1: "new val" };
-      const result = defaults(options, {
-        param1: "default val",
-        param2: "default val 2",
-      });
-      expect(result).toEqual({ param1: "new val", param2: "default val 2" });
-    });
-
-    it("should whitelist keys present in default values", function () {
-      const options = { param1: 1, param2: 2, param3: 3 };
-      const result = defaults(options, {
-        param1: 0,
-        param2: 0,
-      });
-      expect(result).toEqual({ param1: 1, param2: 2 });
-    });
-
-    it("should return an object when passed an empty value", function () {
-      const vals = { param1: 0, param2: 0 };
-      expect(defaults(null, vals)).toEqual(vals);
-      expect(defaults(undefined, vals)).toEqual(vals);
-    });
-  });
-
-  describe("val", function () {
-    it("should return identity", function () {
-      const f = function () {},
-        foo = {};
-      expect(val(f)()).toBe(f);
-      expect(val(foo)()).toBe(foo);
-      expect(val(true)()).toBe(true);
-      expect(val(false)()).toBe(false);
-      expect(val(null)()).toBe(null);
-    });
-  });
-
-  describe("pattern", function () {
-    it("should return the result of a paired function when a condition function returns true", function () {
-      const typeChecker = pattern([
-        [is(Number), val("number!")],
-        [is(String), val("string!")],
-        [is(Boolean), val("boolean!")],
-      ]);
-
-      expect(typeChecker(1)).toBe("number!");
-      expect(typeChecker("foo!")).toBe("string!");
-      expect(typeChecker(true)).toBe("boolean!");
-      expect(typeChecker(false)).toBe("boolean!");
-      expect(typeChecker(undefined)).toBe(undefined);
-    });
-  });
-
-  describe("isInjectable", function () {
-    it("should accept functions", function () {
-      function fn() {}
-      expect(isInjectable(fn)).toBeTruthy();
-    });
-
-    it("should accept functions with parameters", function () {
-      function fn(_foo, _bar) {}
-      expect(isInjectable(fn)).toBeTruthy();
-    });
-
-    it("should accept ng1 annotated functions", function () {
-      fn["$inject"] = ["foo", "bar"];
-      function fn(_foo, _bar) {}
-      expect(isInjectable(fn)).toBeTruthy();
-    });
-
-    it("should accept ng1 array notation", function () {
-      const fn = ["foo", "bar", function (_foo, _bar) {}];
-      expect(isInjectable(fn)).toBeTruthy();
-    });
-  });
-
-  describe("pick", () => {
-    it("should pick inherited properties", () => {
-      const parent = { foo: "foo", bar: "bar" };
-      const child = Object.create(parent);
-      expect(pick(child, ["foo"])).toEqual({ foo: "foo" });
-    });
-
-    it("should not pick missing properties", () => {
-      const obj = { foo: "foo", bar: "bar" };
-      expect(pick(obj, ["baz"])).toEqual({});
-    });
-  });
-
-  describe("map on arrays", () => {
-    it("should map arrays", () => {
-      const src = [1, 2, 3, 4];
-      const dest = map(src, (x) => x * 2);
-
-      expect(src).toEqual([1, 2, 3, 4]);
-      expect(dest).toEqual([2, 4, 6, 8]);
-    });
-
-    it("should map arrays in place when target === src", () => {
-      const src = [1, 2, 3, 4];
-      const dest = map(src, (x) => x * 2, src);
-
-      expect(src).toEqual([2, 4, 6, 8]);
-      expect(dest).toEqual([2, 4, 6, 8]);
-    });
-  });
-
-  describe("map on objects", () => {
-    it("should map objects", () => {
-      const src = { foo: 1, bar: 2, baz: 3 };
-      const dest = map(src, (x) => x * 2);
-
-      expect(src).toEqual({ foo: 1, bar: 2, baz: 3 });
-      expect(dest).toEqual({ foo: 2, bar: 4, baz: 6 });
-    });
-
-    it("should map objects in place when target === src", () => {
-      const src = { foo: 1, bar: 2, baz: 3 };
-      const dest = map(src, (x) => x * 2, src);
-
-      expect(src).toEqual({ foo: 2, bar: 4, baz: 6 });
-      expect(dest).toEqual({ foo: 2, bar: 4, baz: 6 });
-    });
-  });
-
-  describe("tail", () => {
-    it("should return the last element of a non-empty array", () => {
-      expect(tail([1, 2, 3])).toBe(3);
-      expect(tail(["a", "b", "c"])).toBe("c");
-      expect(tail([true, false])).toBe(false);
-    });
-
-    it("should return undefined for an empty array", () => {
-      expect(tail([])).toBeUndefined();
-    });
-
-    it("should return the correct value even if it is falsy", () => {
-      expect(tail([0])).toBe(0);
-      expect(tail([""])).toBe("");
-      expect(tail([null])).toBeNull();
-      expect(tail([undefined])).toBeUndefined(); // still valid
-      expect(tail([false])).toBe(false);
-    });
-
-    it("should work with different types", () => {
-      const obj = { name: "Alice" };
-      expect(tail([obj])).toBe(obj);
-
-      const arr = [
-        [1, 2],
-        [3, 4],
-      ];
-      expect(tail(arr)).toEqual([3, 4]);
-    });
-  });
-
-  describe("Queue", () => {
-    it("peekTail() should show the last enqueued item", () => {
-      const q = new Queue();
-      q.enqueue(1);
-      q.enqueue(2);
-      q.enqueue(3);
-      expect(q.size()).toBe(3);
-      expect(q.peekTail()).toBe(3);
-    });
-
-    it("peekHead() should show the first enqueued item", () => {
-      const q = new Queue();
-      q.enqueue(1);
-      q.enqueue(2);
-      q.enqueue(3);
-      expect(q.size()).toBe(3);
-      expect(q.peekHead()).toBe(1);
-    });
-
-    it("should support a limit (max number of items)", () => {
-      const q = new Queue([], 2);
-      q.enqueue(1);
-      q.enqueue(2);
-      q.enqueue(3);
-      expect(q.size()).toBe(2);
-      expect(q.peekHead()).toBe(2);
-      expect(q.peekTail()).toBe(3);
-    });
-
-    it("clear() should remove all items", () => {
-      const q = new Queue([], 2);
-      q.enqueue(1);
-      q.enqueue(2);
-      q.enqueue(3);
-      expect(q.size()).toBe(2);
-
-      q.clear();
-      expect(q.size()).toBe(0);
-    });
-
-    it("enqueue() should evict from the head when max length is reached", () => {
-      const q = new Queue([], 3);
-      q.enqueue(1);
-      q.enqueue(2);
-      q.enqueue(3);
-      expect(q.size()).toBe(3);
-
-      q.enqueue(4);
-      expect(q.size()).toBe(3);
-
-      const a = q.dequeue();
-      const b = q.dequeue();
-      const c = q.dequeue();
-
-      expect(q.size()).toBe(0);
-      expect([a, b, c]).toEqual([2, 3, 4]);
-    });
-
-    it("onEvict() handlers should be called when an item is evicted", () => {
-      const log = [];
-      const q = new Queue([], 2);
-
-      q.onEvict((item) => log.push(item));
-
-      q.enqueue(1);
-      expect(q.size()).toBe(1);
-      expect(log).toEqual([]);
-
-      q.enqueue(2);
-      expect(q.size()).toBe(2);
-      expect(log).toEqual([]);
-
-      q.enqueue(3);
-      expect(q.size()).toBe(2);
-      expect(log).toEqual([1]);
-
-      q.enqueue(4);
-      expect(q.size()).toBe(2);
-      expect(log).toEqual([1, 2]);
-    });
-
-    it("onEvict() should support multiple handlers", () => {
-      const log = [];
-      const log2 = [];
-      const q = new Queue([], 2);
-
-      q.onEvict((item) => log.push(item));
-      q.onEvict((item) => log2.push(item));
-
-      q.enqueue(1);
-      q.enqueue(2);
-      q.enqueue(3);
-      expect(q.size()).toBe(2);
-      expect(log).toEqual([1]);
-      expect(log2).toEqual([1]);
-
-      q.enqueue(4);
-      expect(q.size()).toBe(2);
-      expect(log).toEqual([1, 2]);
-      expect(log2).toEqual([1, 2]);
-    });
-  });
-});

package/src/shared/constants.js

@@ -1,21 +0,0 @@
-export const VALID_CLASS = "ng-valid";
-export const INVALID_CLASS = "ng-invalid";
-export const PRISTINE_CLASS = "ng-pristine";
-export const DIRTY_CLASS = "ng-dirty";
-export const UNTOUCHED_CLASS = "ng-untouched";
-export const TOUCHED_CLASS = "ng-touched";
-export const EMPTY_CLASS = "ng-empty";
-export const NOT_EMPTY_CLASS = "ng-not-empty";
-
-// x prefix is being kept for view-directive.spec lines 1550, 565
-export const PREFIX_REGEXP = /^((?:x|data)[-])/i;
-export const SPECIAL_CHARS_REGEXP = /[-]+(.)/g;
-
-export const ALIASED_ATTR = {
-  ngMinlength: "minlength",
-  ngMaxlength: "maxlength",
-  ngMin: "min",
-  ngMax: "max",
-  ngPattern: "pattern",
-  ngStep: "step",
-};