@formality-ui/core 0.0.0 → 0.1.0

package/README.md

@@ -34,23 +34,23 @@ This package has no React, Vue, or Svelte dependencies. It exports pure function
 Evaluate dynamic expressions against form state:
 
 ```typescript
-import { evaluate, buildEvaluationContext } from '@formality-ui/core';
+import { evaluate, buildEvaluationContext } from "@formality-ui/core";
 
 const context = buildEvaluationContext({
   fields: {
-    client: { value: { id: 5, name: 'Acme' } },
+    client: { value: { id: 5, name: "Acme" } },
     signed: { value: true },
   },
-  record: { originalName: 'Old Name' },
+  record: { originalName: "Old Name" },
 });
 
 // Simple field access
-evaluate('client', context);        // { id: 5, name: 'Acme' }
-evaluate('client.id', context);     // 5
+evaluate("client", context); // { id: 5, name: 'Acme' }
+evaluate("client.id", context); // 5
 
 // Expressions
-evaluate('client && signed', context);  // true
-evaluate('client.id > 3', context);     // true
+evaluate("client && signed", context); // true
+evaluate("client.id > 3", context); // true
 ```
 
 ### Condition Evaluation
@@ -58,18 +58,18 @@ evaluate('client.id > 3', context);     // true
 Evaluate conditions for field visibility and disabled state:
 
 ```typescript
-import { evaluateConditions } from '@formality-ui/core';
+import { evaluateConditions } from "@formality-ui/core";
 
 const result = evaluateConditions({
   conditions: [
-    { when: 'signed', is: false, disabled: true },
-    { when: 'archived', truthy: true, visible: false },
+    { when: "signed", is: false, disabled: true },
+    { when: "archived", truthy: true, visible: false },
   ],
   fieldValues: { signed: false, archived: false },
 });
 
-result.disabled;  // true
-result.visible;   // true
+result.disabled; // true
+result.visible; // true
 ```
 
 ### Validation
@@ -77,10 +77,15 @@ result.visible;   // true
 Compose and run validators:
 
 ```typescript
-import { runValidator, composeValidators, required, minLength } from '@formality-ui/core';
+import {
+  runValidator,
+  composeValidators,
+  required,
+  minLength,
+} from "@formality-ui/core";
 
 const validator = composeValidators([required(), minLength(3)]);
-const result = await runValidator(validator, 'ab', {});
+const result = await runValidator(validator, "ab", {});
 // { type: 'minLength', message: 'Minimum 3 characters required' }
 ```
 
@@ -89,13 +94,18 @@ const result = await runValidator(validator, 'ab', {});
 Parse and format values:
 
 ```typescript
-import { parse, format, createFloatParser, createFloatFormatter } from '@formality-ui/core';
+import {
+  parse,
+  format,
+  createFloatParser,
+  createFloatFormatter,
+} from "@formality-ui/core";
 
 const parser = createFloatParser();
 const formatter = createFloatFormatter(2);
 
-parse('42.567', parser);        // 42.567 (number)
-format(42.567, formatter);      // '42.57' (string, 2 decimals)
+parse("42.567", parser); // 42.567 (number)
+format(42.567, formatter); // '42.57' (string, 2 decimals)
 ```
 
 ### Label Resolution
@@ -103,100 +113,100 @@ format(42.567, formatter);      // '42.57' (string, 2 decimals)
 Auto-generate human-readable labels from field names:
 
 ```typescript
-import { humanizeLabel, resolveLabel } from '@formality-ui/core';
+import { humanizeLabel, resolveLabel } from "@formality-ui/core";
 
-humanizeLabel('clientContact');      // 'Client Contact'
-humanizeLabel('minGrossMargin');     // 'Min Gross Margin'
-humanizeLabel('userId');             // 'User Id'
+humanizeLabel("clientContact"); // 'Client Contact'
+humanizeLabel("minGrossMargin"); // 'Min Gross Margin'
+humanizeLabel("userId"); // 'User Id'
 ```
 
 ## API Reference
 
 ### Expression Engine
 
