@1money/component-ui 0.0.75 → 0.0.76

package/es/components/ProForm/core/runRules.js

@@ -1,3 +1,4 @@
+import _slicedToArray from "@babel/runtime/helpers/esm/slicedToArray";
 import _typeof from "@babel/runtime/helpers/esm/typeof";
 import _regeneratorRuntime from "@babel/runtime/regenerator";
 function _createForOfIteratorHelper(r, e) { var t = "undefined" != typeof Symbol && r[Symbol.iterator] || r["@@iterator"]; if (!t) { if (Array.isArray(r) || (t = _unsupportedIterableToArray(r)) || e && r && "number" == typeof r.length) { t && (r = t); var _n = 0, F = function F() {}; return { s: F, n: function n() { return _n >= r.length ? { done: !0 } : { done: !1, value: r[_n++] }; }, e: function e(r) { throw r; }, f: F }; } throw new TypeError("Invalid attempt to iterate non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method."); } var o, a = !0, u = !1; return { s: function s() { t = t.call(r); }, n: function n() { var r = t.next(); return a = r.done, r; }, e: function e(r) { u = !0, o = r; }, f: function f() { try { a || null == t["return"] || t["return"](); } finally { if (u) throw o; } } }; }
@@ -30,6 +31,8 @@ var __awaiter = this && this.__awaiter || function (thisArg, _arguments, P, gene
     step((generator = generator.apply(thisArg, _arguments || [])).next());
   });
 };
+import { resolveValue } from './pathUtils';
+import { devWarnOnce } from './devWarning';
 function isThenable(value) {
   return value !== null && _typeof(value) === 'object' && typeof value.then === 'function';
 }
@@ -38,75 +41,534 @@ function isEmptyValue(value) {
   return value === undefined || value === null || value === '' || Array.isArray(value) && value.length === 0;
 }
 /**
- * Filter rules applicable to an interactive trigger. A rule WITHOUT an
- * explicit `validateTrigger` follows the form-level trigger; a rule WITH one
- * runs on exactly those trigger(s), regardless of the form-level setting.
- * Submit-time validation bypasses this filter and runs every rule.
+ * Coerce a thrown/rejected reason into displayable failure content:
+ * a non-empty Error.message or a non-empty plain string — otherwise null
+ * (caller picks its fallback). Shared with the form-level last-resort nets.
  */
