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

package/dist/cjs/behavior/state/validation/conformance-compiler.js

@@ -0,0 +1,385 @@
+"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_compiler_exports = {};
+__export(conformance_compiler_exports, {
+  astToFunction: () => astToFunction
+});
+module.exports = __toCommonJS(conformance_compiler_exports);
+var import_general = require("#general");
+var import_model = require("#model");
+var import_errors = require("../../errors.js");
+var import_conformance_util = require("./conformance-util.js");
+/**
+ * @license
+ * Copyright 2022-2024 Matter.js Authors
+ * SPDX-License-Identifier: Apache-2.0
+ */
+function astToFunction(schema, featureMap, supportedFeatures) {
+  const ast = schema.conformance.ast;
+  const { featuresAvailable, featuresSupported } = import_model.FeatureSet.normalize(featureMap, supportedFeatures);
+  const compiledNode = compile(ast);
+  let validator;
+  switch (compiledNode.code) {
+    case import_conformance_util.Code.Conformant:
+      validator = requireValue;
+      break;
+    case import_conformance_util.Code.Nonconformant:
+    case import_conformance_util.Code.Disallowed:
+      validator = disallowValue;
+      break;
+    case import_conformance_util.Code.Optional:
+      break;
+    case import_conformance_util.Code.Evaluate:
+      const { evaluate } = compiledNode;
+      validator = (value, session, location) => {
+        const staticNode = evaluate(value, location);
+        switch (staticNode.code) {
+          case import_conformance_util.Code.Conformant:
+            requireValue(value, session, location);
+            break;
+          case import_conformance_util.Code.Nonconformant:
+          case import_conformance_util.Code.Disallowed:
+            disallowValue(value, session, location);
+            break;
+          case import_conformance_util.Code.Optional:
+            break;
+          case import_conformance_util.Code.Value:
+            if (staticNode.value === void 0) {
+              disallowValue(value, session, location);
+            } else {
+              requireValue(value, session, location);
+            }
+            break;
+          default:
+            throw new import_conformance_util.UnsupportedConformanceNodeError(schema, compiledNode);
+        }
+      };
+      break;
+    default:
+      throw new import_conformance_util.UnsupportedConformanceNodeError(schema, compiledNode);
+  }
+  if (validator !== disallowValue && schema.effectiveMetatype === import_model.Metatype.enum) {
+    validator = addEnumMemberValidation(validator);
+  }
+  return validator;
+  function compile(ast2) {
+    switch (ast2?.type) {
+      case import_model.Conformance.Special.Empty:
+      case import_model.Conformance.Special.Desc:
+      case import_model.Conformance.Flag.Provisional:
+      case import_model.Conformance.Flag.Deprecated:
+      case import_model.Conformance.Flag.Optional:
+        return { code: import_conformance_util.Code.Optional };
+      case import_model.Conformance.Special.Choice:
+        return createChoice(ast2.param);
+      case import_model.Conformance.Special.Group:
+        return createGroup(ast2.param);
+      case import_model.Conformance.Special.Name:
+        return createName(ast2.param);
+      case import_model.Conformance.Special.OptionalIf:
+        return createOptionalIf(ast2.param);
+      case import_model.Conformance.Special.Value:
+        return createValue(ast2.param);
+      case import_model.Conformance.Flag.Disallowed:
+        return createDisallowed();
+      case import_model.Conformance.Flag.Mandatory:
+        return createMandatory();
+      case import_model.Conformance.Operator.AND:
+      case import_model.Conformance.Operator.OR:
+      case import_model.Conformance.Operator.XOR:
+        return createLogicalBinaryOp(ast2.type, ast2.param);
+      case import_model.Conformance.Operator.EQ:
+      case import_model.Conformance.Operator.NE:
+      case import_model.Conformance.Operator.GT:
+      case import_model.Conformance.Operator.LT:
+      case import_model.Conformance.Operator.GTE:
+      case import_model.Conformance.Operator.LTE:
+        return createComparisonOp(ast2.type, ast2.param);
+      case import_model.Conformance.Operator.NOT:
+        return createNotOp(ast2.param);
+      default:
+        ast2;
+        throw new import_errors.SchemaImplementationError(
+          (0, import_model.DataModelPath)(schema.path),
+          `Unsupported conformance AST node type ${ast2.type}`
+        );
+    }
+  }
+  function createChoice(param) {
+    const compiled = compile(param.expr);
+    const name = param.name;
+    const template = {
+      count: 0,
+      target: param.num,
+      orMore: !!param.orMore
+    };
+    return {
+      code: import_conformance_util.Code.Evaluate,
+      evaluate: (value, options) => {
+        const choices = options?.choices;
+        let choice;
+        if (choices) {
+          choice = choices[name];
+          if (!choice) {
+            choice = choices[name] = { ...template };
+          }
+          if (value !== void 0) {
+            choice.count++;
+          }
+        }
+        return (0, import_conformance_util.evaluateNode)(compiled, value, options);
+      }
+    };
+  }
+  function createGroup(param) {
+    if (!Array.isArray(param)) {
+      throw new import_errors.SchemaImplementationError(
+        (0, import_model.DataModelPath)(schema.path),
+        "Conformance AST group parameter is not an array"
+      );
+    }
+    const members = param.map((test) => compile(test));
+    const reduced = Array();
+    for (const member of members) {
+      if (member.code === import_conformance_util.Code.Nonconformant) {
+        continue;
+      }
+      if (member.code === import_conformance_util.Code.Optional || member.code === import_conformance_util.Code.Conformant) {
+        if (reduced.length) {
+          reduced.push(member);
+          break;
+        }
+        return member;
+      }
+      reduced.push(member);
+    }
+    return {
+      code: import_conformance_util.Code.Evaluate,
+      evaluate: (value, options) => {
+        for (const member of reduced) {
+          const node = (0, import_conformance_util.evaluateNode)(member, value, options);
+          if (node.code !== import_conformance_util.Code.Nonconformant) {
+            return node;
+          }
+        }
+        return import_conformance_util.NonconformantNode;
+      }
+    };
+  }
+  function createName(param) {
+    if (featuresAvailable.has(param)) {
+      if (featuresSupported.has(param)) {
+        return import_conformance_util.ConformantNode;
+      } else {
+        return import_conformance_util.NonconformantNode;
+      }
+    } else {
+      param = (0, import_general.camelize)(param);
+      return {
+        code: import_conformance_util.Code.Evaluate,
+        evaluate: (_value, options) => {
+          return {
+            code: import_conformance_util.Code.Value,
+            value: options?.siblings?.[param]
+          };
+        }
+      };
+    }
+  }
+  function createOptionalIf(param) {
+    let node = compile(param) ?? {};
+    node = (0, import_conformance_util.asConformance)(node);
+    switch (node.code) {
+      case import_conformance_util.Code.Conformant:
+        return { code: import_conformance_util.Code.Optional };
+      case import_conformance_util.Code.Evaluate:
+        const evaluate = node.evaluate;
+        return {
+          code: import_conformance_util.Code.Evaluate,
+          evaluate: (value, options) => {
+            let staticNode = evaluate(value, options);
+            staticNode = (0, import_conformance_util.asConformance)(staticNode);
+            if (staticNode.code === import_conformance_util.Code.Conformant) {
+              return { code: import_conformance_util.Code.Optional };
+            }
+            return staticNode;
+          }
+        };
+      default:
+        return node;
+    }
+  }
+  function createValue(param) {
+    return {
+      code: import_conformance_util.Code.Value,
+      value: param
+    };
+  }
+  function createDisallowed() {
+    return {
+      code: import_conformance_util.Code.Disallowed
+    };
+  }
+  function createMandatory() {
+    return import_conformance_util.ConformantNode;
+  }
+  function createLogicalBinaryOp(operator, { lhs, rhs }) {
+    const compiledLhs = (0, import_conformance_util.createBooleanTest)(compile(lhs));
+    const compiledRhs = (0, import_conformance_util.createBooleanTest)(compile(rhs));
+    switch (operator) {
+      case import_model.Conformance.Operator.AND:
+        if ((0, import_conformance_util.isStatic)(compiledLhs)) {
+          if ((0, import_conformance_util.asBoolean)(compiledLhs)) {
+            return compiledRhs;
+          } else {
+            return import_conformance_util.NonconformantNode;
+          }
+        }
+        if ((0, import_conformance_util.isStatic)(compiledRhs)) {
+          if ((0, import_conformance_util.asBoolean)(compiledRhs)) {
+            return compiledLhs;
+          } else {
+            return import_conformance_util.NonconformantNode;
+          }
+        }
+        return (0, import_conformance_util.createLogicalBinaryEvaluator)(compiledLhs, compiledRhs, (lhs2, rhs2) => lhs2 && rhs2);
+      case import_model.Conformance.Operator.OR:
+        if ((0, import_conformance_util.isStatic)(compiledLhs)) {
+          if ((0, import_conformance_util.asBoolean)(compiledLhs)) {
+            return import_conformance_util.ConformantNode;
+          } else {
+            return compiledRhs;
+          }
+        }
+        if ((0, import_conformance_util.isStatic)(compiledRhs)) {
+          if ((0, import_conformance_util.asBoolean)(compiledRhs)) {
+            return import_conformance_util.ConformantNode;
+          } else {
+            return compiledLhs;
+          }
+        }
+        return (0, import_conformance_util.createLogicalBinaryEvaluator)(compiledLhs, compiledRhs, (lhs2, rhs2) => lhs2 || rhs2);
+      case import_model.Conformance.Operator.XOR:
+        if ((0, import_conformance_util.isStatic)(compiledLhs)) {
+          if ((0, import_conformance_util.asBoolean)(compiledLhs)) {
+            return (0, import_conformance_util.createLogicalInversion)(compiledRhs);
+          } else {
+            return compiledRhs;
+          }
+        }
+        if ((0, import_conformance_util.isStatic)(compiledRhs)) {
+          if ((0, import_conformance_util.asBoolean)(compiledRhs)) {
+            return (0, import_conformance_util.createLogicalInversion)(compiledLhs);
+          } else {
+            return compiledLhs;
+          }
+        }
+        return (0, import_conformance_util.createLogicalBinaryEvaluator)(compiledLhs, compiledRhs, (lhs2, rhs2) => lhs2 ? !rhs2 : rhs2);
+      default:
+        throw new import_errors.SchemaImplementationError(
+          (0, import_model.DataModelPath)(schema.path),
+          `Unknown logical binary operator ${operator}`
+        );
+    }
+  }
+  function createComparisonOp(operator, { lhs, rhs }) {
+    return (0, import_conformance_util.createComparison)(operator, compile(lhs), compile(rhs), schema);
+  }
+  function createNotOp(param) {
+    const operand = compile(param);
+    return (0, import_conformance_util.createLogicalInversion)(operand);
+  }
+  function requireValue(value, _session, location) {
+    if (value === void 0) {
+      throw new import_errors.ConformanceError(schema, location, "Matter requires you to set this attribute");
+    }
+  }
+  function disallowValue(value, _session, location) {
+    if (value !== void 0) {
+      throw new import_errors.ConformanceError(schema, location, "Matter does not allow you to set this attribute");
+    }
+  }
+  function disallowEnumValue(schema2) {
+    return (location) => {
+      throw new import_errors.ConformanceError(
+        schema2,
+        location,
+        `Matter does not allow enum value ${schema2.name} (ID ${schema2.effectiveId}) here`
+      );
+    };
+  }
+  function addEnumMemberValidation(mainValidator) {
+    const members = schema.activeMembers;
+    if (!members.length) {
+      return mainValidator;
+    }
+    let memberValidators;
+    for (const member of members) {
+      const id = member.effectiveId;
+      if (id === void 0) {
+        continue;
+      }
+      const compiledNode2 = compile(member.conformance.ast);
+      let memberValidator;
+      switch (compiledNode2.code) {
+        case import_conformance_util.Code.Conformant:
+        case import_conformance_util.Code.Optional:
+          continue;
+        case import_conformance_util.Code.Nonconformant:
+        case import_conformance_util.Code.Disallowed:
+          memberValidator = disallowEnumValue(member);
+          break;
+        case import_conformance_util.Code.Evaluate:
+          const { evaluate } = compiledNode2;
+          const disallow = disallowEnumValue(member);
+          memberValidator = (location) => {
+            const staticNode = evaluate(true, location);
+            switch (staticNode.code) {
+              case import_conformance_util.Code.Conformant:
+              case import_conformance_util.Code.Optional:
+                break;
+              case import_conformance_util.Code.Nonconformant:
+              case import_conformance_util.Code.Disallowed:
+                disallow(location);
+                break;
+              default:
+                throw new import_conformance_util.UnsupportedConformanceNodeError(member, compiledNode2);
+            }
+          };
+          break;
+        default:
+          throw new import_conformance_util.UnsupportedConformanceNodeError(member, compiledNode2);
+      }
+      if (!memberValidators) {
+        memberValidators = {};
+      }
+      memberValidators[id] = memberValidator;
+    }
+    if (memberValidators === void 0) {
+      return mainValidator;
+    }
+    return (value, session, location) => {
+      mainValidator?.(value, session, location);
+      if (typeof value === "number") {
+        memberValidators[value]?.(location);
+      }
+    };
+  }
+}
+//# sourceMappingURL=conformance-compiler.js.map

