@matter/model 0.11.0-alpha.0-20241005-e3e4e4a7a

package/dist/esm/aspects/Conformance.d.ts

@@ -0,0 +1,147 @@
+/**
+ * @license
+ * Copyright 2022-2024 Matter.js Authors
+ * SPDX-License-Identifier: Apache-2.0
+ */
+import { FieldValue } from "../common/index.js";
+import { Aspect } from "./Aspect.js";
+/**
+ * An operational view of conformance as defined by the Matter Specification.
+ *
+ * We extend the specification's syntax to add ">", "<", ">=" and "<=".  These are required to encode some portions of
+ * the specification that are described in prose.
+ *
+ * "Conformance" controls when a data field or cluster element is allowed or required.
+ */
+export declare class Conformance extends Aspect<Conformance.Definition> {
+    ast: Conformance.Ast;
+    get type(): Conformance.Special | Conformance.Flag | Conformance.Operator.NOT | Conformance.Operator.EQ | Conformance.Operator.NE | Conformance.Operator.OR | Conformance.Operator.XOR | Conformance.Operator.AND | Conformance.Operator.GT | Conformance.Operator.LT | Conformance.Operator.GTE | Conformance.Operator.LTE;
+    get empty(): boolean;
+    /**
+     * Initialize from a Conformance.Definition or the conformance DSL defined by the Matter Specification.
+     */
+    constructor(definition: Conformance.Definition);
+    validateReferences(lookup: Conformance.ReferenceResolver<boolean>): void;
+    /**
+     * Is the associated element mandatory?
+     *
+     * This supports a limited subset of conformance and is only appropriate for field and requirement conformance.
+     */
+    get isMandatory(): boolean;
+    /**
+     * Perform limited conformance evaluation to determine whether this conformance is applicable given a feature
+     * combination.
+     *
+     * Ignores subexpressions that reference field values.
+     *
+     * This is useful for filtering elements at compile time.  For complete accuracy you then need to filter at runtime
+     * once field values are known.
+     */
+    isApplicable(features: Iterable<string>, supportedFeatures: Iterable<string>): boolean;
+    toString(): string;
+    freeze(): void;
+}
+export declare namespace Conformance {
+    type AstParam = Ast.Name | Ast.Value | Ast.Option | Ast.UnaryOperand | Ast.BinaryOperands | Ast.Group | Ast.Choice;
+    type Ast = {
+        type: Special.Empty | Special.Desc | Flag;
+    } | {
+        type: Special.Name;
+        param: Ast.Name;
+    } | {
+        type: Special.Value;
+        param: Ast.Value;
+    } | {
+        type: Special.Choice;
+        param: Ast.Choice;
+    } | {
+        type: Special.Group;
+        param: Ast.Group;
+    } | {
+        type: Special.OptionalIf;
+        param: Ast.Option;
+    } | {
+        type: Operator.AND | Operator.OR | Operator.XOR | Operator.EQ | Operator.NE | Operator.LT | Operator.GT | Operator.LTE | Operator.GTE;
+        param: Ast.BinaryOperands;
+    } | {
+        type: Operator.NOT;
+        param: Ast.UnaryOperand;
+    };
+    namespace Ast {
+        type Name = string;
+        type Value = FieldValue;
+        type Option = Ast;
+        type UnaryOperand = Ast;
+        type BinaryOperands = {
+            lhs: Ast;
+            rhs: Ast;
+        };
+        type Group = Ast[];
+        type Choice = {
+            name: ChoiceName;
+            num: number;
+            orMore?: boolean;
+            expr: Ast;
+        };
+    }
+    enum Special {
+        Empty = "empty",
+        Desc = "desc",
+        Name = "name",
+        Value = "value",
+        Choice = "choice",
+        Group = "group",
+        OptionalIf = "optionalIf"
+    }
+    enum Flag {
+        Mandatory = "M",
+        Optional = "O",
+        Provisional = "P",
+        Deprecated = "D",
+        Disallowed = "X"
+    }
+    enum Operator {
+        NOT = "!",
+        EQ = "==",
+        NE = "!=",
+        OR = "|",
+        XOR = "^",
+        AND = "&",
+        DOT = ".",
+        GT = ">",
+        LT = "<",
+        GTE = ">=",
+        LTE = "<="
+    }
+    const M = Flag.Mandatory;
+    const O = Flag.Optional;
+    const P = Flag.Provisional;
+    const D = Flag.Deprecated;
+    const X = Flag.Disallowed;
+    const EQ = Operator.EQ;
+    const NE = Operator.NE;
+    const OR = Operator.OR;
+    const XOR = Operator.XOR;
+    const AND = Operator.AND;
+    const DOT = Operator.DOT;
+    const GT = Operator.GT;
+    const LT = Operator.LT;
+    const GTE = Operator.GTE;
+    const LTE = Operator.LTE;
+    type Name = string;
+    type Number = number;
+    type ChoiceName = "a" | "b" | "c" | "d" | "e" | "f" | "g" | "h" | "i" | "j" | "k" | "l" | "m" | "n" | "o" | "p" | "q" | "r" | "s" | "t" | "u" | "v" | "w" | "x" | "y" | "z";
+    type ReferenceResolver<T> = (name: string) => T;
+    /**
+     * Supported ways of expressing conformance (conceptually union should include Flag but that is covered by string).
+     */
+    type Definition = string | string[] | {
+        ast: Conformance.Ast;
+    } | undefined;
+    function validateReferences(conformance: Conformance, ast: Ast, resolver: ReferenceResolver<boolean>): void;
+    function serialize(ast: Ast): string;
+    function isBinaryOperator(type: Ast["type"] | Operator): type is Operator;
+    function precedenceOf(operator: Ast["type"] | Operator): number | undefined;
+    function isHigherPrecedence(operator: Ast["type"] | Operator, other: Ast["type"] | Operator): boolean;
+}
+//# sourceMappingURL=Conformance.d.ts.map