-export function filterRulesByTrigger(rules, trigger, formTrigger) {
+export function coerceFailureReason(reason) {
+  if (reason instanceof Error && reason.message) return reason.message;
+  if (typeof reason === 'string' && reason) return reason;
+  return null;
+}
+/**
+ * Failure message for a rejected/thrown custom validator:
+ * Error.message → plain string reason → rule.message → generic fallback.
+ */
+function resolveFailureMessage(reason, rule) {
+  var _a;
+  return (_a = coerceFailureReason(reason)) !== null && _a !== void 0 ? _a : rule.message || 'Validation failed';
+}
+/**
+ * Resolve function-form rules into static rules. The
+ * context exposes the value snapshot the run was invoked with; function rules
+ * must be cheap and side-effect free — they may be resolved more than once
+ * per validation pass.
+ */
+export function resolveRules(rules, values, instance) {
+  // Fast path: no function rules → nothing to resolve, no ctx allocation.
+  // This also makes the engine-internal re-resolution of already-resolved
+  // arrays free.
+  if (!rules.some(function (rule) {
+    return typeof rule === 'function';
+  })) {
+    return rules;
+  }
+  // Live-instance members (setFieldsValue, getFieldError, …) are spread in
+  // when available; the reads always come from the validation-time snapshot.
+  var ctx = Object.assign(Object.assign({}, instance), {
+    getFieldValue: function getFieldValue(name) {
+      return resolveValue(values, name);
+    },
+    getFieldsValue: function getFieldsValue() {
+      return values;
+    }
+  });
+  return rules.map(function (rule) {
+    if (typeof rule !== 'function') return rule;
+    try {
+      return rule(ctx);
+    } catch (err) {
+      // A throwing rule factory must not crash rendering or validation —
+      // surface it as a rule that always fails with the thrown reason.
+      return {
+        validator: function validator() {
+          throw err;
+        }
+      };
+    }
+  });
+}
+/**
+ * Normalize a form/item-level validateTrigger config into the effective
+ * interactive event list: item-level (when present) overrides form-level;
+ * `false` disables interactive validation entirely.
+ */
+export function normalizeTriggers(itemTrigger, formTrigger) {
+  var effective = itemTrigger === undefined ? formTrigger : itemTrigger;
+  if (effective === false) return [];
+  return Array.isArray(effective) ? effective : [effective];
+}
+/**
+ * Filter rules applicable to an interactive event: the event
+ * validates only when it is in the item's effective trigger set. Within the
+ * set, a rule WITHOUT `validateTrigger` runs on every event; a rule WITH one
+ * runs only on matching events — so a rule trigger outside the item's set
+ * never fires interactively. Submit-time validation bypasses this filter and
+ * runs every rule.
+ *
+ * Dev guard: a rule whose (non-empty) trigger set is fully OUTSIDE the
+ * active set can never fire interactively — usually a leftover of the
+ * pre-0.0.76 override semantics, so it warns once. `validateTrigger: []`
+ * is the deliberate submit-only idiom and stays silent.
+ */
+export function filterRulesByTrigger(rules, trigger, activeTriggers, fieldName) {
+  if (!activeTriggers.includes(trigger)) return [];
   return rules.filter(function (rule) {
     var ruleTrigger = rule.validateTrigger;
-    if (!ruleTrigger) return formTrigger === trigger;
-    return Array.isArray(ruleTrigger) ? ruleTrigger.includes(trigger) : ruleTrigger === trigger;
+    if (ruleTrigger === undefined) return true;
+    var ruleTriggers = Array.isArray(ruleTrigger) ? ruleTrigger : [ruleTrigger];
+    var matches = ruleTriggers.includes(trigger);
+    if (!matches && ruleTriggers.length > 0 && !ruleTriggers.some(function (t) {
+      return activeTriggers.includes(t);
+    })) {
+      var name = fieldName !== null && fieldName !== void 0 ? fieldName : '(unknown)';
+      devWarnOnce("trigger:".concat(name, ":").concat(ruleTriggers.join(',')), "[ProForm] Field \"".concat(name, "\": rule validateTrigger [").concat(ruleTriggers.join(', '), "] is outside this field's active trigger set [").concat(activeTriggers.join(', '), "] \u2014 the rule will only run on submit. Include it in the item/form validateTrigger to run it interactively."));
+    }
+    return matches;
   });
 }
+/** Built-in `type` checks. `enum` is handled separately against `rule.enum`. */
+var TYPE_CHECKS = {
+  string: function string(v) {
+    return typeof v === 'string';
+  },
+  number: function number(v) {
+    return typeof v === 'number' && !Number.isNaN(v);
+  },
+  "boolean": function boolean(v) {
+    return typeof v === 'boolean';
+  },
+  method: function method(v) {
+    return typeof v === 'function';
+  },
+  integer: function integer(v) {
+    return typeof v === 'number' && Number.isInteger(v);
+  },
+  "float": function float(v) {
+    return typeof v === 'number' && !Number.isNaN(v) && !Number.isInteger(v);
+  },
+  array: function array(v) {
+    return Array.isArray(v);
+  },
+  object: function object(v) {
+    return _typeof(v) === 'object' && v !== null && !Array.isArray(v);
+  },
+  date: function date(v) {
+    return v instanceof Date ? !Number.isNaN(v.getTime()) : typeof (v === null || v === void 0 ? void 0 : v.getTime) === 'function' && !Number.isNaN(v.getTime());
+  },
+  regexp: function regexp(v) {
+    if (v instanceof RegExp) return true;
+    if (typeof v !== 'string') return false;
+    try {
+      new RegExp(v);
+      return true;
+    } catch (_a) {
+      return false;
+    }
+  },
+  hex: function hex(v) {
+    return typeof v === 'string' && /^#?([a-f0-9]{6}|[a-f0-9]{3})$/i.test(v);
+  },
+  // String-only: coercing via String() would let e.g. ['a@b.co'] stringify
+  // into a passing value.
+  email: function email(v) {
+    return typeof v === 'string' && /^[^\s@]+@[^\s@]+\.[^\s@]+$/.test(v);
+  },
+  url: function url(v) {
+    if (typeof v !== 'string') return false;
+    try {
+      new URL(v);
+      return true;
+    } catch (_a) {
+      return false;
+    }
+  }
+};
+/** Friendly generated messages for the legacy type names; others get a generic one. */
+function typeFailureMessage(name, type) {
+  if (type === 'number') return "".concat(name, " must be a number");
+  if (type === 'email') return "".concat(name, " must be a valid email");
+  if (type === 'url') return "".concat(name, " must be a valid URL");
+  return "".concat(name, " is not a valid ").concat(type);
+}
+/** Measure a value for len/min/max: string → length, array → count, number → value. */
+function measureValue(value) {
+  if (typeof value === 'string') return {
+    measured: value.length,
+    unit: ' characters'
+  };
+  if (Array.isArray(value)) return {
+    measured: value.length,
+    unit: ' items'
+  };
+  if (typeof value === 'number' && !Number.isNaN(value)) return {
+    measured: value,
+    unit: ''
+  };
+  return null;
+}
 /**
  * Evaluate every built-in (non-`validator`) rule kind for a single rule.
- * Returns the error message for the first failing check, or null.
+ * Returns the error content for the first failing check, or null.
+ *
+ * Empty values (undefined / null / '' / empty array) are only checked by
+ * `required` — every other builtin check is skipped, so optional fields
+ * don't error until they have content. Custom validators are NOT subject to
+ * this skip (they receive the empty value and decide themselves).
  */
 function checkBuiltinRules(rule, value, name) {
   if (rule.required && isEmptyValue(value)) {
     return rule.message || "".concat(name, " is required");
   }
-  // min/max: string → length, array → item count, number → numeric value
-  if (rule.min !== undefined || rule.max !== undefined) {
-    var measured = null;
-    var unit = '';
-    if (typeof value === 'string') {
-      measured = value.length;
-      unit = ' characters';
-    } else if (Array.isArray(value)) {
-      measured = value.length;
-      unit = ' items';
-    } else if (typeof value === 'number' && !Number.isNaN(value)) {
-      measured = value;
-    }
-    if (measured !== null) {
-      if (rule.min !== undefined && measured < rule.min) {
-        return rule.message || "".concat(name, " must be at least ").concat(rule.min).concat(unit);
+  if (isEmptyValue(value)) return null;
+  // Non-empty string of only whitespace (the required+whitespace trim idiom).
+  if (rule.whitespace && typeof value === 'string' && value.trim() === '') {
+    return rule.message || "".concat(name, " cannot be blank");
+  }
+  // len: exact length/count/value — takes precedence over min/max.
+  if (rule.len !== undefined) {
+    var m = measureValue(value);
+    if (m !== null && m.measured !== rule.len) {
+      return rule.message || "".concat(name, " must be exactly ").concat(rule.len).concat(m.unit);
+    }
+  } else if (rule.min !== undefined || rule.max !== undefined) {
+    var _m = measureValue(value);
+    if (_m !== null) {
+      if (rule.min !== undefined && _m.measured < rule.min) {
+        return rule.message || "".concat(name, " must be at least ").concat(rule.min).concat(_m.unit);
       }
-      if (rule.max !== undefined && measured > rule.max) {
-        return rule.message || "".concat(name, " must be no more than ").concat(rule.max).concat(unit);
+      if (rule.max !== undefined && _m.measured > rule.max) {
+        return rule.message || "".concat(name, " must be no more than ").concat(rule.max).concat(_m.unit);
       }
     }
   }
-  if (rule.pattern && typeof value === 'string' && !rule.pattern.test(value)) {
-    return rule.message || "".concat(name, " format is invalid");
+  if (rule.pattern && typeof value === 'string') {
+    // A /g or /y regex is stateful: lastIndex persists across .test() calls,
+    // so repeated runs would alternate pass/fail — reset it every run.
+    if (rule.pattern.global || rule.pattern.sticky) rule.pattern.lastIndex = 0;
+    if (!rule.pattern.test(value)) {
+      return rule.message || "".concat(name, " format is invalid");
+    }
+  }
+  if (rule.type && rule.type !== 'enum' && !TYPE_CHECKS[rule.type](value)) {
+    return rule.message || typeFailureMessage(name, rule.type);
   }
-  if (rule["enum"] && Array.isArray(rule["enum"]) && value) {
-    if (!rule["enum"].includes(value)) {
-      return rule.message || "".concat(name, " must be one of ").concat(rule["enum"].join(', '));
+  // enum membership: applies for type 'enum' or whenever rule.enum is present.
+  if (rule["enum"] && Array.isArray(rule["enum"]) && !rule["enum"].includes(value)) {
+    return rule.message || "".concat(name, " must be one of ").concat(rule["enum"].join(', '));
+  }
+  return null;
+}
+function toRuleArray(rules) {
+  if (!rules) return [];
+  return Array.isArray(rules) ? rules : [rules];
+}
+/** Members for deep rules: array → indexed entries, plain object → key entries. */
+function deepMembers(value) {
+  if (Array.isArray(value)) return value.map(function (member, index) {
+    return [String(index), member];
+  });
+  if (value && _typeof(value) === 'object') return Object.entries(value);
+  return [];
+}
+var PASS = {
+  error: null,
+  warning: null
+};
+/**
+ * Dev guard for the pre-0.0.76 validator contract: returning a string or
+ * `false` used to FAIL the rule — under the `(rule, value)` contract return
+ * values are ignored and only throw/reject fails. Such a return is almost
+ * certainly a legacy validator silently passing, so it warns once.
+ */
+function warnLegacyValidatorReturn(name, result) {
+  if (typeof result !== 'string' && result !== false) return;
+  devWarnOnce("validator-return:".concat(name), "[ProForm] Field \"".concat(name, "\": a custom validator returned ").concat(typeof result === 'string' ? 'a string' : 'false', " \u2014 return values are IGNORED; validators fail by throwing or rejecting (a thrown Error's message becomes the field error)."));
+}
+/** Run a rule's transform, containing throws as a rule failure. */
+function applyTransform(rule, rawValue) {
+  if (typeof rule.transform !== 'function') return {
+    ok: true,
+    value: rawValue
+  };
+  try {
+    return {
+      ok: true,
+      value: rule.transform(rawValue)
+    };
+  } catch (err) {
+    return {
+      ok: false,
+      failure: resolveFailureMessage(err, rule)
+    };
+  }
+}
+/**
+ * Flatten a rule's deep sources (`fields` per key, then `defaultField` per
+ * member) into [subRule, memberValue, memberName] tuples — the single place
+ * that knows how deep rules map onto a container value.
+ */
+function deepRuleEntries(rule, value, name) {
+  var entries = [];
+  if (rule.fields) {
+    var source = value;
+    for (var _i = 0, _Object$entries = Object.entries(rule.fields); _i < _Object$entries.length; _i++) {
+      var _Object$entries$_i = _slicedToArray(_Object$entries[_i], 2),
+        key = _Object$entries$_i[0],
+        subRules = _Object$entries$_i[1];
+      var _iterator = _createForOfIteratorHelper(toRuleArray(subRules)),
+        _step;
+      try {
+        for (_iterator.s(); !(_step = _iterator.n()).done;) {
+          var subRule = _step.value;
+          entries.push([subRule, source[key], "".concat(name, ".").concat(key)]);
+        }
+      } catch (err) {
+        _iterator.e(err);
+      } finally {
+        _iterator.f();
+      }
     }
   }
-  if (rule.type === 'number' && value !== undefined && value !== null && value !== '') {
-    if (typeof value !== 'number' || isNaN(value)) {
-      return rule.message || "".concat(name, " must be a number");
+  if (rule.defaultField) {
+    var _iterator2 = _createForOfIteratorHelper(deepMembers(value)),
+      _step2;
+    try {
+      for (_iterator2.s(); !(_step2 = _iterator2.n()).done;) {
+        var _step2$value = _slicedToArray(_step2.value, 2),
+          _key = _step2$value[0],
+          member = _step2$value[1];
+        var _iterator3 = _createForOfIteratorHelper(toRuleArray(rule.defaultField)),
+          _step3;
+        try {
+          for (_iterator3.s(); !(_step3 = _iterator3.n()).done;) {
+            var _subRule = _step3.value;
+            entries.push([_subRule, member, "".concat(name, ".").concat(_key)]);
+          }
+        } catch (err) {
+          _iterator3.e(err);
+        } finally {
+          _iterator3.f();
+        }
+      }
+    } catch (err) {
+      _iterator2.e(err);
+    } finally {
+      _iterator2.f();
     }
   }
-  if (rule.type === 'email' && value) {
-    var emailPattern = /^[^\s@]+@[^\s@]+\.[^\s@]+$/;
-    if (!emailPattern.test(String(value))) {
-      return rule.message || "".concat(name, " must be a valid email");
+  return entries;
+}
+/**
+ * Merge a sub-rule's outcome into the parent's channels. A sub-rule flagged
+ * `warningOnly` contributes its failure as a WARNING; otherwise its error
+ * blocks. Returns true when a blocking error landed (stop walking).
+ */
+function mergeSubResult(acc, subRule, sub) {
+  if (sub.warning !== null && acc.warning === null) acc.warning = sub.warning;
+  if (sub.error !== null) {
+    if (subRule.warningOnly) {
+      if (acc.warning === null) acc.warning = sub.error;
+    } else {
+      acc.error = sub.error;
+      return true;
     }
   }
-  if (rule.type === 'url' && value) {
+  return false;
+}
+/**
+ * Fold one rule's outcome into the run-level channels. A rule flagged
+ * `warningOnly` downgrades everything it produced (own checks AND deep
+ * sub-rules) to a warning. Returns the blocking error to surface, or null.
+ */
+function foldRuleResult(rule, result, state) {
+  var _a;
+  if (rule.warningOnly) {
+    var content = (_a = result.error) !== null && _a !== void 0 ? _a : result.warning;
+    if (content !== null && state.warning === null) state.warning = content;
+    return null;
+  }
+  if (result.warning !== null && state.warning === null) state.warning = result.warning;
+  return result.error;
+}
+/**
+ * Evaluate ONE rule (transform → builtin checks → validator → deep rules)
+ * synchronously. Promise-returning validators are deferred (see runRulesSync).
+ */
+function evalRuleSync(rule, rawValue, name) {
+  var prep = applyTransform(rule, rawValue);
+  if (!prep.ok) return {
+    error: prep.failure,
+    warning: null
+  };
+  var value = prep.value;
+  var failure = checkBuiltinRules(rule, value, name);
+  if (failure === null && typeof rule.validator === 'function') {
     try {
-      new URL(String(value));
-    } catch (_a) {
-      return rule.message || "".concat(name, " must be a valid URL");
+      var result = rule.validator(rule, value);
+      if (isThenable(result)) {
+        result.then(function (resolved) {
+          return warnLegacyValidatorReturn(name, resolved);
+        }, function () {});
+      } else {
+        warnLegacyValidatorReturn(name, result);
+      }
+    } catch (err) {
+      failure = resolveFailureMessage(err, rule);
     }
   }
-  return null;
+  if (failure !== null) return {
+    error: failure,
+    warning: null
+  };
+  if ((rule.fields || rule.defaultField) && !isEmptyValue(value)) {
+    // Deep rules need a container; a non-empty primitive fails the PARENT
+    // (clear attribution) instead of producing confusing child errors.
+    if (_typeof(value) !== 'object' || value === null) {
+      return {
+        error: rule.message || "".concat(name, " must be an object or an array"),
+        warning: null
+      };
+    }
+    var acc = {
+      error: null,
+      warning: null
+    };
+    var _iterator4 = _createForOfIteratorHelper(deepRuleEntries(rule, value, name)),
+      _step4;
+    try {
+      for (_iterator4.s(); !(_step4 = _iterator4.n()).done;) {
+        var _step4$value = _slicedToArray(_step4.value, 3),
+          subRule = _step4$value[0],
+          subValue = _step4$value[1],
+          subName = _step4$value[2];
+        if (mergeSubResult(acc, subRule, evalRuleSync(subRule, subValue, subName))) break;
+      }
+    } catch (err) {
+      _iterator4.e(err);
+    } finally {
+      _iterator4.f();
+    }
+    return acc;
+  }
+  return PASS;
+}
+/** Async counterpart of evalRuleSync — custom validators are awaited. */
+function evalRuleAsync(rule, rawValue, name) {
+  return __awaiter(this, void 0, void 0, /*#__PURE__*/_regeneratorRuntime.mark(function _callee() {
+    var prep, value, failure, result, acc, _iterator5, _step5, _step5$value, subRule, subValue, subName, _t, _t2, _t3, _t4, _t5;
+    return _regeneratorRuntime.wrap(function (_context) {
+      while (1) switch (_context.prev = _context.next) {
+        case 0:
+          prep = applyTransform(rule, rawValue);
+          if (prep.ok) {
+            _context.next = 1;
+            break;
+          }
+          return _context.abrupt("return", {
+            error: prep.failure,
+            warning: null
+          });
+        case 1:
+          value = prep.value;
+          failure = checkBuiltinRules(rule, value, name);
+          if (!(failure === null && typeof rule.validator === 'function')) {
+            _context.next = 5;
+            break;
+          }
+          _context.prev = 2;
+          _context.next = 3;
+          return rule.validator(rule, value);
+        case 3:
+          result = _context.sent;
+          warnLegacyValidatorReturn(name, result);
+          _context.next = 5;
+          break;
+        case 4:
+          _context.prev = 4;
+          _t = _context["catch"](2);
+          failure = resolveFailureMessage(_t, rule);
+        case 5:
+          if (!(failure !== null)) {
+            _context.next = 6;
+            break;
+          }
+          return _context.abrupt("return", {
+            error: failure,
+            warning: null
+          });
+        case 6:
+          if (!((rule.fields || rule.defaultField) && !isEmptyValue(value))) {
+            _context.next = 16;
+            break;
+          }
+          if (!(_typeof(value) !== 'object' || value === null)) {
+            _context.next = 7;
+            break;
+          }
+          return _context.abrupt("return", {
+            error: rule.message || "".concat(name, " must be an object or an array"),
+            warning: null
+          });
+        case 7:
+          acc = {
+            error: null,
+            warning: null
+          };
+          _iterator5 = _createForOfIteratorHelper(deepRuleEntries(rule, value, name));
+          _context.prev = 8;
+          _iterator5.s();
+        case 9:
+          if ((_step5 = _iterator5.n()).done) {
+            _context.next = 12;
+            break;
+          }
+          _step5$value = _slicedToArray(_step5.value, 3), subRule = _step5$value[0], subValue = _step5$value[1], subName = _step5$value[2];
+          _t2 = mergeSubResult;
+          _t3 = acc;
+          _t4 = subRule;
+          _context.next = 10;
+          return evalRuleAsync(subRule, subValue, subName);
+        case 10:
+          if (!_t2(_t3, _t4, _context.sent)) {
+            _context.next = 11;
+            break;
+          }
+          return _context.abrupt("continue", 12);
+        case 11:
+          _context.next = 9;
+          break;
+        case 12:
+          _context.next = 14;
+          break;
+        case 13:
+          _context.prev = 13;
+          _t5 = _context["catch"](8);
+          _iterator5.e(_t5);
+        case 14:
+          _context.prev = 14;
+          _iterator5.f();
+          return _context.finish(14);
+        case 15:
+          return _context.abrupt("return", acc);
+        case 16:
+          return _context.abrupt("return", PASS);
+        case 17:
+        case "end":
+          return _context.stop();
+      }
+    }, _callee, null, [[2, 4], [8, 13, 14, 15]]);
+  }));
 }
 /**
  * Synchronous rule run. A Promise-returning validator CANNOT be evaluated
@@ -114,128 +576,117 @@ function checkBuiltinRules(rule, value, name) {
  * swallowed) and left to the async runs (blur/submit), which always await it.
  * Failing it instead would mis-report "Validation failed" on every keystroke
  * for perfectly valid input.
+ *
+ * The per-rule try/catch is the engine's totality choke point: NO input —
+ * including exotic values that break a builtin check — may escape as a throw;
+ * every failure surfaces through the error/warning channels.
  */
-export function runRulesSync(name, value, values, rules) {
-  var warning = null;
-  var _iterator = _createForOfIteratorHelper(rules),
-    _step;
+export function runRulesSync(name, value, values, rules, instance) {
+  var state = {
+    warning: null
+  };
+  var _iterator6 = _createForOfIteratorHelper(resolveRules(rules, values, instance)),
+    _step6;
   try {
-    for (_iterator.s(); !(_step = _iterator.n()).done;) {
-      var rule = _step.value;
-      var failure = checkBuiltinRules(rule, value, name);
-      if (failure === null && typeof rule.validator === 'function') {
-        try {
-          var result = rule.validator(value, values);
-          if (isThenable(result)) {
-            result.then(undefined, function () {});
-          } else if (result !== true) {
-            failure = typeof result === 'string' ? result : 'Validation failed';
-          }
-        } catch (err) {
-          failure = err instanceof Error ? err.message : 'Validation error';
-        }
-      }
-      if (failure !== null) {
-        if (rule.warningOnly) {
-          warning = warning !== null && warning !== void 0 ? warning : failure;
-        } else {
-          return {
-            error: failure,
-            warning: warning
-          };
-        }
+    for (_iterator6.s(); !(_step6 = _iterator6.n()).done;) {
+      var rule = _step6.value;
+      var result = void 0;
+      try {
+        result = evalRuleSync(rule, value, name);
+      } catch (err) {
+        result = {
+          error: resolveFailureMessage(err, rule),
+          warning: null
+        };
       }
+      var error = foldRuleResult(rule, result, state);
+      if (error !== null) return {
+        error: error,
+        warning: state.warning
+      };
     }
   } catch (err) {
-    _iterator.e(err);
+    _iterator6.e(err);
   } finally {
-    _iterator.f();
+    _iterator6.f();
   }
   return {
     error: null,
-    warning: warning
+    warning: state.warning
   };
 }
 /**
- * Asynchronous rule run. Custom validators are awaited (sync or async). A
- * validator returning `undefined` is treated as passing.
+ * Asynchronous rule run. Custom validators are awaited (sync or async):
+ * resolving passes, rejecting/throwing fails. Return values are ignored.
+ * Shares the totality choke point with runRulesSync.
  */
-export function runRulesAsync(name, value, values, rules) {
-  return __awaiter(this, void 0, void 0, /*#__PURE__*/_regeneratorRuntime.mark(function _callee() {
-    var warning, _iterator2, _step2, rule, failure, result, _t, _t2;
-    return _regeneratorRuntime.wrap(function (_context) {
-      while (1) switch (_context.prev = _context.next) {
+export function runRulesAsync(name, value, values, rules, instance) {
+  return __awaiter(this, void 0, void 0, /*#__PURE__*/_regeneratorRuntime.mark(function _callee2() {
+    var state, _iterator7, _step7, rule, result, error, _t6, _t7;
+    return _regeneratorRuntime.wrap(function (_context2) {
+      while (1) switch (_context2.prev = _context2.next) {
         case 0:
-          warning = null;
-          _iterator2 = _createForOfIteratorHelper(rules);
-          _context.prev = 1;
-          _iterator2.s();
+          state = {
+            warning: null
+          };
+          _iterator7 = _createForOfIteratorHelper(resolveRules(rules, values, instance));
+          _context2.prev = 1;
+          _iterator7.s();
         case 2:
-          if ((_step2 = _iterator2.n()).done) {
-            _context.next = 9;
+          if ((_step7 = _iterator7.n()).done) {
+            _context2.next = 8;
             break;
           }
-          rule = _step2.value;
-          failure = checkBuiltinRules(rule, value, name);
-          if (!(failure === null && typeof rule.validator === 'function')) {
-            _context.next = 6;
-            break;
-          }
-          _context.prev = 3;
-          _context.next = 4;
-          return Promise.resolve(rule.validator(value, values));
+          rule = _step7.value;
+          result = void 0;
+          _context2.prev = 3;
+          _context2.next = 4;
+          return evalRuleAsync(rule, value, name);
         case 4:
-          result = _context.sent;
-          if (result !== true && result !== undefined) {
-            failure = typeof result === 'string' ? result : 'Validation failed';
-          }
-          _context.next = 6;
+          result = _context2.sent;
+          _context2.next = 6;
           break;
         case 5:
-          _context.prev = 5;
-          _t = _context["catch"](3);
-          failure = _t instanceof Error ? _t.message : 'Validation error';
+          _context2.prev = 5;
+          _t6 = _context2["catch"](3);
+          result = {
+            error: resolveFailureMessage(_t6, rule),
+            warning: null
+          };
         case 6:
-          if (!(failure !== null)) {
-            _context.next = 8;
+          error = foldRuleResult(rule, result, state);
+          if (!(error !== null)) {
+            _context2.next = 7;
             break;
           }
-          if (!rule.warningOnly) {
-            _context.next = 7;
-            break;
-          }
-          warning = warning !== null && warning !== void 0 ? warning : failure;
-          _context.next = 8;
-          break;
-        case 7:
-          return _context.abrupt("return", {
-            error: failure,
-            warning: warning
+          return _context2.abrupt("return", {
+            error: error,
+            warning: state.warning
           });
+        case 7:
+          _context2.next = 2;
+          break;
         case 8:
-          _context.next = 2;
+          _context2.next = 10;
           break;
         case 9:
-          _context.next = 11;
-          break;
+          _context2.prev = 9;
+          _t7 = _context2["catch"](1);
+          _iterator7.e(_t7);
         case 10:
-          _context.prev = 10;
-          _t2 = _context["catch"](1);
-          _iterator2.e(_t2);
+          _context2.prev = 10;
+          _iterator7.f();
+          return _context2.finish(10);
         case 11:
-          _context.prev = 11;
-          _iterator2.f();
-          return _context.finish(11);
-        case 12:
-          return _context.abrupt("return", {
+          return _context2.abrupt("return", {
             error: null,
-            warning: warning
+            warning: state.warning
           });
-        case 13:
+        case 12:
         case "end":
-          return _context.stop();
+          return _context2.stop();
       }
-    }, _callee, null, [[1, 10, 11, 12], [3, 5]]);
+    }, _callee2, null, [[1, 9, 10, 11], [3, 5]]);
   }));
 }
-//# sourceMappingURL=data:application/json;charset=utf8;base64,{"version":3,"sources":["components/ProForm/core/runRules.js","components/ProForm/src/components/ProForm/core/runRules.ts"],"names":["__awaiter","thisArg","_arguments","P","generator","adopt","value","resolve","Promise","reject","fulfilled","step","next","e","rejected","result","done","then","apply","isThenable","_typeof","isEmptyValue","undefined","Array","isArray","length","filterRulesByTrigger","rules","trigger","formTrigger","filter","rule","ruleTrigger","validateTrigger","includes","checkBuiltinRules","name","required","message","concat","min","max","measured","unit","Number","isNaN","pattern","test","join","type","emailPattern","String","URL","_a","runRulesSync","values","warning","_iterator","_createForOfIteratorHelper","_step","s","n","failure","validator","err","Error","warningOnly","error","f","runRulesAsync","_regeneratorRuntime","mark","_callee","_iterator2","_step2","_t","_t2","wrap","_context","prev","sent","abrupt","finish","stop"],"mappings":"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","file":"components/ProForm/core/runRules.js","sourcesContent":["var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {\n    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }\n    return new (P || (P = Promise))(function (resolve, reject) {\n        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }\n        function rejected(value) { try { step(generator[\"throw\"](value)); } catch (e) { reject(e); } }\n        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }\n        step((generator = generator.apply(thisArg, _arguments || [])).next());\n    });\n};\nfunction isThenable(value) {\n    return (value !== null &&\n        typeof value === 'object' &&\n        typeof value.then === 'function');\n}\n/** Empty for `required`: undefined / null / '' / empty array. */\nfunction isEmptyValue(value) {\n    return (value === undefined ||\n        value === null ||\n        value === '' ||\n        (Array.isArray(value) && value.length === 0));\n}\n/**\n * Filter rules applicable to an interactive trigger. A rule WITHOUT an\n * explicit `validateTrigger` follows the form-level trigger; a rule WITH one\n * runs on exactly those trigger(s), regardless of the form-level setting.\n * Submit-time validation bypasses this filter and runs every rule.\n */\nexport function filterRulesByTrigger(rules, trigger, formTrigger) {\n    return rules.filter((rule) => {\n        const ruleTrigger = rule.validateTrigger;\n        if (!ruleTrigger)\n            return formTrigger === trigger;\n        return Array.isArray(ruleTrigger)\n            ? ruleTrigger.includes(trigger)\n            : ruleTrigger === trigger;\n    });\n}\n/**\n * Evaluate every built-in (non-`validator`) rule kind for a single rule.\n * Returns the error message for the first failing check, or null.\n */\nfunction checkBuiltinRules(rule, value, name) {\n    if (rule.required && isEmptyValue(value)) {\n        return rule.message || `${name} is required`;\n    }\n    // min/max: string → length, array → item count, number → numeric value\n    if (rule.min !== undefined || rule.max !== undefined) {\n        let measured = null;\n        let unit = '';\n        if (typeof value === 'string') {\n            measured = value.length;\n            unit = ' characters';\n        }\n        else if (Array.isArray(value)) {\n            measured = value.length;\n            unit = ' items';\n        }\n        else if (typeof value === 'number' && !Number.isNaN(value)) {\n            measured = value;\n        }\n        if (measured !== null) {\n            if (rule.min !== undefined && measured < rule.min) {\n                return rule.message || `${name} must be at least ${rule.min}${unit}`;\n            }\n            if (rule.max !== undefined && measured > rule.max) {\n                return rule.message || `${name} must be no more than ${rule.max}${unit}`;\n            }\n        }\n    }\n    if (rule.pattern && typeof value === 'string' && !rule.pattern.test(value)) {\n        return rule.message || `${name} format is invalid`;\n    }\n    if (rule.enum && Array.isArray(rule.enum) && value) {\n        if (!rule.enum.includes(value)) {\n            return rule.message || `${name} must be one of ${rule.enum.join(', ')}`;\n        }\n    }\n    if (rule.type === 'number' && value !== undefined && value !== null && value !== '') {\n        if (typeof value !== 'number' || isNaN(value)) {\n            return rule.message || `${name} must be a number`;\n        }\n    }\n    if (rule.type === 'email' && value) {\n        const emailPattern = /^[^\\s@]+@[^\\s@]+\\.[^\\s@]+$/;\n        if (!emailPattern.test(String(value))) {\n            return rule.message || `${name} must be a valid email`;\n        }\n    }\n    if (rule.type === 'url' && value) {\n        try {\n            new URL(String(value));\n        }\n        catch (_a) {\n            return rule.message || `${name} must be a valid URL`;\n        }\n    }\n    return null;\n}\n/**\n * Synchronous rule run. A Promise-returning validator CANNOT be evaluated\n * here — it is deferred (treated as passing for this run; its rejection is\n * swallowed) and left to the async runs (blur/submit), which always await it.\n * Failing it instead would mis-report \"Validation failed\" on every keystroke\n * for perfectly valid input.\n */\nexport function runRulesSync(name, value, values, rules) {\n    let warning = null;\n    for (const rule of rules) {\n        let failure = checkBuiltinRules(rule, value, name);\n        if (failure === null && typeof rule.validator === 'function') {\n            try {\n                const result = rule.validator(value, values);\n                if (isThenable(result)) {\n                    result.then(undefined, () => { });\n                }\n                else if (result !== true) {\n                    failure = typeof result === 'string' ? result : 'Validation failed';\n                }\n            }\n            catch (err) {\n                failure = err instanceof Error ? err.message : 'Validation error';\n            }\n        }\n        if (failure !== null) {\n            if (rule.warningOnly) {\n                warning = warning !== null && warning !== void 0 ? warning : failure;\n            }\n            else {\n                return { error: failure, warning };\n            }\n        }\n    }\n    return { error: null, warning };\n}\n/**\n * Asynchronous rule run. Custom validators are awaited (sync or async). A\n * validator returning `undefined` is treated as passing.\n */\nexport function runRulesAsync(name, value, values, rules) {\n    return __awaiter(this, void 0, void 0, function* () {\n        let warning = null;\n        for (const rule of rules) {\n            let failure = checkBuiltinRules(rule, value, name);\n            if (failure === null && typeof rule.validator === 'function') {\n                try {\n                    const result = yield Promise.resolve(rule.validator(value, values));\n                    if (result !== true && result !== undefined) {\n                        failure = typeof result === 'string' ? result : 'Validation failed';\n                    }\n                }\n                catch (err) {\n                    failure = err instanceof Error ? err.message : 'Validation error';\n                }\n            }\n            if (failure !== null) {\n                if (rule.warningOnly) {\n                    warning = warning !== null && warning !== void 0 ? warning : failure;\n                }\n                else {\n                    return { error: failure, warning };\n                }\n            }\n        }\n        return { error: null, warning };\n    });\n}",null],"sourceRoot":"../../../../../../../../../../src"}
+//# sourceMappingURL=data:application/json;charset=utf8;base64,{"version":3,"sources":["components/ProForm/core/runRules.js","components/ProForm/src/components/ProForm/core/runRules.ts"],"names":["__awaiter","thisArg","_arguments","P","generator","adopt","value","resolve","Promise","reject","fulfilled","step","next","e","rejected","result","done","then","apply","resolveValue","devWarnOnce","isThenable","_typeof","isEmptyValue","undefined","Array","isArray","length","coerceFailureReason","reason","Error","message","resolveFailureMessage","rule","_a","resolveRules","rules","values","instance","some","ctx","Object","assign","getFieldValue","name","getFieldsValue","map","err","validator","normalizeTriggers","itemTrigger","formTrigger","effective","filterRulesByTrigger","trigger","activeTriggers","fieldName","includes","filter","ruleTrigger","validateTrigger","ruleTriggers","matches","t","concat","join","TYPE_CHECKS","string","v","number","Number","isNaN","boolean","method","integer","isInteger","float","array","object","date","Date","getTime","regexp","RegExp","hex","test","email","url","URL","typeFailureMessage","type","measureValue","measured","unit","checkBuiltinRules","required","whitespace","trim","len","m","min","max","pattern","global","sticky","lastIndex","toRuleArray","deepMembers","member","index","String","entries","PASS","error","warning","warnLegacyValidatorReturn","applyTransform","rawValue","transform","ok","failure","deepRuleEntries","fields","source","_i","_Object$entries","_Object$entries$_i","_slicedToArray","key","subRules","_iterator","_createForOfIteratorHelper","_step","s","n","subRule","push","f","defaultField","_iterator2","_step2","_step2$value","_iterator3","_step3","mergeSubResult","acc","sub","warningOnly","foldRuleResult","state","content","evalRuleSync","prep","resolved","_iterator4","_step4","_step4$value","subValue","subName","evalRuleAsync","_regeneratorRuntime","mark","_callee","_iterator5","_step5","_step5$value","_t","_t2","_t3","_t4","_t5","wrap","_context","prev","abrupt","sent","finish","stop","runRulesSync","_iterator6","_step6","runRulesAsync","_callee2","_iterator7","_step7","_t6","_t7","_context2"],"mappings":"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","file":"components/ProForm/core/runRules.js","sourcesContent":["var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {\n    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }\n    return new (P || (P = Promise))(function (resolve, reject) {\n        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }\n        function rejected(value) { try { step(generator[\"throw\"](value)); } catch (e) { reject(e); } }\n        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }\n        step((generator = generator.apply(thisArg, _arguments || [])).next());\n    });\n};\nimport { resolveValue } from './pathUtils';\nimport { devWarnOnce } from './devWarning';\nfunction isThenable(value) {\n    return (value !== null &&\n        typeof value === 'object' &&\n        typeof value.then === 'function');\n}\n/** Empty for `required`: undefined / null / '' / empty array. */\nfunction isEmptyValue(value) {\n    return (value === undefined ||\n        value === null ||\n        value === '' ||\n        (Array.isArray(value) && value.length === 0));\n}\n/**\n * Coerce a thrown/rejected reason into displayable failure content:\n * a non-empty Error.message or a non-empty plain string — otherwise null\n * (caller picks its fallback). Shared with the form-level last-resort nets.\n */\nexport function coerceFailureReason(reason) {\n    if (reason instanceof Error && reason.message)\n        return reason.message;\n    if (typeof reason === 'string' && reason)\n        return reason;\n    return null;\n}\n/**\n * Failure message for a rejected/thrown custom validator:\n * Error.message → plain string reason → rule.message → generic fallback.\n */\nfunction resolveFailureMessage(reason, rule) {\n    var _a;\n    return (_a = coerceFailureReason(reason)) !== null && _a !== void 0 ? _a : (rule.message || 'Validation failed');\n}\n/**\n * Resolve function-form rules into static rules. The\n * context exposes the value snapshot the run was invoked with; function rules\n * must be cheap and side-effect free — they may be resolved more than once\n * per validation pass.\n */\nexport function resolveRules(rules, values, instance) {\n    // Fast path: no function rules → nothing to resolve, no ctx allocation.\n    // This also makes the engine-internal re-resolution of already-resolved\n    // arrays free.\n    if (!rules.some((rule) => typeof rule === 'function')) {\n        return rules;\n    }\n    // Live-instance members (setFieldsValue, getFieldError, …) are spread in\n    // when available; the reads always come from the validation-time snapshot.\n    const ctx = Object.assign(Object.assign({}, instance), { getFieldValue: (name) => resolveValue(values, name), getFieldsValue: () => values });\n    return rules.map((rule) => {\n        if (typeof rule !== 'function')\n            return rule;\n        try {\n            return rule(ctx);\n        }\n        catch (err) {\n            // A throwing rule factory must not crash rendering or validation —\n            // surface it as a rule that always fails with the thrown reason.\n            return {\n                validator: () => {\n                    throw err;\n                },\n            };\n        }\n    });\n}\n/**\n * Normalize a form/item-level validateTrigger config into the effective\n * interactive event list: item-level (when present) overrides form-level;\n * `false` disables interactive validation entirely.\n */\nexport function normalizeTriggers(itemTrigger, formTrigger) {\n    const effective = itemTrigger === undefined ? formTrigger : itemTrigger;\n    if (effective === false)\n        return [];\n    return Array.isArray(effective) ? effective : [effective];\n}\n/**\n * Filter rules applicable to an interactive event: the event\n * validates only when it is in the item's effective trigger set. Within the\n * set, a rule WITHOUT `validateTrigger` runs on every event; a rule WITH one\n * runs only on matching events — so a rule trigger outside the item's set\n * never fires interactively. Submit-time validation bypasses this filter and\n * runs every rule.\n *\n * Dev guard: a rule whose (non-empty) trigger set is fully OUTSIDE the\n * active set can never fire interactively — usually a leftover of the\n * pre-0.0.76 override semantics, so it warns once. `validateTrigger: []`\n * is the deliberate submit-only idiom and stays silent.\n */\nexport function filterRulesByTrigger(rules, trigger, activeTriggers, fieldName) {\n    if (!activeTriggers.includes(trigger))\n        return [];\n    return rules.filter((rule) => {\n        const ruleTrigger = rule.validateTrigger;\n        if (ruleTrigger === undefined)\n            return true;\n        const ruleTriggers = Array.isArray(ruleTrigger) ? ruleTrigger : [ruleTrigger];\n        const matches = ruleTriggers.includes(trigger);\n        if (!matches &&\n            ruleTriggers.length > 0 &&\n            !ruleTriggers.some((t) => activeTriggers.includes(t))) {\n            const name = fieldName !== null && fieldName !== void 0 ? fieldName : '(unknown)';\n            devWarnOnce(`trigger:${name}:${ruleTriggers.join(',')}`, `[ProForm] Field \"${name}\": rule validateTrigger [${ruleTriggers.join(', ')}] is outside this field's active trigger set [${activeTriggers.join(', ')}] — the rule will only run on submit. Include it in the item/form validateTrigger to run it interactively.`);\n        }\n        return matches;\n    });\n}\n/** Built-in `type` checks. `enum` is handled separately against `rule.enum`. */\nconst TYPE_CHECKS = {\n    string: (v) => typeof v === 'string',\n    number: (v) => typeof v === 'number' && !Number.isNaN(v),\n    boolean: (v) => typeof v === 'boolean',\n    method: (v) => typeof v === 'function',\n    integer: (v) => typeof v === 'number' && Number.isInteger(v),\n    float: (v) => typeof v === 'number' && !Number.isNaN(v) && !Number.isInteger(v),\n    array: (v) => Array.isArray(v),\n    object: (v) => typeof v === 'object' && v !== null && !Array.isArray(v),\n    date: (v) => v instanceof Date\n        ? !Number.isNaN(v.getTime())\n        : typeof (v === null || v === void 0 ? void 0 : v.getTime) === 'function' &&\n            !Number.isNaN(v.getTime()),\n    regexp: (v) => {\n        if (v instanceof RegExp)\n            return true;\n        if (typeof v !== 'string')\n            return false;\n        try {\n            new RegExp(v);\n            return true;\n        }\n        catch (_a) {\n            return false;\n        }\n    },\n    hex: (v) => typeof v === 'string' && /^#?([a-f0-9]{6}|[a-f0-9]{3})$/i.test(v),\n    // String-only: coercing via String() would let e.g. ['a@b.co'] stringify\n    // into a passing value.\n    email: (v) => typeof v === 'string' && /^[^\\s@]+@[^\\s@]+\\.[^\\s@]+$/.test(v),\n    url: (v) => {\n        if (typeof v !== 'string')\n            return false;\n        try {\n            new URL(v);\n            return true;\n        }\n        catch (_a) {\n            return false;\n        }\n    },\n};\n/** Friendly generated messages for the legacy type names; others get a generic one. */\nfunction typeFailureMessage(name, type) {\n    if (type === 'number')\n        return `${name} must be a number`;\n    if (type === 'email')\n        return `${name} must be a valid email`;\n    if (type === 'url')\n        return `${name} must be a valid URL`;\n    return `${name} is not a valid ${type}`;\n}\n/** Measure a value for len/min/max: string → length, array → count, number → value. */\nfunction measureValue(value) {\n    if (typeof value === 'string')\n        return { measured: value.length, unit: ' characters' };\n    if (Array.isArray(value))\n        return { measured: value.length, unit: ' items' };\n    if (typeof value === 'number' && !Number.isNaN(value))\n        return { measured: value, unit: '' };\n    return null;\n}\n/**\n * Evaluate every built-in (non-`validator`) rule kind for a single rule.\n * Returns the error content for the first failing check, or null.\n *\n * Empty values (undefined / null / '' / empty array) are only checked by\n * `required` — every other builtin check is skipped, so optional fields\n * don't error until they have content. Custom validators are NOT subject to\n * this skip (they receive the empty value and decide themselves).\n */\nfunction checkBuiltinRules(rule, value, name) {\n    if (rule.required && isEmptyValue(value)) {\n        return rule.message || `${name} is required`;\n    }\n    if (isEmptyValue(value))\n        return null;\n    // Non-empty string of only whitespace (the required+whitespace trim idiom).\n    if (rule.whitespace && typeof value === 'string' && value.trim() === '') {\n        return rule.message || `${name} cannot be blank`;\n    }\n    // len: exact length/count/value — takes precedence over min/max.\n    if (rule.len !== undefined) {\n        const m = measureValue(value);\n        if (m !== null && m.measured !== rule.len) {\n            return rule.message || `${name} must be exactly ${rule.len}${m.unit}`;\n        }\n    }\n    else if (rule.min !== undefined || rule.max !== undefined) {\n        const m = measureValue(value);\n        if (m !== null) {\n            if (rule.min !== undefined && m.measured < rule.min) {\n                return rule.message || `${name} must be at least ${rule.min}${m.unit}`;\n            }\n            if (rule.max !== undefined && m.measured > rule.max) {\n                return rule.message || `${name} must be no more than ${rule.max}${m.unit}`;\n            }\n        }\n    }\n    if (rule.pattern && typeof value === 'string') {\n        // A /g or /y regex is stateful: lastIndex persists across .test() calls,\n        // so repeated runs would alternate pass/fail — reset it every run.\n        if (rule.pattern.global || rule.pattern.sticky)\n            rule.pattern.lastIndex = 0;\n        if (!rule.pattern.test(value)) {\n            return rule.message || `${name} format is invalid`;\n        }\n    }\n    if (rule.type && rule.type !== 'enum' && !TYPE_CHECKS[rule.type](value)) {\n        return rule.message || typeFailureMessage(name, rule.type);\n    }\n    // enum membership: applies for type 'enum' or whenever rule.enum is present.\n    if (rule.enum && Array.isArray(rule.enum) && !rule.enum.includes(value)) {\n        return rule.message || `${name} must be one of ${rule.enum.join(', ')}`;\n    }\n    return null;\n}\nfunction toRuleArray(rules) {\n    if (!rules)\n        return [];\n    return Array.isArray(rules) ? rules : [rules];\n}\n/** Members for deep rules: array → indexed entries, plain object → key entries. */\nfunction deepMembers(value) {\n    if (Array.isArray(value))\n        return value.map((member, index) => [String(index), member]);\n    if (value && typeof value === 'object')\n        return Object.entries(value);\n    return [];\n}\nconst PASS = { error: null, warning: null };\n/**\n * Dev guard for the pre-0.0.76 validator contract: returning a string or\n * `false` used to FAIL the rule — under the `(rule, value)` contract return\n * values are ignored and only throw/reject fails. Such a return is almost\n * certainly a legacy validator silently passing, so it warns once.\n */\nfunction warnLegacyValidatorReturn(name, result) {\n    if (typeof result !== 'string' && result !== false)\n        return;\n    devWarnOnce(`validator-return:${name}`, `[ProForm] Field \"${name}\": a custom validator returned ${typeof result === 'string' ? 'a string' : 'false'} — return values are IGNORED; validators fail by throwing or rejecting (a thrown Error's message becomes the field error).`);\n}\n/** Run a rule's transform, containing throws as a rule failure. */\nfunction applyTransform(rule, rawValue) {\n    if (typeof rule.transform !== 'function')\n        return { ok: true, value: rawValue };\n    try {\n        return { ok: true, value: rule.transform(rawValue) };\n    }\n    catch (err) {\n        return { ok: false, failure: resolveFailureMessage(err, rule) };\n    }\n}\n/**\n * Flatten a rule's deep sources (`fields` per key, then `defaultField` per\n * member) into [subRule, memberValue, memberName] tuples — the single place\n * that knows how deep rules map onto a container value.\n */\nfunction deepRuleEntries(rule, value, name) {\n    const entries = [];\n    if (rule.fields) {\n        const source = value;\n        for (const [key, subRules] of Object.entries(rule.fields)) {\n            for (const subRule of toRuleArray(subRules)) {\n                entries.push([subRule, source[key], `${name}.${key}`]);\n            }\n        }\n    }\n    if (rule.defaultField) {\n        for (const [key, member] of deepMembers(value)) {\n            for (const subRule of toRuleArray(rule.defaultField)) {\n                entries.push([subRule, member, `${name}.${key}`]);\n            }\n        }\n    }\n    return entries;\n}\n/**\n * Merge a sub-rule's outcome into the parent's channels. A sub-rule flagged\n * `warningOnly` contributes its failure as a WARNING; otherwise its error\n * blocks. Returns true when a blocking error landed (stop walking).\n */\nfunction mergeSubResult(acc, subRule, sub) {\n    if (sub.warning !== null && acc.warning === null)\n        acc.warning = sub.warning;\n    if (sub.error !== null) {\n        if (subRule.warningOnly) {\n            if (acc.warning === null)\n                acc.warning = sub.error;\n        }\n        else {\n            acc.error = sub.error;\n            return true;\n        }\n    }\n    return false;\n}\n/**\n * Fold one rule's outcome into the run-level channels. A rule flagged\n * `warningOnly` downgrades everything it produced (own checks AND deep\n * sub-rules) to a warning. Returns the blocking error to surface, or null.\n */\nfunction foldRuleResult(rule, result, state) {\n    var _a;\n    if (rule.warningOnly) {\n        const content = (_a = result.error) !== null && _a !== void 0 ? _a : result.warning;\n        if (content !== null && state.warning === null)\n            state.warning = content;\n        return null;\n    }\n    if (result.warning !== null && state.warning === null)\n        state.warning = result.warning;\n    return result.error;\n}\n/**\n * Evaluate ONE rule (transform → builtin checks → validator → deep rules)\n * synchronously. Promise-returning validators are deferred (see runRulesSync).\n */\nfunction evalRuleSync(rule, rawValue, name) {\n    const prep = applyTransform(rule, rawValue);\n    if (!prep.ok)\n        return { error: prep.failure, warning: null };\n    const value = prep.value;\n    let failure = checkBuiltinRules(rule, value, name);\n    if (failure === null && typeof rule.validator === 'function') {\n        try {\n            const result = rule.validator(rule, value);\n            if (isThenable(result)) {\n                result.then((resolved) => warnLegacyValidatorReturn(name, resolved), () => { });\n            }\n            else {\n                warnLegacyValidatorReturn(name, result);\n            }\n        }\n        catch (err) {\n            failure = resolveFailureMessage(err, rule);\n        }\n    }\n    if (failure !== null)\n        return { error: failure, warning: null };\n    if ((rule.fields || rule.defaultField) && !isEmptyValue(value)) {\n        // Deep rules need a container; a non-empty primitive fails the PARENT\n        // (clear attribution) instead of producing confusing child errors.\n        if (typeof value !== 'object' || value === null) {\n            return { error: rule.message || `${name} must be an object or an array`, warning: null };\n        }\n        const acc = { error: null, warning: null };\n        for (const [subRule, subValue, subName] of deepRuleEntries(rule, value, name)) {\n            if (mergeSubResult(acc, subRule, evalRuleSync(subRule, subValue, subName)))\n                break;\n        }\n        return acc;\n    }\n    return PASS;\n}\n/** Async counterpart of evalRuleSync — custom validators are awaited. */\nfunction evalRuleAsync(rule, rawValue, name) {\n    return __awaiter(this, void 0, void 0, function* () {\n        const prep = applyTransform(rule, rawValue);\n        if (!prep.ok)\n            return { error: prep.failure, warning: null };\n        const value = prep.value;\n        let failure = checkBuiltinRules(rule, value, name);\n        if (failure === null && typeof rule.validator === 'function') {\n            try {\n                const result = (yield rule.validator(rule, value));\n                warnLegacyValidatorReturn(name, result);\n            }\n            catch (err) {\n                failure = resolveFailureMessage(err, rule);\n            }\n        }\n        if (failure !== null)\n            return { error: failure, warning: null };\n        if ((rule.fields || rule.defaultField) && !isEmptyValue(value)) {\n            // Deep rules need a container; a non-empty primitive fails the PARENT\n            // (clear attribution) instead of producing confusing child errors.\n            if (typeof value !== 'object' || value === null) {\n                return { error: rule.message || `${name} must be an object or an array`, warning: null };\n            }\n            const acc = { error: null, warning: null };\n            for (const [subRule, subValue, subName] of deepRuleEntries(rule, value, name)) {\n                if (mergeSubResult(acc, subRule, yield evalRuleAsync(subRule, subValue, subName)))\n                    break;\n            }\n            return acc;\n        }\n        return PASS;\n    });\n}\n/**\n * Synchronous rule run. A Promise-returning validator CANNOT be evaluated\n * here — it is deferred (treated as passing for this run; its rejection is\n * swallowed) and left to the async runs (blur/submit), which always await it.\n * Failing it instead would mis-report \"Validation failed\" on every keystroke\n * for perfectly valid input.\n *\n * The per-rule try/catch is the engine's totality choke point: NO input —\n * including exotic values that break a builtin check — may escape as a throw;\n * every failure surfaces through the error/warning channels.\n */\nexport function runRulesSync(name, value, values, rules, instance) {\n    const state = { warning: null };\n    for (const rule of resolveRules(rules, values, instance)) {\n        let result;\n        try {\n            result = evalRuleSync(rule, value, name);\n        }\n        catch (err) {\n            result = { error: resolveFailureMessage(err, rule), warning: null };\n        }\n        const error = foldRuleResult(rule, result, state);\n        if (error !== null)\n            return { error, warning: state.warning };\n    }\n    return { error: null, warning: state.warning };\n}\n/**\n * Asynchronous rule run. Custom validators are awaited (sync or async):\n * resolving passes, rejecting/throwing fails. Return values are ignored.\n * Shares the totality choke point with runRulesSync.\n */\nexport function runRulesAsync(name, value, values, rules, instance) {\n    return __awaiter(this, void 0, void 0, function* () {\n        const state = { warning: null };\n        for (const rule of resolveRules(rules, values, instance)) {\n            let result;\n            try {\n                result = yield evalRuleAsync(rule, value, name);\n            }\n            catch (err) {\n                result = { error: resolveFailureMessage(err, rule), warning: null };\n            }\n            const error = foldRuleResult(rule, result, state);\n            if (error !== null)\n                return { error, warning: state.warning };\n        }\n        return { error: null, warning: state.warning };\n    });\n}",null],"sourceRoot":"../../../../../../../../../../src"}