@woosh/meep-engine 2.110.13 → 2.110.15

package/src/core/model/reactive/trigger/ReactiveTrigger.spec.js

@@ -1,5 +0,0 @@
-import { ReactiveTrigger } from "./ReactiveTrigger.js";
-
-test('constructor does not throw', () => {
-    new ReactiveTrigger('true');
-});

package/src/core/model/stat/LinearModifier.spec.js

@@ -1,96 +0,0 @@
-import LinearModifier from "./LinearModifier.js";
-
-test("constructor doesn't throw", () => {
-    new LinearModifier(1, 1);
-});
-
-test("constructor parameter propagation", () => {
-    const m = new LinearModifier(3, -7);
-
-    expect(m.a).toBe(3);
-    expect(m.b).toBe(-7);
-});
-
-test("equals method", () => {
-    const a = new LinearModifier(3, -7);
-    a.source = 0;
-
-    const b = new LinearModifier(3, -7);
-    b.source = 1;
-
-    const c = new LinearModifier(3, 11);
-    c.source = 0;
-
-    const d = new LinearModifier(13, -7);
-    d.source = 0;
-
-    const e = new LinearModifier(3, -7);
-    e.source = 0;
-
-    expect(a.equals(e)).toBe(true);
-    expect(a.equals(b)).toBe(false);
-    expect(a.equals(c)).toBe(false);
-    expect(a.equals(d)).toBe(false);
-});
-
-test("hash", () => {
-    const mod = new LinearModifier(3, -7);
-
-    const hash = mod.hash();
-
-    expect(mod.hash()).toEqual(hash); // idempotency
-    expect(typeof hash).toEqual("number");
-    expect(Number.isInteger(hash)).toBe(true);
-});
-
-test("copy", () => {
-
-    const source = new LinearModifier(3, -7);
-    const target = new LinearModifier(1, 1);
-
-    target.copy(source);
-
-    expect(target.a).toBe(3);
-    expect(target.b).toBe(-7);
-
-    // check that original was not changed
-
-    expect(source.a).toBe(3);
-    expect(source.b).toBe(-7);
-});
-
-test("clone", () => {
-
-    const source = new LinearModifier(3, -7);
-
-    const clone = source.clone();
-
-    expect(clone.equals(source)).toBe(true);
-
-});
-
-test("to/from JSON consistency", () => {
-
-    const source = new LinearModifier(3, -7);
-    const target = new LinearModifier(1, 1);
-
-    target.fromJSON(source.toJSON());
-
-    expect(target.a).toBe(3);
-    expect(target.b).toBe(-7);
-
-    // check that original was not changed
-
-    expect(source.a).toBe(3);
-    expect(source.b).toBe(-7);
-});
-
-test("toString produces a valid string", () => {
-
-    const s = new LinearModifier(3, -7).toString();
-
-    expect(typeof s).toBe("string");
-    expect(s.trim().length).toBeGreaterThan(0);
-
-});
-

package/src/core/model/stat/Stat.spec.js

