react-f0rm 0.2.2 → 0.3.0

package/dist/form-94c70b4b.mjs

@@ -0,0 +1,378 @@
+function getSet(ee, key) {
+  var set = ee.get(key);
+  if (set) return set;
+  var newSet = new Set();
+  ee.set(key, newSet);
+  return newSet;
+}
+function emit$1(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);
+  });
+}
+function on(ee, key, handler) {
+  var set = getSet(ee, key);
+  set.add(handler);
+  return function () {
+    return set.delete(handler);
+  };
+}
+
+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);
+  pathCache.set(path, value);
+  return value;
+}
+function parsePath(path) {
+  const result = [];
+  let identifier = "";
+  const flushIdentifier = () => {
+    result.push(identifier);
+    identifier = "";
+  };
+  for (let i = 0; i < path.length; i++) {
+    const char = path[i];
+    if (char === ".") {
+      if (identifier !== "") flushIdentifier();
+    } else if (char === "[") {
+      if (identifier !== "") flushIdentifier();
+      const quote = path[i + 1];
+      if (quote === '"' || quote === "'") {
+        const close = path.indexOf(quote, i + 2);
+        if (close === -1) {
+          throw new TypeError(`Unterminated quote in path: ${path}`);
+        }
+        if (path[close + 1] !== "]") {
+          throw new TypeError(
+            `Expected "]" after quoted segment in path: ${path}`
+          );
+        }
+        result.push(path.slice(i + 2, close));
+        i = close + 1;
+      } else {
+        const close = path.indexOf("]", i + 1);
+        if (close === -1) {
+          throw new TypeError(`Unterminated bracket in path: ${path}`);
+        }
+        const content = path.slice(i + 1, close);
+        result.push(/^-?\d+$/.test(content) ? Number(content) : content);
+        i = close;
+      }
+    } else {
+      identifier += char;
+    }
+  }
+  if (identifier !== "" || result.length === 0) flushIdentifier();
+  return result;
+}
+function get(values, path) {
+  return path.reduce((current, p) => {
+    if (current == null) return void 0;
+    return current[p];
+  }, values);
+}
+function unset(values, path) {
+  if (!path.length || values == null) return values;
+  const [prop, ...props] = path;
+  if (props.length) {
+    const next = unset(values[prop], props);
+    return next === values[prop] ? values : set(values, path, next);
+  }
+  if (Array.isArray(values)) {
+    if (!(prop in values)) return values;
+    const arr = values.slice();
+    delete arr[prop];
+    return arr;
+  }
+  if (typeof values !== "object" || !(prop in values)) return values;
+  const copy = { ...values };
+  delete copy[prop];
+  return copy;
+}
+function set(values, path, value) {
+  if (!path.length) return value;
+  const [prop, ...props] = path;
+  if (typeof prop === "number") {
+    const arr = Array.isArray(values) ? values.slice() : [];
+    arr[prop] = set(arr[prop], props, value);
+    return arr;
+  }
+  return { ...values, [prop]: set(values && values[prop], props, value) };
+}
+function setOwned(root, path, value, owned) {
+  if (!path.length) return value;
+  let container = root;
+  let parent = null;
+  let parentProp = "";
+  for (let i = 0; i < path.length; i++) {
+    const prop = path[i];
+    if (!owned.has(container)) {
+      let copy;
+      if (typeof prop === "number") {
+        copy = Array.isArray(container) ? container.slice() : [];
+      } else {
+        copy = { ...container };
+      }
+      owned.add(copy);
+      if (i === 0) root = copy;
+      else parent[parentProp] = copy;
+      container = copy;
+    }
+    if (i === path.length - 1) {
+      container[prop] = value;
+    } else {
+      parent = container;
+      parentProp = prop;
+      container = container[prop];
+    }
+  }
+  return root;
+}
+function waitUntil(emitter, event, isResolve, isReject) {
+  return new Promise((resolve, reject) => {
+    if (isReject()) return void reject();
+    if (isResolve()) return void resolve();
+    const off = on(emitter, event, () => {
+      if (isReject()) {
+        off();
+        reject();
+        return;
+      }
+      if (!isResolve()) return;
+      off();
+      resolve();
+    });
+  });
+}
+
+function create(name) {
+  const value = normalizePath(name);
+  return { value, key: JSON.stringify(value) };
+}
+
+const emit = emit$1;
+const VALIDATION_OUTCOME = /* @__PURE__ */ Symbol("validation-outcome");
+function getValues(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 getValue(form, name) {
+  return getValueByPath(form, create(name));
+}
+function getValueByPath({ initialValues, parsedValues, values, deleted }, path) {
+  if (values.has(path.key)) return values.get(path.key);
+  if (deleted.has(path.key)) return void 0;
+  return get(parsedValues ?? initialValues, path.value);
+}
+function setValueByPath(form, path, value, options) {
+  const { emitter, values, deleted } = form;
+  values.set(path.key, value);
+  reviveBranch(deleted, path);
+  bumpDirtyVersion(form);
+  if (options?.shouldTouch) setTouchedByPath(form, path);
+  if (options?.shouldValidate) form.validators.get(path.key)?.();
+  emit(emitter, "change", path);
+}
+function getErrors({ errors }) {
+  const entries = [];
+  for (const [key, list] of errors) {
+    const path = JSON.parse(key).join(".");
+    for (const { type, message } of list) entries.push({ path, type, message });
+  }
+  return entries;
+}
+function setError(form, name, error) {
+  setErrorByPath(form, create(name), error);
+}
+function setErrorByPath({ emitter, errors }, path, error) {
+  const list = normalizeErrors(error);
+  if (list) errors.set(path.key, list);
+  else errors.delete(path.key);
+  emit(emitter, "errors", path);
+}
+function normalizeErrors(error) {
+  if (typeof error === "string") {
+    return error ? [{ type: "custom", message: error }] : void 0;
+  }
+  if (isFieldError(error)) return [error];
+  if (!error) return void 0;
+  const list = [];
+  error.forEach((item) => {
+    if (typeof item === "string" && item) {
+      list.push({ type: "custom", message: item });
+    } else if (isFieldError(item)) {
+      list.push(item);
+    }
+  });
+  return list.length ? list : void 0;
+}
+function clearErrors(form, name) {
+  const { emitter, errors } = form;
+  if (name === void 0) {
+    errors.clear();
+    emit(emitter, "errors");
+    return;
+  }
+  const paths = typeof name === "string" || isSegmentsPath(name) ? [create(name)] : name.map((one) => create(one));
+  for (const { key } of paths) errors.delete(key);
+  for (const path of paths) emit(emitter, "errors", path);
+}
+function setTouchedByPath({ emitter, touched }, path) {
+  if (touched.has(path.key)) return;
+  touched.add(path.key);
+  emit(emitter, "touched", path);
+}
+function forEachDirtyField({ initialValues, values }, fn) {
+  for (const [key, value] of values) {
+    const path = JSON.parse(key);
+    if (get(initialValues, path) !== value) fn(path.join("."));
+  }
+}
+const dirtyFieldsCaches = /* @__PURE__ */ new WeakMap();
+function bumpDirtyVersion(form) {
+  const cache = dirtyFieldsCaches.get(form);
+  if (cache) cache.version++;
+}
+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 getTouchedFields({ touched }) {
+  return Array.from(
+    touched,
+    (key) => JSON.parse(key).join(".")
+  );
+}
+function reviveBranch(deleted, { key }) {
+  if (!deleted.size) return;
+  for (const tombstone of deleted) {
+    if (tombstone === key || tombstone.startsWith(`${key.slice(0, -1)},`) || key.startsWith(`${tombstone.slice(0, -1)},`)) {
+      deleted.delete(tombstone);
+    }
+  }
+}
+function reset(form, initialValues, options) {
+  const dirtyValues = options?.keepDirtyValues ? Object.keys(getDirtyFields(form)).map((key) => ({
+    key,
+    value: getValue(form, key)
+  })) : [];
+  form.initialValues = initialValues;
+  form.parsedValues = void 0;
+  if (!options?.keepErrors) clearErrors(form);
+  const { emitter, touched, values, deleted, validating } = form;
+  values.clear();
+  deleted.clear();
+  if (!options?.keepTouched) touched.clear();
+  validating.clear();
+  if (!options?.keepIsSubmitting) form.isSubmitting = false;
+  if (!options?.keepSubmitCount) form.submitCount = 0;
+  if (!options?.keepIsSubmitted) form.isSubmitSuccessful = void 0;
+  bumpDirtyVersion(form);
+  for (const { key, value } of dirtyValues) {
+    setValueByPath(form, create(key), value);
+  }
+  emit(emitter, "change");
+  emit(emitter, "touched");
+  emit(emitter, "validating");
+  emit(emitter, "submitting");
+  emit(emitter, "submitCount");
+  emit(emitter, "submitSuccessful");
+  emit(emitter, "reset");
+}
+function hasErrors({ errors }) {
+  return errors.size > 0;
+}
+async function trigger(form, name) {
+  const settle = () => waitUntil(
+    form.emitter,
+    "validating",
+    () => !form.validating.size,
+    () => false
+  );
+  if (name === void 0) {
+    form.validators.forEach((validator) => validator());
+    await settle();
+    if (form.validate) {
+      const result = await form.validate(getValues(form));
+      applyValidateResult(form, result);
+    }
+    return !hasErrors(form);
+  }
+  const keys = typeof name === "string" || isSegmentsPath(name) ? [create(name).key] : name.map((one) => create(one).key);
+  keys.forEach((key) => form.validators.get(key)?.());
+  await settle();
+  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 setFormErrors(form, result, segments = []) {
+  Object.entries(result).forEach(([key, value]) => {
+    const path = [...segments, ...normalizePath(key)];
+    if (typeof value === "string") {
+      if (value) setError(form, path, value);
+    } else if (Array.isArray(value)) {
+      setError(form, path, value);
+    } else if (isFieldError(value)) {
+      setError(form, path, value);
+    } else if (value && typeof value === "object") {
+      setFormErrors(form, value, path);
+    }
+  });
+}
+function setParsedValues(form, values) {
+  if (values === void 0 || values === form.parsedValues) return;
+  form.parsedValues = values;
+  emit(form.emitter, "change");
+}
+function applyValidateResult(form, result) {
+  if (!result) return;
+  if (typeof result === "object" && VALIDATION_OUTCOME in result) {
+    const outcome = result;
+    if (outcome.errors) setFormErrors(form, outcome.errors);
+    setParsedValues(form, outcome.values);
+    return;
+  }
+  setFormErrors(form, result);
+}
+
+export { VALIDATION_OUTCOME as V, getTouchedFields as a, getValues as b, getErrors as c, getDirtyFields as g, on as o, reset as r, trigger as t };
+//# sourceMappingURL=form-94c70b4b.mjs.map

package/dist/form-94c70b4b.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"form-94c70b4b.mjs","sources":["../node_modules/.pnpm/@for-fun+event-emitter@1.0.0/node_modules/@for-fun/event-emitter/dist/event-emitter.esm.js","../src/util.ts","../src/path.ts","../src/form.ts"],"sourcesContent":["function getSet(ee, key) {\n  var set = ee.get(key);\n  if (set) return set;\n  var newSet = new Set();\n  ee.set(key, newSet);\n  return newSet;\n}\nvar errorEvent = Symbol('error');\nfunction create() {\n  return new Map();\n}\nfunction emit(ee, key) {\n  for (var _len = arguments.length, args = new Array(_len > 2 ? _len - 2 : 0), _key = 2; _key < _len; _key++) {\n    args[_key - 2] = arguments[_key];\n  }\n  (ee.get(key) || []).forEach(function (h) {\n    return h.apply(void 0, args);\n  });\n}\nfunction emitError(ee, err) {\n  var handlerSet = ee.get(errorEvent);\n  if (!handlerSet || !handlerSet.size) throw err;\n  handlerSet.forEach(function (h) {\n    return h(err);\n  });\n}\nfunction on(ee, key, handler) {\n  var set = getSet(ee, key);\n  set.add(handler);\n  return function () {\n    return set.delete(handler);\n  };\n}\nfunction onError(ee, handler) {\n  return on(ee, errorEvent, handler);\n}\nfunction once(ee, key, handler) {\n  var off = on(ee, key, function () {\n    off();\n    handler.apply(void 0, arguments);\n  });\n  return off;\n}\nfunction onceError(ee, handler) {\n  return once(ee, errorEvent, handler);\n}\nfunction bindContext(context) {\n  return function (func) {\n    return func.bind(null, context);\n  };\n}\nfunction createAndBind() {\n  var ee = create();\n  var bind = bindContext(ee);\n  return {\n    emit: bind(emit),\n    emitError: bind(emitError),\n    on: bind(on),\n    onError: bind(onError),\n    once: bind(once),\n    onceError: bind(onceError)\n  };\n}\n\nexport { bindContext, create, createAndBind, emit, emitError, errorEvent, on, onError, once, onceError };\n//# sourceMappingURL=event-emitter.esm.js.map\n","import {on} from '@for-fun/event-emitter';\nimport type {EventEmitter} from '@for-fun/event-emitter';\n\nconst pathCache = new Map<string, (string | number)[]>();\n\nexport function normalizePath(\n  path: string | (string | number)[]\n): (string | number)[] {\n  if (Array.isArray(path)) return path;\n  const cached = pathCache.get(path);\n  if (cached) return cached;\n  const value = parsePath(path);\n  pathCache.set(path, value);\n  return value;\n}\n\nfunction parsePath(path: string): (string | number)[] {\n  const result: (string | number)[] = [];\n  let identifier = '';\n  const flushIdentifier = () => {\n    result.push(identifier);\n    identifier = '';\n  };\n\n  for (let i = 0; i < path.length; i++) {\n    const char = path[i];\n    if (char === '.') {\n      if (identifier !== '') flushIdentifier();\n    } else if (char === '[') {\n      if (identifier !== '') flushIdentifier();\n      const quote = path[i + 1];\n      if (quote === '\"' || quote === \"'\") {\n        const close = path.indexOf(quote, i + 2);\n        if (close === -1) {\n          throw new TypeError(`Unterminated quote in path: ${path}`);\n        }\n        if (path[close + 1] !== ']') {\n          throw new TypeError(\n            `Expected \"]\" after quoted segment in path: ${path}`\n          );\n        }\n        result.push(path.slice(i + 2, close));\n        i = close + 1;\n      } else {\n        const close = path.indexOf(']', i + 1);\n        if (close === -1) {\n          throw new TypeError(`Unterminated bracket in path: ${path}`);\n        }\n        const content = path.slice(i + 1, close);\n        result.push(/^-?\\d+$/.test(content) ? Number(content) : content);\n        i = close;\n      }\n    } else {\n      identifier += char;\n    }\n  }\n  if (identifier !== '' || result.length === 0) flushIdentifier();\n  return result;\n}\n\nexport function get(values: any, path: (string | number)[]): any {\n  return path.reduce((current: any, p: string | number) => {\n    if (current == null) return undefined;\n    return current[p];\n  }, values);\n}\n\n/**\n * Immutable counterpart of {@link set}: removes the path from the value\n * tree, copying only along the touched branch (untouched branches stay\n * shared with the source, like set). Deletes the key entirely rather than\n * writing undefined, so the result carries no `a: undefined` entries.\n */\nexport function unset(values: any, path: (string | number)[]): any {\n  if (!path.length || values == null) return values;\n  const [prop, ...props] = path;\n  if (props.length) {\n    const next = unset(values[prop], props);\n    return next === values[prop] ? values : set(values, path, next);\n  }\n  if (Array.isArray(values)) {\n    if (!(prop in values)) return values;\n    const arr = values.slice();\n    delete arr[prop as number];\n    return arr;\n  }\n  if (typeof values !== 'object' || !(prop in values)) return values;\n  const copy = {...values};\n  delete copy[prop as string];\n  return copy;\n}\n\nexport function set(values: any, path: (string | number)[], value: any): any {\n  if (!path.length) return value;\n\n  const [prop, ...props] = path;\n  if (typeof prop === 'number') {\n    const arr = Array.isArray(values) ? values.slice() : [];\n    arr[prop] = set(arr[prop], props, value);\n    return arr;\n  }\n  return {...values, [prop]: set(values && values[prop], props, value)};\n}\n\n/**\n * Ownership-tracked {@link set}: merge many paths into one tree without\n * re-copying containers the merge itself already created.\n *\n * Containers present in `owned` (freshly created by an earlier call of the\n * same merge) are mutated in place; every other container -- nodes borrowed\n * from the seed tree and user leaf values -- is copied first with the exact\n * copy rules `set` applies (numeric prop: array slice, or a fresh array\n * when the node is not one; string prop: object spread). Chaining\n * `setOwned` over a list of paths therefore produces the tree chaining\n * `set` would, in the same insertion order, but allocates each distinct\n * container once (O(distinct path prefixes)) instead of re-copying the\n * whole branch for every path (O(paths x depth)).\n *\n * Use a fresh `owned` set per merge and thread the returned root (a copied\n * replacement when the seed root itself had to be copied) into the next\n * call. Borrowed containers are never mutated.\n */\nexport function setOwned(\n  root: any,\n  path: (string | number)[],\n  value: any,\n  owned: Set<object>\n): any {\n  if (!path.length) return value;\n  let container = root;\n  let parent: any = null;\n  let parentProp: string | number = '';\n  for (let i = 0; i < path.length; i++) {\n    const prop = path[i];\n    if (!owned.has(container)) {\n      let copy: any;\n      if (typeof prop === 'number') {\n        copy = Array.isArray(container) ? container.slice() : [];\n      } else {\n        copy = {...container};\n      }\n      owned.add(copy);\n      if (i === 0) root = copy;\n      else parent[parentProp] = copy;\n      container = copy;\n    }\n    if (i === path.length - 1) {\n      container[prop] = value;\n    } else {\n      parent = container;\n      parentProp = prop;\n      container = container[prop];\n    }\n  }\n  return root;\n}\n\nexport function isNil(value: any): value is null | undefined {\n  return value == null;\n}\n\nexport function isEmpty(value: any): boolean {\n  if (isNil(value)) return true;\n  if (typeof value !== 'object') return false;\n\n  const values = Object.values(value);\n  return values.length === 0 || values.every(isEmpty);\n}\n\nexport function isPromise(value: any): value is Promise<any> {\n  return value && typeof value.then === 'function';\n}\n\nexport function waitUntil(\n  emitter: EventEmitter<any>,\n  event: string,\n  isResolve: () => boolean,\n  isReject: () => boolean\n): Promise<void> {\n  return new Promise<void>((resolve, reject) => {\n    if (isReject()) return void reject();\n    if (isResolve()) return void resolve();\n\n    const off = on(emitter, event as any, () => {\n      if (isReject()) {\n        off();\n        reject();\n        return;\n      }\n      // Condition not reached yet — stay subscribed and keep waiting. (The\n      // previous `if (isResolve()) return` was inverted: it hung forever\n      // once the condition held and resolved prematurely while it didn't.)\n      if (!isResolve()) return;\n      off();\n      resolve();\n    });\n  });\n}\n","import {normalizePath} from './util';\n\nexport type PathSegments = (string | number)[];\nexport type Name = string | PathSegments;\nexport type Path = {value: PathSegments; key: string};\n\nexport default function create(name: Name): Path {\n  const value = normalizePath(name);\n  return {value, key: JSON.stringify(value)};\n}\n","import {create as createEmitter, emit as _emit} from '@for-fun/event-emitter';\nimport type {EventEmitter} from '@for-fun/event-emitter';\nimport createPath from './path';\nimport type {Name, Path, PathSegments} from './path';\nimport type {FieldPath, PathValueOf} from './types';\nimport {get, normalizePath, setOwned, unset, waitUntil} from './util';\n\nexport type {Name};\nexport type {FieldPath, PathValue} from './types';\n\nconst emit = _emit as (\n  emitter: EventEmitter,\n  event: string,\n  ...args: any[]\n) => void;\n\n/** A field error: `type` identifies the error kind ('custom' for plain\n * string errors), `message` is the display text. */\nexport interface FieldError {\n  type: string;\n  message: string;\n}\n\n/** A flattened entry from {@link getErrors}. */\nexport type FieldErrorEntry = {path: string; type: string; message: string};\n\n/** When a field is validated:\n * - `'onSubmit'` (default): only on submit\n * - `'onBlur'`: when the field loses focus\n * - `'onChange'`: on every change\n * - `'onTouched'`: on first blur, then on every change\n * - `'all'`: on both change and blur\n */\nexport type ValidationMode =\n  | 'onSubmit'\n  | 'onBlur'\n  | 'onChange'\n  | 'onTouched'\n  | 'all';\n\n/** When a field is re-validated after it already has an error:\n * - `'onChange'` (default): on every change\n * - `'onBlur'`: when the field loses focus\n * - `'onSubmit'`: only on submit (no live re-validation)\n */\nexport type ReValidateMode = 'onChange' | 'onBlur' | 'onSubmit';\n\n/** Brand marking a form-level validate result as a structured\n * {@link ValidationOutcome} (parsed values and/or errors) rather than a\n * plain nested error record. Symbols cannot collide with user error\n * records, so detection is an exact `VALIDATION_OUTCOME in result`. */\nexport const VALIDATION_OUTCOME: unique symbol = Symbol('validation-outcome');\n\n/** Structured form-level validate result: `errors` uses the same nested\n * shape a plain error record uses, `values` is the schema's parsed output\n * (coerce/transform results included). Either side may be omitted. */\nexport type ValidationOutcome<T> = {\n  [VALIDATION_OUTCOME]: true;\n  errors?: Record<string, any>;\n  values?: T;\n};\n\n/** What a form-level validate function may return: a plain nested error\n * record (flattened into field errors — the long-standing shape), or a\n * branded {@link ValidationOutcome} whose `values` become the form's\n * parsedValues baseline. */\nexport type ValidateResult<T> =\n  | Record<string, any>\n  | ValidationOutcome<T>\n  | Promise<Record<string, any> | ValidationOutcome<T>>;\n\nexport interface Form<T extends Record<string, any> = any> {\n  emitter: EventEmitter;\n  mode: ValidationMode;\n  reValidateMode: ReValidateMode;\n  initialValues: T;\n  values: Map<string, any>;\n  /** Tombstones of unregistered field paths (JSON path keys): reading or\n   * merging values must not fall back to initialValues for these paths. */\n  deleted: Set<string>;\n  /** Every error registered for a field, as a non-empty array (the\n   * write-side {@link setErrorByPath} normalizes to this invariant, so\n   * readers never need to guard against an empty list). Readers wanting\n   * the display error take the first entry ({@link getError}); readers\n   * wanting all of them use {@link getFieldErrors}. */\n  errors: Map<string, FieldError[]>;\n  touched: Set<string>;\n  validators: Map<string, () => void>;\n  validating: Set<string>;\n  /** Parsed values from the last successful schema validation: the\n   * schema's complete output tree (coerced/transformed values included).\n   * Sits between initialValues and the values Map in {@link getValues}\n   * until `reset`/`setInitialValues` clears it. Never affects dirty\n   * state — that compares live edits against initialValues only. */\n  parsedValues: T | undefined;\n  validate?: (values: T) => ValidateResult<T>;\n  isSubmitting: boolean;\n  submitCount: number;\n  isSubmitSuccessful: boolean | undefined;\n  /** Form-level disabled flag, OR-ed into every bound field's `disabled`\n   * (form flag || the field's own option). Seeded from\n   * {@link Options}.disabled at create time and toggled at runtime with\n   * {@link setDisabled}, which emits a payload-less 'disabled' event so\n   * subscribed fields re-render. */\n  disabled: boolean;\n}\n\nexport type Options<T extends Record<string, any> = any> = {\n  initialValues?: T;\n  /** When fields are validated. Defaults to `'onSubmit'`. See\n   * {@link ValidationMode}. */\n  mode?: ValidationMode;\n  /** When a field is re-validated after it already has an error — it only\n   * takes effect once the field has an error. Defaults to `'onChange'`. See\n   * {@link ReValidateMode}. */\n  reValidateMode?: ReValidateMode;\n  /**\n   * Form-level validator. Returns a record of errors keyed by field path;\n   * nested objects are flattened ('a.b' style) and array values contribute\n   * every non-empty string they hold as separate errors (zod `flatten()`\n   * formErrors style). Schema adapters instead return a branded\n   * {@link ValidationOutcome}: `errors` flattens the same way, `values`\n   * (the schema's parsed output) becomes the form's parsedValues baseline\n   * that {@link getValues} layers over initialValues.\n   */\n  validate?: (values: T) => ValidateResult<T>;\n  /** Start the form with every bound field disabled — the flag bound\n   * fields OR with their own `disabled` option (a field cannot opt out\n   * of a disabled form). Toggle later with {@link setDisabled}.\n   * Defaults to `false`. */\n  disabled?: boolean;\n};\n\n/**\n * Create form instance\n * @param options\n * @return form instance\n */\nexport default function create<T extends Record<string, any> = any>(\n  options?: Options<T>\n): Form<T> {\n  const emitter = createEmitter();\n  return {\n    emitter,\n    ...options,\n    mode: options?.mode ?? 'onSubmit',\n    reValidateMode: options?.reValidateMode ?? 'onChange',\n    disabled: options?.disabled ?? false,\n    initialValues: (options?.initialValues ?? {}) as T,\n    values: new Map(),\n    deleted: new Set(),\n    errors: new Map(),\n    touched: new Set(),\n    validators: new Map(),\n    validating: new Set(),\n    parsedValues: undefined,\n    isSubmitting: false,\n    submitCount: 0,\n    isSubmitSuccessful: undefined\n  };\n}\n\n/**\n * Get form values: the values Map layered over parsedValues (when a schema\n * validation produced them) layered over initialValues.\n *\n * Merged with copy-on-write ownership tracking ({@link setOwned}): every\n * distinct container on a written path is allocated once and shared by all\n * paths through it, instead of re-copying the whole branch for every key.\n * One owned set spans the whole merge, so containers borrowed from the\n * parsedValues tree are copied before mutation exactly like initialValues\n * ones. The result is still a freshly merged tree per call, with untouched\n * branches sharing references with the baseline exactly like chained\n * `set` did -- callers may treat it as their own copy.\n *\n * parsedValues is the schema's complete output tree: once validation\n * succeeds it replaces the initialValues baseline (fields the schema\n * dropped disappear), while live edits in the values Map still win over\n * both. It never affects dirty state — {@link isDirty} and\n * {@link getDirtyFields} compare live edits against initialValues only,\n * because parsing is not a user edit.\n *\n * @param form\n */\nexport function getValues<T extends Record<string, any> = any>(\n  form: Form<T>\n): T {\n  const {initialValues, parsedValues, values, deleted} = form;\n  const owned = new Set<object>();\n  let merged = parsedValues ?? initialValues;\n  for (const [key, value] of values) {\n    merged = setOwned(merged, JSON.parse(key), value, owned);\n  }\n  // Unregistered fields leave a tombstone in `deleted`; remove those paths\n  // from the merged result so they don't fall back to initialValues. unset\n  // is immutable (set() shares untouched branches with initialValues, so a\n  // mutating delete would corrupt them) and deletes the key outright rather\n  // than writing undefined, which would leave `a: undefined` entries behind\n  // in anything that spreads getValues().\n  for (const key of deleted) {\n    merged = unset(merged, JSON.parse(key));\n  }\n  return merged;\n}\n\n/**\n * Get field value\n * @param form\n * @param name\n */\nexport function getValue<\n  T extends Record<string, any> = any,\n  P extends FieldPath<T> | Name = Name\n>(form: Form<T>, name: P): PathValueOf<T, P> {\n  return getValueByPath(form, createPath(name));\n}\n\n/**\n * Get field value by path\n * @param form\n * @param path\n */\nexport function getValueByPath(\n  {initialValues, parsedValues, values, deleted}: Form,\n  path: Path\n): any {\n  if (values.has(path.key)) return values.get(path.key);\n  // Unregistered path: the tombstone blocks the initialValues fallback.\n  if (deleted.has(path.key)) return undefined;\n  // Same layering as getValues: parsed values (when present) are the\n  // baseline above initialValues.\n  return get(parsedValues ?? initialValues, path.value);\n}\n\n/** Options accepted by {@link setValue} / {@link setValueByPath}. Every flag\n * defaults to `false`; omitting the options object entirely keeps the plain\n * set-value behavior (no validation, no touched marking). */\nexport interface SetFieldOptions {\n  /** Run the field's registered validator (if any) after the value lands,\n   * same as triggering that single field. Defaults to `false`. */\n  shouldValidate?: boolean;\n  /** Mark the field as touched. Defaults to `false`. */\n  shouldTouch?: boolean;\n  /** Reserved for a future manual dirty marker. Dirty state is currently\n   * derived from comparing values against initialValues, so this flag is\n   * accepted but does nothing. Defaults to `false`. */\n  shouldDirty?: boolean;\n}\n\n/**\n * Set field value\n * @param form\n * @param name\n * @param value\n * @param options\n */\nexport function setValue<\n  T extends Record<string, any> = any,\n  P extends FieldPath<T> | Name = Name\n>(\n  form: Form<T>,\n  name: P,\n  value: PathValueOf<T, P>,\n  options?: SetFieldOptions\n): void {\n  setValueByPath(form, createPath(name), value, options);\n}\n\n/**\n * Set field value\n * @param form\n * @param path\n * @param value\n * @param options\n */\nexport function setValueByPath(\n  form: Form,\n  path: Path,\n  value: any,\n  options?: SetFieldOptions\n): void {\n  const {emitter, values, deleted} = form;\n  values.set(path.key, value);\n  reviveBranch(deleted, path);\n  bumpDirtyVersion(form);\n  if (options?.shouldTouch) setTouchedByPath(form, path);\n  if (options?.shouldValidate) form.validators.get(path.key)?.();\n  emit(emitter, 'change', path);\n}\n\n/**\n * Get field error\n * @param form\n * @param name\n * @return FieldError object or undefined\n */\nexport function getError<\n  T extends Record<string, any> = any,\n  P extends FieldPath<T> | Name = Name\n>(form: Form<T>, name: P): FieldError | undefined {\n  return getErrorByPath(form, createPath(name));\n}\n\n/**\n * Get field error by path\n * @param form\n * @param path\n * @return first FieldError of the field, or undefined\n */\nexport function getErrorByPath(\n  {errors}: Form,\n  path: Path\n): FieldError | undefined {\n  return errors.get(path.key)?.[0];\n}\n\n/** Shared empty result for {@link getFieldErrorsByPath}: a fresh `[]` per\n * call would allocate on the hot no-error path, and the stored arrays are\n * handed out by reference too, so callers must treat results as read-only. */\nconst NO_ERRORS: FieldError[] = [];\n\n/**\n * Get all errors of a field\n * @param form\n * @param name\n * @return every error registered for the field (insertion order); an empty\n *         array when the field has none\n */\nexport function getFieldErrors<\n  T extends Record<string, any> = any,\n  P extends FieldPath<T> | Name = Name\n>(form: Form<T>, name: P): FieldError[] {\n  return getFieldErrorsByPath(form, createPath(name));\n}\n\n/**\n * Get all errors of a field by path\n * @param form\n * @param path\n * @return every error registered for the field (insertion order); an empty\n *         array when the field has none\n */\nexport function getFieldErrorsByPath({errors}: Form, path: Path): FieldError[] {\n  return errors.get(path.key) ?? NO_ERRORS;\n}\n\n/**\n * Get all errors\n * @param form\n * @return array of {path, type, message} entries, in insertion order; path\n *         is the user-facing dotted field path ('a.b', 'list.0'), and a\n *         field holding several errors contributes one entry per error\n */\nexport function getErrors({errors}: Form): FieldErrorEntry[] {\n  const entries: FieldErrorEntry[] = [];\n  for (const [key, list] of errors) {\n    const path = (JSON.parse(key) as PathSegments).join('.');\n    for (const {type, message} of list) entries.push({path, type, message});\n  }\n  return entries;\n}\n\n/**\n * Get first error message\n * @param form\n * @return first error's message string, or undefined when there are no errors\n */\nexport function getFirstError({errors}: Form): string | undefined {\n  return errors.values().next().value?.[0]?.message;\n}\n\n/** Snapshot of one field's aggregated state, as {@link getFieldState}\n * returns it. `errors` is the stored array shared with the form — treat it\n * as read-only, like every {@link getFieldErrors} result. */\nexport interface FieldState<T = any> {\n  value: T;\n  error: FieldError | undefined;\n  errors: FieldError[];\n  isDirty: boolean;\n  isTouched: boolean;\n  isValidating: boolean;\n}\n\n/**\n * Get one field's aggregated state: the layered value ({@link getValue}),\n * the first error ({@link getError}) and every error ({@link\n * getFieldErrors}), dirtiness, the touched flag, and whether a validator\n * is in flight. `isDirty` applies the same per-field rule as {@link\n * getDirtyFields}: a live value exists and differs from initialValues at\n * that path (parsedValues never counts — parsing is not an edit).\n *\n * @param form\n * @param name\n */\nexport function getFieldState<\n  T extends Record<string, any> = any,\n  P extends FieldPath<T> | Name = Name\n>(form: Form<T>, name: P): FieldState<PathValueOf<T, P>> {\n  const path = createPath(name);\n  const {initialValues, values, touched, validating} = form;\n  const live = values.get(path.key);\n  return {\n    value: getValueByPath(form, path),\n    error: getErrorByPath(form, path),\n    errors: getFieldErrorsByPath(form, path),\n    isDirty: values.has(path.key) && get(initialValues, path.value) !== live,\n    isTouched: touched.has(path.key),\n    isValidating: validating.has(path.key)\n  };\n}\n\nexport function unsetValidatingByPath(\n  {emitter, validating}: Form,\n  path: Path\n): void {\n  validating.delete(path.key);\n  // Path payload lets key-scoped subscribers (onKeyEvent) skip unrelated\n  // fields; payload-less listeners ignore it.\n  emit(emitter, 'validating', path);\n}\n\nexport function setValidatingByPath(\n  {emitter, validating}: Form,\n  path: Path\n): void {\n  validating.add(path.key);\n  emit(emitter, 'validating', path);\n}\n\n/**\n * Set field error\n * @param form\n * @param name\n * @param error string is normalized to {type: 'custom', message}; a\n *        FieldError object is stored as-is; an array holds several errors\n *        (falsy items dropped, strings normalized); undefined clears\n */\nexport function setError<\n  T extends Record<string, any> = any,\n  P extends FieldPath<T> | Name = Name\n>(\n  form: Form<T>,\n  name: P,\n  error: string | FieldError | (string | FieldError)[] | undefined\n): void {\n  setErrorByPath(form, createPath(name), error);\n}\n\n/**\n * Set field error\n * @param form\n * @param path\n * @param error string is normalized to {type: 'custom', message}; a\n *        FieldError object is stored as-is; an array holds several errors\n *        (falsy items dropped, strings normalized); undefined clears\n */\nexport function setErrorByPath(\n  {emitter, errors}: Form,\n  path: Path,\n  error: string | FieldError | (string | FieldError)[] | undefined\n): void {\n  const list = normalizeErrors(error);\n  // An empty result (undefined, '', or an array of only falsy items) clears\n  // the key: the errors Map never stores an empty list, so hasErrors stays\n  // a plain size check and readers can index [0] unguarded.\n  if (list) errors.set(path.key, list);\n  else errors.delete(path.key);\n  // Path payload lets key-scoped subscribers (onKeyEvent) skip unrelated\n  // fields; payload-less listeners ignore it.\n  emit(emitter, 'errors', path);\n}\n\n/** Normalize any {@link setErrorByPath} input into the stored non-empty\n * FieldError[] shape, or undefined when there is nothing to store. */\nfunction normalizeErrors(\n  error: string | FieldError | (string | FieldError)[] | undefined\n): FieldError[] | undefined {\n  if (typeof error === 'string') {\n    return error ? [{type: 'custom', message: error}] : undefined;\n  }\n  if (isFieldError(error)) return [error];\n  if (!error) return undefined;\n  // Falsy items drop out before normalization, so '' never becomes a\n  // stored {type: 'custom', message: ''} placeholder.\n  const list: FieldError[] = [];\n  error.forEach(item => {\n    if (typeof item === 'string' && item) {\n      list.push({type: 'custom', message: item});\n    } else if (isFieldError(item)) {\n      list.push(item);\n    }\n  });\n  return list.length ? list : undefined;\n}\n\n/**\n * Clear errors\n * @param form\n * @param name a single path or a list of paths; omit to clear every error\n */\nexport function clearErrors(form: Form, name?: Name | Name[]): void {\n  const {emitter, errors} = form;\n  if (name === undefined) {\n    errors.clear();\n    // Payload-less broadcast: every error subscriber re-syncs.\n    emit(emitter, 'errors');\n    return;\n  }\n  // Same single-path vs list discrimination as trigger: a segment array\n  // holding a number is one path ('a.0' shape), not a list of names.\n  const paths =\n    typeof name === 'string' || isSegmentsPath(name)\n      ? [createPath(name)]\n      : name.map(one => createPath(one));\n  for (const {key} of paths) errors.delete(key);\n  // Path-payload emits — the setErrorByPath scoping — wake exactly the\n  // affected fields' subscribers.\n  for (const path of paths) emit(emitter, 'errors', path);\n}\n\n/**\n * Set field touched state\n * @param form\n * @param name\n */\nexport function setTouched(form: Form, name: Name): void {\n  setTouchedByPath(form, createPath(name));\n}\n\n/**\n * Set field touched state\n * @param form\n * @param path\n */\nexport function setTouchedByPath({emitter, touched}: Form, path: Path): void {\n  if (touched.has(path.key)) return;\n  touched.add(path.key);\n  // Path payload lets key-scoped subscribers (onKeyEvent) skip unrelated\n  // fields; payload-less listeners ignore it.\n  emit(emitter, 'touched', path);\n}\n\n/**\n * Check if field has been touched\n * @param form\n * @param name\n */\nexport function hasTouched<\n  T extends Record<string, any> = any,\n  P extends FieldPath<T> | Name = Name\n>(form: Form<T>, name: P): boolean {\n  return hasTouchedByPath(form, createPath(name));\n}\n\n/**\n * Check if field has been touched\n * @param form\n * @param path\n */\nexport function hasTouchedByPath({touched}: Form, path: Path): boolean {\n  return touched.has(path.key);\n}\n\n/**\n * Is dirty -- any value differs from initialValues\n * @param form\n */\nexport function isDirty(form: Form): boolean {\n  let dirty = false;\n  forEachDirtyField(form, () => {\n    dirty = true;\n  });\n  return dirty;\n}\n\nfunction forEachDirtyField(\n  {initialValues, values}: Form,\n  fn: (dottedKey: string) => void\n): void {\n  for (const [key, value] of values) {\n    const path = JSON.parse(key) as PathSegments;\n    if (get(initialValues, path) !== value) fn(path.join('.'));\n  }\n}\n\n/** Per-form memoization of {@link getDirtyFields}. `version` counts value\n * mutations since the cached `result` was computed: bump points increment\n * it, reads reset it, so a non-zero version means the cache is stale. */\ninterface DirtyFieldsCache {\n  version: number;\n  result: Record<string, boolean>;\n}\n\nconst dirtyFieldsCaches = new WeakMap<Form, DirtyFieldsCache>();\n\n/**\n * Invalidate `form`'s cached {@link getDirtyFields} result. Called at every\n * point that can change values or initialValues (setValueByPath,\n * removeFieldByPath, setInitialValues, reset) so repeated reads hand out a\n * stable reference and useWatch's Object.is snapshot check can skip\n * re-renders.\n */\nfunction bumpDirtyVersion(form: Form): void {\n  const cache = dirtyFieldsCaches.get(form);\n  if (cache) cache.version++;\n}\n\nfunction computeDirtyFields(form: Form): Record<string, boolean> {\n  const dirtyFields: Record<string, boolean> = {};\n  forEachDirtyField(form, key => {\n    dirtyFields[key] = true;\n  });\n  return dirtyFields;\n}\n\n/** Dirty entries only ever map to `true`, so equal key sets mean shallow\n * equal results. */\nfunction sameDirtyKeys(\n  a: Record<string, boolean>,\n  b: Record<string, boolean>\n): boolean {\n  const aKeys = Object.keys(a);\n  if (aKeys.length !== Object.keys(b).length) return false;\n  return aKeys.every(key => b[key] === true);\n}\n\n/**\n * Get dirty fields -- fields whose current value differs from initialValues.\n * Keys are user-facing dotted paths ('a.b', 'a.0.c'), unlike the JSON array\n * keys stored in the values Map.\n * @param form\n * @return object mapping each dirty field's dotted path to true; the same\n * reference is returned until the dirty set actually changes\n */\nexport function getDirtyFields(form: Form): Record<string, boolean> {\n  let cache = dirtyFieldsCaches.get(form);\n  if (!cache) {\n    cache = {version: 0, result: computeDirtyFields(form)};\n    dirtyFieldsCaches.set(form, cache);\n  } else if (cache.version > 0) {\n    const result = computeDirtyFields(form);\n    // Keep the old reference when the dirty set is unchanged (values always\n    // map to true) so subscribers see identity-stable snapshots.\n    if (!sameDirtyKeys(cache.result, result)) cache.result = result;\n    cache.version = 0;\n  }\n  return cache.result;\n}\n\n/**\n * Get touched fields as user-facing dotted paths ('a.b', 'a.0.c'), unlike\n * the JSON array keys stored in the touched Set.\n * @param form\n * @return array of touched fields' dotted paths\n */\nexport function getTouchedFields({touched}: Form): string[] {\n  return Array.from(touched, key =>\n    (JSON.parse(key) as PathSegments).join('.')\n  );\n}\n\n/**\n * Is touched -- any field has been touched\n * @param form\n */\nexport function isTouched({touched}: Form): boolean {\n  return touched.size > 0;\n}\n\n/**\n * Remove field\n * @param form\n * @param name\n */\nexport function removeField(form: Form, name: Name): void {\n  removeFieldByPath(form, createPath(name));\n}\n\n/**\n * Remove field\n * @param form\n * @param path\n */\nexport function removeFieldByPath(\n  form: Form,\n  {key, value: segments}: Path\n): void {\n  const {emitter, values, touched, errors, validating, deleted} = form;\n  values.delete(key);\n  touched.delete(key);\n  errors.delete(key);\n  validating.delete(key);\n  // Tombstone the unregistered path so later reads do not fall back to\n  // initialValues and \"revive\" the field's old initial value. A tombstone\n  // never shadows live values: skip it when the branch is already covered\n  // by a live ancestor key (e.g. a FieldArray rewrite stored the whole\n  // array at the parent path) or a still-mounted descendant key.\n  if (!hasLiveBranch(values, segments)) deleted.add(key);\n  bumpDirtyVersion(form);\n  emit(emitter, 'change');\n  emit(emitter, 'touched');\n  emit(emitter, 'errors');\n  emit(emitter, 'validating');\n}\n\n/**\n * Does a live value cover the branch at `segments` -- either at an ancestor\n * key or below it at a descendant key?\n */\nfunction hasLiveBranch(\n  values: Map<string, any>,\n  segments: PathSegments\n): boolean {\n  for (let i = 1; i < segments.length; i++) {\n    if (values.has(JSON.stringify(segments.slice(0, i)))) return true;\n  }\n  const stem = `${JSON.stringify(segments).slice(0, -1)},`;\n  for (const key of values.keys()) {\n    if (key.startsWith(stem)) return true;\n  }\n  return false;\n}\n\n/**\n * Writing a value revives its whole branch: drop any removal tombstone for\n * the path itself, its ancestors, or its descendants (a remounted field\n * overwrites its own tombstone; rewriting a parent array supersedes the\n * tombstones of shifted child paths).\n */\nfunction reviveBranch(deleted: Set<string>, {key}: Path): void {\n  if (!deleted.size) return;\n  for (const tombstone of deleted) {\n    if (\n      tombstone === key ||\n      tombstone.startsWith(`${key.slice(0, -1)},`) ||\n      key.startsWith(`${tombstone.slice(0, -1)},`)\n    ) {\n      deleted.delete(tombstone);\n    }\n  }\n}\n\n/**\n * Set form initialValues\n * @param form\n * @param initialValues\n */\nexport function setInitialValues(form: Form, initialValues: any): void {\n  if (form.initialValues === initialValues) return;\n  form.initialValues = initialValues;\n  // A new baseline invalidates the previous schema parse.\n  form.parsedValues = undefined;\n  form.values.clear();\n  form.deleted.clear();\n  bumpDirtyVersion(form);\n  emit(form.emitter, 'change');\n}\n\n/** Options accepted by {@link reset}. Every flag defaults to `false` —\n * omitting the object (or any flag) keeps the plain full-reset behavior.\n * Names mirror react-hook-form's reset options to ease migration. */\nexport interface ResetOptions {\n  /** Keep the current values of fields that are dirty — differ from the\n   * pre-reset initialValues (the same rule {@link getDirtyFields} applies).\n   * Clean fields fall back to the new initialValues as usual. */\n  keepDirtyValues?: boolean;\n  /** Keep the touched set instead of clearing it. */\n  keepTouched?: boolean;\n  /** Keep field errors instead of clearing them. */\n  keepErrors?: boolean;\n  /** Keep the submitted flag (`isSubmitSuccessful`) instead of clearing\n   * it. */\n  keepIsSubmitted?: boolean;\n  /** Keep `submitCount` instead of resetting it to 0. */\n  keepSubmitCount?: boolean;\n  /** Keep `isSubmitting` instead of resetting it to false. */\n  keepIsSubmitting?: boolean;\n}\n\n/**\n * Reset form\n * @param form\n * @param initialValues\n * @param options keep-flags to preserve slices of state through the reset\n */\nexport function reset(\n  form: Form,\n  initialValues?: any,\n  options?: ResetOptions\n): void {\n  // Snapshot dirty fields' live values before the wipe: dirtiness is\n  // measured against the pre-reset initialValues, so capture must happen\n  // before form.values and form.initialValues are touched.\n  const dirtyValues = options?.keepDirtyValues\n    ? Object.keys(getDirtyFields(form)).map(key => ({\n        key,\n        value: getValue(form, key)\n      }))\n    : [];\n  form.initialValues = initialValues;\n  // The fresh baseline drops any schema parse from the previous cycle.\n  form.parsedValues = undefined;\n  if (!options?.keepErrors) clearErrors(form);\n  const {emitter, touched, values, deleted, validating} = form;\n  values.clear();\n  deleted.clear();\n  if (!options?.keepTouched) touched.clear();\n  validating.clear();\n  if (!options?.keepIsSubmitting) form.isSubmitting = false;\n  if (!options?.keepSubmitCount) form.submitCount = 0;\n  if (!options?.keepIsSubmitted) form.isSubmitSuccessful = undefined;\n  bumpDirtyVersion(form);\n  // Write the kept dirty values back over the fresh baseline: plain\n  // setValueByPath, so no validation fires and nothing is marked touched.\n  for (const {key, value} of dirtyValues) {\n    setValueByPath(form, createPath(key), value);\n  }\n  emit(emitter, 'change');\n  emit(emitter, 'touched');\n  emit(emitter, 'validating');\n  emit(emitter, 'submitting');\n  emit(emitter, 'submitCount');\n  emit(emitter, 'submitSuccessful');\n  emit(emitter, 'reset');\n}\n\n/** Options accepted by {@link resetField}. The flags default to `false`;\n * `value` has no default — omitted, the field falls back to initialValues;\n * provided, the explicit value becomes the live value with no fallback at\n * all. Mirrors react-hook-form's resetField options (`value` plays their\n * `defaultValue`'s role) to ease migration. */\nexport interface ResetFieldOptions {\n  /** Keep the field's touched flag instead of clearing it. */\n  keepTouched?: boolean;\n  /** Keep the field's errors instead of clearing them. */\n  keepErrors?: boolean;\n  /** Explicit post-reset value for the field — never falls back to\n   * initialValues. */\n  value?: any;\n}\n\n/**\n * Reset a single field: drop its live value (reads fall back to the\n * baseline — initialValues, or the schema's parsed output when one\n * exists, in which case the path is removed from parsedValues and the\n * initial value pinned back so the field reads initialValues again),\n * clear its touched flag and errors, and revive the path's removal\n * tombstones — the inverse of {@link removeFieldByPath}. Other fields\n * and the submission flags are untouched; see {@link reset} for the\n * form-wide counterpart.\n *\n * @param form\n * @param name\n * @param options\n */\nexport function resetField<\n  T extends Record<string, any> = any,\n  P extends FieldPath<T> | Name = Name\n>(form: Form<T>, name: P, options?: ResetFieldOptions): void {\n  const path = createPath(name);\n  const {emitter, values, touched, errors, deleted} = form;\n  values.delete(path.key);\n  // A parse baseline wholesale-shadows initialValues in reads (see\n  // getValues), so unset alone would read the path as undefined. Remove\n  // the path from the tree (immutable — parsedValues shares branches with\n  // the schema's own output) and pin the initial value back as the live\n  // value: equal to initialValues, so the field stays clean.\n  if (form.parsedValues !== undefined) {\n    form.parsedValues = unset(form.parsedValues, path.value);\n    const initial = get(form.initialValues, path.value);\n    if (initial !== undefined) values.set(path.key, initial);\n  }\n  if (options && 'value' in options) {\n    values.set(path.key, options.value);\n  }\n  // A reset re-registers the branch, same as a write: tombstones on the\n  // path or around it stop applying.\n  reviveBranch(deleted, path);\n  // Payload-less like removeFieldByPath: reviveBranch can un-tombstone\n  // ancestor or descendant paths, whose readers must re-sync too.\n  emit(emitter, 'change');\n  if (!options?.keepTouched && touched.delete(path.key)) {\n    emit(emitter, 'touched', path);\n  }\n  if (!options?.keepErrors && errors.delete(path.key)) {\n    emit(emitter, 'errors', path);\n  }\n  bumpDirtyVersion(form);\n}\n\n/**\n * @param form\n */\nexport function hasErrors({errors}: Form): boolean {\n  return errors.size > 0;\n}\n\n/**\n * Trigger field validation.\n *\n * Without `name` every registered field validator runs. A single `name` —\n * dotted string or segments array — runs only that field's validator, and\n * an array of names runs each one in order. An empty array is a no-op, as\n * is any name with no registered validator. An array argument counts as\n * one segments path only when it mixes in numbers (`['items', 0]`); pure\n * string arrays are name lists, so `['a', 'b']` triggers fields `a` and\n * `b`, not the nested path `a.b`.\n *\n * The returned promise waits for the triggered validation to settle —\n * async validators included — so their errors have already landed in\n * `form.errors` when it resolves. It never rejects: landing errors is the\n * expected outcome here, not a failure. Resolves `true` when the triggered\n * scope is error-free, `false` otherwise. Without `name` the scope is all\n * fields plus the form-level `validate` result (which runs after field\n * validators settle, same pipeline as {@link ensureValidate}); with `name`\n * only those fields' own errors count and form-level `validate` is\n * skipped (RHF semantics).\n *\n * Fire-and-forget callers may ignore the promise: the validator kicks\n * still happen synchronously, matching the pre-promise behavior.\n *\n * @param form\n * @param name field name(s) to trigger, or all fields when omitted\n * @return whether the triggered scope is error-free once validation settles\n */\nexport async function trigger(\n  form: Form,\n  name?: Name | Name[]\n): Promise<boolean> {\n  // Never reject (an error landing is a normal outcome, not a failure), so\n  // waitUntil's isReject is permanently false. Waiting on the whole\n  // `validating` set is deliberately conservative: it also rides out\n  // unrelated in-flight validators rather than racing them.\n  const settle = () =>\n    waitUntil(\n      form.emitter,\n      'validating',\n      () => !form.validating.size,\n      () => false\n    );\n\n  if (name === undefined) {\n    form.validators.forEach(validator => validator());\n    await settle();\n    if (form.validate) {\n      const result = await form.validate(getValues(form));\n      applyValidateResult(form, result);\n    }\n    return !hasErrors(form);\n  }\n\n  const keys: string[] =\n    typeof name === 'string' || isSegmentsPath(name)\n      ? [createPath(name).key]\n      : name.map(one => createPath(one).key);\n  keys.forEach(key => form.validators.get(key)?.());\n  await settle();\n  return keys.every(key => !form.errors.has(key));\n}\n\n/** Numbers only occur inside a segments path (`['a', 0]`), never as\n * standalone names, so a top-level number marks `name` as one single path\n * rather than a list of names. */\nfunction isSegmentsPath(name: PathSegments | Name[]): name is PathSegments {\n  return (name as (number | unknown)[]).some(part => typeof part === 'number');\n}\n\nfunction isFieldError(value: any): value is FieldError {\n  return (\n    !!value &&\n    typeof value === 'object' &&\n    typeof value.type === 'string' &&\n    typeof value.message === 'string'\n  );\n}\n\n/**\n * Flatten a form-level validate result and write each leaf error through\n * setError. Nested objects descend into deeper paths ({a: {b: 'msg'}} sets\n * the 'a.b' error), array values contribute every non-empty string they\n * hold as separate errors (zod flatten() formErrors style), and\n * FieldError-shaped objects are stored as-is. Falsy values are skipped.\n */\nfunction setFormErrors(\n  form: Form,\n  result: Record<string, any>,\n  segments: PathSegments = []\n): void {\n  Object.entries(result).forEach(([key, value]) => {\n    const path: PathSegments = [...segments, ...normalizePath(key)];\n    if (typeof value === 'string') {\n      if (value) setError(form, path, value);\n    } else if (Array.isArray(value)) {\n      setError(form, path, value);\n    } else if (isFieldError(value)) {\n      setError(form, path, value);\n    } else if (value && typeof value === 'object') {\n      setFormErrors(form, value, path);\n    }\n  });\n}\n\n/** Store a schema validator's parsed output as the getValues baseline\n * layer above initialValues. Payload-less 'change' notifies value\n * watchers (useValue, useDirtyFields, ...); dirty state is untouched —\n * it only compares live edits against initialValues, and parsing is not\n * an edit. */\nfunction setParsedValues(form: Form, values: any): void {\n  if (values === undefined || values === form.parsedValues) return;\n  form.parsedValues = values;\n  emit(form.emitter, 'change');\n}\n\n/**\n * Land a form-level validate result. A plain record keeps the\n * long-standing behavior — flattened into field errors by\n * {@link setFormErrors}. A branded {@link ValidationOutcome} splits\n * instead: `errors` flattens exactly like a plain record, and `values`\n * (the schema's parsed output — coerced/transformed values included)\n * becomes the form's parsedValues baseline. Falsy results are skipped,\n * branded or not.\n */\nfunction applyValidateResult(\n  form: Form,\n  result: ValidateResult<any> | undefined\n): void {\n  if (!result) return;\n  if (typeof result === 'object' && VALIDATION_OUTCOME in result) {\n    const outcome = result as ValidationOutcome<any>;\n    if (outcome.errors) setFormErrors(form, outcome.errors);\n    setParsedValues(form, outcome.values);\n    return;\n  }\n  setFormErrors(form, result as Record<string, any>);\n}\n\n/**\n * Validate and throw if any field error.\n * @param form\n * @return resolve if no error; reject and stop validate if has an error\n */\nexport async function ensureValidate(form: Form): Promise<void> {\n  form.validators.forEach(validator => validator());\n\n  await waitUntil(\n    form.emitter,\n    'validating',\n    () => !form.validating.size,\n    () => hasErrors(form)\n  ).catch(() => {\n    throw new Error(getFirstError(form));\n  });\n\n  if (form.validate) {\n    const result = await form.validate(getValues(form));\n    applyValidateResult(form, result);\n    if (hasErrors(form)) throw new Error(getFirstError(form));\n  }\n}\n\n/**\n * Validate and return if any field error.\n * @param form\n * @return error message string or void\n */\nexport async function validate(form: Form): Promise<void | string> {\n  return ensureValidate(form).catch(e => e.message);\n}\n\nexport function setIsSubmitting(form: Form, value: boolean): void {\n  form.isSubmitting = value;\n  emit(form.emitter, 'submitting');\n}\n\nexport function incrementSubmitCount(form: Form): void {\n  form.submitCount++;\n  emit(form.emitter, 'submitCount');\n}\n\nexport function setSubmitSuccessful(form: Form, value: boolean): void {\n  form.isSubmitSuccessful = value;\n  emit(form.emitter, 'submitSuccessful');\n}\n\n/**\n * Set the form-level disabled flag and emit a payload-less 'disabled'\n * event — subscribed fields (useField and the components built on it)\n * re-render with the merged disabled state: form flag || their own\n * `disabled` option.\n * @param form\n * @param value\n */\nexport function setDisabled(form: Form, value: boolean): void {\n  form.disabled = value;\n  emit(form.emitter, 'disabled');\n}\n\n/** Structural slice of a <form>-like element: an elements collection whose\n * controls expose the constraint-validation members we read. Matches the\n * DOM HTMLFormElement shape without coupling the core to DOM types. */\ninterface NativeFormElement {\n  elements: ArrayLike<{\n    name: string;\n    checkValidity: () => boolean;\n    validationMessage: string;\n  }>;\n}\n\n/**\n * Converts a control's DOM name to the user-visible dotted path. Field\n * components render the path key (JSON.stringify'd segments, '[\"a\",\"0\"]')\n * as the name attribute, so JSON keys are parsed back and joined with\n * dots; any other name value is returned as-is.\n */\nfunction nameToPath(name: string): string {\n  if (name.startsWith('[')) {\n    try {\n      const segments = JSON.parse(name);\n      if (Array.isArray(segments)) return segments.join('.');\n    } catch {\n      // Not a JSON path key — fall through and use the raw name.\n    }\n  }\n  return name;\n}\n\n/**\n * Collects the constraints failing native validation on a <form> as\n * {@link FieldErrorEntry} entries, in DOM order.\n *\n * Design note: native errors are deliberately NOT written into the form's\n * errors Map. That Map tracks custom validator state, while native\n * validity is transient DOM state owned by the browser (surfaced through\n * reportValidity); onInvalidSubmit receives this snapshot directly.\n */\nfunction getNativeErrors(formEl: NativeFormElement): FieldErrorEntry[] {\n  const errors: FieldErrorEntry[] = [];\n  const {elements} = formEl;\n  for (let i = 0; i < elements.length; i++) {\n    const el = elements[i];\n    if (\n      el.name &&\n      typeof el.checkValidity === 'function' &&\n      !el.checkValidity()\n    ) {\n      errors.push({\n        path: nameToPath(el.name),\n        type: 'native',\n        message: el.validationMessage\n      });\n    }\n  }\n  return errors;\n}\n\n/** Submit callbacks for {@link handleSubmit}. All optional — a missing\n * callback is simply skipped, matching the <Form> component semantics. */\nexport interface HandleSubmitOptions<T extends Record<string, any> = any> {\n  /** Called after validation passes, before onValidSubmit. */\n  onSubmit?: (values: T, e?: any) => void | Promise<void>;\n  /** Called after validation passes, following a successful onSubmit. */\n  onValidSubmit?: (values: T, e?: any) => void | Promise<void>;\n  /**\n   * Called when validation fails.\n   * @param errors array of {path, type, message} entries in insertion\n   *        order; path is the dotted field path ('a.b', 'list.0'), type is\n   *        the error kind ('custom' for plain string errors, 'native' for\n   *        failed DOM constraint validation), message is the display text\n   * @param values current form values\n   */\n  onInvalidSubmit?: (errors: FieldErrorEntry[], values: T) => void;\n  /**\n   * Focus the first error field after a failed submit. Defaults to true —\n   * only an explicit `false` disables it. When custom validation fails,\n   * a 'focusError' event carrying the first error's path key is emitted\n   * on the form (bound fields such as <Field> subscribe and focus their\n   * input); when native constraint validation fails, the submitted\n   * form's first ':invalid' control is focused directly.\n   */\n  shouldFocusError?: boolean;\n}\n\n/**\n * Create an async submit handler for `form` — the headless counterpart of\n * the <Form> component's onSubmit wiring.\n *\n * Behavior mirrors <Form> exactly: preventDefault when present, then the\n * submit state machine (isSubmitting/submitCount/isSubmitSuccessful) runs\n * around native constraint validation (via `e.currentTarget.checkValidity`,\n * skipped when the target has no checkValidity — e.g. React Native or\n * toolbar-button submits) and custom validators. Failed validation fires\n * onInvalidSubmit with the flattened error entries; a passing submit runs\n * onSubmit then onValidSubmit. Errors thrown by either are swallowed into\n * isSubmitSuccessful=false rather than rejecting the returned promise.\n * Failed validation also focuses the offending field (see\n * {@link HandleSubmitOptions.shouldFocusError}).\n *\n * @param form form instance\n * @param options submit callbacks\n * @return async event handler, callable without an event object\n */\nexport function handleSubmit<T extends Record<string, any> = any>(\n  form: Form<T>,\n  options?: HandleSubmitOptions<T>\n): (e?: {preventDefault?: () => void; currentTarget?: any}) => Promise<void> {\n  const {\n    onSubmit,\n    onValidSubmit,\n    onInvalidSubmit,\n    shouldFocusError = true\n  } = options ?? {};\n  return async e => {\n    if (e && typeof e.preventDefault === 'function') {\n      e.preventDefault();\n    }\n    const formEl = e?.currentTarget;\n    setIsSubmitting(form, true);\n    incrementSubmitCount(form);\n    const values = getValues(form);\n\n    if (\n      formEl &&\n      typeof formEl.checkValidity === 'function' &&\n      formEl.checkValidity() === false\n    ) {\n      formEl.reportValidity();\n      // Focus the first natively-invalid control directly off the DOM;\n      // native failures never enter the errors Map (see below).\n      if (shouldFocusError && typeof formEl.querySelector === 'function') {\n        const invalid = formEl.querySelector(':invalid') as HTMLElement | null;\n        if (invalid && typeof invalid.focus === 'function') invalid.focus();\n      }\n      setIsSubmitting(form, false);\n      setSubmitSuccessful(form, false);\n      // Native constraint failures are read from the DOM (not the errors\n      // Map, which only holds custom validation state — see getNativeErrors).\n      if (onInvalidSubmit) onInvalidSubmit(getNativeErrors(formEl), values);\n      return;\n    }\n\n    const error = await validate(form);\n\n    if (error) {\n      setIsSubmitting(form, false);\n      setSubmitSuccessful(form, false);\n      // Notify bound fields (e.g. <Field>) so the first errored one can\n      // focus its input; the payload is the errors Map's first key.\n      if (shouldFocusError) {\n        const firstKey = form.errors.keys().next().value;\n        if (firstKey !== undefined) emit(form.emitter, 'focusError', firstKey);\n      }\n      if (onInvalidSubmit) onInvalidSubmit(getErrors(form), values);\n      return;\n    }\n\n    try {\n      // Re-read after validation: a schema validator's parsed output\n      // (ValidationOutcome.values) landed in parsedValues during\n      // validate(), and the submit callbacks must see the coerced /\n      // transformed values, not the raw pre-validation snapshot.\n      const submitted = getValues(form);\n      if (onSubmit) await onSubmit(submitted, e);\n      if (onValidSubmit) await onValidSubmit(submitted, e);\n      setSubmitSuccessful(form, true);\n    } catch {\n      setSubmitSuccessful(form, false);\n    } finally {\n      setIsSubmitting(form, false);\n    }\n  };\n}\n\n/** Options accepted by {@link setFocus}. All flags default to `false`. */\nexport interface SetFocusOptions {\n  /** Select the field's text after focusing it. Bound fields call\n   * `select()` on their element; elements without one (custom `as`\n   * components) just focus. */\n  shouldSelect?: boolean;\n}\n\n/**\n * Programmatically focus a bound field's element (e.g. the <Field>'s\n * input).\n *\n * Rides the same 'focusError' event channel a failed handleSubmit uses to\n * focus the first errored field: the payload is the target's path key,\n * with the focus options as a second, backward-compatible argument (older\n * subscribers declared with a single `key` parameter simply ignore it).\n * Being event-driven, it is a silent no-op when the field is unmounted or\n * nothing subscribes — unknown names never throw.\n *\n * @param form form instance\n * @param name field name (dot path or segments path)\n * @param options focus options\n */\nexport function setFocus(\n  form: Form,\n  name: Name,\n  options?: SetFocusOptions\n): void {\n  const {key} = createPath(name);\n  // Omit the options argument when absent so the payload is exactly the\n  // shape handleSubmit emits after a failed submit.\n  if (options) emit(form.emitter, 'focusError', key, options);\n  else emit(form.emitter, 'focusError', key);\n}\n"],"names":["emit","_emit","createPath"],"mappings":"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","x_google_ignoreList":[0]}