@woosh/meep-engine 2.48.6 → 2.48.8

package/package.json

@@ -5,7 +5,7 @@
   "description": "Fully featured ECS game engine written in JavaScript",
   "type": "module",
   "author": "Alexander Goldring",
-  "version": "2.48.6",
+  "version": "2.48.8",
   "main": "build/meep.module.js",
   "module": "build/meep.module.js",
   "exports": {

package/src/core/assert.js

@@ -1,5 +1,6 @@
 import { isArrayEqualStrict } from "./collection/array/isArrayEqualStrict.js";
 import { isTypedArray } from "./collection/array/typed/isTypedArray.js";
+import { InMemoryDescriptor } from "./debug/InMemoryDescriptor.js";
 
 function equal(a, b, m) {
     assert(a === b, m) // eslint-disable-line eqeqeq
@@ -385,6 +386,30 @@ assert.isFiniteNumber = function (value, name = "value") {
     }
 };
 
+/**
+ * @template T
+ * @param {T} value
+ * @param {string} name
+ * @param {Matcher<T>} matcher
+ */
+assert.that = function (value, name, matcher) {
+    if (matcher.matches(value)) {
+        return;
+    }
+
+    const mismatch_description = new InMemoryDescriptor();
+
+    mismatch_description.appendText(`Expected ${name} to be `);
+
+    matcher.describeTo(mismatch_description);
+
+    mismatch_description.appendText(" instead ");
+
+    matcher.describeMismatch(value, mismatch_description);
+
+    throw new Error(mismatch_description.value);
+}
+
 export {
     assert
 };

package/src/core/debug/BaseDescription.js

@@ -0,0 +1,85 @@
+import { Description } from "./Description.js";
+import { SelfDescribingValueIterator } from "./SelfDescribingValueIterator.js";
+
+
+function descriptionOf(value) {
+    try {
+        return String(value);
+    } catch (e) {
+        return 'VALUE@0';
+    }
+}
+
+/**
+ *
+ * @param {number} value
+ * @return {string}
+ */
+function formatNumber(value) {
+    return String(value);
+}
+
+
+export class BaseDescription extends Description {
+    appendDescriptionOf(value) {
+        value.describeTo(this);
+        return this;
+    }
+
+    #toJavaScriptSyntax(unformatted) {
+        this.appendText('"');
+
+        // TODO escape string
+        this.appendText(unformatted);
+
+        this.appendText('"');
+    }
+
+    appendValue(value) {
+        if (value == null) {
+            this.appendText("null");
+        } else if (value === undefined) {
+            this.appendText("undefined");
+        } else if (typeof value === "string") {
+            this.#toJavaScriptSyntax(value);
+        } else if (typeof value === "number") {
+            this.appendText(formatNumber(value));
+        } else if (Array.isArray(value)) {
+            this.appendValueList("[", ", ", "]", value);
+        } else {
+            this.appendText('<');
+            this.appendText(descriptionOf(value));
+            this.appendText('>');
+        }
+        return this;
+    }
+
+    appendValueList(start, separator, end, values) {
+        this.appendList(start, separator, end, new SelfDescribingValueIterator(values));
+        return this;
+    }
+
+    appendList(start, separator, end, values) {
+        let separate = false;
+
+        this.appendText(start);
+
+        /**
+         *
+         */
+        const iterator = values[Symbol.iterator]();
+
+        for (let i = iterator.next(); i.done !== true; i = iterator.next()) {
+            if (separate) {
+                this.appendText(separator);
+            }
+
+            this.appendDescriptionOf(i.value);
+            separate = true;
+        }
+
+        this.appendText(end);
+
+        return this;
+    }
+}

package/src/core/debug/BaseMatcher.js

@@ -0,0 +1,7 @@
+import { Matcher } from "./Matcher.js";
+
+export class BaseMatcher extends Matcher {
+    describeMismatch(item, mismatch_description) {
+        mismatch_description.appendText("was ").appendValue(item);
+    }
+}

package/src/core/debug/Description.js

