@woosh/meep-engine 2.48.10 → 2.48.12

package/package.json

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

package/src/core/collection/HashMap.js

@@ -589,7 +589,7 @@ export class HashMap {
                 } else {
                     return {
                         done: false,
-                        value: n.value[0]
+                        value: n.value[1]
                     };
                 }
 
@@ -616,7 +616,7 @@ export class HashMap {
                 } else {
                     return {
                         done: false,
-                        value: n.value[1]
+                        value: n.value[0]
                     };
                 }
 

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

@@ -1,5 +1,5 @@
 import { HashMap } from "./HashMap.js";
-import { passThrough, strictEquals } from "../function/Functions.js";
+import { passThrough, returnOne, strictEquals } from "../function/Functions.js";
 
 /**
  *
@@ -74,3 +74,26 @@ test("retrieval works as intended after hash map grows", () => {
     expect(m.get(-7)).toEqual("c");
 
 });
+
+
+test("key iterator", () => {
+    const map = new HashMap({
+        keyHashFunction: returnOne,
+        keyEqualityFunction: strictEquals
+    });
+
+    map.set(7, "hello");
+
+    expect(map.keys().next().value).toBe(7);
+});
+
+test("value iterator", () => {
+    const map = new HashMap({
+        keyHashFunction: returnOne,
+        keyEqualityFunction: strictEquals
+    });
+
+    map.set(7, "hello");
+
+    expect(map.values().next().value).toBe("hello");
+});

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

@@ -0,0 +1,63 @@
+import { BaseMatcher } from "../BaseMatcher.js";
+
+
+const RX = /%([0-9]+)/gi;
+
+export class DescribeAs extends BaseMatcher {
+    /**
+     * @type {string}
+     */
+    template
+    /**
+     * @type {Matcher}
+     */
+    matcher
+    /**
+     * @type {[]}
+     */
+    values
+
+    /**
+     *
+     * @param {string} template
+     * @param {Matcher} matcher
+     * @param {[]} values
+     */
+    constructor(template, matcher, values) {
+        super();
+
+        this.template = template;
+        this.matcher = matcher;
+        this.values = values;
+    }
+
+    matches(item, mismatch_description) {
+        return this.matcher.matches(item, mismatch_description);
+    }
+
+    describeTo(description) {
+
+        let textStart = 0;
+
+        const matches = this.template.matchAll(RX);
+
+        for (let i = 0; i < matches.length; i++) {
+            const match = matches[i];
+
+            description.appendText(this.template.substring(textStart, match.index));
+
+            const group_index = parseInt(match.groups[1]);
+
+            description.appendValue(this.values[group_index]);
+
+            textStart = match[0].length;
+        }
+        if (textStart < this.template.length) {
+            description.appendText(this.template.slice(textStart));
+        }
+    }
+
+    describeMismatch(item, mismatch_description) {
+        this.matcher.describeMismatch(item, mismatch_description);
+    }
+}

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

@@ -0,0 +1,19 @@
+import { BaseMatcher } from "../BaseMatcher.js";
+
+export class IsAnything extends BaseMatcher {
+    message
+
+    constructor(message = "ANYTHING") {
+        super();
+
+        this.message = message;
+    }
+
+    matches(item, mismatch_description = NullDescription.INSTANCE) {
+        return false;
+    }
+
+    describeTo(description) {
+        description.appendText(this.message);
+    }
+}

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

@@ -7,43 +7,90 @@ import { IsIterableContaining } from "./IsIterableContaining.js";
 import { Matcher } from "../Matcher.js";
 import { IsUndefined } from "./IsUndefined.js";
 import { IsIn } from "./IsIn.js";
+import { IsAnything } from "./IsAnything.js";
+import { DescribeAs } from "./DescribeAs.js";
 
+/**
+ * @template T
+ * @param {Matcher<T>} matchers
+ * @return {Matcher<T>}
+ */
 export function anyOf(...matchers) {
     return new AnyOf(matchers);
 }
 
+/**
+ * @template T
+ * @param {Matcher<T>} matchers
+ * @return {Matcher<T>}
+ */
 export function allOf(...matchers) {
     return new AllOf(matchers);
 }
 
+/**
+ * @template T
+ * @param {Matcher<T>} matcher
+ * @return {Matcher<T>}
+ */
 export function not(matcher) {
     return new IsNot(matcher);
 }
 
+/**
+ * @template T
+ * @param {T} thing
+ * @return {Matcher<T>}
+ */
 export function equalTo(thing) {
     return new IsEqual(thing);
 }
 
+/**
+ * @template T
+ * @param {T} thing
+ * @return {Matcher<T>}
+ */
 export function notEqualTo(thing) {
     return not(equalTo(thing));
 }
 
+/**
+ * @template T
+ * @return {Matcher<T>}
+ */
 export function isNull() {
     return new IsNull();
 }
 
+/**
+ * @template T
+ * @return {Matcher<T>}
+ */
 export function isNotNull() {
     return not(isNull());
 }
 
+/**
+ * @template T
+ * @return {Matcher<T>}
+ */
 export function isUndefined() {
     return new IsUndefined();
 }
 
+/**
+ * @template T
+ * @return {Matcher<T>}
+ */
 export function isDefined() {
     return not(isUndefined());
 }
 
+/**
+ * @template T
+ * @return {Matcher<T>}
+ */
 export const isNoUndefined = isDefined;
 
 /**
@@ -77,3 +124,41 @@ export function isIn(array) {
 export function isOneOf(...elements) {
     return isIn(elements);
 }
+
+
+/**
+ * @template T
+ * @param {string} template
+ * @param {Matcher<T>} matcher
+ * @param {[]} values
+ * @returns {Matcher<T>}
+ */
+function describeAs(template, matcher, values) {
+    return new DescribeAs(template, matcher, values);
+}
+
+/**
+ *
+ * @template T
+ * @param {string} [message]
+ * @return {Matcher<T>}
+ */
+export function anything(message) {
+    return new IsAnything(message);
+}
+
+/**
+ * @template T
+ * @param {string} [message]
+ * @return {Matcher<T>}
+ */
+export function nothing(message) {
+    const matcher = not(anything());
+
+    if (message !== undefined) {
+        return describeAs(message, matcher, []);
+    } else {
+        return matcher;
+    }
+}
+