@woosh/meep-engine 2.110.14 → 2.110.15

package/src/core/collection/map/HashMap.spec.js

@@ -1,291 +0,0 @@
-import { passThrough } from "../../function/passThrough.js";
-import { returnOne } from "../../function/returnOne.js";
-import { strictEquals } from "../../function/strictEquals.js";
-import { generate_next_linear_congruential_index, HashMap } from "./HashMap.js";
-
-/**
- *
- * @returns {HashMap}
- */
-function makeSample() {
-    return new HashMap({
-        keyHashFunction(k) {
-            return 1;
-        },
-        keyEqualityFunction(a, b) {
-            return a === b;
-        }
-    });
-}
-
-
-test('put and get same value', () => {
-    const m = makeSample();
-
-    m.set("hey", 42);
-
-    expect(m.size).toBe(1);
-
-    expect(m.get("hey")).toBe(42);
-});
-
-test("map has a key", () => {
-    const m = makeSample();
-
-    expect(m.has('cat')).toBe(false);
-
-    m.set('cat', 1);
-
-    expect(m.has('cat')).toBe(true);
-});
-
-test("put 2 values with same hash", () => {
-
-
-    const m = makeSample();
-
-    m.set("a", 7);
-    m.set("b", 42);
-
-    expect(m.size).toBe(2);
-
-    expect(m.get("a")).toBe(7);
-    expect(m.get("b")).toBe(42);
-});
-
-test("overwrite a value with the same key", () => {
-
-    const map = new HashMap({
-        keyHashFunction: returnOne,
-        keyEqualityFunction: strictEquals
-    });
-
-    map.set("x", 3);
-    map.set("x", 7);
-
-    expect(map.get("x")).toBe(7);
-
-});
-
-test("getOrCompute", () => {
-
-    const values = [1, 3, 5];
-
-    const compute = () => values.shift();
-
-    const map = new HashMap({
-        keyHashFunction: returnOne,
-        keyEqualityFunction: strictEquals
-    });
-
-    expect(map.getOrCompute("x", compute)).toBe(1);
-    expect(map.getOrCompute("x", compute)).toBe(1);
-
-    expect(map.getOrCompute("y", compute)).toBe(3);
-    expect(map.getOrCompute("y", compute)).toBe(3);
-});
-
-test("getOrSet", () => {
-
-    const map = new HashMap({
-        keyHashFunction: returnOne,
-        keyEqualityFunction: strictEquals
-    });
-
-    map.getOrSet(3, "hello");
-
-    expect(map.get(3)).toBe("hello");
-
-    map.getOrSet(3, "kitty");
-
-    expect(map.get(3)).toBe("hello");
-
-});
-
-test("retrieval works as intended after hash map grows", () => {
-    const m = new HashMap({
-        keyHashFunction: passThrough,
-        keyEqualityFunction: strictEquals,
-        capacity: 1,
-        loadFactor: 1
-    });
-
-    m.set(1, "a");
-
-    expect(m.get(1)).toEqual("a")
-
-    m.set(150, "b");
-
-    expect(m.get(1)).toEqual("a");
-    expect(m.get(150)).toEqual("b");
-
-    m.set(-7, "c");
-
-    expect(m.get(1)).toEqual("a");
-    expect(m.get(150)).toEqual("b");
-    expect(m.get(-7)).toEqual("c");
-
-});
-
-test("after deletion element is not found", () => {
-    const map = new HashMap({
-        keyHashFunction: passThrough,
-        keyEqualityFunction: strictEquals,
-    });
-
-    map.set(1, "a");
-
-    map.delete(1);
-
-    expect(map.size).toBe(0);
-    expect(map.get(1)).toBeUndefined();
-});
-
-test("deleting an element then inserting another one all with hash collisions", () => {
-    const map = new HashMap({
-        keyHashFunction: returnOne,
-        keyEqualityFunction: strictEquals,
-    });
-
-    map.set(1, "a");
-    map.set(7, "b");
-
-    map.delete(1);
-
-    expect(map.get(7)).toBe("b");
-    expect(map.get(1)).toBeUndefined();
-
-    map.set(13, "c");
-
-    expect(map.get(13)).toBe("c");
-
-    map.delete(13);
-
-    expect(map.get(7)).toBe("b");
-    expect(map.get(13)).toBeUndefined();
-});
-
-
-test("key iterator", () => {
-    const map = new HashMap({
-        keyHashFunction: returnOne,
-        keyEqualityFunction: strictEquals
-    });
-
-    map.set(7, "hello");
-
-    const iterator = map.keys();
-    expect(iterator.next().value).toBe(7);
-    expect(iterator.next()).toEqual({
-        done: true,
-        value: undefined
-    });
-});
-
-test("value iterator", () => {
-    const map = new HashMap({
-        keyHashFunction: returnOne,
-        keyEqualityFunction: strictEquals
-    });
-
-    map.set(7, "hello");
-
-    const iterator = map.values();
-    expect(iterator.next().value).toBe("hello");
-    expect(iterator.next()).toEqual({
-        done: true,
-        value: undefined
-    });
-});
-
-test("forEach", () => {
-    const map = new HashMap({
-        keyHashFunction: returnOne,
-        keyEqualityFunction: strictEquals
-    });
-
-    const mock = jest.fn();
-
-    map.forEach(mock);
-
-    expect(mock).not.toHaveBeenCalled();
-
-    map.set(7, "hello");
-    map.set(3, "kitty");
-
-    map.forEach(mock);
-
-    expect(mock).toHaveBeenCalledTimes(2);
-    expect(mock).toHaveBeenCalledWith("kitty", 3, map);
-    expect(mock).toHaveBeenCalledWith("hello", 7, map);
-});
-
-
-test("clear works as expected", () => {
-    const map = new HashMap({
-        keyHashFunction: passThrough,
-        keyEqualityFunction: strictEquals
-    });
-
-    map.set(7, "hello");
-
-    map.clear();
-
-    expect(map.get(7)).toBe(undefined);
-    expect(map.size).toBe(0);
-});
-
-test("lcg 32", () => {
-    const generated = new Uint32Array(32);
-
-    let next = 0;
-    for (let i = 0; i < 32; i++) {
-
-        generated[i] = next;
-
-        next = generate_next_linear_congruential_index(next, 31);
-
-    }
-
-    generated.sort();
-
-    for (let i = 0; i < 32; i++) {
-        expect(generated[i]).toBe(i);
-    }
-});
-
-
-test.skip("performance - random fill 100,000", () => {
-    const map = new HashMap({
-        keyHashFunction: passThrough,
-        keyEqualityFunction: strictEquals
-    });
-
-    const map_warmup = new HashMap({
-        keyHashFunction: passThrough,
-        keyEqualityFunction: strictEquals
-    });
-
-    // warm up
-    for (let i = 0; i < 10000; i++) {
-        map_warmup.set(i, i);
-        map_warmup.get(i);
-    }
-
-    const t0 = performance.now();
-
-    for (let i = 0; i < 100000; i++) {
-        map.set(i, i);
-    }
-
-    const t1 = performance.now();
-
-    for (let i = 0; i < 100000; i++) {
-        map.get(i);
-    }
-
-    const t2 = performance.now();
-
-    console.log(`Fill: ${t1 - t0}ms`)
-    console.log(`Drain: ${t2 - t1}ms`)
-});