@@ -1,111 +0,0 @@
-import LinearModifier from "./LinearModifier.js";
-import Stat from "./Stat.js";
-
-test("constructor", () => {
-    const s = new Stat(42);
-
-    expect(s.getValue()).toBe(42);
-});
-
-test("equals", () => {
-    const a = new Stat(42);
-    const b = new Stat(42);
-
-    expect(a.equals(b)).toBe(true);
-
-    const c = new Stat(21);
-
-    expect(a.equals(c)).toBe(false);
-
-    c.addModifier(new LinearModifier(2, 0));
-
-    expect(a.equals(c)).toBe(true);
-});
-
-test("order of modifiers doesn't matter", () => {
-    const a = new LinearModifier(3, 7);
-    const b = new LinearModifier(11, -13);
-    const c = new LinearModifier(-17, 19);
-    const d = new LinearModifier(-23, -29);
-
-    const combinations = [
-        [a, b, c, d],
-        [a, b, d, c],
-        [a, d, c, b],
-        [a, d, b, c],
-        [a, c, b, d],
-        [a, c, d, b],
-
-        [b, a, c, d],
-        [b, a, d, c],
-        [b, c, a, d],
-        [b, c, d, a],
-        [b, d, a, c],
-        [b, d, c, a],
-
-        [c, a, b, d],
-        [c, a, d, b],
-        [c, b, a, d],
-        [c, b, d, a],
-        [c, d, a, b],
-        [c, d, b, a],
-
-        [d, a, b, c],
-        [d, a, c, b],
-        [d, b, a, c],
-        [d, b, c, a],
-        [d, c, a, b],
-        [d, c, b, a],
-    ];
-
-    for (let i = 0; i < combinations.length; i++) {
-
-        const combination = combinations[i];
-        const s = new Stat(1);
-
-        for (let j = 0; j < combination.length; j++) {
-
-            const mod = combination[j];
-
-            s.addModifier(mod)
-        }
-
-        expect(s.getValue()).toEqual(-45);
-    }
-});
-
-test("toString produces a valid string", () => {
-    const stat = new Stat(1);
-
-    const s = stat.toString();
-
-    expect(typeof s).toBe("string");
-    expect(s.trim().length).toBeGreaterThan(0);
-});
-
-test("copy", () => {
-    const source = new Stat(7);
-
-    source.addModifier(LinearModifier.CONSTANT_ONE);
-
-    const other = new Stat(1);
-
-    other.copy(source);
-
-    expect(other.getBaseValue()).toBe(7);
-    expect(other.hasModifier(LinearModifier.CONSTANT_ONE));
-
-    expect(other.equals(source)).toBe(true);
-});
-
-test("to/from JSON consistency", () => {
-
-    const source = new Stat(7);
-    source.addModifier(LinearModifier.CONSTANT_ONE);
-
-    const destination = new Stat(1);
-
-    destination.fromJSON(source.toJSON());
-
-    expect(destination.equals(source)).toBe(true);
-});

package/src/core/parser/simple/readHexToken.spec.js

@@ -1,21 +0,0 @@
-import { readHexToken } from "./readHexToken.js";
-
-test("0x7", () => {
-    const token = readHexToken("0x7", 0, 3);
-    expect(token.value).toBe(7);
-});
-
-test("0xFF", () => {
-    const token = readHexToken("0xFF", 0, 4);
-    expect(token.value).toBe(0xFF);
-});
-
-test("0x1234567890", () => {
-    const token = readHexToken("0x1234567890", 0, 12);
-    expect(token.value).toBe(0x1234567890);
-});
-
-test("0xABCDEF", () => {
-    const token = readHexToken("0xABCDEF", 0, 8);
-    expect(token.value).toBe(0xABCDEF);
-});

package/src/core/parser/simple/readIdentifierToken.spec.js

@@ -1,32 +0,0 @@
-import { readIdentifierToken } from "./readIdentifierToken.js";
-
-test('parse identifier token starting with a number', () => {
-    expect(() => readIdentifierToken('0', 0, 1)).toThrow();
-    expect(() => readIdentifierToken('1', 0, 1)).toThrow();
-    expect(() => readIdentifierToken('2', 0, 1)).toThrow();
-    expect(() => readIdentifierToken('3', 0, 1)).toThrow();
-    expect(() => readIdentifierToken('4', 0, 1)).toThrow();
-    expect(() => readIdentifierToken('5', 0, 1)).toThrow();
-    expect(() => readIdentifierToken('6', 0, 1)).toThrow();
-    expect(() => readIdentifierToken('7', 0, 1)).toThrow();
-    expect(() => readIdentifierToken('8', 0, 1)).toThrow();
-    expect(() => readIdentifierToken('9', 0, 1)).toThrow();
-
-
-    expect(() => readIdentifierToken('9a', 0, 2)).toThrow();
-});
-
-test('parse identifier token with length 1', () => {
-    expect(readIdentifierToken('a', 0, 1).value).toBe('a');
-    expect(readIdentifierToken('A', 0, 1).value).toBe('A');
-    expect(readIdentifierToken('z', 0, 1).value).toBe('z');
-    expect(readIdentifierToken('Z', 0, 1).value).toBe('Z');
-    expect(readIdentifierToken('_', 0, 1).value).toBe('_');
-});
-
-test('parse identifier valid tokens', () => {
-    expect(readIdentifierToken('aa', 0, 2).value).toBe('aa');
-    expect(readIdentifierToken('a1', 0, 2).value).toBe('a1');
-    expect(readIdentifierToken('z ', 0, 2).value).toBe('z');
-    expect(readIdentifierToken('___ ', 0, 4).value).toBe('___');
-});