package/dist/cjs/behavior/state/validation/conformance-compiler.js.map

@@ -0,0 +1,6 @@
+{
+  "version": 3,
+  "sources": ["../../../../../src/behavior/state/validation/conformance-compiler.ts"],
+  "mappings": "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",
+  "names": ["ast", "lhs", "rhs", "schema", "compiledNode"]
+}

package/dist/cjs/behavior/state/validation/conformance-util.d.ts

@@ -0,0 +1,80 @@
+/**
+ * @license
+ * Copyright 2022-2024 Matter.js Authors
+ * SPDX-License-Identifier: Apache-2.0
+ */
+import { Conformance, SchemaErrorPath, SchemaImplementationError } from "#model";
+import { Schema } from "../../supervision/Schema.js";
+import { Val } from "../Val.js";
+import { ValidationLocation } from "./location.js";
+export declare class UnsupportedConformanceNodeError extends SchemaImplementationError {
+    constructor(schema: Schema, compiledNode: DynamicNode);
+}
+export declare enum Code {
+    Nonconformant = "nonconformant",
+    Conformant = "conformant",
+    Optional = "optional",
+    Disallowed = "disallowed",
+    Value = "value",
+    Evaluate = "evaluate"
+}
+export interface ValueNode {
+    code: Code.Value;
+    value: Val;
+}
+export type StaticNode = {
+    code: Code.Nonconformant | Code.Optional | Code.Conformant | Code.Disallowed;
+} | ValueNode;
+export interface RuntimeNode {
+    code: Code.Evaluate;
+    evaluate: (value: Val, location: ValidationLocation) => StaticNode;
+}
+export type DynamicNode = StaticNode | RuntimeNode;
+/**
+ * Convert a static node to a dynamic node at runtime.
+ */
+export declare function evaluateNode(node: DynamicNode, value: Val, location: ValidationLocation): StaticNode;
+/**
+ * Cast value nodes to a conformance.
+ *
+ * A value node is conformant if the value is defined
+ *
+ * Non-value nodes are returned unchanged.
+ */
+export declare function asConformance<T extends DynamicNode>(node: T): T | {
+    readonly code: Code.Nonconformant | Code.Conformant;
+};
+export declare function isStatic(node: DynamicNode): node is StaticNode;
+export declare function asBoolean(node: StaticNode): boolean;
+/**
+ * Throw an error if a node is not a value.
+ *
+ * We use this to ensure inputs to binary operators make sense.
+ */
+export declare function assertValue(location: SchemaErrorPath, node: DynamicNode, where: string): asserts node is ValueNode;
+export declare const ConformantNode: {
+    readonly code: Code.Conformant;
+};
+export declare const NonconformantNode: {
+    readonly code: Code.Nonconformant;
+};
+/**
+ * Create a node that logically inverts the value of the input node.
+ */
+export declare function createLogicalInversion(node: DynamicNode): DynamicNode;
+type BinaryOperator<T> = (lhs: T, rhs: T) => boolean;
+/**
+ * Create a node that evaluates a logical binary operator at runtime.
+ */
+export declare function createLogicalBinaryEvaluator(lhs: RuntimeNode, rhs: RuntimeNode, operator: BinaryOperator<boolean>): RuntimeNode;
+/**
+ * Create a node that evaluates a comparison operator.
+ */
+export declare function createComparison(operatorName: Conformance.Operator, lhs: DynamicNode, rhs: DynamicNode, schema: Schema): DynamicNode;
+/**
+ * Create a node that performs a runtime boolean test.
+ */
+export declare function createBooleanTest(node: DynamicNode): DynamicNode;
+export type EnumMemberValidator = (location: ValidationLocation) => void;
+export {};
+//# sourceMappingURL=conformance-util.d.ts.map