-| Function | Description |
-|----------|-------------|
-| `evaluate(expr, context)` | Evaluate an expression string against context |
-| `evaluateDescriptor(descriptor, context)` | Evaluate a SelectValue descriptor |
-| `buildEvaluationContext(fields, record, props)` | Build evaluation context |
-| `buildFormContext(fields, record)` | Build form-level context |
-| `buildFieldContext(name, fields, record, props)` | Build field-level context |
-| `inferFieldsFromExpression(expr)` | Extract field dependencies from expression |
-| `inferFieldsFromDescriptor(descriptor)` | Extract field dependencies from descriptor |
-| `clearExpressionCache()` | Clear the expression parser cache |
+| Function                                         | Description                                   |
+| ------------------------------------------------ | --------------------------------------------- |
+| `evaluate(expr, context)`                        | Evaluate an expression string against context |
+| `evaluateDescriptor(descriptor, context)`        | Evaluate a SelectValue descriptor             |
+| `buildEvaluationContext(fields, record, props)`  | Build evaluation context                      |
+| `buildFormContext(fields, record)`               | Build form-level context                      |
+| `buildFieldContext(name, fields, record, props)` | Build field-level context                     |
+| `inferFieldsFromExpression(expr)`                | Extract field dependencies from expression    |
+| `inferFieldsFromDescriptor(descriptor)`          | Extract field dependencies from descriptor    |
+| `clearExpressionCache()`                         | Clear the expression parser cache             |
 
 ### Condition Evaluation
 
-| Function | Description |
-|----------|-------------|
-| `evaluateConditions(input)` | Evaluate conditions and return disabled/visible/setValue |
-| `conditionMatches(condition, context)` | Check if a single condition matches |
-| `mergeConditionResults(results)` | Merge multiple condition results |
-| `inferFieldsFromConditions(conditions)` | Extract field dependencies from conditions |
+| Function                                | Description                                              |
+| --------------------------------------- | -------------------------------------------------------- |
+| `evaluateConditions(input)`             | Evaluate conditions and return disabled/visible/setValue |
+| `conditionMatches(condition, context)`  | Check if a single condition matches                      |
+| `mergeConditionResults(results)`        | Merge multiple condition results                         |
+| `inferFieldsFromConditions(conditions)` | Extract field dependencies from conditions               |
 
 ### Validation
 
-| Function | Description |
-|----------|-------------|
-| `runValidator(spec, value, formValues, validators)` | Run validator(s) asynchronously |
-| `runValidatorSync(spec, value, formValues, validators)` | Run validator(s) synchronously |
-| `isValid(result)` | Check if validation result is valid |
-| `composeValidators(validators)` | Compose multiple validators |
-| `required()` | Built-in required validator |
-| `minLength(min)` | Built-in minimum length validator |
-| `maxLength(max)` | Built-in maximum length validator |
-| `pattern(regex)` | Built-in pattern validator |
-| `resolveErrorMessage(result, messages)` | Resolve error message from result |
-| `formatTypeAsMessage(type)` | Format validation type as message |
-| `createErrorMessages(config)` | Create error messages configuration |
-| `getErrorType(result)` | Get the error type from result |
-| `createValidationError(type, message)` | Create a validation error object |
+| Function                                                | Description                         |
+| ------------------------------------------------------- | ----------------------------------- |
+| `runValidator(spec, value, formValues, validators)`     | Run validator(s) asynchronously     |
+| `runValidatorSync(spec, value, formValues, validators)` | Run validator(s) synchronously      |
+| `isValid(result)`                                       | Check if validation result is valid |
+| `composeValidators(validators)`                         | Compose multiple validators         |
+| `required()`                                            | Built-in required validator         |
+| `minLength(min)`                                        | Built-in minimum length validator   |
+| `maxLength(max)`                                        | Built-in maximum length validator   |
+| `pattern(regex)`                                        | Built-in pattern validator          |
+| `resolveErrorMessage(result, messages)`                 | Resolve error message from result   |
+| `formatTypeAsMessage(type)`                             | Format validation type as message   |
+| `createErrorMessages(config)`                           | Create error messages configuration |
+| `getErrorType(result)`                                  | Get the error type from result      |
+| `createValidationError(type, message)`                  | Create a validation error object    |
 
 ### Value Transformation
 
