@formality-ui/core 0.0.0 → 0.1.0

package/dist/index.js

@@ -31,7 +31,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");
@@ -120,6 +121,13 @@ function buildEvaluationContext(fieldValues, record, props, fieldStates) {
 }
 
 // src/expression/evaluate.ts
+jsep.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;
@@ -168,17 +176,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 "!==":
@@ -314,15 +389,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;
     }
@@ -355,9 +458,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") {
@@ -370,6 +536,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;
   }
@@ -377,11 +558,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;
@@ -389,7 +578,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;
     }
@@ -411,7 +605,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)
+        );
       }
     }
   }
@@ -424,9 +620,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;
@@ -462,7 +663,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));
@@ -498,7 +703,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;
       }
@@ -507,7 +717,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);
@@ -560,7 +772,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;
       }
@@ -742,7 +959,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;
     }