package/dist/cjs/behavior/state/validation/conformance-util.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"conformance-util.d.ts","sourceRoot":"","sources":["../../../../../src/behavior/state/validation/conformance-util.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AAEH,OAAO,EAAE,WAAW,EAAiB,eAAe,EAAE,yBAAyB,EAAE,MAAM,QAAQ,CAAC;AAChG,OAAO,EAAE,MAAM,EAAE,MAAM,6BAA6B,CAAC;AACrD,OAAO,EAAE,GAAG,EAAE,MAAM,WAAW,CAAC;AAChC,OAAO,EAAE,kBAAkB,EAAE,MAAM,eAAe,CAAC;AAEnD,qBAAa,+BAAgC,SAAQ,yBAAyB;gBAC9D,MAAM,EAAE,MAAM,EAAE,YAAY,EAAE,WAAW;CAMxD;AAED,oBAAY,IAAI;IAEZ,aAAa,kBAAkB;IAG/B,UAAU,eAAe;IAGzB,QAAQ,aAAa;IAGrB,UAAU,eAAe;IAGzB,KAAK,UAAU;IAGf,QAAQ,aAAa;CACxB;AAED,MAAM,WAAW,SAAS;IACtB,IAAI,EAAE,IAAI,CAAC,KAAK,CAAC;IACjB,KAAK,EAAE,GAAG,CAAC;CACd;AAED,MAAM,MAAM,UAAU,GAChB;IACI,IAAI,EAAE,IAAI,CAAC,aAAa,GAAG,IAAI,CAAC,QAAQ,GAAG,IAAI,CAAC,UAAU,GAAG,IAAI,CAAC,UAAU,CAAC;CAChF,GACD,SAAS,CAAC;AAEhB,MAAM,WAAW,WAAW;IACxB,IAAI,EAAE,IAAI,CAAC,QAAQ,CAAC;IACpB,QAAQ,EAAE,CAAC,KAAK,EAAE,GAAG,EAAE,QAAQ,EAAE,kBAAkB,KAAK,UAAU,CAAC;CACtE;AAED,MAAM,MAAM,WAAW,GAAG,UAAU,GAAG,WAAW,CAAC;AAEnD;;GAEG;AACH,wBAAgB,YAAY,CAAC,IAAI,EAAE,WAAW,EAAE,KAAK,EAAE,GAAG,EAAE,QAAQ,EAAE,kBAAkB,GAAG,UAAU,CAKpG;AAED;;;;;;GAMG;AACH,wBAAgB,aAAa,CAAC,CAAC,SAAS,WAAW,EAAE,IAAI,EAAE,CAAC;;EAW3D;AAED,wBAAgB,QAAQ,CAAC,IAAI,EAAE,WAAW,GAAG,IAAI,IAAI,UAAU,CAE9D;AAED,wBAAgB,SAAS,CAAC,IAAI,EAAE,UAAU,WAUzC;AAED;;;;GAIG;AACH,wBAAgB,WAAW,CAAC,QAAQ,EAAE,eAAe,EAAE,IAAI,EAAE,WAAW,EAAE,KAAK,EAAE,MAAM,GAAG,OAAO,CAAC,IAAI,IAAI,SAAS,CAOlH;AAED,eAAO,MAAM,cAAc;;CAAqC,CAAC;AACjE,eAAO,MAAM,iBAAiB;;CAAwC,CAAC;AAEvE;;GAEG;AACH,wBAAgB,sBAAsB,CAAC,IAAI,EAAE,WAAW,GAAG,WAAW,CA0BrE;AAED,KAAK,cAAc,CAAC,CAAC,IAAI,CAAC,GAAG,EAAE,CAAC,EAAE,GAAG,EAAE,CAAC,KAAK,OAAO,CAAC;AAErD;;GAEG;AACH,wBAAgB,4BAA4B,CACxC,GAAG,EAAE,WAAW,EAChB,GAAG,EAAE,WAAW,EAChB,QAAQ,EAAE,cAAc,CAAC,OAAO,CAAC,GAClC,WAAW,CAUb;AAsCD;;GAEG;AACH,wBAAgB,gBAAgB,CAC5B,YAAY,EAAE,WAAW,CAAC,QAAQ,EAClC,GAAG,EAAE,WAAW,EAChB,GAAG,EAAE,WAAW,EAChB,MAAM,EAAE,MAAM,GACf,WAAW,CAmBb;AAED;;GAEG;AACH,wBAAgB,iBAAiB,CAAC,IAAI,EAAE,WAAW,GAAG,WAAW,CAgBhE;AAED,MAAM,MAAM,mBAAmB,GAAG,CAAC,QAAQ,EAAE,kBAAkB,KAAK,IAAI,CAAC"}