-| Function | Description |
-|----------|-------------|
-| `parse(value, parser, parsers)` | Parse input value |
-| `format(value, formatter, formatters)` | Format value for display |
-| `extractValueField(value, field)` | Extract a field from a value object |
-| `transformFieldName(name, config)` | Transform field name based on config |
-| `createFloatParser()` | Create float parser |
-| `createFloatFormatter(decimals)` | Create float formatter with precision |
-| `createIntParser()` | Create integer parser |
-| `createTrimParser()` | Create string trimming parser |
-| `createDefaultParsers()` | Create default parsers configuration |
-| `createDefaultFormatters()` | Create default formatters configuration |
+| Function                               | Description                             |
+| -------------------------------------- | --------------------------------------- |
+| `parse(value, parser, parsers)`        | Parse input value                       |
+| `format(value, formatter, formatters)` | Format value for display                |
+| `extractValueField(value, field)`      | Extract a field from a value object     |
+| `transformFieldName(name, config)`     | Transform field name based on config    |
+| `createFloatParser()`                  | Create float parser                     |
+| `createFloatFormatter(decimals)`       | Create float formatter with precision   |
+| `createIntParser()`                    | Create integer parser                   |
+| `createTrimParser()`                   | Create string trimming parser           |
+| `createDefaultParsers()`               | Create default parsers configuration    |
+| `createDefaultFormatters()`            | Create default formatters configuration |
 
 ### Configuration
 
-| Function | Description |
-|----------|-------------|
-| `deepMerge(target, source)` | Deep merge objects |
-| `mergeInputConfigs(base, override)` | Merge input configurations |
-| `resolveInputConfig(type, inputs, formInputs)` | Resolve input configuration |
-| `resolveFieldType(name, config, inputs)` | Resolve field type from config |
-| `mergeStaticProps(layers)` | Merge static props from multiple layers |
-| `mergeFieldProps(layers)` | Merge props from multiple layers |
-| `createConfigContext(config)` | Create configuration context |
-| `resolveInitialValue(name, config, inputConfig, record)` | Resolve initial field value |
-| `resolveAllInitialValues(config, inputs, record)` | Resolve all initial values |
-| `isEmptyValue(value)` | Check if a value is empty |
-| `getInputDefaultValue(inputConfig)` | Get default value from input config |
-| `mergeRecordWithDefaults(config, inputs, record)` | Merge record with default values |
+| Function                                                 | Description                             |
+| -------------------------------------------------------- | --------------------------------------- |
+| `deepMerge(target, source)`                              | Deep merge objects                      |
+| `mergeInputConfigs(base, override)`                      | Merge input configurations              |
+| `resolveInputConfig(type, inputs, formInputs)`           | Resolve input configuration             |
+| `resolveFieldType(name, config, inputs)`                 | Resolve field type from config          |
+| `mergeStaticProps(layers)`                               | Merge static props from multiple layers |
+| `mergeFieldProps(layers)`                                | Merge props from multiple layers        |
+| `createConfigContext(config)`                            | Create configuration context            |
+| `resolveInitialValue(name, config, inputConfig, record)` | Resolve initial field value             |
+| `resolveAllInitialValues(config, inputs, record)`        | Resolve all initial values              |
+| `isEmptyValue(value)`                                    | Check if a value is empty               |
+| `getInputDefaultValue(inputConfig)`                      | Get default value from input config     |
+| `mergeRecordWithDefaults(config, inputs, record)`        | Merge record with default values        |
 
 ### Labels & Ordering
 