package/src/core/parser/simple/readNumberToken.spec.js

@@ -1,17 +0,0 @@
-import { readNumberToken } from "./readNumberToken.js";
-
-test("hex", () => {
-    expect(readNumberToken("0x3", 0, 3).value).toBe(3);
-});
-
-test("signed integer", () => {
-    expect(readNumberToken("+3", 0, 2).value).toBe(3);
-    expect(readNumberToken("3", 0, 1).value).toBe(3);
-    expect(readNumberToken("-7", 0, 2).value).toBe(-7);
-});
-
-test("decimal", () => {
-    expect(readNumberToken("1.0", 0, 3).value).toBe(1);
-    expect(readNumberToken("0.1", 0, 3).value).toBe(0.1);
-    expect(readNumberToken("-0.830", 0, 6).value).toBe(-0.830);
-});

package/src/core/parser/simple/readReferenceToken.spec.js

@@ -1,18 +0,0 @@
-import { readReferenceToken } from "./readReferenceToken.js";
-import TokenType from "./TokenType.js";
-
-test('parse reference a.b', () => {
-    const token = readReferenceToken('a.b', 0, 3);
-
-    expect(token.end).toBe(3);
-    expect(token.start).toBe(0);
-    expect(token.name).toBe(TokenType.Reference);
-
-    const identifiers = token.value;
-
-    expect(Array.isArray(identifiers)).toBe(true);
-    expect(identifiers.length).toBe(2);
-
-    expect(identifiers[0].value).toBe('a');
-    expect(identifiers[1].value).toBe('b');
-});

package/src/core/parser/simple/readStringToken.spec.js

@@ -1,57 +0,0 @@
-import { readStringToken } from "./readStringToken.js";
-
-test('parse empty string literal', () => {
-    const token = readStringToken('""', 0, 2);
-
-    expect(token.value).toBe("");
-    expect(token.start).toBe(0);
-    expect(token.end).toBe(2);
-});
-
-test('parse short string literal', () => {
-    const token = readStringToken('"1"', 0, 3);
-
-    expect(token.value).toBe("1");
-    expect(token.start).toBe(0);
-    expect(token.end).toBe(3);
-});
-
-test('parse short string literal from longer input', () => {
-    const token = readStringToken('"1"  ', 0, 5);
-
-    expect(token.value).toBe("1");
-    expect(token.start).toBe(0);
-    expect(token.end).toBe(3);
-});
-
-test('parse long string literal', () => {
-    const token = readStringToken('"hello world"', 0, 13);
-
-    expect(token.value).toBe("hello world");
-    expect(token.start).toBe(0);
-    expect(token.end).toBe(13);
-});
-
-test('parse a single escaped quote string literal', () => {
-    const token = readStringToken('"\\""', 0, 4);
-
-    expect(token.value).toBe('\"');
-    expect(token.start).toBe(0);
-    expect(token.end).toBe(4);
-});
-
-test('parse string literal with escaped quotes', () => {
-    const token = readStringToken('"what is \\"?"', 0, 13);
-
-    expect(token.value).toBe('what is "?');
-    expect(token.start).toBe(0);
-    expect(token.end).toBe(13);
-});
-
-test('parse string literal sequential escape sequences', () => {
-    const token = readStringToken('"\\n\\t"', 0, 6);
-
-    expect(token.value).toBe('\n\t');
-    expect(token.start).toBe(0);
-    expect(token.end).toBe(6);
-});

