@matter/model 0.12.0-alpha.0-20241229-9d9c99934 → 0.12.0-alpha.0-20241231-9ac20db97

package/src/common/FieldValue.ts

@@ -47,6 +47,11 @@ export namespace FieldValue {
     export const none = "none";
     export type none = typeof none;
 
+    /**
+     * A field value that allows type extension.
+     */
+    export type Open = FieldValue | { type: string };
+
     /**
      * If a field value isn't a primitive type, it's an object with a type field indicating one of these types.
      */
@@ -55,7 +60,7 @@ export namespace FieldValue {
     /**
      * Test for one of the special placeholder types.
      */
-    export function is(value: FieldValue | undefined, type: Type) {
+    export function is(value: Open | undefined, type: Type) {
         return value && (value as any).type === type;
     }
 
@@ -150,7 +155,7 @@ export namespace FieldValue {
             return `${(value as Celsius).value}°C`;
         }
         if (is(value, percent)) {
-            return `${(value as Percent).value}%';`;
+            return `${(value as Percent).value}%`;
         }
         if (is(value, properties)) {
             return stringSerialize((value as Properties).properties) ?? "?";
@@ -161,7 +166,7 @@ export namespace FieldValue {
     /**
      * Given a type name as a hint, do our best to convert a field value to a number.
      */
-    export function numericValue(value: FieldValue | undefined, typeName?: string) {
+    export function numericValue(value: Open | undefined, typeName?: string) {
         if (typeof value === "boolean") {
             return value ? 1 : 0;
         }
@@ -240,7 +245,7 @@ export namespace FieldValue {
     /**
      * Get the referenced name if the FieldValue is a reference.
      */
-    export function referenced(value: FieldValue | undefined) {
+    export function referenced(value: Open | undefined) {
         if (is(value, reference)) {
             return (value as Reference).name;
         }

package/src/logic/definition-validation/ValueValidator.ts

@@ -49,7 +49,7 @@ export class ValueValidator<T extends ValueModel> extends ModelValidator<T> {
     private validateAspect(name: string) {
         const aspect = (this.model as any)[name] as Aspect;
         if (aspect?.errors) {
-            aspect.errors.forEach((e: DefinitionError) => this.model.error(e.code, e.message));
+            aspect.errors.forEach((e: DefinitionError) => this.model.error(e.code, `${e.source}: ${e.message}`));
         }
     }
 

package/src/parser/Lexer.ts

@@ -16,10 +16,10 @@ function isNameChar(c: string) {
  *
  * Tokenizes simple text dialects.  Currently sufficient for Matter conformance and constraint tokenization.
  */
-export class Lexer<T extends BasicToken> {
+export class Lexer<T extends BasicToken<KW>, const KW extends string[] = []> {
     #keywords: Set<string>;
 
-    constructor(keywords: Iterable<string> = []) {
+    constructor(keywords?: KW) {
         if (keywords instanceof Set) {
             this.#keywords = keywords;
         } else {
@@ -117,33 +117,7 @@ function* lex(
         return;
     }
 
-    function tokenizeNumber(sign: number) {
-        markStart();
-        if (sign === -1) {
-            // Skip "-" prefix
-            next();
-        }
-
-        if (current.value === "0") {
-            if (peeked.value === "x") {
-                next();
-                next();
-                return tokenizeDigits(16, sign, hexadecimalValueOf);
-            } else if (peeked.value === "b") {
-                next();
-                next();
-                return tokenizeDigits(2, sign, binaryValueOf);
-            }
-        }
-
-        return tokenizeDigits(10, sign, decimalValueOf);
-    }
-
-    function tokenizeDigits(
-        base: number,
-        sign: number,
-        valueOf: (digit: string[1] | undefined) => number | undefined,
-    ): BasicToken {
+    function tokenizeDigits(base: number, valueOf: (digit: string[1] | undefined) => number | undefined): BasicToken {
         // The first digit may not actually be a digit if number is hexadecimal or binary
         let num = valueOf(current.value);
         if (num === undefined) {
@@ -161,7 +135,19 @@ function* lex(
             num = num * base + digitValue;
         }
 
-        num *= sign;
+        if (base === 10 && peeked.value === ".") {
+            next();
+            let fraction = "";
+            while (true) {
+                const digitValue = valueOf(peeked.value);
+                if (digitValue === undefined) {
+                    break;
+                }
+                fraction += peeked.value;
+                next();
+            }
+            num = Number.parseFloat(`${num}.${fraction}`);
+        }
 
         // Handle specialized suffices for percents and temperatures
         if (peeked.value === "%") {
@@ -169,7 +155,7 @@ function* lex(
             return { type: "value", value: FieldValue.Percent(num), startLine, startChar };
         } else if (peeked.value === "°") {
             next();
-            if (peeked.value?.toLowerCase() === "C") {
+            if (peeked.value?.toLowerCase() === "c") {
                 next();
             }
             return { type: "value", value: FieldValue.Celsius(num), startLine, startChar };
@@ -190,22 +176,34 @@ function* lex(
             case "]":
             case "(":
             case ")":
+            case "{":
+            case "}":
+            case "-":
             case "+":
             case "/":
             case "*":
                 yield { type: current.value, startLine: line, startChar: char };
                 break;
 
-            case "-":
-                if (peeked.value !== undefined && (peeked.value >= "0" || peeked.value <= "0")) {
-                    yield tokenizeNumber(-1);
-                } else {
-                    yield { type: current.value, startLine: line, startChar: char };
+            case "0":
+                markStart();
+
+                if (current.value === "0") {
+                    if (peeked.value === "x") {
+                        next();
+                        next();
+                        yield tokenizeDigits(16, hexadecimalValueOf);
+                        break;
+                    }
+
+                    if (peeked.value === "b") {
+                        next();
+                        next();
+                        yield tokenizeDigits(2, binaryValueOf);
+                    }
                 }
-                break;
 
-            case "0":
-                yield tokenizeNumber(1);
+                yield tokenizeDigits(10, decimalValueOf);
                 break;
 
             case "1":
@@ -217,7 +215,7 @@ function* lex(
             case "7":
             case "8":
             case "9":
-                yield tokenizeDigits(10, 1, decimalValueOf);
+                yield tokenizeDigits(10, decimalValueOf);
                 break;
 
             case "!":

package/src/parser/Token.ts

@@ -18,7 +18,11 @@ export interface Token {
 /**
  * The base token produced by the tokenizer.
  */
-export type BasicToken = BasicToken.Special | BasicToken.Word | BasicToken.Number;
+export type BasicToken<KW extends string[] = []> =
+    | BasicToken.Special
+    | BasicToken.Word
+    | BasicToken.Number
+    | BasicToken.Keyword<KW>;
 
 /**
  * A {@link BasicToken} with additional keywords.
@@ -39,6 +43,8 @@ export namespace BasicToken {
         | "]"
         | "("
         | ")"
+        | "{"
+        | "}"
         | "-"
         | "+"
         | "*"
@@ -61,4 +67,8 @@ export namespace BasicToken {
         type: "value";
         value: FieldValue;
     }
+
+    export interface Keyword<T extends string[]> extends Token {
+        type: T[number];
+    }
 }

package/src/parser/TokenStream.ts

@@ -50,10 +50,10 @@ export function TokenStream<T extends Token>(iterator: Iterator<T>): TokenStream
                     return "end of statement";
 
                 case "word":
-                    return `word "${(this.token as unknown as BasicToken.Word).value}`;
+                    return `word "${(this.token as unknown as BasicToken.Word).value}"`;
 
                 case "number":
-                    return `number "${(this.token as unknown as BasicToken.Number).value}`;
+                    return `number "${(this.token as unknown as BasicToken.Number).value}"`;
 
                 default:
                     if (this.token?.type.match(/[a-z]/i)) {