-| Function | Description |
-|----------|-------------|
-| `humanizeLabel(fieldName)` | Convert camelCase to human-readable |
-| `resolveLabel(name, config, evaluated, props)` | Resolve field label |
-| `resolveFormTitle(formConfig, record)` | Resolve form title |
-| `isAutoGeneratedLabel(label, fieldName)` | Check if label was auto-generated |
-| `createLabelWithUnit(label, unit)` | Create label with unit suffix |
-| `parseLabelWithUnit(labelWithUnit)` | Parse label with unit |
-| `sortFieldsByOrder(fields, config)` | Sort fields by order property |
-| `getUnusedFields(allFields, usedFields)` | Get unused field names |
-| `getOrderedUnusedFields(allFields, usedFields, config)` | Get ordered unused fields |
+| Function                                                | Description                         |
+| ------------------------------------------------------- | ----------------------------------- |
+| `humanizeLabel(fieldName)`                              | Convert camelCase to human-readable |
+| `resolveLabel(name, config, evaluated, props)`          | Resolve field label                 |
+| `resolveFormTitle(formConfig, record)`                  | Resolve form title                  |
+| `isAutoGeneratedLabel(label, fieldName)`                | Check if label was auto-generated   |
+| `createLabelWithUnit(label, unit)`                      | Create label with unit suffix       |
+| `parseLabelWithUnit(labelWithUnit)`                     | Parse label with unit               |
+| `sortFieldsByOrder(fields, config)`                     | Sort fields by order property       |
+| `getUnusedFields(allFields, usedFields)`                | Get unused field names              |
+| `getOrderedUnusedFields(allFields, usedFields, config)` | Get ordered unused fields           |
 
 ## TypeScript Types
 
