@woosh/meep-engine 2.49.6 → 2.49.8

package/src/core/model/reactive/trigger/BlackboardTrigger.js

@@ -56,6 +56,11 @@ export class BlackboardTrigger {
 
         if (this.isLinked) {
             //already linked
+
+            if (this.blackboard !== blackboard) {
+                throw new Error(`Already linked to another blackboard`);
+            }
+
             return;
         }
 

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

@@ -0,0 +1,24 @@
+import { BlackboardTrigger } from "./BlackboardTrigger.js";
+import { Blackboard } from "../../../../engine/intelligence/blackboard/Blackboard.js";
+
+test("constructor does not throw", () => {
+    expect(() => new BlackboardTrigger()).not.toThrow();
+});
+
+test("numeric equality", () => {
+
+    const trigger = new BlackboardTrigger();
+    trigger.code = "a == 7";
+
+    const bb = Blackboard.fromJSON({
+        a: 7
+    });
+
+    trigger.link(bb);
+
+    expect(trigger.getExpression().getValue()).toBe(true);
+
+    bb.acquireNumber("a").set(1);
+
+    expect(trigger.getExpression().getValue()).toBe(false);
+});

package/src/core/parser/simple/readBooleanToken.js

@@ -0,0 +1,38 @@
+import ParserError from "./ParserError.js";
+import Token from "./Token.js";
+import TokenType from "./TokenType.js";
+import DataType from "./DataType.js";
+
+/**
+ *
+ * @param {string} text
+ * @param {number} cursor
+ * @param {number} length
+ * @returns {Token}
+ */
+export function readBooleanToken(text, cursor, length) {
+    const firstChar = text.charAt(cursor);
+
+    let value;
+    let end = cursor;
+
+    if (firstChar === 't' && length - cursor >= 4) {
+        if (text.substring(cursor + 1, cursor + 4) === 'rue') {
+            value = true;
+            end = cursor + 4;
+        } else {
+            throw new ParserError(cursor, `expected 'true', instead got '${text.substring(cursor, cursor + 4)}'`, text);
+        }
+    } else if (firstChar === 'f' && length - cursor >= 5) {
+        if (text.substring(cursor + 1, cursor + 5) === 'alse') {
+            value = false;
+            end = cursor + 5;
+        } else {
+            throw new ParserError(cursor, `expected 'false', instead got '${text.substring(cursor, cursor + 5)}'`, text);
+        }
+    } else {
+        throw new ParserError(cursor, `expected 't' or 'f', instead got '${firstChar}'`, text);
+    }
+
+    return new Token(value, cursor, end, TokenType.LiteralBoolean, DataType.Boolean);
+}

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

@@ -0,0 +1,95 @@
+import ParserError from "./ParserError.js";
+import Token from "./Token.js";
+import DataType from "./DataType.js";
+
+/**
+ *
+ * @param {string} text
+ * @param {number} cursor
+ * @param {number} length
+ * @returns {Token}
+ */
+export function readHexToken(text, cursor, length) {
+    const c0 = text.charAt(cursor);
+    const c1 = text.charAt(cursor + 1);
+
+    if (c0 !== '0' || !(c1 === 'x' || c1 === 'X')) {
+        throw new ParserError(cursor, 'Expected hex prefix 0x', text);
+    }
+
+    let i = cursor + 2;
+    let value = 0;
+
+    main_loop: for (; i < length;) {
+        const char = text.charAt(i);
+        let digit;
+        switch (char) {
+            case '0':
+                digit = 0;
+                break;
+            case '1':
+                digit = 1;
+                break;
+            case '2':
+                digit = 2;
+                break;
+            case '3':
+                digit = 3;
+                break;
+            case '4':
+                digit = 4;
+                break;
+            case '5':
+                digit = 5;
+                break;
+            case '6':
+                digit = 6;
+                break;
+            case '7':
+                digit = 7;
+                break;
+            case '8':
+                digit = 8;
+                break;
+            case '9':
+                digit = 9;
+                break;
+            case 'a':
+            case 'A':
+                digit = 10;
+                break;
+            case 'b':
+            case 'B':
+                digit = 11;
+                break;
+            case 'c':
+            case 'C':
+                digit = 12;
+                break;
+            case 'd':
+            case 'D':
+                digit = 13;
+                break;
+            case 'e':
+            case 'E':
+                digit = 14;
+                break;
+            case 'f':
+            case 'F':
+                digit = 15;
+                break;
+            default:
+                if (i === cursor) {
+                    //first character is not a digit
+                    throw new ParserError(i, `Expected a digit [0,1,2,3,4,5,6,7,8,9,A,B,C,D,E,F] but got '${char}' instead`, text);
+                }
+                //not a digit
+                break main_loop;
+        }
+        i++;
+        value = value * 16 + digit;
+    }
+
+
+    return new Token(value, cursor, i, null, DataType.Number);
+}

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

@@ -0,0 +1,21 @@
+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.js

@@ -0,0 +1,43 @@
+import ParserError from "./ParserError.js";
+import Token from "./Token.js";
+import TokenType from "./TokenType.js";
+import DataType from "./DataType.js";
+
+const RX_IDENTIFIER_CHAR = /^[a-zA-Z0-9_]/;
+/**
+ * @readonly
+ * @type {RegExp}
+ */
+export const RX_IDENTIFIER_FIRST_CHAR = /^[a-zA-Z_]/;
+
+/**
+ * Read C99 style IDENTIFIER token
+ * @param {string} text
+ * @param {number} cursor
+ * @param {number} length
+ * @returns {Token}
+ */
+export function readIdentifierToken(text, cursor, length) {
+    let i = cursor;
+
+
+    const firstChar = text.charAt(i);
+
+    if (!RX_IDENTIFIER_FIRST_CHAR.test(firstChar)) {
+        throw new ParserError(i, `Expected first character to match /${RX_IDENTIFIER_FIRST_CHAR.toString()}/, instead got '${firstChar}'`, text);
+    }
+
+    i++;
+
+    for (; i < length; i++) {
+        const char = text.charAt(i);
+
+        if (!RX_IDENTIFIER_CHAR.test(char)) {
+            break;
+        }
+    }
+
+    const value = text.substring(cursor, i);
+
+    return new Token(value, cursor, i, TokenType.Identifier, DataType.String);
+}

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

@@ -0,0 +1,32 @@
+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/readLiteralToken.js

@@ -0,0 +1,96 @@
+import { skipWhitespace } from "./skipWhitespace.js";
+import Token from "./Token.js";
+import DataType from "./DataType.js";
+import ParserError from "./ParserError.js";
+import { readBooleanToken } from "./readBooleanToken.js";
+import { readStringToken } from "./readStringToken.js";
+import { readNumberToken } from "./readNumberToken.js";
+
+/**
+ *
+ * @param {string} text
+ * @param {number} cursor
+ * @param {number} length
+ * @return {Token}
+ */
+function readArrayLiteral(text, cursor, length) {
+    let i = cursor;
+
+    const firstChar = text.charAt(i);
+    if (firstChar !== '[') {
+        throw new ParserError(cursor, `expected array start: '[', got '${firstChar}' instead`, text);
+    }
+
+    i++;
+
+    const values = [];
+    while (i < length) {
+        i = skipWhitespace(text, i, length);
+
+        const token = readLiteralToken(text, i, length);
+
+        i = token.end;
+
+        values.push(token);
+
+        //try find separator
+        i = skipWhitespace(text, i, length);
+        if (i < length) {
+            const char = text.charAt(i);
+            if (char === ',') {
+                //separator
+                i++;
+            } else if (char === ']') {
+                //end of sequence
+                i++;
+                break;
+            } else {
+                //unexpected input
+                throw new ParserError(i, `Unexpected input '${char}', expected either separator ',' or end of sequence ']'`, text);
+            }
+        } else {
+            throw new ParserError(i, `Unterminated array literal`, text);
+        }
+    }
+
+    return new Token(values, cursor, i, 'array', DataType.Array);
+}
+
+/**
+ *
+ * @param {string} text
+ * @param {number} cursor
+ * @param {number} length
+ * @returns {Token}
+ */
+function readLiteralToken(text, cursor, length) {
+    const firstChar = text.charAt(cursor);
+
+    switch (firstChar) {
+        case 't':
+        case 'f':
+            return readBooleanToken(text, cursor, length);
+        case '\"':
+        case "\'":
+            return readStringToken(text, cursor, length);
+        case '-':
+        case '+':
+        case '0':
+        case '1':
+        case '2':
+        case '3':
+        case '4':
+        case '5':
+        case '6':
+        case '7':
+        case '8':
+        case '9':
+            return readNumberToken(text, cursor, length);
+        case '[':
+            return readArrayLiteral(text, cursor, length);
+        default:
+            throw new ParserError(cursor, "Expected literal start, but found '" + firstChar + "'", text);
+    }
+}
+
+export { readLiteralToken };

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

@@ -0,0 +1,73 @@
+import { skipWhitespace } from "./skipWhitespace.js";
+import { readHexToken } from "./readHexToken.js";
+import { readUnsignedIntegerToken } from "./readUnsignedIntegerToken.js";
+import Token from "./Token.js";
+import TokenType from "./TokenType.js";
+import DataType from "./DataType.js";
+
+/**
+ *
+ * @param {string} text
+ * @param {number} cursor
+ * @param {number} length
+ * @returns {Token}
+ */
+export function readNumberToken(text, cursor, length) {
+    let i = cursor;
+
+    //read optional sign
+    function readSign(text) {
+        let sign = 1;
+        const firstChar = text.charAt(i);
+        if (firstChar === '-') {
+            sign = -1;
+        } else if (firstChar === '+') {
+            sign = 1;
+        } else {
+            return 1;
+        }
+
+        i = skipWhitespace(text, i + 1, length);
+
+        return sign;
+    }
+
+    const sign = readSign(text);
+
+    let value;
+
+    if (text.charAt(i) === '0' && (text.charAt(i + 1) === 'x' || text.charAt(i + 1) === 'X')) {
+        // hex number
+        const token = readHexToken(text, i, length);
+
+        i = token.end;
+
+        value = token.value;
+
+    } else {
+
+        const wholePart = readUnsignedIntegerToken(text, i, length);
+
+        i = wholePart.end;
+
+        value = wholePart.value;
+
+        if (i < length) {
+            const dot = text.charAt(i);
+            if (dot === '.') {
+                i++;
+                const fraction = readUnsignedIntegerToken(text, i, length);
+
+                const digits = (fraction.end - fraction.start);
+
+                value += fraction.value / Math.pow(10, digits);
+
+                i = fraction.end;
+            }
+        }
+    }
+
+    value *= sign;
+
+    return new Token(value, cursor, i, TokenType.LiteralNumber, DataType.Number);
+}

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

@@ -0,0 +1,17 @@
+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.js

@@ -0,0 +1,48 @@
+import DataType from "./DataType.js";
+import Token from "./Token.js";
+import TokenType from "./TokenType.js";
+import { readIdentifierToken } from "./readIdentifierToken.js";
+
+
+/**
+ *
+ * @param {String} text
+ * @param {number} cursor
+ * @param {number} length
+ * @returns {Token}
+ */
+export function readReferenceToken(text, cursor, length) {
+    let i = cursor;
+
+    const identifiers = [];
+
+    let identifier;
+
+    identifier = readIdentifierToken(text, i, length);
+
+    identifiers.push(identifier);
+
+    i = identifier.end;
+
+    for (; ;) {
+
+        const firstChar = text.charAt(i);
+
+        if (firstChar !== '.') {
+            break;
+        }
+
+        //skip over the separator
+        i++;
+
+        identifier = readIdentifierToken(text, i, length);
+
+        identifiers.push(identifier);
+
+        i = identifier.end;
+    }
+
+    return new Token(identifiers, cursor, i, TokenType.Reference, DataType.String);
+}
+
+

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

@@ -0,0 +1,18 @@
+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.js

@@ -0,0 +1,94 @@
+import ParserError from "./ParserError.js";
+import Token from "./Token.js";
+import TokenType from "./TokenType.js";
+import DataType from "./DataType.js";
+
+/**
+ *
+ * @param {string} text
+ * @param {number} cursor
+ * @returns {string}
+ */
+function readQuote(text, cursor) {
+    const char = text.charAt(cursor);
+
+    if (char !== '"' && char !== '\'') {
+        throw new ParserError(cursor, "Expected \", found " + char + " instead", text);
+    }
+
+    return char;
+}
+
+/**
+ *
+ * @param {string} text
+ * @param {number} cursor
+ * @param {number} length
+ * @returns {Token}
+ */
+export function readStringToken(text, cursor, length) {
+    let i = cursor;
+
+    const openingQuote = readQuote(text, i);
+
+    i++;
+
+    let char;
+
+    let value = '';
+    const lastPossibleChar = length - 1;
+
+    for (; i < lastPossibleChar; i++) {
+        char = text.charAt(i);
+
+        if (char === '\\') {
+            i++;
+            //read escape sequence
+            char = text.charAt(i);
+
+            switch (char) {
+                case 'n':
+                    value += '\n';
+                    break;
+                case 't':
+                    value += '\t';
+                    break;
+                case 'r':
+                    value += '\r';
+                    break;
+                case 'b':
+                    value += '\b';
+                    break;
+                case 'f':
+                    value += '\f';
+                    break;
+                case 'v':
+                    value += '\v';
+                    break;
+                case '0':
+                    value += '\0';
+                    break;
+                case '\\':
+                case "'":
+                case '"':
+                default:
+                    value += char;
+                    break;
+            }
+        } else if (char !== openingQuote) {
+            value += char;
+        } else {
+            break;
+        }
+    }
+
+    char = text.charAt(i);
+
+    if (char !== openingQuote) {
+        throw new ParserError(cursor, "Expected string terminator : " + openingQuote + ", but found '" + char + "' instead", text);
+    }
+
+    i++;
+
+    return new Token(value, cursor, i, TokenType.LiteralString, DataType.String);
+}

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

@@ -0,0 +1,57 @@
+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/{readUnsignedInteger.js → readUnsignedIntegerToken.js}

@@ -9,7 +9,7 @@ import DataType from "./DataType.js";
  * @param {number} length
  * @returns {Token}
  */
-export function readUnsignedInteger(text, cursor, length) {
+export function readUnsignedIntegerToken(text, cursor, length) {
     let i = cursor;
 
     let value = 0;