package/src/core/collection/queue/Deque.spec.js

@@ -1,276 +0,0 @@
-import { Deque } from "./Deque.js";
-
-test("constructor doesn't throw ", () => {
-    expect(() => new Deque()).not.toThrow();
-});
-
-test("add one element", () => {
-    const deque = new Deque();
-
-    deque.add(1);
-
-    expect(deque.size()).toBe(1);
-});
-
-test('first in last out, forward', () => {
-    const deque = new Deque();
-
-    deque.addFirst(1);
-    deque.addFirst(2);
-    deque.addFirst(3);
-
-    expect(deque.removeLast()).toBe(1);
-    expect(deque.removeLast()).toBe(2);
-    expect(deque.removeLast()).toBe(3);
-});
-
-test('first in last out, backward', () => {
-    const deque = new Deque();
-
-    deque.addLast(1);
-    deque.addLast(2);
-    deque.addLast(3);
-
-    expect(deque.removeFirst()).toBe(1);
-    expect(deque.removeFirst()).toBe(2);
-    expect(deque.removeFirst()).toBe(3);
-});
-
-test('first in first out, forward', () => {
-    const deque = new Deque();
-
-    deque.addFirst(1);
-    deque.addFirst(2);
-    deque.addFirst(3);
-
-    expect(deque.removeFirst()).toBe(3);
-    expect(deque.removeFirst()).toBe(2);
-    expect(deque.removeFirst()).toBe(1);
-});
-
-test('first in first out, backward', () => {
-    const deque = new Deque();
-
-    deque.addLast(1);
-    deque.addLast(2);
-    deque.addLast(3);
-
-    expect(deque.removeLast()).toBe(3);
-    expect(deque.removeLast()).toBe(2);
-    expect(deque.removeLast()).toBe(1);
-});
-
-test('isEmpty', () => {
-    const deque = new Deque();
-
-    expect(deque.isEmpty()).toBe(true);
-
-    deque.addLast(1);
-
-    expect(deque.isEmpty()).toBe(false);
-
-    deque.removeLast();
-
-    expect(deque.isEmpty()).toBe(true);
-});
-
-test('size', () => {
-    const deque = new Deque();
-
-    expect(deque.size()).toBe(0);
-
-    deque.addLast(1);
-
-    expect(deque.size()).toBe(1);
-
-    deque.addLast(1);
-
-    expect(deque.size()).toBe(2);
-
-    deque.removeLast();
-
-    expect(deque.size()).toBe(1);
-
-    deque.removeLast();
-
-    expect(deque.size()).toBe(0);
-});
-
-test("remove the only item", () => {
-    const deque = new Deque();
-
-    deque.add(7);
-
-    expect(deque.remove(7)).toBe(true);
-
-    expect(deque.size()).toBe(0);
-});
-
-test("remove first item", () => {
-
-    const deque = new Deque();
-
-    deque.add(7);
-    deque.add(13);
-
-    expect(deque.remove(7)).toBe(true);
-    expect(deque.size()).toBe(1);
-
-    expect(deque.pop()).toBe(13);
-});
-
-test("remove last item", () => {
-
-    const deque = new Deque();
-
-    deque.add(7);
-    deque.add(13);
-
-    expect(deque.remove(13)).toBe(true);
-    expect(deque.size()).toBe(1);
-
-    expect(deque.pop()).toBe(7);
-});
-
-test("remove middle item", () => {
-
-    const deque = new Deque();
-
-    deque.add(7);
-    deque.add(13);
-    deque.add(17);
-
-    expect(deque.remove(13)).toBe(true);
-    expect(deque.size()).toBe(2);
-
-    expect(deque.pop()).toBe(7);
-    expect(deque.pop()).toBe(17);
-});
-
-test("remove non-existent element", () => {
-
-    const deque = new Deque();
-
-    expect(deque.remove(1)).toBe(false);
-
-    deque.add(3);
-
-    expect(deque.remove(1)).toBe(false);
-
-    expect(deque.size()).toBe(1);
-});
-
-
-test("clear", () => {
-
-    const deque = new Deque();
-
-    expect(() => deque.clear()).not.toThrow();
-
-    expect(deque.size()).toBe(0);
-
-    deque.add('x');
-
-    deque.clear();
-
-    expect(deque.size()).toBe(0);
-
-});
-
-test("has", () => {
-
-    const deque = new Deque();
-
-    expect(deque.has(1)).toBe(false);
-
-    deque.add(1);
-
-    expect(deque.has(1)).toBe(true);
-});
-
-test("getFirst", () => {
-
-    const deque = new Deque();
-
-    expect(deque.getFirst()).toBeUndefined();
-
-    deque.addFirst(1);
-
-    expect(deque.getFirst()).toBe(1);
-
-    deque.addFirst(3);
-
-    expect(deque.getFirst()).toBe(3);
-});
-
-test("getLast", () => {
-
-    const deque = new Deque();
-
-    expect(deque.getFirst()).toBeUndefined();
-
-    deque.addFirst(1);
-
-    expect(deque.getLast()).toBe(1);
-
-    deque.addFirst(3);
-
-    expect(deque.getLast()).toBe(1);
-
-    deque.removeLast();
-
-    expect(deque.getLast()).toBe(3);
-});
-
-test("fill queue beyond default size and then drain it", () => {
-    const queue = new Deque(1);
-
-    queue.add(1);
-    expect(queue.size()).toBe(1);
-
-    queue.add(2);
-    expect(queue.size()).toBe(2);
-
-    queue.add(3);
-    expect(queue.size()).toBe(3);
-
-    // Drain
-
-    expect(queue.pop()).toBe(1);
-    expect(queue.size()).toBe(2);
-
-    expect(queue.pop()).toBe(2);
-    expect(queue.size()).toBe(1);
-
-    expect(queue.pop()).toBe(3);
-    expect(queue.size()).toBe(0);
-});
-
-
-test("toArray", () => {
-
-    const q = new Deque(2);
-
-    expect(q.toArray()).toEqual([]);
-
-    q.addLast(1);
-
-    expect(q.toArray()).toEqual([1]);
-
-    q.addLast(7);
-
-    expect(q.toArray()).toEqual([1, 7]);
-
-    q.removeFirst();
-
-    expect(q.toArray()).toEqual([7]);
-});
-
-test("Symbol.iterator",()=>{
-    const q = new Deque();
-
-    q.addLast(1);
-    q.addLast(7);
-
-    expect(Array.from(q)).toEqual([1,7]);
-});