@@ -239,15 +249,15 @@ import type {
 
   // Expression
   EvaluationContext,
-} from '@formality-ui/core';
+} from "@formality-ui/core";
 ```
 
 ## Constants
 
-| Constant | Description |
-|----------|-------------|
+| Constant             | Description                             |
+| -------------------- | --------------------------------------- |
 | `QUALIFIED_PREFIXES` | Prefixes for qualified field references |
-| `KEYWORDS` | Reserved keywords in expressions |
+| `KEYWORDS`           | Reserved keywords in expressions        |
 
 ## License
 

package/dist/index.cjs

@@ -37,7 +37,8 @@ var FIELD_STATE_PROPERTIES = /* @__PURE__ */ new Set([
   "isDirty",
   "isValidating",
   "error",
-  "invalid"
+  "invalid",
+  "disabled"
 ]);
 var FIELD_PROXY_MARKER = /* @__PURE__ */ Symbol.for("formality.fieldProxy");
 var FIELD_PROXY_VALUE = /* @__PURE__ */ Symbol.for("formality.fieldProxyValue");
@@ -126,6 +127,13 @@ function buildEvaluationContext(fieldValues, record, props, fieldStates) {
 }
 
 // src/expression/evaluate.ts
+jsep__default.default.addUnaryOp("typeof");
+function isSafeNumber(value) {
+  if (value === null || value === void 0) {
+    return false;
+  }
+  return typeof value === "number" && !Number.isNaN(value) && Number.isFinite(value);
+}
 function getProperty(obj, key) {
   if (obj === null || obj === void 0) {
     return void 0;
@@ -174,17 +182,84 @@ function evaluateNode(node, context) {
       const right = evaluateNode(binaryNode.right, context);
       const leftValue = unwrapFieldProxy(left);
       const rightValue = unwrapFieldProxy(right);
+      if (binaryNode.operator === "+") {
+        const leftIsString = typeof leftValue === "string";
+        const rightIsString = typeof rightValue === "string";
+        const leftIsArray = Array.isArray(leftValue);
+        const rightIsArray = Array.isArray(rightValue);
+        if (leftIsString || rightIsString || leftIsArray || rightIsArray) {
+          const leftStr = leftIsArray ? leftValue.join(",") : String(leftValue ?? "");
+          const rightStr = rightIsArray ? rightValue.join(",") : String(rightValue ?? "");
+          return leftStr + rightStr;
+        }
+        if (!isSafeNumber(leftValue) || !isSafeNumber(rightValue)) {
+          if (process.env.NODE_ENV !== "production") {
+            console.warn(
+              `[Formality Expression] Type error: Invalid operands for + (null/undefined not allowed): left=${typeof leftValue}, right=${typeof rightValue}`
+            );
+          }
+          return void 0;
+        }
+        const result = leftValue + rightValue;
+        if (!Number.isFinite(result)) {
+          if (process.env.NODE_ENV !== "production") {
+            console.warn(
+              `[Formality Expression] Arithmetic overflow: ${leftValue} + ${rightValue} produced ${result}`
+            );
+          }
+          return void 0;
+        }
+        return result;
+      }
+      const arithmeticOps = ["-", "*", "/", "%"];
+      if (arithmeticOps.includes(binaryNode.operator)) {
+        if (!isSafeNumber(leftValue) || !isSafeNumber(rightValue)) {
+          if (process.env.NODE_ENV !== "production") {
+            console.warn(
+              `[Formality Expression] Type error: Invalid operands for ${binaryNode.operator} (null/undefined not allowed): left=${typeof leftValue}, right=${typeof rightValue}`
+            );
+          }
+          return void 0;
+        }
+        const l = leftValue;
+        const r = rightValue;
+        if (binaryNode.operator === "/" || binaryNode.operator === "%") {
+          if (r === 0) {
+            if (process.env.NODE_ENV !== "production") {
+              const opName = binaryNode.operator === "/" ? "Division" : "Modulo";
+              console.warn(`[Formality Expression] ${opName} by zero`);
+            }
+            return void 0;
+          }
+        }
+        let result;
+        switch (binaryNode.operator) {
+          case "-":
+            result = l - r;
+            break;
+          case "*":
+            result = l * r;
+            break;
+          case "/":
+            result = l / r;
+            break;
+          case "%":
+            result = l % r;
+            break;
+          default:
+            throw new Error(`Unknown operator: ${binaryNode.operator}`);
+        }
+        if (!Number.isFinite(result)) {
+          if (process.env.NODE_ENV !== "production") {
+            console.warn(
+              `[Formality Expression] Arithmetic overflow: ${l} ${binaryNode.operator} ${r} produced ${result}`
+            );
+          }
+          return void 0;
+        }
+        return result;
+      }
       switch (binaryNode.operator) {
-        case "+":
-          return leftValue + rightValue;
-        case "-":
-          return leftValue - rightValue;
-        case "*":
-          return leftValue * rightValue;
-        case "/":
-          return leftValue / rightValue;
-        case "%":
-          return leftValue % rightValue;
         case "===":
           return leftValue === rightValue;
         case "!==":
@@ -320,15 +395,43 @@ function inferFieldsFromExpression(expr) {
   IDENTIFIER_REGEX.lastIndex = 0;
   while ((match = IDENTIFIER_REGEX.exec(expr)) !== null) {
     const identifier = match[1];
+    const matchIndex = match.index;
+    let inString = false;
+    let stringChar = "";
+    let escapeNext = false;
+    for (let i = 0; i < matchIndex; i++) {
+      const char = expr[i];
+      if (escapeNext) {
+        escapeNext = false;
+        continue;
+      }
+      if (char === "\\") {
+        escapeNext = true;
+        continue;
+      }
+      if (!inString && (char === '"' || char === "'" || char === "`")) {
+        inString = true;
+        stringChar = char;
+        continue;
+      }
+      if (inString && char === stringChar) {
+        inString = false;
+        stringChar = "";
+        continue;
+      }
+    }
+    if (inString) {
+      continue;
+    }
     if (KEYWORD_SET.has(identifier)) {
       continue;
     }
-    const beforeMatch = expr.slice(0, match.index);
+    const beforeMatch = expr.slice(0, matchIndex);
     const lastNonWhitespace = beforeMatch.trimEnd().slice(-1);
     if (lastNonWhitespace === ".") {
       continue;
     }
-    const afterMatch = expr.slice(match.index + identifier.length);
+    const afterMatch = expr.slice(matchIndex + identifier.length);
     if (afterMatch.startsWith(".") && QUALIFIED_PREFIX_SET.has(identifier)) {
       continue;
     }
@@ -361,9 +464,72 @@ function inferFieldsFromDescriptor(descriptor) {
 }
 
 // src/conditions/evaluate.ts
