react-f0rm 1.1.0 → 1.2.0

package/dist/index.umd.js

@@ -23,6 +23,67 @@
 
   var React__namespace = /*#__PURE__*/_interopNamespaceDefault(React);
 
+  function _arrayLikeToArray(r, a) {
+    (null == a || a > r.length) && (a = r.length);
+    for (var e = 0, n = Array(a); e < a; e++) n[e] = r[e];
+    return n;
+  }
+  function _createForOfIteratorHelper(r, e) {
+    var t = "undefined" != typeof Symbol && r[Symbol.iterator] || r["@@iterator"];
+    if (!t) {
+      if (Array.isArray(r) || (t = _unsupportedIterableToArray(r)) || e) {
+        t && (r = t);
+        var n = 0,
+          F = function () {};
+        return {
+          s: F,
+          n: function () {
+            return n >= r.length ? {
+              done: true
+            } : {
+              done: false,
+              value: r[n++]
+            };
+          },
+          e: function (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 = true,
+      u = false;
+    return {
+      s: function () {
+        t = t.call(r);
+      },
+      n: function () {
+        var r = t.next();
+        return a = r.done, r;
+      },
+      e: function (r) {
+        u = true, o = r;
+      },
+      f: function () {
+        try {
+          a || null == t.return || t.return();
+        } finally {
+          if (u) throw o;
+        }
+      }
+    };
+  }
+  function _unsupportedIterableToArray(r, a) {
+    if (r) {
+      if ("string" == typeof r) return _arrayLikeToArray(r, a);
+      var t = {}.toString.call(r).slice(8, -1);
+      return "Object" === t && r.constructor && (t = r.constructor.name), "Map" === t || "Set" === t ? Array.from(r) : "Arguments" === t || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(t) ? _arrayLikeToArray(r, a) : void 0;
+    }
+  }
+
   function getSet(ee, key) {
     var set = ee.get(key);
     if (set) return set;
@@ -30,31 +91,101 @@
     ee.set(key, newSet);
     return newSet;
   }
+
+  // DEV-only listener-leak warning. Checked via process.env.NODE_ENV because the
+  // build pipeline has no compile-time constant injection; the typeof guard
+  // keeps direct browser usage of the UMD build safe. In production the whole
+  // machinery is skipped and `on` only pays one boolean test.
+  var DEV = typeof process !== 'undefined' && process.env && process.env.NODE_ENV !== 'production';
+  var DEFAULT_MAX_LISTENERS = 10;
+  var maxListenersMap = new WeakMap();
+  var warnedKeysMap = new WeakMap();
+  function _setMaxListeners(ee, n) {
+    maxListenersMap.set(ee, n);
+  }
+  function checkMaxListeners(ee, key, size) {
+    var max = maxListenersMap.get(ee);
+    if (max === undefined) max = DEFAULT_MAX_LISTENERS;
+    if (max <= 0 || size <= max) return;
+    var warnedKeys = warnedKeysMap.get(ee);
+    if (!warnedKeys) {
+      warnedKeys = new Set();
+      warnedKeysMap.set(ee, warnedKeys);
+    }
+    if (warnedKeys.has(key)) return;
+    warnedKeys.add(key);
+    // eslint-disable-next-line no-console
+    console.warn("Possible event-emitter memory leak: ".concat(size, " \"").concat(String(key), "\" listeners added. ") + "Use setMaxListeners(ee, n) to raise the limit, or 0 to disable this warning.");
+  }
+  var errorEvent = Symbol('error');
   function create$2() {
     return new Map();
   }
+
+  // A throwing handler must not stop its peers: errors are collected while the
+  // remaining handlers still run, then reported through emitError (the
+  // errorEvent channel). If no error handler is subscribed either, the first
+  // collected error is rethrown to the emit caller instead of being swallowed.
+  // Iteration follows Set semantics: a listener added while this emit runs is
+  // still visited by that same emit, and a listener removed before it is
+  // visited is skipped. Removing a whole key (off/removeAllListeners) does not
+  // affect an emit already in flight.
   function emit(ee, key) {
     for (var _len = arguments.length, args = new Array(_len > 2 ? _len - 2 : 0), _key = 2; _key < _len; _key++) {
       args[_key - 2] = arguments[_key];
     }
-    (ee.get(key) || []).forEach(function (h) {
-      return h.apply(void 0, args);
+    var set = ee.get(key);
+    if (!set || !set.size) return;
+    var errors;
+    set.forEach(function (h) {
+      try {
+        h.apply(void 0, args);
+      } catch (err) {
+        if (errors) errors.push(err);else errors = [err];
+      }
+    });
+    if (errors) {
+      var _iterator = _createForOfIteratorHelper(errors),
+        _step;
+      try {
+        for (_iterator.s(); !(_step = _iterator.n()).done;) {
+          var err = _step.value;
+          emitError(ee, err);
+        }
+      } catch (err) {
+        _iterator.e(err);
+      } finally {
+        _iterator.f();
+      }
+    }
+  }
+  function emitError(ee, err) {
+    var handlerSet = ee.get(errorEvent);
+    if (!handlerSet || !handlerSet.size) throw err;
+    handlerSet.forEach(function (h) {
+      return h(err);
     });
   }
   function on(ee, key, handler) {
     var set = getSet(ee, key);
     set.add(handler);
+    if (DEV) checkMaxListeners(ee, key, set.size);
     return function () {
       return set.delete(handler);
     };
   }
 
+  const PATH_CACHE_LIMIT = 1e4;
   const pathCache = /* @__PURE__ */ new Map();
   function normalizePath(path) {
     if (Array.isArray(path)) return path;
     const cached = pathCache.get(path);
     if (cached) return cached;
     const value = parsePath(path);
+    if (pathCache.size >= PATH_CACHE_LIMIT) {
+      const oldest = pathCache.keys().next();
+      if (!oldest.done) pathCache.delete(oldest.value);
+    }
     pathCache.set(path, value);
     return value;
   }
@@ -225,110 +356,59 @@
     return { value, key: JSON.stringify(value) };
   }
 
-  const VALIDATION_OUTCOME = /* @__PURE__ */ Symbol("validation-outcome");
-  function create(options) {
-    const emitter = create$2();
-    return {
-      emitter,
-      ...options,
-      mode: options?.mode ?? "onSubmit",
-      reValidateMode: options?.reValidateMode ?? "onChange",
-      disabled: options?.disabled ?? false,
-      validateDeps: options?.validateDeps ? new Set(options.validateDeps.map((dep) => create$1(dep).key)) : void 0,
-      initialValues: options?.initialValues ?? {},
-      values: /* @__PURE__ */ new Map(),
-      deleted: /* @__PURE__ */ new Set(),
-      errors: /* @__PURE__ */ new Map(),
-      touched: /* @__PURE__ */ new Set(),
-      validators: /* @__PURE__ */ new Map(),
-      changeHandlers: /* @__PURE__ */ new Map(),
-      validating: /* @__PURE__ */ new Set(),
-      parsedValues: void 0,
-      isSubmitting: false,
-      submitCount: 0,
-      isSubmitSuccessful: void 0
-    };
-  }
   const valuesCaches = /* @__PURE__ */ new WeakMap();
   function bumpValuesVersion(form) {
     const cache = valuesCaches.get(form);
     if (cache) cache.version++;
   }
-  function getValues(form) {
-    let cache = valuesCaches.get(form);
-    if (!cache) {
-      cache = { version: 0, result: computeValues(form) };
-      valuesCaches.set(form, cache);
-    } else if (cache.version > 0) {
-      cache.result = computeValues(form);
-      cache.version = 0;
-    }
-    return cache.result;
+  const dirtyBaselines = /* @__PURE__ */ new WeakMap();
+  function getDirtyBaseline(form, key, segments) {
+    const baselines = dirtyBaselines.get(form);
+    if (baselines?.has(key)) return baselines.get(key);
+    return get(form.initialValues, segments);
   }
-  function computeValues(form) {
-    const { initialValues, parsedValues, values, deleted } = form;
-    const owned = /* @__PURE__ */ new Set();
-    let merged = parsedValues ?? initialValues;
-    for (const [key, value] of values) {
-      merged = setOwned(merged, JSON.parse(key), value, owned);
-    }
-    for (const key of deleted) {
-      merged = unset(merged, JSON.parse(key));
+  function setDirtyBaseline(form, { key }, value) {
+    let baselines = dirtyBaselines.get(form);
+    if (!baselines) {
+      baselines = /* @__PURE__ */ new Map();
+      dirtyBaselines.set(form, baselines);
     }
-    return merged;
-  }
-  function getValue(form, name) {
-    return getValueByPath(form, create$1(name));
+    baselines.set(key, value);
   }
-  function getValueByPath({ initialValues, parsedValues, values, deleted }, path) {
-    const { key, value: segments } = path;
-    if (values.has(key)) return values.get(key);
-    if (deleted.has(key)) return void 0;
-    for (let i = segments.length - 1; i > 0; i--) {
-      const ancestorKey = JSON.stringify(segments.slice(0, i));
-      if (values.has(ancestorKey)) {
-        return get(values.get(ancestorKey), segments.slice(i));
-      }
+  function pruneDirtyBaselines(form, { key }) {
+    const baselines = dirtyBaselines.get(form);
+    if (!baselines?.size) return;
+    const stem = `${key.slice(0, -1)},`;
+    for (const baselineKey of baselines.keys()) {
+      if (baselineKey.startsWith(stem)) baselines.delete(baselineKey);
     }
-    return get(parsedValues ?? initialValues, segments);
   }
-  function setValue(form, name, value, options) {
-    setValueByPath(form, create$1(name), value, options);
-  }
-  function setValueByPath(form, path, value, options) {
-    const { emitter, values, deleted } = form;
-    values.set(path.key, value);
-    pruneDescendantKeys(values, path);
-    reviveBranch(deleted, path);
-    pruneDirtyBaselines(form, path);
-    if (options?.shouldDirty === false) setDirtyBaseline(form, path, value);
-    bumpDirtyVersion(form);
-    bumpValuesVersion(form);
-    if (options?.shouldTouch) setTouchedByPath(form, path);
-    if (options?.shouldValidate) form.validators.get(path.key)?.();
-    emit(emitter, "change", path);
+  function clearDirtyBaselines(form, key) {
+    const baselines = dirtyBaselines.get(form);
+    if (!baselines) return;
+    if (key === void 0) baselines.clear();
+    else baselines.delete(key);
   }
-  function seedValueByPath(form, path, value) {
-    const { values, deleted } = form;
-    values.set(path.key, value);
-    pruneDescendantKeys(values, path);
-    reviveBranch(deleted, path);
-    pruneDirtyBaselines(form, path);
-    bumpDirtyVersion(form);
-    bumpValuesVersion(form);
+  const dirtyFieldsCaches = /* @__PURE__ */ new WeakMap();
+  function bumpDirtyVersion(form) {
+    const cache = dirtyFieldsCaches.get(form);
+    if (cache) cache.version++;
   }
-  function emitChangeByPath({ emitter }, path) {
-    emit(emitter, "change", path);
+  function isSegmentsPath(name) {
+    return name.some((part) => typeof part === "number");
   }
-  function changeValue(form, name, value, options) {
-    changeValueByPath(form, create$1(name), value, options);
+  function isFieldError(value) {
+    return !!value && typeof value === "object" && typeof value.type === "string" && typeof value.message === "string";
   }
-  function changeValueByPath(form, path, value, options) {
-    if (options?.shouldDirty === false) setDirtyBaseline(form, path, value);
-    const change = form.changeHandlers.get(path.key);
-    if (change) change(value);
-    else setValueByPath(form, path, value, options);
+  function setParsedValues(form, values) {
+    if (values === void 0 || values === form.parsedValues) return;
+    form.parsedValues = values;
+    bumpValuesVersion(form);
+    emit(form.emitter, "change");
   }
+
+  const FORM_ERROR = "_form";
+  const VALIDATION_OUTCOME = /* @__PURE__ */ Symbol("validation-outcome");
   function getError(form, name) {
     return getErrorByPath(form, create$1(name));
   }
@@ -353,29 +433,6 @@
   function getFirstError({ errors }) {
     return errors.values().next().value?.[0]?.message;
   }
-  function getFieldState(form, name) {
-    const path = create$1(name);
-    const { values, touched, validating } = form;
-    const live = values.get(path.key);
-    return {
-      value: getValueByPath(form, path),
-      error: getErrorByPath(form, path),
-      errors: getFieldErrorsByPath(form, path),
-      // Same rule as getDirtyFields, committed baselines included: the field
-      // is dirty while its live value differs from its effective baseline.
-      isDirty: values.has(path.key) && getDirtyBaseline(form, path.key, path.value) !== live,
-      isTouched: touched.has(path.key),
-      isValidating: validating.has(path.key)
-    };
-  }
-  function unsetValidatingByPath({ emitter, validating }, path) {
-    validating.delete(path.key);
-    emit(emitter, "validating", path);
-  }
-  function setValidatingByPath({ emitter, validating }, path) {
-    validating.add(path.key);
-    emit(emitter, "validating", path);
-  }
   function setError(form, name, error) {
     setErrorByPath(form, create$1(name), error);
   }
@@ -425,6 +482,10 @@
       );
     }
   }
+  function hasErrors({ errors }) {
+    return errors.size > 0;
+  }
+
   function setTouched(form, name) {
     setTouchedByPath(form, create$1(name));
   }
@@ -439,97 +500,111 @@
   function hasTouchedByPath({ touched }, path) {
     return touched.has(path.key);
   }
-  function isDirty(form) {
-    let dirty = false;
-    forEachDirtyField(form, () => {
-      dirty = true;
-    });
-    return dirty;
-  }
-  function forEachDirtyField(form, fn) {
-    for (const [key, value] of form.values) {
-      const path = JSON.parse(key);
-      if (getDirtyBaseline(form, key, path) !== value) fn(path.join("."));
-    }
+  function getTouchedFields({ touched }) {
+    return Array.from(
+      touched,
+      (key) => JSON.parse(key).join(".")
+    );
   }
-  const dirtyBaselines = /* @__PURE__ */ new WeakMap();
-  function getDirtyBaseline(form, key, segments) {
-    const baselines = dirtyBaselines.get(form);
-    if (baselines?.has(key)) return baselines.get(key);
-    return get(form.initialValues, segments);
+  function isTouched({ touched }) {
+    return touched.size > 0;
   }
-  function setDirtyBaseline(form, { key }, value) {
-    let baselines = dirtyBaselines.get(form);
-    if (!baselines) {
-      baselines = /* @__PURE__ */ new Map();
-      dirtyBaselines.set(form, baselines);
+
+  function getValues(form) {
+    let cache = valuesCaches.get(form);
+    if (!cache) {
+      cache = { version: 0, result: computeValues(form) };
+      valuesCaches.set(form, cache);
+    } else if (cache.version > 0) {
+      cache.result = computeValues(form);
+      cache.version = 0;
     }
-    baselines.set(key, value);
+    return cache.result;
   }
-  function pruneDirtyBaselines(form, { key }) {
-    const baselines = dirtyBaselines.get(form);
-    if (!baselines?.size) return;
-    const stem = `${key.slice(0, -1)},`;
-    for (const baselineKey of baselines.keys()) {
-      if (baselineKey.startsWith(stem)) baselines.delete(baselineKey);
+  function computeValues(form) {
+    const { initialValues, parsedValues, values, deleted } = form;
+    const owned = /* @__PURE__ */ new Set();
+    let merged = parsedValues ?? initialValues;
+    for (const [key, value] of values) {
+      merged = setOwned(merged, JSON.parse(key), value, owned);
     }
+    for (const key of deleted) {
+      merged = unset(merged, JSON.parse(key));
+    }
+    return merged;
   }
-  function clearDirtyBaselines(form, key) {
-    const baselines = dirtyBaselines.get(form);
-    if (!baselines) return;
-    if (key === void 0) baselines.clear();
-    else baselines.delete(key);
+  function getValue(form, name) {
+    return getValueByPath(form, create$1(name));
   }
-  const dirtyFieldsCaches = /* @__PURE__ */ new WeakMap();
-  function bumpDirtyVersion(form) {
-    const cache = dirtyFieldsCaches.get(form);
-    if (cache) cache.version++;
+  function getValueByPath({ initialValues, parsedValues, values, deleted }, path) {
+    const { key, value: segments } = path;
+    if (values.has(key)) return values.get(key);
+    if (deleted.has(key)) return void 0;
+    for (let i = segments.length - 1; i > 0; i--) {
+      const ancestorKey = JSON.stringify(segments.slice(0, i));
+      if (values.has(ancestorKey)) {
+        return get(values.get(ancestorKey), segments.slice(i));
+      }
+    }
+    return get(parsedValues ?? initialValues, segments);
   }
-  function computeDirtyFields(form) {
-    const dirtyFields = {};
-    forEachDirtyField(form, (key) => {
-      dirtyFields[key] = true;
-    });
-    return dirtyFields;
+  function setValue(form, name, value, options) {
+    setValueByPath(form, create$1(name), value, options);
   }
-  function sameDirtyKeys(a, b) {
-    const aKeys = Object.keys(a);
-    if (aKeys.length !== Object.keys(b).length) return false;
-    return aKeys.every((key) => b[key] === true);
+  function setValueByPath(form, path, value, options) {
+    const { emitter, values, deleted } = form;
+    values.set(path.key, value);
+    pruneDescendantKeys(values, path);
+    reviveBranch(deleted, path);
+    pruneDirtyBaselines(form, path);
+    if (options?.shouldDirty === false) setDirtyBaseline(form, path, value);
+    bumpDirtyVersion(form);
+    bumpValuesVersion(form);
+    if (options?.shouldTouch) setTouchedByPath(form, path);
+    if (options?.shouldValidate) form.validators.get(path.key)?.();
+    emit(emitter, "change", path);
   }
-  function getDirtyFields(form) {
-    let cache = dirtyFieldsCaches.get(form);
-    if (!cache) {
-      cache = { version: 0, result: computeDirtyFields(form) };
-      dirtyFieldsCaches.set(form, cache);
-    } else if (cache.version > 0) {
-      const result = computeDirtyFields(form);
-      if (!sameDirtyKeys(cache.result, result)) cache.result = result;
-      cache.version = 0;
-    }
-    return cache.result;
+  function seedValueByPath(form, path, value) {
+    const { values, deleted } = form;
+    values.set(path.key, value);
+    pruneDescendantKeys(values, path);
+    reviveBranch(deleted, path);
+    pruneDirtyBaselines(form, path);
+    bumpDirtyVersion(form);
+    bumpValuesVersion(form);
   }
-  function getTouchedFields({ touched }) {
-    return Array.from(
-      touched,
-      (key) => JSON.parse(key).join(".")
-    );
+  function emitChangeByPath({ emitter }, path) {
+    emit(emitter, "change", path);
   }
-  function isTouched({ touched }) {
-    return touched.size > 0;
+  function getFieldState(form, name) {
+    const path = create$1(name);
+    const { values, touched, validating } = form;
+    const live = values.get(path.key);
+    return {
+      value: getValueByPath(form, path),
+      error: getErrorByPath(form, path),
+      errors: getFieldErrorsByPath(form, path),
+      // Same rule as getDirtyFields, committed baselines included: the field
+      // is dirty while its live value differs from its effective baseline.
+      isDirty: values.has(path.key) && getDirtyBaseline(form, path.key, path.value) !== live,
+      isTouched: touched.has(path.key),
+      isValidating: validating.has(path.key)
+    };
   }
-  function removeField(form, name) {
-    removeFieldByPath(form, create$1(name));
+  function removeField(form, name, options) {
+    removeFieldByPath(form, create$1(name), options);
   }
-  function removeFieldByPath(form, path) {
+  function removeFieldByPath(form, path, options) {
     const { key, value: segments } = path;
     const { emitter, values, touched, errors, validating, deleted } = form;
-    values.delete(key);
-    touched.delete(key);
-    errors.delete(key);
+    if (!options?.keepValue && !options?.keepDirty) {
+      values.delete(key);
+      clearDirtyBaselines(form, key);
+      if (!hasLiveBranch(values, segments)) deleted.add(key);
+    }
+    if (!options?.keepTouched) touched.delete(key);
+    if (!options?.keepError) errors.delete(key);
     validating.delete(key);
-    clearDirtyBaselines(form, key);
-    if (!hasLiveBranch(values, segments)) deleted.add(key);
     bumpDirtyVersion(form);
     bumpValuesVersion(form);
     emit(emitter, "change", path);
@@ -575,17 +650,37 @@
     bumpValuesVersion(form);
     emit(form.emitter, "change");
   }
+  function collectValueLeaves(node, segments, out) {
+    if (node !== null && typeof node === "object") {
+      if (Array.isArray(node)) {
+        for (let i = 0; i < node.length; i++) {
+          collectValueLeaves(node[i], [...segments, i], out);
+        }
+        return;
+      }
+      const keys = Object.keys(node);
+      if (keys.length > 0) {
+        for (const k of keys) {
+          collectValueLeaves(node[k], [...segments, k], out);
+        }
+        return;
+      }
+    }
+    out.push({ segments, value: node });
+  }
   function reset(form, initialValues, options) {
-    const dirtyValues = [];
-    if (options?.keepDirtyValues) {
+    const keptValues = [];
+    if (options?.keepValues) {
+      collectValueLeaves(getValues(form), [], keptValues);
+    } else if (options?.keepDirtyValues) {
       for (const [key, value] of form.values) {
         const segments = JSON.parse(key);
         if (getDirtyBaseline(form, key, segments) !== value) {
-          dirtyValues.push({ segments, value });
+          keptValues.push({ segments, value });
         }
       }
     }
-    form.initialValues = initialValues;
+    form.initialValues = options?.keepDefaultValues ? form.initialValues : initialValues ?? form.initialValues;
     form.parsedValues = void 0;
     if (!options?.keepErrors) clearErrors(form);
     const { emitter, touched, values, deleted, validating } = form;
@@ -599,7 +694,7 @@
     if (!options?.keepIsSubmitted) form.isSubmitSuccessful = void 0;
     bumpDirtyVersion(form);
     bumpValuesVersion(form);
-    for (const { segments, value } of dirtyValues) {
+    for (const { segments, value } of keptValues) {
       setValueByPath(form, create$1(segments), value);
     }
     emit(emitter, "change");
@@ -634,10 +729,172 @@
     bumpDirtyVersion(form);
     bumpValuesVersion(form);
   }
-  function hasErrors({ errors }) {
-    return errors.size > 0;
+
+  function isDirty(form) {
+    let dirty = false;
+    forEachDirtyField(form, () => {
+      dirty = true;
+    });
+    return dirty;
+  }
+  function forEachDirtyField(form, fn) {
+    for (const [key, value] of form.values) {
+      const path = JSON.parse(key);
+      if (getDirtyBaseline(form, key, path) !== value) fn(path.join("."));
+    }
+  }
+  function computeDirtyFields(form) {
+    const dirtyFields = {};
+    forEachDirtyField(form, (key) => {
+      dirtyFields[key] = true;
+    });
+    return dirtyFields;
+  }
+  function sameDirtyKeys(a, b) {
+    const aKeys = Object.keys(a);
+    if (aKeys.length !== Object.keys(b).length) return false;
+    return aKeys.every((key) => b[key] === true);
+  }
+  function getDirtyFields(form) {
+    let cache = dirtyFieldsCaches.get(form);
+    if (!cache) {
+      cache = { version: 0, result: computeDirtyFields(form) };
+      dirtyFieldsCaches.set(form, cache);
+    } else if (cache.version > 0) {
+      const result = computeDirtyFields(form);
+      if (!sameDirtyKeys(cache.result, result)) cache.result = result;
+      cache.version = 0;
+    }
+    return cache.result;
+  }
+
+  function unsetValidatingByPath({ emitter, validating }, path) {
+    validating.delete(path.key);
+    emit(emitter, "validating", path);
+  }
+  function setValidatingByPath({ emitter, validating }, path) {
+    validating.add(path.key);
+    emit(emitter, "validating", path);
+  }
+  function registerValidatorByPath(form, path, registration) {
+    let timer = null;
+    let controller = null;
+    let marked = false;
+    let lock = null;
+    let errorSource = null;
+    const hasErrors2 = (errors) => errors !== void 0 && !(Array.isArray(errors) && errors.length === 0);
+    const mark = () => {
+      if (marked) return;
+      marked = true;
+      setValidatingByPath(form, path);
+    };
+    const unmark = () => {
+      if (!marked) return;
+      marked = false;
+      unsetValidatingByPath(form, path);
+    };
+    const runSync = () => {
+      const sync = registration.sync();
+      if (!sync) return false;
+      const errors = sync(getValueByPath(form, path), { form, path });
+      if (!hasErrors2(errors)) {
+        if (!registration.validate() || errorSource === "sync") {
+          setErrorByPath(form, path, void 0);
+          errorSource = null;
+        }
+        return false;
+      }
+      setErrorByPath(form, path, errors);
+      errorSource = "sync";
+      return true;
+    };
+    const supersede = () => {
+      if (timer !== null) {
+        clearTimeout(timer);
+        timer = null;
+      }
+      controller?.abort();
+      lock = {};
+    };
+    const runValidator = () => {
+      const fn = registration.validate();
+      if (!fn) {
+        unmark();
+        return;
+      }
+      controller?.abort();
+      controller = new AbortController();
+      const round = lock = {};
+      let result;
+      try {
+        result = fn(getValueByPath(form, path), {
+          form,
+          path,
+          signal: controller.signal
+        });
+      } catch (e) {
+        unmark();
+        throw e;
+      }
+      if (!isPromise(result)) {
+        setErrorByPath(form, path, result);
+        errorSource = hasErrors2(result) ? "validator" : null;
+        unmark();
+        return;
+      }
+      mark();
+      result.then(
+        (error) => {
+          if (lock === round) {
+            setErrorByPath(form, path, error);
+            errorSource = hasErrors2(error) ? "validator" : null;
+          }
+        }
+      ).catch(() => {
+      }).finally(() => {
+        if (lock === round) {
+          unmark();
+          lock = null;
+        }
+      });
+    };
+    const run = () => {
+      timer = null;
+      if (runSync()) {
+        supersede();
+        unmark();
+        return;
+      }
+      runValidator();
+    };
+    const kick = () => {
+      if (runSync()) {
+        supersede();
+        unmark();
+        return;
+      }
+      if (!registration.validate()) return;
+      const debounce = registration.debounce();
+      if (debounce > 0) {
+        if (timer !== null) clearTimeout(timer);
+        else mark();
+        timer = setTimeout(run, debounce);
+        return;
+      }
+      runValidator();
+    };
+    form.validators.set(path.key, kick);
+    return () => {
+      form.validators.delete(path.key);
+      if (timer !== null) {
+        clearTimeout(timer);
+        timer = null;
+      }
+      unmark();
+      controller?.abort();
+    };
   }
-  async function trigger(form, name) {
+  async function trigger(form, name, options) {
     const settle = (keys2) => waitUntil(
       form.emitter,
       "validating",
@@ -648,18 +905,25 @@
       form.validators.forEach((validator) => validator());
       await settle();
       if (form.validate) await runFormValidate(form);
+      if (options?.shouldTouch) touchKeys(form, [...form.validators.keys()]);
+      if (options?.shouldFocus) {
+        const firstKey = form.errors.keys().next().value;
+        if (firstKey !== void 0) emit(form.emitter, "focusError", firstKey);
+      }
       return !hasErrors(form);
     }
     const keys = typeof name === "string" || isSegmentsPath(name) ? [create$1(name).key] : name.map((one) => create$1(one).key);
     keys.forEach((key) => form.validators.get(key)?.());
     await settle(keys);
+    if (options?.shouldTouch) touchKeys(form, keys);
+    if (options?.shouldFocus) {
+      const firstKey = keys.find((key) => form.errors.has(key));
+      if (firstKey !== void 0) emit(form.emitter, "focusError", firstKey);
+    }
     return keys.every((key) => !form.errors.has(key));
   }
-  function isSegmentsPath(name) {
-    return name.some((part) => typeof part === "number");
-  }
-  function isFieldError(value) {
-    return !!value && typeof value === "object" && typeof value.type === "string" && typeof value.message === "string";
+  function touchKeys(form, keys) {
+    keys.forEach((key) => setTouchedByPath(form, create$1(JSON.parse(key))));
   }
   function setFormErrors(form, result, segments = [], footprint) {
     Object.entries(result).forEach(([key, value]) => {
@@ -689,12 +953,6 @@
     const stored = form.errors.get(path.key);
     if (stored) footprint.set(path.key, stored);
   }
-  function setParsedValues(form, values) {
-    if (values === void 0 || values === form.parsedValues) return;
-    form.parsedValues = values;
-    bumpValuesVersion(form);
-    emit(form.emitter, "change");
-  }
   function applyValidateResult(form, result) {
     const footprint = form.validateDeps ? getFormErrorFootprint(form) : void 0;
     if (footprint) {
@@ -892,6 +1150,55 @@
   async function validate(form) {
     return ensureValidate(form).catch((e) => e.message);
   }
+
+  const fieldModes = /* @__PURE__ */ new WeakMap();
+  function changeValue(form, name, value, options) {
+    changeValueByPath(form, create$1(name), value, options);
+  }
+  function changeValueByPath(form, path, value, options) {
+    if (options?.shouldDirty === false) setDirtyBaseline(form, path, value);
+    if (fieldModes.get(form)?.get(path.key)) {
+      userChangeByPath(form, path, value);
+    } else {
+      setValueByPath(form, path, value, options);
+    }
+  }
+  function registerFieldMode(form, path, mode) {
+    let modes = fieldModes.get(form);
+    if (!modes) {
+      modes = /* @__PURE__ */ new Map();
+      fieldModes.set(form, modes);
+    }
+    const displaced = modes.has(path.key);
+    const token = {};
+    modes.set(path.key, { mode, token });
+    return { token, displaced };
+  }
+  function unregisterFieldMode(form, path, token) {
+    const modes = fieldModes.get(form);
+    const entry = modes?.get(path.key);
+    if (modes && entry && entry.token === token) modes.delete(path.key);
+  }
+  function runUserChangeGate(form, path, mode) {
+    if (mode === "onChange" || mode === "all" || mode === "onTouched" && hasTouchedByPath(form, path) || getFieldErrorsByPath(form, path).length > 0 && form.reValidateMode === "onChange")
+      form.validators.get(path.key)?.();
+    revalidateFormOnChange(form, path, mode);
+    revalidateDependentsOnChange(form, path, mode);
+  }
+  function userChangeByPath(form, path, value) {
+    setValueByPath(form, path, value);
+    const entry = fieldModes.get(form)?.get(path.key);
+    if (entry) runUserChangeGate(form, path, entry.mode ?? form.mode);
+  }
+  function userBlur(form, path) {
+    setTouchedByPath(form, path);
+    const entry = fieldModes.get(form)?.get(path.key);
+    if (!entry) return;
+    const mode = entry.mode ?? form.mode;
+    if (mode === "onBlur" || mode === "onTouched" || mode === "all" || getFieldErrorsByPath(form, path).length > 0 && form.reValidateMode === "onBlur")
+      form.validators.get(path.key)?.();
+  }
+
   function setIsSubmitting(form, value) {
     form.isSubmitting = value;
     emit(form.emitter, "submitting");
@@ -938,6 +1245,7 @@
       onSubmit,
       onValidSubmit,
       onInvalidSubmit,
+      onAction,
       shouldFocusError = true
     } = options ?? {};
     return async (e) => {
@@ -974,6 +1282,7 @@
         const submitted = getValues(form);
         if (onSubmit) await onSubmit(submitted, e);
         if (onValidSubmit) await onValidSubmit(submitted, e);
+        if (onAction) await onAction(submitted, e);
         setSubmitSuccessful(form, true);
       } catch {
         setSubmitSuccessful(form, false);
@@ -982,12 +1291,58 @@
       }
     };
   }
+
   function setFocus(form, name, options) {
     const { key } = create$1(name);
     if (options) emit(form.emitter, "focusError", key, options);
     else emit(form.emitter, "focusError", key);
   }
 
+  function create(options) {
+    const emitter = create$2();
+    _setMaxListeners(emitter, 0);
+    let source = options?.initialValues ?? {};
+    if (typeof source === "function") source = source();
+    const form = {
+      emitter,
+      ...options,
+      mode: options?.mode ?? "onSubmit",
+      reValidateMode: options?.reValidateMode ?? "onChange",
+      disabled: options?.disabled ?? false,
+      validateDeps: options?.validateDeps ? new Set(options.validateDeps.map((dep) => create$1(dep).key)) : void 0,
+      initialValues: {},
+      values: /* @__PURE__ */ new Map(),
+      deleted: /* @__PURE__ */ new Set(),
+      errors: /* @__PURE__ */ new Map(),
+      touched: /* @__PURE__ */ new Set(),
+      validators: /* @__PURE__ */ new Map(),
+      validating: /* @__PURE__ */ new Set(),
+      parsedValues: void 0,
+      isSubmitting: false,
+      submitCount: 0,
+      isSubmitSuccessful: void 0,
+      isLoading: false
+    };
+    if (isPromise(source)) {
+      form.isLoading = true;
+      emit(emitter, "loading");
+      Promise.resolve(source).then(
+        (resolved) => {
+          form.isLoading = false;
+          emit(emitter, "loading");
+          setInitialValues(form, resolved ?? {});
+        },
+        (error) => {
+          form.isLoading = false;
+          emit(emitter, "loading");
+        }
+      );
+    } else {
+      form.initialValues = source;
+    }
+    return form;
+  }
+
   function defaultMessage(type, bound) {
     switch (type) {
       case "required":
@@ -1297,6 +1652,9 @@
       seededRef.current = { done: false, source: void 0 };
     React.useEffect(() => {
       if (initialValues === void 0) return;
+      if (typeof initialValues === "function" || isPromise(initialValues)) {
+        return;
+      }
       const seeded = seededRef.current;
       if (seeded.done && (seeded.source === initialValues || isEqual(seeded.source, initialValues))) {
         return;
@@ -1321,12 +1679,14 @@
     }, [form, values]);
     return form;
   }
-  function useWatchCore(subscribeFactory, getter) {
+  function useWatchCore(subscribeFactory, getter, isEqual2) {
     const cacheRef = React.useRef(null);
     if (cacheRef.current === null) cacheRef.current = { hasValue: false };
     const cache = cacheRef.current;
     const getterRef = React.useRef(getter);
     getterRef.current = getter;
+    const isEqualRef = React.useRef(isEqual2);
+    isEqualRef.current = isEqual2;
     const getSnapshot = React.useCallback(() => {
       if (!cache.hasValue) {
         cache.value = getterRef.current();
@@ -1338,6 +1698,14 @@
       (notify) => {
         cache.hasValue = false;
         const invalidate = () => {
+          const compare = isEqualRef.current;
+          if (compare && cache.hasValue) {
+            const next = getterRef.current();
+            if (compare(cache.value, next)) return;
+            cache.value = next;
+            notify();
+            return;
+          }
           cache.hasValue = false;
           notify();
         };
@@ -1347,12 +1715,13 @@
     );
     return shimExports.useSyncExternalStore(subscribe, getSnapshot, getSnapshot);
   }
-  function useWatch(emitter, event, getter) {
+  function useWatch(formOrEmitter, event, getter, isEqual2) {
+    const emitter = "emitter" in formOrEmitter ? formOrEmitter.emitter : formOrEmitter;
     const subscribeFactory = React.useCallback(
       (invalidate) => on(emitter, event, invalidate),
       [emitter, event]
     );
-    return useWatchCore(subscribeFactory, getter);
+    return useWatchCore(subscribeFactory, getter, isEqual2);
   }
   function useValue(form, name) {
     return useValueByPath(form, create$1(name));
@@ -1410,19 +1779,71 @@
     );
   }
   function useIsDirty(form) {
-    return useWatch(form.emitter, "change", isDirty.bind(null, form));
+    return useWatch(form, "change", isDirty.bind(null, form));
   }
   function useDirtyFields(form) {
-    return useWatch(form.emitter, "change", getDirtyFields.bind(null, form));
+    return useWatch(form, "change", getDirtyFields.bind(null, form));
   }
   function useTouchedFields(form) {
-    return useWatch(form.emitter, "touched", getTouchedFields.bind(null, form));
+    return useWatch(form, "touched", getTouchedFields.bind(null, form));
+  }
+  const FORM_STATE_EVENTS = [
+    "change",
+    "errors",
+    "touched",
+    "validating",
+    "submitting",
+    "submitCount",
+    "submitSuccessful",
+    "disabled",
+    "loading"
+  ];
+  function getFormState(form) {
+    return {
+      isDirty: isDirty(form),
+      dirtyFields: getDirtyFields(form),
+      isTouched: form.touched.size > 0,
+      touchedFields: getTouchedFields(form),
+      hasErrors: hasErrors(form),
+      isValid: !hasErrors(form),
+      isSubmitting: form.isSubmitting,
+      isValidating: form.validating.size > 0,
+      isSubmitSuccessful: form.isSubmitSuccessful,
+      submitCount: form.submitCount,
+      isLoading: form.isLoading,
+      disabled: form.disabled
+    };
+  }
+  function isSameFormState(a, b) {
+    const sameTouched = a.touchedFields.length === b.touchedFields.length && a.touchedFields.every((path, i) => path === b.touchedFields[i]);
+    return a.isDirty === b.isDirty && a.dirtyFields === b.dirtyFields && a.isTouched === b.isTouched && sameTouched && a.hasErrors === b.hasErrors && a.isValid === b.isValid && a.isSubmitting === b.isSubmitting && a.isValidating === b.isValidating && a.isSubmitSuccessful === b.isSubmitSuccessful && a.submitCount === b.submitCount && a.isLoading === b.isLoading && a.disabled === b.disabled;
+  }
+  function useFormState(form) {
+    const getter = React.useCallback(() => getFormState(form), [form]);
+    const subscribeFactory = React.useCallback(
+      (invalidate) => {
+        const offs = FORM_STATE_EVENTS.map(
+          (event) => on(form.emitter, event, invalidate)
+        );
+        return () => {
+          for (const off of offs) off();
+        };
+      },
+      [form.emitter]
+    );
+    return useWatchCore(subscribeFactory, getter, isSameFormState);
   }
   function useHasErrors(form) {
-    return useWatch(form.emitter, "errors", hasErrors.bind(null, form));
+    return useWatch(form, "errors", hasErrors.bind(null, form));
+  }
+  function useIsValid(form) {
+    return useWatch(form, "errors", () => !hasErrors(form));
   }
   function useIsSubmitting(form) {
-    return useWatch(form.emitter, "submitting", () => form.isSubmitting);
+    return useWatch(form, "submitting", () => form.isSubmitting);
+  }
+  function useIsLoading(form) {
+    return useWatch(form, "loading", () => form.isLoading);
   }
   function useCanSubmit(form) {
     const { emitter } = form;
@@ -1443,7 +1864,23 @@
     );
   }
   function useSubmitCount(form) {
-    return useWatch(form.emitter, "submitCount", () => form.submitCount);
+    return useWatch(form, "submitCount", () => form.submitCount);
+  }
+  function useIsValidating(form) {
+    return useWatch(form, "validating", () => form.validating.size > 0);
+  }
+  function useIsSubmitSuccessful(form) {
+    return useWatch(
+      form.emitter,
+      "submitSuccessful",
+      () => !!form.isSubmitSuccessful
+    );
+  }
+  function useFormError(form) {
+    return useErrorByPath(form, create$1(FORM_ERROR))?.message;
+  }
+  function useFormErrors(form) {
+    return useFieldErrorsByPath(form, create$1(FORM_ERROR));
   }
 
   function usePath(name) {
@@ -1468,92 +1905,29 @@
     const contextForm = React.useContext(FormContext);
     const form = formProp || contextForm;
     if (!form) throw new Error("no form provided");
-    const lockRef = React.useRef(null);
     const validateRef = React.useRef(validate);
     validateRef.current = validate;
     const debounceRef = React.useRef(options?.debounce ?? 0);
     debounceRef.current = options?.debounce ?? 0;
-    React.useEffect(() => {
-      let timer = null;
-      let controller = null;
-      let marked = false;
-      const mark = () => {
-        if (marked) return;
-        marked = true;
-        setValidatingByPath(form, path);
-      };
-      const unmark = () => {
-        if (!marked) return;
-        marked = false;
-        unsetValidatingByPath(form, path);
-      };
-      const run = () => {
-        timer = null;
-        const fn = validateRef.current;
-        if (!fn) {
-          unmark();
-          return;
-        }
-        controller?.abort();
-        controller = new AbortController();
-        const lock = lockRef.current = {};
-        let result;
-        try {
-          result = fn(getValueByPath(form, path), {
-            form,
-            path,
-            signal: controller.signal
-          });
-        } catch (e) {
-          unmark();
-          throw e;
-        }
-        if (!isPromise(result)) {
-          setErrorByPath(form, path, result);
-          unmark();
-          return;
-        }
-        mark();
-        result.then(
-          (error) => {
-            if (lock === lockRef.current) {
-              setErrorByPath(form, path, error);
-            }
-          }
-        ).catch(() => {
-        }).finally(() => {
-          if (lock === lockRef.current) {
-            unmark();
-            lockRef.current = null;
-          }
-        });
-      };
-      const validator = () => {
-        const debounce = debounceRef.current;
-        if (debounce > 0) {
-          if (timer !== null) clearTimeout(timer);
-          else mark();
-          timer = setTimeout(run, debounce);
-          return;
-        }
-        run();
-      };
-      form.validators.set(path.key, validator);
-      return () => {
-        form.validators.delete(path.key);
-        if (timer !== null) {
-          clearTimeout(timer);
-          timer = null;
-        }
-        unmark();
-        controller?.abort();
-      };
-    }, [form, path.key]);
+    const syncRef = React.useRef(options?.sync);
+    syncRef.current = options?.sync;
+    React.useEffect(
+      () => registerValidatorByPath(form, path, {
+        validate: () => validateRef.current,
+        debounce: () => debounceRef.current,
+        sync: () => syncRef.current
+      }),
+      // eslint-disable-next-line react-hooks/exhaustive-deps -- deps are `path.key` on purpose: usePath returns a stable Path per key, so re-subscribing on key (not object identity) is enough
+      [form, path.key]
+    );
     return useStageFn(() => form.validators.get(path.key)?.());
   }
 
+  function hasRuleConstraints(rules) {
+    return rules.required !== void 0 || rules.min !== void 0 || rules.max !== void 0 || rules.minLength !== void 0 || rules.maxLength !== void 0 || rules.pattern !== void 0;
+  }
   function combineRulesAndValidate(rules, validate) {
-    if (!rules) return validate;
+    if (!rules || !hasRuleConstraints(rules)) return validate;
     const ruleValidator = rulesToValidator(rules);
     if (!validate) return ruleValidator;
     return (value, meta) => {
@@ -1585,6 +1959,25 @@
     }, [errors, delay, shown]);
     return delay === void 0 ? errors : shown;
   }
+  function useFieldValue(form, path, uncontrolled) {
+    const snapshotRef = React.useRef({
+      has: false,
+      value: void 0
+    });
+    const getter = React.useCallback(() => {
+      if (!uncontrolled) return getValueByPath(form, path);
+      if (!snapshotRef.current.has) {
+        snapshotRef.current = { has: true, value: getValueByPath(form, path) };
+      }
+      return snapshotRef.current.value;
+    }, [uncontrolled, form, path]);
+    const subscribeFactory = React.useCallback(
+      (invalidate) => uncontrolled ? () => {
+      } : onPathEvent(form.emitter, "change", path, "leaf", invalidate),
+      [uncontrolled, form.emitter, path]
+    );
+    return useWatchCore(subscribeFactory, getter);
+  }
   function useFieldCore({
     form: f1,
     name,
@@ -1596,6 +1989,7 @@
     validateDeps,
     delayError,
     disabled,
+    uncontrolled,
     mode: modeOption
   }, Context) {
     const contextForm = React.useContext(Context);
@@ -1613,35 +2007,23 @@
       seededRef.current = false;
       emitChangeByPath(form, path);
     });
-    const validator = useValidate(
-      combineRulesAndValidate(rules, validate),
-      path,
-      form,
-      {
-        debounce: validateDebounce
-      }
-    );
+    const restRules = rules ? { ...rules, required: void 0 } : void 0;
+    useValidate(combineRulesAndValidate(restRules, validate), path, form, {
+      debounce: validateDebounce,
+      sync: rules && rules.required !== void 0 ? rulesToValidator({ required: rules.required }) : void 0
+    });
     const liveErrors = useFieldErrorsByPath(form, path);
     const errors = useDelayedErrors(liveErrors, delayError);
     const errorObject = errors[0];
     const error = errorObject?.message;
-    const value = useValueByPath(form, path);
-    const formDisabled = useWatch(form.emitter, "disabled", () => form.disabled);
-    const mode = modeOption ?? form.mode;
-    const onChange = useStageFn((v) => {
-      setValueByPath(form, path, v);
-      if (mode === "onChange" || mode === "all" || mode === "onTouched" && hasTouchedByPath(form, path) || liveErrors.length > 0 && form.reValidateMode === "onChange")
-        validator();
-      revalidateFormOnChange(form, path, mode);
-      revalidateDependentsOnChange(form, path, mode);
-    });
+    const value = useFieldValue(form, path, !!uncontrolled);
+    const formDisabled = useWatch(form, "disabled", () => form.disabled);
+    const onChange = useStageFn((v) => userChangeByPath(form, path, v));
+    const onBlur = useStageFn(() => userBlur(form, path));
     React.useEffect(() => {
-      form.changeHandlers.set(path.key, onChange);
-      return () => {
-        if (form.changeHandlers.get(path.key) === onChange)
-          form.changeHandlers.delete(path.key);
-      };
-    }, [form, path.key, onChange]);
+      const { token, displaced } = registerFieldMode(form, path, modeOption);
+      return () => unregisterFieldMode(form, path, token);
+    }, [form, path.key, modeOption]);
     const depsKey = validateDeps?.length ? validateDeps.join("\n") : void 0;
     React.useEffect(() => {
       if (!depsKey) return;
@@ -1649,14 +2031,29 @@
       registerFieldValidateDeps(form, path.key, depKeys);
       return () => unregisterFieldValidateDeps(form, path.key, depKeys);
     }, [form, path.key, depsKey]);
-    const onBlur = useStageFn(() => {
-      setTouchedByPath(form, path);
-      if (mode === "onBlur" || mode === "onTouched" || mode === "all" || liveErrors.length > 0 && form.reValidateMode === "onBlur")
-        validator();
-    });
+    const elementRef = React.useRef(null);
+    const focusRef = React.useCallback((el) => {
+      elementRef.current = el;
+    }, []);
+    React.useEffect(
+      () => on(
+        form.emitter,
+        "focusError",
+        (key, options) => {
+          if (key !== path.key) return;
+          const el = elementRef.current;
+          if (!el || typeof el.focus !== "function") return;
+          el.focus();
+          if (options?.shouldSelect && typeof el.select === "function") {
+            el.select();
+          }
+        }
+      ),
+      [form, path.key]
+    );
     React.useEffect(
       () => () => {
-        if (shouldUnregister !== false) {
+        if ((shouldUnregister ?? form.shouldUnregister) !== false) {
           removeFieldByPath(form, path);
         }
       },
@@ -1671,7 +2068,8 @@
       onChange,
       onBlur,
       name: path.key,
-      disabled: formDisabled || !!disabled
+      disabled: formDisabled || !!disabled,
+      focusRef
     };
   }
   function useField(options) {
@@ -1900,29 +2298,72 @@
     return group;
   }
 
+  function appendFormDataValue(fd, key, value) {
+    if (value == null) return;
+    if (Array.isArray(value)) {
+      for (const item of value) appendFormDataValue(fd, key, item);
+      return;
+    }
+    if (typeof FileList !== "undefined" && value instanceof FileList) {
+      for (let i = 0; i < value.length; i++) fd.append(key, value.item(i));
+      return;
+    }
+    if (typeof File !== "undefined" && value instanceof File) {
+      fd.append(key, value, value.name);
+      return;
+    }
+    if (typeof Blob !== "undefined" && value instanceof Blob) {
+      fd.append(key, value);
+      return;
+    }
+    if (value instanceof Date) {
+      fd.append(key, value.toISOString());
+      return;
+    }
+    fd.append(
+      key,
+      typeof value === "object" ? JSON.stringify(value) : String(value)
+    );
+  }
+  function formDataFromValues(values) {
+    const fd = new FormData();
+    for (const key of Object.keys(values)) {
+      appendFormDataValue(fd, key, values[key]);
+    }
+    return fd;
+  }
+
   function Form({
     form: f1,
     context,
     initialValues,
     values,
+    shouldUnregister,
     onSubmit,
     onValidSubmit,
     onInvalidSubmit,
+    action,
     shouldFocusError,
     ...props
   }) {
-    const f2 = useForm({ initialValues, values });
+    const f2 = useForm({ initialValues, values, shouldUnregister });
     const form = f1 || f2;
     const submit = handleSubmit(form, {
       onSubmit,
       onValidSubmit,
       onInvalidSubmit,
-      shouldFocusError
+      shouldFocusError,
+      onAction: action ? (values2) => action(formDataFromValues(values2)) : void 0
     });
     const { Provider } = context ?? FormContext;
     return /* @__PURE__ */ React__namespace.createElement(Provider, { value: form }, /* @__PURE__ */ React__namespace.createElement("form", { ...props, noValidate: true, onSubmit: submit }));
   }
 
+  function FormField({ children, ...options }) {
+    const field = useField(options);
+    return children(field);
+  }
+
   function setRef(ref, value) {
     if (typeof ref === "function") {
       ref(value);
@@ -1960,25 +2401,19 @@
       disabled,
       delayError,
       mode,
+      uncontrolled,
       ...props
     }, ref) => {
       const innerRef = React__namespace.useRef(null);
       const [nativeInvalidCount, setNativeInvalidCount] = React__namespace.useState(0);
-      const mergedRef = React__namespace.useCallback(
-        (node) => {
-          innerRef.current = node;
-          setRef(ref, node);
-        },
-        [ref]
-      );
       const {
         value,
         onChange,
         onBlur,
         error,
-        form,
         name: fieldKey,
-        disabled: isDisabled
+        disabled: isDisabled,
+        focusRef
       } = useField({
         name,
         form: formProp,
@@ -1989,6 +2424,9 @@
         delayError,
         disabled,
         mode,
+        // File inputs cannot be value-controlled at all — force the
+        // uncontrolled path so no `value` prop ever reaches the element.
+        uncontrolled: uncontrolled || props.type === "file",
         validate: (...params) => {
           const el = innerRef.current;
           if (el && typeof el.checkValidity === "function") {
@@ -2001,6 +2439,14 @@
           if (validate) return validate(...params);
         }
       });
+      const mergedRef = React__namespace.useCallback(
+        (node) => {
+          innerRef.current = node;
+          focusRef(node);
+          setRef(ref, node);
+        },
+        [ref, focusRef]
+      );
       const Component = as || "input";
       React__namespace.useEffect(() => {
         const el = innerRef.current;
@@ -2015,23 +2461,9 @@
       React__namespace.useEffect(() => {
         if (nativeInvalidCount > 0) innerRef.current?.reportValidity();
       }, [nativeInvalidCount]);
-      React__namespace.useEffect(
-        () => on(
-          form.emitter,
-          "focusError",
-          (key, options) => {
-            if (key !== fieldKey) return;
-            const el = innerRef.current;
-            if (!el || typeof el.focus !== "function") return;
-            el.focus();
-            if (options?.shouldSelect && typeof el.select === "function") {
-              el.select();
-            }
-          }
-        ),
-        [form, fieldKey]
-      );
-      const toValue = eventToValue ?? ((e) => e.target.value);
+      const isFile = props.type === "file";
+      const toValue = eventToValue ?? (isFile ? (e) => e.target.files : (e) => e.target.value);
+      const valueProps = valueToProps ? valueToProps(value) : isFile ? {} : uncontrolled ? { defaultValue: value } : { value };
       const errorId = errorIdFromKey(fieldKey);
       return /* @__PURE__ */ React__namespace.createElement(React__namespace.Fragment, null, /* @__PURE__ */ React__namespace.createElement(
         Component,
@@ -2040,7 +2472,7 @@
           name: fieldKey,
           onBlur,
           ...asProps,
-          ...valueToProps ? valueToProps(value) : { value },
+          ...valueProps,
           ...ariaProps(error, fieldKey, props),
           disabled: isDisabled,
           onChange: (e) => onChange(toValue(e)),
@@ -2160,9 +2592,11 @@
   exports.Checkbox = Checkbox;
   exports.CheckboxGroupContext = CheckboxGroupContext;
   exports.CheckboxGroupProvider = CheckboxGroupProvider;
+  exports.FORM_ERROR = FORM_ERROR;
   exports.Field = Field;
   exports.Form = Form;
   exports.FormContext = FormContext;
+  exports.FormField = FormField;
   exports.FormProvider = FormProvider;
   exports.Select = Select;
   exports.VALIDATION_OUTCOME = VALIDATION_OUTCOME;
@@ -2193,7 +2627,9 @@
   exports.incrementSubmitCount = incrementSubmitCount;
   exports.isDirty = isDirty;
   exports.isTouched = isTouched;
+  exports.registerFieldMode = registerFieldMode;
   exports.registerFieldValidateDeps = registerFieldValidateDeps;
+  exports.registerValidatorByPath = registerValidatorByPath;
   exports.removeField = removeField;
   exports.removeFieldByPath = removeFieldByPath;
   exports.reset = reset;
@@ -2216,6 +2652,7 @@
   exports.setValueByPath = setValueByPath;
   exports.subscribe = subscribe;
   exports.trigger = trigger;
+  exports.unregisterFieldMode = unregisterFieldMode;
   exports.unregisterFieldValidateDeps = unregisterFieldValidateDeps;
   exports.unsetValidatingByPath = unsetValidatingByPath;
   exports.useCanSubmit = useCanSubmit;
@@ -2230,9 +2667,16 @@
   exports.useFieldErrorsByPath = useFieldErrorsByPath;
   exports.useForm = useForm;
   exports.useFormContext = useFormContext;
+  exports.useFormError = useFormError;
+  exports.useFormErrors = useFormErrors;
+  exports.useFormState = useFormState;
   exports.useHasErrors = useHasErrors;
   exports.useIsDirty = useIsDirty;
+  exports.useIsLoading = useIsLoading;
+  exports.useIsSubmitSuccessful = useIsSubmitSuccessful;
   exports.useIsSubmitting = useIsSubmitting;
+  exports.useIsValid = useIsValid;
+  exports.useIsValidating = useIsValidating;
   exports.useSubmitCount = useSubmitCount;
   exports.useTouched = useTouched;
   exports.useTouchedByPath = useTouchedByPath;
@@ -2240,6 +2684,9 @@
   exports.useValue = useValue;
   exports.useValueByPath = useValueByPath;
   exports.useWatch = useWatch;
+  exports.useWatchCore = useWatchCore;
+  exports.userBlur = userBlur;
+  exports.userChangeByPath = userChangeByPath;
   exports.validate = validate;
 
 }));