package/src/core/collection/set/HashSet.spec.js

@@ -1,39 +0,0 @@
-import { strictEquals } from "../../function/strictEquals.js";
-import { computeStringHash } from "../../primitives/strings/computeStringHash.js";
-import { HashSet } from "./HashSet.js";
-
-test("constructor", () => {
-    const set = new HashSet();
-});
-
-test("add same element twice", () => {
-
-    const set = new HashSet({
-        keyHashFunction: computeStringHash,
-        keyEqualityFunction: strictEquals
-    });
-
-    set.add("a");
-
-    expect(set.size).toBe(1);
-
-    set.add("a");
-
-    expect(set.size).toBe(1);
-});
-
-test("iterator symbol",()=>{
-
-    const set = new HashSet({
-        keyHashFunction: computeStringHash,
-        keyEqualityFunction: strictEquals
-    });
-
-    set.add("a");
-
-    const iterator = set[Symbol.iterator]();
-    expect(iterator.next()).toEqual({
-        done:false,
-        value: "a"
-    });
-});

package/src/core/collection/set/compute_set_difference.spec.js

@@ -1,45 +0,0 @@
-import { compute_set_difference } from "./compute_set_difference.js";
-
-/**
- * @template T
- * @param {T[]} a
- * @param {T[]} b
- * @return {T[]}
- */
-function using_arrays(a, b) {
-    return Array.from(compute_set_difference(new Set(a), new Set(b))).sort();
-}
-
-test("empty sets", () => {
-
-    expect(using_arrays([], [])).toEqual([]);
-
-});
-
-test("empty and single element", () => {
-
-    expect(using_arrays([1], [])).toEqual([1]);
-    expect(using_arrays([], [1])).toEqual([1]);
-
-});
-
-test("no difference", () => {
-
-    expect(using_arrays([1, 2, 3], [1, 2, 3])).toEqual([]);
-    expect(using_arrays([1, 2, 3], [2, 3, 1])).toEqual([]);
-    expect(using_arrays([1, 2, 3], [3, 1, 2])).toEqual([]);
-    expect(using_arrays([1, 2, 3], [3, 2, 1])).toEqual([]);
-    expect(using_arrays([1, 2, 3], [2, 1, 3])).toEqual([]);
-
-    expect(using_arrays([2, 3, 1], [1, 2, 3])).toEqual([]);
-    expect(using_arrays([3, 1, 2], [1, 2, 3])).toEqual([]);
-    expect(using_arrays([3, 2, 1], [1, 2, 3])).toEqual([]);
-    expect(using_arrays([2, 1, 3], [1, 2, 3])).toEqual([]);
-
-});
-
-test("partial", () => {
-
-    expect(using_arrays([1, 2, 3, 7], [11, 1, 2, 3])).toEqual([11, 7]);
-
-});

