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

package/dist/cjs/aspects/Conformance.js

@@ -0,0 +1,514 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var Conformance_exports = {};
+__export(Conformance_exports, {
+  Conformance: () => Conformance
+});
+module.exports = __toCommonJS(Conformance_exports);
+var import_common = require("../common/index.js");
+var import_parser = require("../parser/index.js");
+var import_Aspect = require("./Aspect.js");
+/**
+ * @license
+ * Copyright 2022-2024 Matter.js Authors
+ * SPDX-License-Identifier: Apache-2.0
+ */
+class Conformance extends import_Aspect.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 import_common.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 = (0, import_parser.TokenStream)(import_parser.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);
+}
+//# sourceMappingURL=Conformance.js.map

package/dist/cjs/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"]
+}

package/dist/cjs/aspects/Constraint.d.ts

@@ -0,0 +1,82 @@
+/**
+ * @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 constraints as defined by the Matter specification.
+ *
+ * A "constraint" limits possible data values.
+ *
+ * Formally a constraint is not considered a quality by the specification. It is handled similarly to qualities, though,
+ * so we keep it in the same section.
+ */
+export declare class Constraint extends Aspect<Constraint.Definition> implements Constraint.Ast {
+    desc?: boolean;
+    value?: FieldValue;
+    min?: FieldValue;
+    max?: FieldValue;
+    in?: FieldValue;
+    entry?: Constraint;
+    parts?: Constraint[];
+    /**
+     * Initialize from a Constraint.Definition or the constraint DSL defined by the Matter Specification.
+     */
+    constructor(definition: Constraint.Definition);
+    /**
+     * Test a value against a constraint.  Does not recurse into arrays.
+     */
+    test(value: FieldValue, properties?: Record<string, any>): boolean;
+    toString(): string;
+    freeze(): void;
+}
+export declare namespace Constraint {
+    type NumberOrIdentifier = number | string;
+    /**
+     * Parsed list structure.
+     */
+    type Ast = {
+        /**
+         * Indicates constraint is defined in prose and cannot be enforced automatically.
+         */
+        desc?: boolean;
+        /**
+         * Constant value.
+         */
+        value?: FieldValue;
+        /**
+         * Lower bound on value or sequence length.
+         */
+        min?: FieldValue;
+        /**
+         * Upper bound on value or sequence length.
+         */
+        max?: FieldValue;
+        /**
+         * Require set membership for the value.
+         */
+        in?: FieldValue;
+        /**
+         * Constraint on list child element.
+         */
+        entry?: Ast;
+        /**
+         * List of sub-constraints in a sequence.
+         */
+        parts?: Ast[];
+    };
+    /**
+     * These are all ways to describe a constraint.
+     */
+    type Definition = (Ast & {
+        definition?: Definition;
+    }) | string | number | undefined;
+    /**
+     * Parse constraint DSL.  Extremely lenient.
+     */
+    function parse(constraint: Constraint, definition: string): Ast;
+    function serialize(ast: Ast): string;
+}
+//# sourceMappingURL=Constraint.d.ts.map

package/dist/cjs/aspects/Constraint.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"Constraint.d.ts","sourceRoot":"","sources":["../../../src/aspects/Constraint.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AAGH,OAAO,EAAE,UAAU,EAAE,MAAM,oBAAoB,CAAC;AAChD,OAAO,EAAE,MAAM,EAAE,MAAM,aAAa,CAAC;AAErC;;;;;;;GAOG;AACH,qBAAa,UAAW,SAAQ,MAAM,CAAC,UAAU,CAAC,UAAU,CAAE,YAAW,UAAU,CAAC,GAAG;IAC3E,IAAI,CAAC,EAAE,OAAO,CAAC;IACf,KAAK,CAAC,EAAE,UAAU,CAAC;IACnB,GAAG,CAAC,EAAE,UAAU,CAAC;IACjB,GAAG,CAAC,EAAE,UAAU,CAAC;IACjB,EAAE,CAAC,EAAE,UAAU,CAAC;IAChB,KAAK,CAAC,EAAE,UAAU,CAAC;IACnB,KAAK,CAAC,EAAE,UAAU,EAAE,CAAC;IAE7B;;OAEG;gBACS,UAAU,EAAE,UAAU,CAAC,UAAU;IAsD7C;;OAEG;IACH,IAAI,CAAC,KAAK,EAAE,UAAU,EAAE,UAAU,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,GAAG,CAAC,GAAG,OAAO;IA0DzD,QAAQ;IAOR,MAAM;CAMlB;AAED,yBAAiB,UAAU,CAAC;IACxB,KAAY,kBAAkB,GAAG,MAAM,GAAG,MAAM,CAAC;IAEjD;;OAEG;IACH,KAAY,GAAG,GAAG;QACd;;WAEG;QACH,IAAI,CAAC,EAAE,OAAO,CAAC;QAEf;;WAEG;QACH,KAAK,CAAC,EAAE,UAAU,CAAC;QAEnB;;WAEG;QACH,GAAG,CAAC,EAAE,UAAU,CAAC;QAEjB;;WAEG;QACH,GAAG,CAAC,EAAE,UAAU,CAAC;QAEjB;;WAEG;QACH,EAAE,CAAC,EAAE,UAAU,CAAC;QAEhB;;WAEG;QACH,KAAK,CAAC,EAAE,GAAG,CAAC;QAEZ;;WAEG;QACH,KAAK,CAAC,EAAE,GAAG,EAAE,CAAC;KACjB,CAAC;IAEF;;OAEG;IACH,KAAY,UAAU,GAAG,CAAC,GAAG,GAAG;QAAE,UAAU,CAAC,EAAE,UAAU,CAAA;KAAE,CAAC,GAAG,MAAM,GAAG,MAAM,GAAG,SAAS,CAAC;IA8G3F;;OAEG;IACH,SAAgB,KAAK,CAAC,UAAU,EAAE,UAAU,EAAE,UAAU,EAAE,MAAM,GAAG,GAAG,CAwGrE;IA6BD,SAAgB,SAAS,CAAC,GAAG,EAAE,GAAG,GAAG,MAAM,CAQ1C;CACJ"}