-function evaluateConditionMatch(condition, context, fieldValues) {
+function evaluateFieldMatcher(fieldName, matcher, fieldValues, fieldStates) {
+  const fieldValue = fieldValues[fieldName];
+  const fieldState = fieldStates?.[fieldName];
+  if (typeof matcher !== "object" || matcher === null) {
+    return fieldValue === matcher;
+  }
+  if (matcher.isValid !== void 0) {
+    const isFieldValid = fieldState ? !fieldState.invalid && !fieldState.error : true;
+    if (matcher.isValid !== isFieldValid) {
+      return false;
+    }
+  }
+  if (matcher.isDisabled !== void 0) {
+    const isFieldDisabled = fieldState?.disabled ?? false;
+    if (matcher.isDisabled !== isFieldDisabled) {
+      return false;
+    }
+  }
+  if (matcher.is !== void 0) {
+    if (fieldValue !== matcher.is) {
+      return false;
+    }
+  }
+  const truthyCheck = matcher.truthy ?? matcher.isTruthy;
+  if (truthyCheck !== void 0) {
+    const isTruthy = Boolean(fieldValue);
+    if (truthyCheck !== isTruthy) {
+      return false;
+    }
+  }
+  const hasAnyMatcher = matcher.is !== void 0 || matcher.truthy !== void 0 || matcher.isTruthy !== void 0 || matcher.isValid !== void 0 || matcher.isDisabled !== void 0;
+  if (!hasAnyMatcher) {
+    return Boolean(fieldValue);
+  }
+  return true;
+}
+function isStateFieldMatcher(value) {
+  if (typeof value !== "object" || value === null) {
+    return false;
+  }
+  return "isValid" in value || "isDisabled" in value;
+}
+function evaluateConditionMatch(condition, context, fieldValues, fieldStates) {
+  if (condition.when !== void 0 && typeof condition.when === "object") {
+    for (const [fieldName, matcher] of Object.entries(condition.when)) {
+      if (!evaluateFieldMatcher(fieldName, matcher, fieldValues, fieldStates)) {
+        return false;
+      }
+    }
+    if (condition.isDisabled !== void 0) {
+      if (!fieldStates) {
+        return false;
+      }
+      const fieldsWithStateMatchers = Object.entries(condition.when).filter(([, matcher]) => isStateFieldMatcher(matcher)).map(([fieldName]) => fieldName);
+      const fieldsToCheck = fieldsWithStateMatchers.length > 0 ? fieldsWithStateMatchers : Object.keys(condition.when);
+      const allFieldsMatchDisabled = fieldsToCheck.every(
+        (fieldName) => fieldStates[fieldName]?.disabled === condition.isDisabled
+      );
+      if (!allFieldsMatchDisabled) {
+        return false;
+      }
+    }
+    return true;
+  }
   let triggerValue;
-  if (condition.when !== void 0) {
+  if (typeof condition.when === "string") {
     triggerValue = fieldValues[condition.when];
   } else if (condition.selectWhen !== void 0) {
     if (typeof condition.selectWhen === "string") {
@@ -376,6 +542,21 @@ function evaluateConditionMatch(condition, context, fieldValues) {
   } else {
     return false;
   }
+  if (typeof condition.when === "string" && fieldStates) {
+    const fieldState = fieldStates[condition.when];
+    if (condition.isValid !== void 0) {
+      const isFieldValid = fieldState ? !fieldState.invalid && !fieldState.error : true;
+      if (condition.isValid !== isFieldValid) {
+        return false;
+      }
+    }
+    if (condition.isDisabled !== void 0) {
+      const isFieldDisabled = fieldState?.disabled ?? false;
+      if (condition.isDisabled !== isFieldDisabled) {
+        return false;
+      }
+    }
+  }
   if (condition.is !== void 0) {
     return triggerValue === condition.is;
   }
@@ -383,11 +564,19 @@ function evaluateConditionMatch(condition, context, fieldValues) {
     const isTruthy = Boolean(triggerValue);
     return condition.truthy ? isTruthy : !isTruthy;
   }
+  if (condition.isValid !== void 0 || condition.isDisabled !== void 0) {
+    return true;
+  }
   return Boolean(triggerValue);
 }
 function evaluateConditions(input) {
   const { conditions, fieldValues, fieldStates, record, props } = input;
-  const context = buildEvaluationContext(fieldValues, record, props, fieldStates);
+  const context = buildEvaluationContext(
+    fieldValues,
+    record,
+    props,
+    fieldStates
+  );
   let disabled;
   let visible;
   let setValue;
@@ -395,7 +584,12 @@ function evaluateConditions(input) {
   let hasVisibleCondition = false;
   let hasSetCondition = false;
   for (const condition of conditions) {
-    const isMatched = evaluateConditionMatch(condition, context, fieldValues);
+    const isMatched = evaluateConditionMatch(
+      condition,
+      context,
+      fieldValues,
+      fieldStates
+    );
     if (!isMatched) {
       continue;
     }
@@ -417,7 +611,9 @@ function evaluateConditions(input) {
       } else if (typeof condition.selectSet === "function") {
         setValue = condition.selectSet;
       } else {
-        setValue = unwrapFieldProxy(evaluateDescriptor(condition.selectSet, context));
+        setValue = unwrapFieldProxy(
+          evaluateDescriptor(condition.selectSet, context)
+        );
       }
     }
   }
@@ -430,9 +626,14 @@ function evaluateConditions(input) {
     hasSetCondition
   };
 }
-function conditionMatches(condition, fieldValues, record, props) {
-  const context = buildEvaluationContext(fieldValues, record, props);
-  return evaluateConditionMatch(condition, context, fieldValues);
+function conditionMatches(condition, fieldValues, record, props, fieldStates) {
+  const context = buildEvaluationContext(
+    fieldValues,
+    record,
+    props,
+    fieldStates
+  );
+  return evaluateConditionMatch(condition, context, fieldValues, fieldStates);
 }
 function mergeConditionResults(results) {
   let disabled;
@@ -468,7 +669,11 @@ function inferFieldsFromConditions(conditions) {
   const fields = [];
   for (const condition of conditions) {
     if (condition.when !== void 0) {
-      fields.push(condition.when);
+      if (typeof condition.when === "string") {
+        fields.push(condition.when);
+      } else {
+        fields.push(...Object.keys(condition.when));
+      }
     }
     if (condition.selectWhen !== void 0) {
       fields.push(...inferFieldsFromDescriptor(condition.selectWhen));
@@ -504,7 +709,12 @@ function resolveNamedValidator(name, validators) {
 async function runValidator(spec, value, formValues, namedValidators) {
   if (Array.isArray(spec)) {
     for (const item of spec) {
-      const result = await runValidator(item, value, formValues, namedValidators);
+      const result = await runValidator(
+        item,
+        value,
+        formValues,
+        namedValidators
+      );
       if (!isValid(result)) {
         return result;
       }
@@ -513,7 +723,9 @@ async function runValidator(spec, value, formValues, namedValidators) {
   }
   if (typeof spec === "string") {
     if (!namedValidators) {
-      console.warn(`Named validator "${spec}" requested but no validators provided`);
+      console.warn(
+        `Named validator "${spec}" requested but no validators provided`
+      );
       return true;
     }
     const validator = resolveNamedValidator(spec, namedValidators);
@@ -566,7 +778,12 @@ function isValid(result) {
 function composeValidators(validators, namedValidators) {
   return async (value, formValues) => {
     for (const spec of validators) {
-      const result = await runValidator(spec, value, formValues, namedValidators);
+      const result = await runValidator(
+        spec,
+        value,
+        formValues,
+        namedValidators
+      );
       if (!isValid(result)) {
         return result;
       }
@@ -748,7 +965,9 @@ function format(value, formatterSpec, namedFormatters) {
     const formatter = namedFormatters?.[formatterSpec];
     if (!formatter) {
       if (process.env.NODE_ENV !== "production") {
-        console.warn(`Formatter "${formatterSpec}" not found in formatters config`);
+        console.warn(
+          `Formatter "${formatterSpec}" not found in formatters config`
+        );
       }
       return value;
     }