package/src/core/collection/set/compute_set_intersection.spec.js

@@ -1,45 +0,0 @@
-import { compute_set_intersection } from "./compute_set_intersection.js";
-
-/**
- * @template T
- * @param {T[]} a
- * @param {T[]} b
- * @return {T[]}
- */
-function using_arrays(a, b) {
-    return Array.from(compute_set_intersection(new Set(a), new Set(b))).sort();
-}
-
-test("empty sets", () => {
-
-    expect(using_arrays([], [])).toEqual([]);
-
-});
-
-test("empty and single element", () => {
-
-    expect(using_arrays([1], [])).toEqual([]);
-    expect(using_arrays([], [1])).toEqual([]);
-
-});
-
-test("no difference", () => {
-
-    expect(using_arrays([1, 2, 3], [1, 2, 3])).toEqual([1, 2, 3]);
-    expect(using_arrays([1, 2, 3], [2, 3, 1])).toEqual([1, 2, 3]);
-    expect(using_arrays([1, 2, 3], [3, 1, 2])).toEqual([1, 2, 3]);
-    expect(using_arrays([1, 2, 3], [3, 2, 1])).toEqual([1, 2, 3]);
-    expect(using_arrays([1, 2, 3], [2, 1, 3])).toEqual([1, 2, 3]);
-
-    expect(using_arrays([2, 3, 1], [1, 2, 3])).toEqual([1, 2, 3]);
-    expect(using_arrays([3, 1, 2], [1, 2, 3])).toEqual([1, 2, 3]);
-    expect(using_arrays([3, 2, 1], [1, 2, 3])).toEqual([1, 2, 3]);
-    expect(using_arrays([2, 1, 3], [1, 2, 3])).toEqual([1, 2, 3]);
-
-});
-
-test("partial", () => {
-
-    expect(using_arrays([1, 2, 3, 7], [11, 1, 2, 3])).toEqual([1, 2, 3]);
-
-});