package/dist/esm/aspects/Conformance.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"Conformance.d.ts","sourceRoot":"","sources":["../../../src/aspects/Conformance.ts"],"names":[],"mappings":"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"}

package/dist/esm/aspects/Conformance.js

@@ -0,0 +1,494 @@
+/**
+ * @license
+ * Copyright 2022-2024 Matter.js Authors
+ * SPDX-License-Identifier: Apache-2.0
+ */
+import { FieldValue } from "../common/index.js";
+import { Lexer, TokenStream } from "../parser/index.js";
+import { Aspect } from "./Aspect.js";
+class Conformance extends Aspect {
+  ast;
+  get type() {
+    return this.ast.type;
+  }
+  get empty() {
+    return this.type === Conformance.Special.Empty;
+  }
+  /**
+   * Initialize from a Conformance.Definition or the conformance DSL defined by the Matter Specification.
+   */
+  constructor(definition) {
+    super(definition);
+    if (definition === void 0) {
+      this.ast = { type: Conformance.Special.Empty };
+      return;
+    }
+    let ast;
+    if (typeof definition === "string") {
+      ast = ParsedAst(this, definition);
+    } else if (Array.isArray(definition)) {
+      const asts = definition.map((def) => ParsedAst(this, def));
+      if (asts.length === 1) {
+        ast = asts[0];
+      } else {
+        ast = {
+          type: Conformance.Special.Group,
+          param: asts
+        };
+      }
+    } else {
+      ast = definition.ast;
+    }
+    this.ast = ast;
+  }
+  validateReferences(lookup) {
+    return Conformance.validateReferences(this, this.ast, lookup);
+  }
+  /**
+   * Is the associated element mandatory?
+   *
+   * This supports a limited subset of conformance and is only appropriate for field and requirement conformance.
+   */
+  get isMandatory() {
+    const conformance = this.ast;
+    if (conformance.type === Conformance.Flag.Mandatory) {
+      return true;
+    }
+    if (conformance.type === Conformance.Special.Group) {
+      for (const c of conformance.param) {
+        if (c.type === Conformance.Flag.Provisional) {
+          return false;
+        }
+        if (c.type === Conformance.Flag.Mandatory) {
+          return true;
+        }
+      }
+    }
+    return false;
+  }
+  /**
+   * Perform limited conformance evaluation to determine whether this conformance is applicable given a feature
+   * combination.
+   *
+   * Ignores subexpressions that reference field values.
+   *
+   * This is useful for filtering elements at compile time.  For complete accuracy you then need to filter at runtime
+   * once field values are known.
+   */
+  isApplicable(features, supportedFeatures) {
+    const fset = features instanceof Set ? features : new Set(features);
+    const sfset = supportedFeatures instanceof Set ? supportedFeatures : new Set(supportedFeatures);
+    return computeApplicability(fset, sfset, this.ast) !== false;
+  }
+  toString() {
+    return Conformance.serialize(this.ast);
+  }
+  freeze() {
+    freezeAst(this.ast);
+    super.freeze();
+  }
+}
+((Conformance2) => {
+  let Special;
+  ((Special2) => {
+    Special2["Empty"] = "empty";
+    Special2["Desc"] = "desc";
+    Special2["Name"] = "name";
+    Special2["Value"] = "value";
+    Special2["Choice"] = "choice";
+    Special2["Group"] = "group";
+    Special2["OptionalIf"] = "optionalIf";
+  })(Special = Conformance2.Special || (Conformance2.Special = {}));
+  let Flag;
+  ((Flag2) => {
+    Flag2["Mandatory"] = "M";
+    Flag2["Optional"] = "O";
+    Flag2["Provisional"] = "P";
+    Flag2["Deprecated"] = "D";
+    Flag2["Disallowed"] = "X";
+  })(Flag = Conformance2.Flag || (Conformance2.Flag = {}));
+  let Operator;
+  ((Operator2) => {
+    Operator2["NOT"] = "!";
+    Operator2["EQ"] = "==";
+    Operator2["NE"] = "!=";
+    Operator2["OR"] = "|";
+    Operator2["XOR"] = "^";
+    Operator2["AND"] = "&";
+    Operator2["DOT"] = ".";
+    Operator2["GT"] = ">";
+    Operator2["LT"] = "<";
+    Operator2["GTE"] = ">=";
+    Operator2["LTE"] = "<=";
+  })(Operator = Conformance2.Operator || (Conformance2.Operator = {}));
+  Conformance2.M = "M" /* Mandatory */;
+  Conformance2.O = "O" /* Optional */;
+  Conformance2.P = "P" /* Provisional */;
+  Conformance2.D = "D" /* Deprecated */;
+  Conformance2.X = "X" /* Disallowed */;
+  Conformance2.EQ = "==" /* EQ */;
+  Conformance2.NE = "!=" /* NE */;
+  Conformance2.OR = "|" /* OR */;
+  Conformance2.XOR = "^" /* XOR */;
+  Conformance2.AND = "&" /* AND */;
+  Conformance2.DOT = "." /* DOT */;
+  Conformance2.GT = ">" /* GT */;
+  Conformance2.LT = "<" /* LT */;
+  Conformance2.GTE = ">=" /* GTE */;
+  Conformance2.LTE = "<=" /* LTE */;
+  function serializeAtomic(ast, otherOperator) {
+    const serialized = serialize(ast);
+    if (ast.type === "group" /* Group */ || otherOperator !== void 0 && isHigherPrecedence(otherOperator, ast.type)) {
+      return `(${serialized})`;
+    }
+    return serialized;
+  }
+  function validateReferences(conformance, ast, resolver) {
+    switch (ast.type) {
+      case "|" /* OR */:
+      case "^" /* XOR */:
+      case "&" /* AND */:
+      case "==" /* EQ */:
+      case "!=" /* NE */:
+      case ">" /* GT */:
+      case "<" /* LT */:
+      case ">=" /* GTE */:
+      case "<=" /* LTE */:
+        validateReferences(conformance, ast.param.lhs, resolver);
+        validateReferences(conformance, ast.param.rhs, resolver);
+        break;
+      case "!" /* NOT */:
+        validateReferences(conformance, ast.param, resolver);
+        break;
+      case "group" /* Group */:
+        for (const a of ast.param) {
+          validateReferences(conformance, a, resolver);
+        }
+        break;
+      case "name" /* Name */:
+        if (!resolver(ast.param)) {
+          conformance.error(
+            `UNRESOLVED_CONFORMANCE_${ast.type.toUpperCase()}`,
+            `Conformance ${ast.type} reference "${ast.param}" does not resolve`
+          );
+        }
+        break;
+    }
+  }
+  Conformance2.validateReferences = validateReferences;
+  function serialize(ast) {
+    switch (ast.type) {
+      case "|" /* OR */:
+      case "^" /* XOR */:
+      case "&" /* AND */:
+      case "==" /* EQ */:
+      case "!=" /* NE */:
+      case ">" /* GT */:
+      case "<" /* LT */:
+      case ">=" /* GTE */:
+      case "<=" /* LTE */:
+        const lhs = serializeAtomic(ast.param.lhs, ast.type);
+        const rhs = serializeAtomic(ast.param.rhs, ast.type);
+        return `${lhs} ${ast.type} ${rhs}`;
+      case "!" /* NOT */:
+        return `!${serializeAtomic(ast.param)}`;
+      case "empty" /* Empty */:
+        return "";
+      case "desc" /* Desc */:
+        return "desc";
+      case "choice" /* Choice */:
+        let result = `${serializeAtomic(ast.param.expr)}.${ast.param.name}`;
+        if (ast.param.num > 1) {
+          result = `${result}${ast.param.num}`;
+        }
+        if (ast.param.orMore) {
+          result = `${result}+`;
+        }
+        return result;
+      case "group" /* Group */:
+        return ast.param.map((d) => serialize(d)).join(", ");
+      case "optionalIf" /* OptionalIf */:
+        return `[${serialize(ast.param)}]`;
+      case "name" /* Name */:
+      case "value" /* Value */:
+        return FieldValue.serialize(ast.param);
+      default:
+        return ast.type;
+    }
+  }
+  Conformance2.serialize = serialize;
+  function isBinaryOperator(type) {
+    return Parser.BinaryOperators.has(type);
+  }
+  Conformance2.isBinaryOperator = isBinaryOperator;
+  function precedenceOf(operator) {
+    const index = Parser.BinaryOperatorPrecedence.findIndex((ops) => ops.indexOf(operator) != -1);
+    return index === -1 ? void 0 : index;
+  }
+  Conformance2.precedenceOf = precedenceOf;
+  function isHigherPrecedence(operator, other) {
+    const precedence1 = precedenceOf(operator);
+    if (precedence1 === void 0) {
+      return false;
+    }
+    const precedence2 = precedenceOf(other);
+    if (precedence2 === void 0) {
+      return false;
+    }
+    return precedence1 < precedence2;
+  }
+  Conformance2.isHigherPrecedence = isHigherPrecedence;
+})(Conformance || (Conformance = {}));
+const flags = new Set(Object.values(Conformance.Flag));
+function ParsedAst(conformance, definition) {
+  definition = definition.replace(" or ", " | ");
+  const tokens = TokenStream(Lexer.Basic.lex(definition, (code, message) => conformance.error(code, message)));
+  return parseGroup();
+  function parseGroup(end) {
+    const group = [];
+    function groupAsAst() {
+      if (group.length === 1) {
+        return group[0];
+      }
+      return {
+        type: "group" /* Group */,
+        param: group
+      };
+    }
+    while (true) {
+      if (tokens.done) {
+        if (end) {
+          conformance.error("UNTERMINATED_CONFORMANCE_GROUPING", "Unterminated conformance grouping");
+        }
+        return groupAsAst();
+      }
+      const optional = !end && atOperator("[");
+      if (optional) {
+        tokens.next();
+        let expr = {
+          type: "optionalIf" /* OptionalIf */,
+          param: parseGroup("]")
+        };
+        expr = parseChoice(expr);
+        group.push(expr);
+      } else {
+        const expr = parseExpression();
+        if (expr) {
+          group.push(expr);
+        }
+      }
+      if (atOperator(",")) {
+        tokens.next();
+      } else if (end && atOperator(end)) {
+        tokens.next();
+        return groupAsAst();
+      }
+    }
+  }
+  function atOperator(operator) {
+    const { token } = tokens;
+    return token && token.type === operator;
+  }
+  function parseExpression() {
+    const elements = [];
+    let expr = parseAtomicExpression();
+    if (expr) {
+      elements.push(expr);
+    }
+    while (tokens.token && Parser.BinaryOperators.has(tokens.token.type)) {
+      elements.push(tokens.token.type);
+      tokens.next();
+      expr = parseAtomicExpression();
+      if (expr) {
+        elements.push(expr);
+      }
+    }
+    Parser.BinaryOperatorPrecedence.forEach((operators) => {
+      for (let i = 0; i < elements.length; i++) {
+        if (operators.indexOf(elements[i + 1]) !== -1) {
+          const [lhs, op, rhs] = elements.splice(i, 3);
+          elements.splice(i, 0, {
+            type: op,
+            param: { lhs, rhs }
+          });
+          i--;
+        }
+      }
+    });
+    return elements[0];
+  }
+  function extractChoiceNameAndNumber(text) {
+    let name = text[0];
+    let num;
+    if (name[0] < "a" || name[0] > "z") {
+      conformance.error("INVALID_CHOICE", "Choice indicator is not a lowercase letter");
+      name = "?";
+      num = 1;
+    } else if (text.length > 1) {
+      num = Number.parseInt(text[1]);
+      if (Number.isNaN(num) || num < 0 || num > 9) {
+        conformance.error("INVALID_CHOICE", "Choice indicator may only be a single lowercase letter");
+        name = "?";
+        num = 1;
+      } else if (name.length > 2) {
+        conformance.error("INVALID_CHOICE", "Choice number followed by unexpected word characters");
+        name = "?";
+      }
+    } else {
+      num = 1;
+    }
+    return { name, num };
+  }
+  function parseChoice(expr) {
+    if (!atOperator(".")) {
+      return expr;
+    }
+    tokens.next();
+    let name, num;
+    if (tokens.token?.type !== "word") {
+      conformance.error("INVALID_CHOICE", 'Choice indicator (".") not followed by identifier');
+      name = "?";
+      num = 1;
+    } else {
+      ({ name, num } = extractChoiceNameAndNumber(tokens.token.value));
+      tokens.next();
+    }
+    const choice = { name, expr, num };
+    if (atOperator("+")) {
+      choice.orMore = true;
+      tokens.next();
+    }
+    return {
+      type: "choice" /* Choice */,
+      param: choice
+    };
+  }
+  function parseAtomicExpression() {
+    const expr = parseAtomicExpressionWithoutChoice();
+    if (!expr) {
+      return;
+    }
+    return parseChoice(expr);
+  }
+  function parseAtomicExpressionWithoutChoice() {
+    if (!tokens.token) {
+      conformance.error("PREMATURE_CONFORMANCE_TERMINATION", "Terminated with expression expected");
+      return;
+    }
+    if (tokens.token.type === "word") {
+      const name = tokens.token.value;
+      tokens.next();
+      if (flags.has(name)) {
+        return { type: name };
+      }
+      if (name.toLowerCase() === "desc") {
+        return { type: "desc" /* Desc */ };
+      }
+      if (name === "null") {
+        return { type: "value" /* Value */, param: null };
+      }
+      return { type: "name" /* Name */, param: name };
+    }
+    if (tokens.token.type === "value") {
+      const value = tokens.token.value;
+      tokens.next();
+      return { type: "value" /* Value */, param: value };
+    }
+    if (atOperator("!")) {
+      tokens.next();
+      return { type: "!" /* NOT */, param: parseAtomicExpression() };
+    }
+    if (atOperator("(")) {
+      tokens.next();
+      return parseGroup(")");
+    }
+    conformance.error("UNEXPECTED_CONFORMANCE_TOKEN", `Unexpected "${tokens.token.type}"`);
+    tokens.next();
+  }
+}
+var Parser;
+((Parser2) => {
+  Parser2.BinaryOperatorPrecedence = [["&"], ["|", "^"], [">", "<", ">=", "<="], ["==", "!="]];
+  Parser2.BinaryOperators = new Set(Parser2.BinaryOperatorPrecedence.flat());
+})(Parser || (Parser = {}));
+function computeApplicability(features, supportedFeatures, ast) {
+  function processNode(ast2) {
+    switch (ast2.type) {
+      case "name" /* Name */:
+        if (features.has(ast2.param)) {
+          return supportedFeatures.has(ast2.param);
+        }
+        break;
+      case "!" /* NOT */:
+        const subvalue = processNode(ast2.param);
+        if (typeof subvalue === "boolean") {
+          return !subvalue;
+        }
+        break;
+      case "&" /* AND */:
+        if (!processNode(ast2.param.lhs) || !processNode(ast2.param.rhs)) {
+          return false;
+        }
+        break;
+      case "|" /* OR */:
+        if (!processNode(ast2.param.lhs) && !processNode(ast2.param.rhs)) {
+          return false;
+        }
+        break;
+      case "X" /* Disallowed */:
+        return false;
+      case "optionalIf" /* OptionalIf */:
+        return processNode(ast2.param);
+      case "group" /* Group */:
+        for (const child of ast2.param) {
+          if (processNode(child)) {
+            return true;
+          }
+        }
+        return false;
+    }
+    return true;
+  }
+  return processNode(ast);
+}
+function freezeAst(ast) {
+  switch (ast.type) {
+    case "|" /* OR */:
+    case "^" /* XOR */:
+    case "&" /* AND */:
+    case "==" /* EQ */:
+    case "!=" /* NE */:
+    case ">" /* GT */:
+    case "<" /* LT */:
+    case ">=" /* GTE */:
+    case "<=" /* LTE */:
+      freezeAst(ast.param.lhs);
+      freezeAst(ast.param.rhs);
+      Object.freeze(ast.param);
+      break;
+    case "!" /* NOT */:
+    case "optionalIf" /* OptionalIf */:
+      freezeAst(ast.param);
+      break;
+    case "value" /* Value */:
+      if (typeof ast.param === "object" && ast.param !== null) {
+        Object.freeze(ast.param);
+      }
+      break;
+    case "choice" /* Choice */:
+      freezeAst(ast.param.expr);
+      Object.freeze(ast.param);
+      break;
+    case "group" /* Group */:
+      for (const entry of ast.param) {
+        freezeAst(entry);
+      }
+      Object.freeze(ast.param);
+      break;
+  }
+  Object.freeze(ast);
+}
+export {
+  Conformance
+};
+//# sourceMappingURL=Conformance.js.map

package/dist/esm/aspects/Conformance.js.map

@@ -0,0 +1,6 @@
+{
+  "version": 3,
+  "sources": ["../../../src/aspects/Conformance.ts"],
+  "mappings": "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",
+  "names": ["Conformance", "Special", "Flag", "Operator", "Parser", "ast"]
+}