@matter/model 0.12.0-alpha.0-20241228-9f74a0273 → 0.12.0-alpha.0-20241231-14ac774ba

package/src/logic/index.ts

@@ -12,6 +12,7 @@ export * from "./cluster-variance/VarianceCondition.js";
 export * from "./ClusterVariance.js";
 export * from "./DefaultValue.js";
 export * from "./MergedModel.js";
+export * from "./ModelDiff.js";
 export * from "./ModelVariantTraversal.js";
 export * from "./Scope.js";
 export * from "./ValidateModel.js";

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)) {