package/src/core/parser/simple/readUnsignedIntegerToken.spec.js

@@ -1,6 +0,0 @@
-import { readUnsignedIntegerToken } from "./readUnsignedIntegerToken.js";
-
-test("sequence with all digits", () => {
-    const token = readUnsignedIntegerToken("1234567890", 0, 10);
-    expect(token.value).toEqual(1234567890);
-});

package/src/core/path/computeFileExtension.spec.js

@@ -1,13 +0,0 @@
-import { computeFileExtension } from "./computeFileExtension.js";
-
-test('extract extension of cat.txt', () => {
-    expect(computeFileExtension('cat.txt')).toEqual('txt');
-});
-
-test('extract extension of ../hmm/cat.txt', () => {
-    expect(computeFileExtension('../hmm/cat.txt')).toEqual('txt');
-});
-
-test('extract extension of empty string', () => {
-    expect(computeFileExtension('')).toBeNull();
-});

package/src/core/path/computePathBase.spec.js

@@ -1,13 +0,0 @@
-import { computePathBase } from "./computePathBase.js";
-
-test('extract base path of empty string', () => {
-    expect(computePathBase('')).toBe('');
-});
-
-test('extract base path of hello', () => {
-    expect(computePathBase('hello')).toBe('hello');
-});
-
-test('extract base path of hello/there/world', () => {
-    expect(computePathBase('hello/there/world')).toBe('world');
-});

package/src/core/path/computePathDirectory.spec.js

@@ -1,8 +0,0 @@
-import {computePathDirectory} from "./computePathDirectory.js";
-
-test("basics", () => {
-    expect(computePathDirectory('')).toBe("");
-    expect(computePathDirectory('/')).toBe("");
-    expect(computePathDirectory('/hello')).toBe("");
-    expect(computePathDirectory('/hello/world')).toBe("/hello");
-});

package/src/core/primitives/array/computeStridedIntegerArrayHash.spec.js

@@ -1,28 +0,0 @@
-import { computeStridedIntegerArrayHash } from "./computeStridedIntegerArrayHash.js";
-
-/**
- *
- * @param {number[]} value
- * @param {number} [stride]
- */
-function check(value, stride = 1) {
-    const hash = computeStridedIntegerArrayHash(value, 0, value.length, 1);
-
-    expect(typeof hash).toBe('number');
-    expect(Number.isInteger(hash)).toBe(true);
-
-}
-
-test("sanity", () => {
-
-    check([], 1);
-
-    check([1], 1);
-    check([1], 3);
-
-    check([1, 3], 1);
-    check([1, 3], 3);
-
-    check([1, 3, 7], 3);
-
-});

package/src/core/primitives/numbers/computeHashFloat.spec.js

@@ -1,14 +0,0 @@
-import { computeHashFloat } from "./computeHashFloat.js";
-
-test("computeHashFloat", () => {
-    expect(computeHashFloat(500)).toEqual(computeHashFloat(500));
-
-    expect(computeHashFloat(500)).not.toEqual(computeHashFloat(400))
-});
-
-test("hash is an integer", () => {
-    const hash = computeHashFloat(1.237);
-
-    expect(typeof hash).toBe("number");
-    expect(Number.isInteger(hash)).toBe(true);
-});

package/src/core/primitives/numbers/number_compare_ascending.spec.js

@@ -1,9 +0,0 @@
-import { number_compare_ascending } from "./number_compare_ascending.js";
-
-test("basics", () => {
-
-    expect([1, 2].sort(number_compare_ascending)).toEqual([1, 2]);
-
-    expect([2, 1].sort(number_compare_ascending)).toEqual([1, 2]);
-
-});