@@ -0,0 +1,53 @@
+export class Description {
+    /**
+     *
+     * @param {SelfDescribing} value
+     * @returns {this}
+     */
+    appendDescriptionOf(value) {
+        throw new Error('Not Implemented');
+    }
+
+    /**
+     * @param {string} start
+     * @param {string} separator
+     * @param {string} end
+     * @param {Iterable<SelfDescribing>} values
+     * @returns {this}
+     */
+    appendList(start, separator, end, values) {
+        throw new Error('Not Implemented');
+    }
+
+    /**
+     *
+     * @param {string} text
+     * @returns {this}
+     */
+    appendText(text) {
+        throw new Error('Not Implemented');
+    }
+
+    /**
+     * @template T
+     * @param {T} value
+     * @returns {this}
+     */
+    appendValue(value) {
+        throw new Error('Not Implemented');
+    }
+
+    /**
+     *
+     * @template T
+     * @param {string} start
+     * @param {string} separator
+     * @param {string} end
+     * @param {Iterable<T>} values
+     * @returns {this}
+     */
+    appendValueList(start, separator, end, values) {
+        throw new Error('Not Implemented');
+    }
+
+}

package/src/core/debug/InMemoryDescriptor.js

@@ -0,0 +1,11 @@
+import { BaseDescription } from "./BaseDescription.js";
+
+export class InMemoryDescriptor extends BaseDescription {
+    value = ""
+
+    appendText(text) {
+        this.value += text;
+
+        return this;
+    }
+}

package/src/core/debug/Matcher.js

@@ -0,0 +1,35 @@
+import { SelfDescribing } from "./SelfDescribing.js";
+import { NullDescription } from "./NullDescription.js";
+
+/**
+ * Heavily influenced by Hamcrest, pretty much a straight port
+ * @template T
+ */
+export class Matcher extends SelfDescribing {
+
+    /**
+     *
+     * @param {T} item
+     * @param {Description} [mismatch_description]
+     * @returns {boolean}
+     */
+    matches(item, mismatch_description = NullDescription.INSTANCE) {
+        throw new Error('Not Implemented');
+    }
+
+    /**
+     *
+     * @param {T} item
+     * @param {Description} mismatch_description
+     * @returns {void}
+     */
+    describeMismatch(item, mismatch_description) {
+        throw new Error('Not Implemented');
+    }
+}
+
+/**
+ * @readonly
+ * @type {boolean}
+ */
+Matcher.prototype.isMatcher = true;

package/src/core/debug/NullDescription.js

@@ -0,0 +1,28 @@
+import { Description } from "./Description.js";
+
+/**
+ * Special description that doesn't record anything
+ */
+export class NullDescription extends Description {
+    appendText(text) {
+        return this;
+    }
+
+    appendList(start, separator, end, values) {
+        return this;
+    }
+
+    appendValueList(start, separator, end, values) {
+        return this;
+    }
+
+    appendValue(value) {
+        return this;
+    }
+
+    appendDescriptionOf(value) {
+        return this;
+    }
+}
+
+NullDescription.INSTANCE = new NullDescription();

package/src/core/debug/SelfDescribing.js

@@ -0,0 +1,15 @@
+/**
+ * The ability of an object to describe itself.
+ */
+export class SelfDescribing {
+    /**
+     * Generates a description of the object.  The description may be part of a
+     * description of a larger object of which this is just a component, so it
+     * should be worded appropriately.
+     * @param {Description} description The description to be built or appended to
+     * @returns {void}
+     */
+    describeTo(description) {
+        throw new Error('Not Implemented');
+    }
+}

package/src/core/debug/SelfDescribingValue.js

@@ -0,0 +1,15 @@
+import { SelfDescribing } from "./SelfDescribing.js";
+
+export class SelfDescribingValue extends SelfDescribing{
+    value;
+
+    constructor(value) {
+        super();
+
+        this.value = value;
+    }
+
+    describeTo(description) {
+        description.appendValue(this.value);
+    }
+}

package/src/core/debug/SelfDescribingValueIterator.js

@@ -0,0 +1,27 @@
+import { SelfDescribingValue } from "./SelfDescribingValue.js";
+
+/**
+ * @template T
+ * @extends Iterable<SelfDescribing>
+ */
+export class SelfDescribingValueIterator {
+    #iterable;
+
+    /**
+     *
+     * @param {Iterable<T>} iterable
+     */
+    constructor(iterable) {
+        this.#iterable = iterable;
+    }
+
+    * [Symbol.iterator]() {
+
+        for (const el of this.#iterable) {
+
+            yield new SelfDescribingValue(el);
+
+        }
+
+    }
+}

package/src/core/debug/matchers/AllOf.js

