@woosh/meep-engine 2.48.10 → 2.48.11

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.11",
   "main": "build/meep.module.js",
   "module": "build/meep.module.js",
   "exports": {

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,6 +7,8 @@ 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";
 
 export function anyOf(...matchers) {
     return new AnyOf(matchers);
@@ -16,34 +18,69 @@ 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 +114,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;
+    }
+}
+