package/src/core/primitives/numbers/number_compare_descending.spec.js

@@ -1,9 +0,0 @@
-import { number_compare_descending } from "./number_compare_descending.js";
-
-test("basics", () => {
-
-    expect([2, 1].sort(number_compare_descending)).toEqual([2, 1]);
-
-    expect([1, 2].sort(number_compare_descending)).toEqual([2, 1]);
-
-});

package/src/core/primitives/numbers/number_format_by_thousands.spec.js

@@ -1,12 +0,0 @@
-import { number_format_by_thousands } from "./number_format_by_thousands.js";
-
-test("basics", () => {
-
-    expect(number_format_by_thousands(0, ',')).toEqual("0");
-    expect(number_format_by_thousands(987, ',')).toEqual("987");
-    expect(number_format_by_thousands(1234, ',')).toEqual("1,234");
-    expect(number_format_by_thousands(987654321, ',')).toEqual("987,654,321");
-
-    // different separator
-    expect(number_format_by_thousands(1234, ' -> ')).toEqual("1 -> 234");
-});

package/src/core/primitives/numbers/number_pretty_print.spec.js

@@ -1,19 +0,0 @@
-import { number_pretty_print } from "./number_pretty_print.js";
-
-test("sanity", () => {
-
-    const zero = number_pretty_print(0);
-
-    expect(typeof zero).toBe('string');
-    expect(zero.trim().length).toBeGreaterThan(0);
-
-
-    const fraction = number_pretty_print(-1.123456790);
-
-    expect(typeof fraction).toBe('string');
-    expect(fraction.trim().length).toBeGreaterThan(0);
-
-
-    // different strings for different inputs
-    expect(zero).not.toEqual(fraction);
-});

package/src/core/primitives/strings/compareStrings.spec.js

@@ -1,12 +0,0 @@
-import { compareStrings } from "./compareStrings.js";
-
-test("stability", () => {
-
-    const array_a = ["a", undefined, "test", null, ""];
-    const array_b = [null, undefined, "", "a", "test"];
-
-    array_a.sort(compareStrings);
-    array_b.sort(compareStrings);
-
-    expect(array_a).toEqual(array_b);
-});

package/src/core/primitives/strings/computeStringHash.spec.js

@@ -1,20 +0,0 @@
-import { computeStringHash } from "./computeStringHash.js";
-
-function check(value) {
-    // must produce a number
-    const hash = computeStringHash(value);
-    expect(typeof hash).toBe('number');
-    expect(Number.isInteger(hash)).toBe(true);
-    expect(computeStringHash(value)).toEqual(hash); // stability
-}
-
-test('hash', () => {
-
-    check('');
-    check('cat');
-    check('tomato');
-    check(null);
-    check(undefined);
-
-    expect(computeStringHash('tomato')).not.toBe(computeStringHash('potato'));
-});

package/src/core/primitives/strings/insert_after.spec.js

@@ -1,16 +0,0 @@
-import { insert_after } from "./insert_after.js";
-
-test("basics", () => {
-
-    expect(insert_after("aba", "b", "c")).toBe("abca");
-    expect(insert_after("a", "a", "c")).toBe("ac");
-    expect(insert_after("ba", "a", "c")).toBe("bac");
-
-});
-
-test("non-occurrence", () => {
-
-    expect(insert_after("", "a", "c")).toBe("");
-    expect(insert_after("b", "a", "c")).toBe("b");
-
-});

package/src/core/primitives/strings/insert_before.spec.js

@@ -1,16 +0,0 @@
-import { insert_before } from "./insert_before.js";
-
-test("basics", () => {
-
-    expect(insert_before("aba", "b", "c")).toBe("acba");
-    expect(insert_before("a", "a", "c")).toBe("ca");
-    expect(insert_before("ba", "a", "c")).toBe("bca");
-
-});
-
-test("non-occurrence", () => {
-
-    expect(insert_before("", "a", "c")).toBe("");
-    expect(insert_before("b", "a", "c")).toBe("b");
-
-});