package/dist/cjs/behavior/state/validation/conformance-util.js

@@ -0,0 +1,177 @@
+"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_util_exports = {};
+__export(conformance_util_exports, {
+  Code: () => Code,
+  ConformantNode: () => ConformantNode,
+  NonconformantNode: () => NonconformantNode,
+  UnsupportedConformanceNodeError: () => UnsupportedConformanceNodeError,
+  asBoolean: () => asBoolean,
+  asConformance: () => asConformance,
+  assertValue: () => assertValue,
+  createBooleanTest: () => createBooleanTest,
+  createComparison: () => createComparison,
+  createLogicalBinaryEvaluator: () => createLogicalBinaryEvaluator,
+  createLogicalInversion: () => createLogicalInversion,
+  evaluateNode: () => evaluateNode,
+  isStatic: () => isStatic
+});
+module.exports = __toCommonJS(conformance_util_exports);
+var import_model = require("#model");
+/**
+ * @license
+ * Copyright 2022-2024 Matter.js Authors
+ * SPDX-License-Identifier: Apache-2.0
+ */
+class UnsupportedConformanceNodeError extends import_model.SchemaImplementationError {
+  constructor(schema, compiledNode) {
+    super(
+      (0, import_model.DataModelPath)(schema.path),
+      `Unknown or unsupported top-level conformance node type ${compiledNode.code}`
+    );
+  }
+}
+var Code = /* @__PURE__ */ ((Code2) => {
+  Code2["Nonconformant"] = "nonconformant";
+  Code2["Conformant"] = "conformant";
+  Code2["Optional"] = "optional";
+  Code2["Disallowed"] = "disallowed";
+  Code2["Value"] = "value";
+  Code2["Evaluate"] = "evaluate";
+  return Code2;
+})(Code || {});
+function evaluateNode(node, value, location) {
+  if (node.code === "evaluate" /* Evaluate */) {
+    return node.evaluate(value, location);
+  }
+  return node;
+}
+function asConformance(node) {
+  if (node.code === "value" /* Value */) {
+    return {
+      code: node.value === void 0 || node.value === null || node.value === false ? "nonconformant" /* Nonconformant */ : "conformant" /* Conformant */
+    };
+  } else {
+    return node;
+  }
+}
+function isStatic(node) {
+  return node.code !== "evaluate" /* Evaluate */;
+}
+function asBoolean(node) {
+  node = asConformance(node);
+  switch (node.code) {
+    case "conformant" /* Conformant */:
+    case "optional" /* Optional */:
+      return true;
+    default:
+      return false;
+  }
+}
+function assertValue(location, node, where) {
+  if (node.code !== "value" /* Value */) {
+    throw new import_model.SchemaImplementationError(
+      location,
+      `Expected a value for ${where} but conformance node is "${node.code}"`
+    );
+  }
+}
+const ConformantNode = { code: "conformant" /* Conformant */ };
+const NonconformantNode = { code: "nonconformant" /* Nonconformant */ };
+function createLogicalInversion(node) {
+  const operand = asConformance(node);
+  switch (operand.code) {
+    case "nonconformant" /* Nonconformant */:
+      return ConformantNode;
+    case "evaluate" /* Evaluate */:
+      const evaluate = operand.evaluate;
+      return {
+        code: "evaluate" /* Evaluate */,
+        evaluate: (value, options) => {
+          let staticOperand = evaluate(value, options);
+          staticOperand = asConformance(staticOperand);
+          if (staticOperand.code === "nonconformant" /* Nonconformant */) {
+            return ConformantNode;
+          }
+          return NonconformantNode;
+        }
+      };
+    default:
+      return NonconformantNode;
+  }
+}
+function createLogicalBinaryEvaluator(lhs, rhs, operator) {
+  return {
+    code: "evaluate" /* Evaluate */,
+    evaluate: (value, options) => {
+      const staticLhs = evaluateNode(lhs, value, options);
+      const staticRhs = evaluateNode(rhs, value, options);
+      return operator(asBoolean(staticLhs), asBoolean(staticRhs)) ? ConformantNode : NonconformantNode;
+    }
+  };
+}
+const ComparisonOperators = {
+  [import_model.Conformance.Operator.EQ]: (a, b) => a === b,
+  [import_model.Conformance.Operator.GT]: (a, b) => a > b,
+  [import_model.Conformance.Operator.GTE]: (a, b) => a >= b,
+  [import_model.Conformance.Operator.LT]: (a, b) => a < b,
+  [import_model.Conformance.Operator.LTE]: (a, b) => a <= b
+};
+function performComparison(operatorName, lhs, rhs, schema, location) {
+  const operator = ComparisonOperators[operatorName];
+  if (operator === void 0) {
+    throw new import_model.SchemaImplementationError((0, import_model.DataModelPath)(schema.path), `Unknown binary operator ${operatorName}`);
+  }
+  assertValue(location, lhs, `Left-hand side of "${operatorName}"`);
+  assertValue(location, rhs, `Right-hand side of "${operatorName}"`);
+  if (lhs.value !== void 0 && lhs.value !== null && rhs.value !== void 0 && rhs.value !== null && operator(lhs.value, rhs.value)) {
+    return ConformantNode;
+  }
+  return NonconformantNode;
+}
+function createComparison(operatorName, lhs, rhs, schema) {
+  if (isStatic(lhs) && isStatic(rhs)) {
+    return performComparison(operatorName, lhs, rhs, schema, (0, import_model.DataModelPath)(schema.path));
+  }
+  return {
+    code: "evaluate" /* Evaluate */,
+    evaluate: (value, location) => performComparison(
+      operatorName,
+      evaluateNode(lhs, value, location),
+      evaluateNode(rhs, value, location),
+      schema,
+      location
+    )
+  };
+}
+function createBooleanTest(node) {
+  if (isStatic(node)) {
+    return node;
+  }
+  const { evaluate } = node;
+  return {
+    code: "evaluate" /* Evaluate */,
+    evaluate: (value, location) => {
+      const result = evaluate(value, location);
+      assertValue(location, result, "boolean test");
+      return asConformance(result);
+    }
+  };
+}
+//# sourceMappingURL=conformance-util.js.map

package/dist/cjs/behavior/state/validation/conformance-util.js.map

@@ -0,0 +1,6 @@
+{
+  "version": 3,
+  "sources": ["../../../../../src/behavior/state/validation/conformance-util.ts"],
+  "mappings": "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",
+  "names": ["Code"]
+}