@@ -0,0 +1,38 @@
+import { Matcher } from "../Matcher.js";
+import { NullDescription } from "../NullDescription.js";
+import { BaseMatcher } from "../BaseMatcher.js";
+
+export class AllOf extends BaseMatcher {
+    /**
+     * @type {Matcher[]}
+     */
+    #matchers;
+
+    /**
+     *
+     * @param {Matcher[]} matchers
+     */
+    constructor(matchers) {
+        super();
+
+        this.#matchers = matchers;
+    }
+
+    matches(item, mismatch_description) {
+        for (const matcher of this.#matchers) {
+            if (!matcher.matches(item, NullDescription.INSTANCE)) {
+
+                mismatch_description.appendDescriptionOf(matcher).appendText(" ");
+                matcher.describeMismatch(item, mismatch_description);
+
+                return false;
+            }
+        }
+
+        return true;
+    }
+
+    describeTo(description) {
+        description.appendList("(", ' and ', ")", this.#matchers);
+    }
+}

package/src/core/debug/matchers/AnyOf.js

@@ -0,0 +1,35 @@
+import { Matcher } from "../Matcher.js";
+import { NullDescription } from "../NullDescription.js";
+import { BaseMatcher } from "../BaseMatcher.js";
+
+export class AnyOf extends BaseMatcher {
+    /**
+     * @type {Matcher[]}
+     */
+    #matchers;
+
+    /**
+     *
+     * @param {Matcher[]} matchers
+     */
+    constructor(matchers) {
+        super();
+
+        this.#matchers = matchers;
+    }
+
+    matches(item, mismatch_description) {
+        for (const matcher of this.#matchers) {
+            if (!matcher.matches(item, NullDescription.INSTANCE)) {
+
+                return true;
+            }
+        }
+
+        return false;
+    }
+
+    describeTo(description) {
+        description.appendList("(", " or ", ")", this.#matchers);
+    }
+}

package/src/core/debug/matchers/CombinableMatcher.js

@@ -0,0 +1,53 @@
+import { BaseMatcher } from "../BaseMatcher.js";
+import { NullDescription } from "../NullDescription.js";
+import { AllOf } from "./AllOf.js";
+import { AnyOf } from "./AnyOf.js";
+
+export class CombinableMatcher extends BaseMatcher {
+
+    /**
+     * @type {Matcher}
+     */
+    #matcher
+
+    /**
+     *
+     * @param {Matcher} matcher
+     */
+    constructor(matcher) {
+        super();
+        this.#matcher = matcher;
+    }
+
+
+    matches(item, mismatch_description) {
+        if (!this.#matcher.matches(item, NullDescription.INSTANCE)) {
+            this.#matcher.describeMismatch(item, mismatch_description);
+            return false;
+        }
+
+        return true;
+    }
+
+    describeTo(description) {
+        description.appendDescriptionOf(this.#matcher);
+    }
+
+    /**
+     *
+     * @param {Matcher} other
+     * @return {CombinableMatcher}
+     */
+    and(other) {
+        return new CombinableMatcher(new AllOf([this.#matcher, other]))
+    }
+
+    /**
+     *
+     * @param {Matcher} other
+     * @return {CombinableMatcher}
+     */
+    or(other) {
+        return new CombinableMatcher(new AnyOf([this.#matcher, other]));
+    }
+}

package/src/core/debug/matchers/IsEqual.js

@@ -0,0 +1,44 @@
+import { BaseMatcher } from "../BaseMatcher.js";
+import { isArrayEqualStrict } from "../../collection/array/isArrayEqualStrict.js";
+
+export class IsEqual extends BaseMatcher {
+    #expected;
+
+    constructor(expected) {
+        super();
+        this.#expected = expected;
+    }
+
+    matches(item, mismatch_description) {
+        return this.areEqual(item, this.#expected);
+    }
+
+    describeTo(description) {
+        description.appendValue(this.#expected);
+    }
+
+
+    areEqual(actual, expected) {
+        if (expected === actual) {
+            return true;
+        }
+
+        if (actual === null || actual === undefined) {
+            return false;
+        }
+
+        if (expected !== null && Array.isArray(actual)) {
+            return Array.isArray(expected) && isArrayEqualStrict(actual, expected);
+        }
+
+        if (typeof actual === "object" && typeof expected === "object" && typeof actual.equals === "function") {
+
+            return actual.equals(expected);
+
+        }
+
+        return false;
+    }
+
+
+}

package/src/core/debug/matchers/IsIterableContaining.js

@@ -0,0 +1,74 @@
+import { BaseMatcher } from "../BaseMatcher.js";
+import { NullDescription } from "../NullDescription.js";
+
+export class IsIterableContaining extends BaseMatcher {
+    /**
+     * @type {Matcher}
+     */
+    #element_matcher
+
+    /**
+     *
+     * @param {Matcher} matcher
+     */
+    constructor(matcher) {
+        super();
+
+        this.#element_matcher = matcher;
+    }
+
+    matches(item, mismatch_description) {
+        if (this.#isEmpty(item)) {
+            mismatch_description.appendText("was empty");
+            return false;
+        }
+
+        for (const itemElement of item) {
+            if (this.#element_matcher.matches(itemElement, NullDescription.INSTANCE)) {
+                return true;
+            }
+        }
+
+        mismatch_description.appendText("mismatches were: [");
+
+        let is_past_first = false;
+
+        for (const itemElement of item) {
+            if (is_past_first) {
+                mismatch_description.appendText(", ");
+            }
+
+            this.#element_matcher.describeMismatch(item, mismatch_description);
+
+            is_past_first = true;
+        }
+
+
+        mismatch_description.appendText("]");
+
+        return false;
+
+    }
+
+    /**
+     *
+     * @param {Iterable} iterable
+     * @return {boolean}
+     */
+    #isEmpty(iterable) {
+        const iterator = iterable[Symbol.iterator]();
+
+        const el = iterator.next();
+
+        return el.done === true;
+    }
+
+
+    describeTo(description) {
+
+        description
+            .appendText("a collection containing ")
+            .appendDescriptionOf(this.#element_matcher);
+
+    }
+}

package/src/core/debug/matchers/IsNot.js

@@ -0,0 +1,26 @@
+import { Matcher } from "../Matcher.js";
+import { BaseMatcher } from "../BaseMatcher.js";
+
+export class IsNot extends BaseMatcher {
+    /**
+     * @type {Matcher}
+     */
+    #matcher
+
+    /**
+     *
+     * @param {Matcher} matcher
+     */
+    constructor(matcher) {
+        super();
+        this.#matcher = matcher;
+    }
+
+    matches(item, mismatch_description) {
+        return !this.#matcher.matches(item, mismatch_description);
+    }
+
+    describeTo(description) {
+        description.appendText('not ').appendDescriptionOf(this.#matcher);
+    }
+}

package/src/core/debug/matchers/IsNull.js

@@ -0,0 +1,11 @@
+import { BaseMatcher } from "../BaseMatcher.js";
+
+export class IsNull extends BaseMatcher {
+    matches(item, mismatch_description) {
+        return item === null;
+    }
+
+    describeTo(description) {
+        description.appendText("null");
+    }
+}

package/src/core/debug/matchers/IsUndefined.js

@@ -0,0 +1,11 @@
+import { BaseMatcher } from "../BaseMatcher.js";
+
+export class IsUndefined extends BaseMatcher {
+    matches(item, mismatch_description) {
+        return item === undefined;
+    }
+
+    describeTo(description) {
+        description.appendText("undefined");
+    }
+}

package/src/core/debug/matchers/matchers.js

@@ -0,0 +1,50 @@
+import { AnyOf } from "./AnyOf.js";
+import { AllOf } from "./AllOf.js";
+import { IsNot } from "./IsNot.js";
+import { IsEqual } from "./IsEqual.js";
+import { IsNull } from "./IsNull.js";
+import { IsIterableContaining } from "./IsIterableContaining.js";
+import { Matcher } from "../Matcher.js";
+
+export function anyOf(...matchers) {
+    return new AnyOf(matchers);
+}
+
+export function allOf(...matchers) {
+    return new AllOf(matchers);
+}
+
+export function not(matcher) {
+    return new IsNot(matcher);
+}
+
+export function equalTo(thing) {
+    return new IsEqual(thing);
+}
+
+export function notEqualTo(thing) {
+    return not(equalTo(thing));
+}
+
+export function isNull() {
+    return new IsNull();
+}
+
+export function isNotNull() {
+    return not(isNull());
+}
+
+/**
+ * @template
+ * @param {Matcher|T} value
+ * @return {Matcher}
+ */
+export function hasItem(value) {
+    if (value instanceof Matcher) {
+        return new IsIterableContaining(value);
+    } else {
+        return new IsIterableContaining(equalTo(value));
+    }
+
+}
+

package/src/core/model/node-graph/node/NodeInstancePortReference.js

@@ -64,6 +64,26 @@ export class NodeInstancePortReference {
         return this.connections.length > 0;
     }
 
+    /**
+     * Checks if a connection exists from this endpoint to a specific node instance
+     * @param {number} node_instance_id
+     * @returns {boolean}
+     */
+    isConnectedToNode(node_instance_id) {
+        const connections = this.connections;
+        const connection_count = connections.length;
+
+        for (let i = 0; i < connection_count; i++) {
+            const connection = connections[i];
+
+            if (connection.isAttachedToNode(node_instance_id)) {
+                return true;
+            }
+        }
+
+        return false;
+    }
+
 
     /**
      *