package/src/core/primitives/strings/string_capitalize.spec.js

@@ -1,13 +0,0 @@
-import { string_capitalize } from "./string_capitalize.js";
-
-test("capitalize", () => {
-    expect(string_capitalize("")).toBe("");
-
-    expect(string_capitalize("a")).toBe("A");
-
-    expect(string_capitalize("A")).toBe("A");
-
-    expect(string_capitalize("aa")).toBe("Aa");
-
-    expect(string_capitalize("AA")).toBe("AA");
-});

package/src/core/primitives/strings/string_compute_common_prefix.spec.js

@@ -1,23 +0,0 @@
-import { string_compute_common_prefix } from "./string_compute_common_prefix.js";
-
-test("common prefix", () => {
-    expect(string_compute_common_prefix([])).toBe("");
-
-    expect(string_compute_common_prefix([""])).toBe("");
-
-    expect(string_compute_common_prefix(["a"])).toBe("a");
-
-    expect(string_compute_common_prefix(["abc"])).toBe("abc");
-
-    expect(string_compute_common_prefix(["aa"])).toBe("aa");
-
-    expect(string_compute_common_prefix(["aa", "ab"])).toBe("a");
-
-    expect(string_compute_common_prefix(["abc", "abb"])).toBe("ab");
-
-    expect(string_compute_common_prefix(["abc", "abc"])).toBe("abc");
-
-    expect(string_compute_common_prefix(["abc", "abc", "a"])).toBe("a");
-
-    expect(string_compute_common_prefix(["abc", "abc", ""])).toBe("");
-});

package/src/core/primitives/strings/string_format_camel_to_kebab.spec.js

@@ -1,8 +0,0 @@
-import { string_format_camel_to_kebab } from "./string_format_camel_to_kebab.js";
-
-test('camelToKebab', () => {
-    expect(string_format_camel_to_kebab('a')).toBe('a');
-    expect(string_format_camel_to_kebab('aA')).toBe('a-a');
-    expect(string_format_camel_to_kebab('helloWoRLD')).toBe('hello-wo-rld');
-    expect(string_format_camel_to_kebab('A')).toBe('a');
-});

package/src/core/primitives/strings/string_jaro_winkler.spec.js

@@ -1,39 +0,0 @@
-import { string_jaro_winkler } from "./string_jaro_winkler.js";
-
-test("empty strings", () => {
-
-    expect(string_jaro_winkler("", "")).toBe(1)
-
-});
-
-test("whitespace", () => {
-    expect(string_jaro_winkler(" ", " ")).toBe(1);
-
-    expect(string_jaro_winkler("\n", "\n")).toBe(1);
-    expect(string_jaro_winkler("\t", "\t")).toBe(1);
-
-    expect(string_jaro_winkler("  ", " ")).toBeGreaterThan(0);
-});
-
-test("negative cases", () => {
-
-
-    expect(string_jaro_winkler("a", "")).toBe(0);
-    expect(string_jaro_winkler("", "a")).toBe(0);
-
-    expect(string_jaro_winkler("a", "b")).toBe(0);
-    expect(string_jaro_winkler("b", "a")).toBe(0);
-
-});
-
-test("known cases", () => {
-
-
-    expect(string_jaro_winkler("a", "a")).toBeCloseTo(1);
-    expect(string_jaro_winkler("aa", "aa")).toBeCloseTo(1);
-    expect(string_jaro_winkler("abc", "abc")).toBeCloseTo(1);
-
-    expect(string_jaro_winkler("DwAyNE", "DuANE")).toBeCloseTo(0.84);
-    expect(string_jaro_winkler("TRATE", "TRACE")).toBeCloseTo(0.906667);
-
-});