@echojs-ecosystem/form 0.1.0

package/dist/index.js

@@ -0,0 +1,867 @@
+import { signal, effect } from '@echojs-ecosystem/reactivity';
+
+// src/primitives/field.ts
+
+// src/primitives/field-persist.ts
+var fieldPersistable = (field) => ({
+  value: () => field.$value.peek(),
+  set: (next) => field.set(next),
+  subscribe(listener) {
+    let prev = field.$value.peek();
+    return field.$value.subscribe(() => {
+      const next = field.$value.peek();
+      listener(next, prev);
+      prev = next;
+    });
+  }
+});
+var fieldArrayPersistable = (fieldArray) => ({
+  value: () => [...fieldArray.$items.peek()],
+  set: (next) => fieldArray.replace([...next]),
+  subscribe(listener) {
+    let prev = [...fieldArray.$items.peek()];
+    return fieldArray.$items.subscribe(() => {
+      const next = [...fieldArray.$items.peek()];
+      listener(next, prev);
+      prev = next;
+    });
+  }
+});
+var attachFieldPersist = (field) => {
+  const { value, subscribe } = fieldPersistable(field);
+  const target = Object.assign(field, { value, subscribe });
+  target.extend = (extension) => {
+    const result = extension(fieldPersistable(target));
+    Object.assign(target, result);
+    return target;
+  };
+  return target;
+};
+var attachFieldArrayPersist = (fieldArray) => {
+  const { value, set, subscribe } = fieldArrayPersistable(fieldArray);
+  const target = Object.assign(fieldArray, { value, set, subscribe });
+  target.extend = (extension) => {
+    const result = extension(fieldArrayPersistable(target));
+    Object.assign(target, result);
+    return target;
+  };
+  return target;
+};
+
+// src/primitives/field.ts
+var defaultMeta = () => ({
+  dirty: false,
+  touched: false,
+  focused: false,
+  errors: []
+});
+var createField = (initial) => {
+  let binding;
+  const $value = signal(initial);
+  const $meta = signal(defaultMeta());
+  const setValue = (next) => {
+    $value.set(next);
+    $meta.update((prev) => ({ ...prev, dirty: true, errors: [] }));
+  };
+  const focus = () => {
+    $meta.update((prev) => ({ ...prev, focused: true }));
+  };
+  const blur = () => {
+    $meta.update((prev) => ({ ...prev, focused: false, touched: true }));
+  };
+  const bind = () => {
+    if (binding) return binding;
+    const isBool = typeof initial === "boolean";
+    const onInputText = (event) => {
+      if (isBool) return;
+      const raw = event.currentTarget.value;
+      setValue(raw);
+    };
+    const onChangeText = (event) => {
+      if (isBool) {
+        const checked = event.currentTarget.checked;
+        setValue(checked);
+        return;
+      }
+      const raw = event.currentTarget.value;
+      setValue(raw);
+    };
+    const onFocus = () => focus();
+    const onBlur = () => blur();
+    binding = { onInputText, onChangeText, onFocus, onBlur };
+    return binding;
+  };
+  const validate = () => [];
+  const validateAsync = async () => [];
+  const core = {
+    $value,
+    $meta,
+    value: () => $value.value(),
+    meta: () => $meta.value(),
+    get handlers() {
+      return bind();
+    },
+    set: (next) => setValue(next),
+    reset: (next) => {
+      $value.set(next !== void 0 ? next : initial);
+      $meta.set(defaultMeta());
+    },
+    focus,
+    blur,
+    touch: () => $meta.update((prev) => ({ ...prev, touched: true })),
+    bind,
+    validate,
+    validateAsync,
+    clearErrors: () => $meta.update((prev) => ({ ...prev, errors: [] }))
+  };
+  return attachFieldPersist(core);
+};
+var createFieldArray = (initial = []) => {
+  const initialSnapshot = [...initial];
+  const $items = signal([...initial]);
+  const append = (item) => {
+    $items.update((prev) => [...prev, item]);
+  };
+  const prepend = (item) => {
+    $items.update((prev) => [item, ...prev]);
+  };
+  const removeAt = (index) => {
+    $items.update((prev) => prev.filter((_, i) => i !== index));
+  };
+  const move = (from, to) => {
+    $items.update((prev) => {
+      if (from === to) return prev;
+      if (from < 0 || to < 0) return prev;
+      if (from >= prev.length || to >= prev.length) return prev;
+      const next = prev.slice();
+      const [item] = next.splice(from, 1);
+      next.splice(to, 0, item);
+      return next;
+    });
+  };
+  const updateAt = (index, fn) => {
+    $items.update((prev) => prev.map((x, i) => i === index ? fn(x) : x));
+  };
+  const replace = (next) => {
+    $items.set([...next]);
+  };
+  const reset = () => {
+    $items.set([...initialSnapshot]);
+  };
+  const core = {
+    $items,
+    append,
+    prepend,
+    removeAt,
+    move,
+    updateAt,
+    replace,
+    reset
+  };
+  return attachFieldArrayPersist(core);
+};
+
+// src/primitives/nested-field-array-ops.ts
+var buildOps = (fieldArray, cfg) => {
+  const removeAt = (index) => {
+    fieldArray.removeAt(index);
+  };
+  const children = cfg.children;
+  const hasChildren = !!children && Object.keys(children).length > 0;
+  const at = hasChildren ? (index) => {
+    const row = fieldArray.$items.value()[index];
+    if (!row) return void 0;
+    const slice = {};
+    for (const key of Object.keys(children)) {
+      const childCfg = children[key];
+      if (!childCfg) continue;
+      const childArr = row[key];
+      slice[key] = buildOps(childArr, childCfg);
+    }
+    return slice;
+  } : (_index) => void 0;
+  return {
+    append: (item) => {
+      fieldArray.append(item ?? cfg.newRow());
+    },
+    removeAt,
+    remove: removeAt,
+    at
+  };
+};
+var defineNestedFieldArrayOps = (fieldArray, cfg) => buildOps(fieldArray, cfg);
+
+// src/primitives/fieldSet.ts
+var createFieldSet = (fields) => {
+  const validate = () => {
+    const out = {};
+    for (const [key, value] of Object.entries(fields)) {
+      if (value && typeof value.validate === "function") {
+        out[key] = value.validate();
+      }
+    }
+    return out;
+  };
+  const reset = () => {
+    for (const value of Object.values(fields)) {
+      if (value && typeof value.reset === "function") {
+        value.reset();
+      }
+    }
+  };
+  return { fields, validate, reset };
+};
+
+// src/validation/flatten.ts
+var pathKey = (path) => (path ?? []).map((segment) => typeof segment === "symbol" ? String(segment) : String(segment)).join(".");
+var flattenFieldErrors = (issues) => {
+  const out = {};
+  for (const issue of issues) {
+    const key = pathKey(issue.path);
+    const resolvedKey = key.length ? key : "$root";
+    const arr = out[resolvedKey] ?? [];
+    arr.push(issue.message);
+    out[resolvedKey] = arr;
+  }
+  return out;
+};
+
+// src/validation/standard-schema.ts
+var asRecord = (v) => typeof v === "object" && v !== null ? v : null;
+var isIssueLikeArray = (v) => Array.isArray(v) && v.every(
+  (x) => x && typeof x === "object" && typeof x.message === "string"
+);
+var normalizeStandardSchemaPathSegments = (path) => Array.from(path ?? []).map((segment) => {
+  if (typeof segment === "string" || typeof segment === "number") return String(segment);
+  if (typeof segment === "symbol") return String(segment);
+  if (segment && typeof segment === "object" && "key" in segment) {
+    const key = segment.key;
+    return typeof key === "symbol" ? String(key) : String(key);
+  }
+  return String(segment);
+});
+var normalizeStandardSchemaIssues = (result) => {
+  if (typeof result === "string") return [{ message: result }];
+  if (Array.isArray(result) && result.every((x) => typeof x === "string")) {
+    return result.map((message2) => ({ message: message2 }));
+  }
+  if (Array.isArray(result) && isIssueLikeArray(result)) {
+    return Array.from(result).map((i) => ({
+      message: i.message,
+      path: normalizeStandardSchemaPathSegments(i.path ?? [])
+    }));
+  }
+  const rec = asRecord(result);
+  if (!rec) return [];
+  const directIssues = rec.issues ?? rec.errors ?? rec.issue;
+  if (Array.isArray(directIssues) && isIssueLikeArray(directIssues)) {
+    return Array.from(directIssues).map((i) => ({
+      message: i.message,
+      path: normalizeStandardSchemaPathSegments(i.path ?? [])
+    }));
+  }
+  if ("value" in rec && !("issues" in rec)) return [];
+  const message = rec.message;
+  if (typeof message === "string") return [{ message }];
+  return [];
+};
+var standardSchemaIssuesForUnknown = async (schema, value) => {
+  const raw = schema["~standard"].validate(value);
+  const result = raw instanceof Promise ? await raw : raw;
+  const rec = typeof result === "object" && result !== null ? result : null;
+  const issuesUnknown = rec && Object.prototype.hasOwnProperty.call(rec, "issues") ? rec.issues : void 0;
+  if (Array.isArray(issuesUnknown) && issuesUnknown.every((issue) => issue && typeof issue.message === "string")) {
+    const issues2 = Array.from(
+      issuesUnknown
+    ).map((issue) => ({
+      message: issue.message,
+      path: normalizeStandardSchemaPathSegments(issue.path ?? [])
+    }));
+    return issues2.length > 0 ? { ok: false, issues: issues2 } : { ok: true, issues: [] };
+  }
+  const issues = normalizeStandardSchemaIssues(result);
+  return issues.length > 0 ? { ok: false, issues } : { ok: true, issues: [] };
+};
+var standardSchemaIssuesForUnknownSync = (schema, value) => {
+  const raw = schema["~standard"].validate(value);
+  if (raw instanceof Promise) {
+    throw new Error(
+      "[@echojs-ecosystem/form] Schema validation returned a Promise. Use field.validateAsync() / form.validateAsync(), or wrap with async handling."
+    );
+  }
+  const rec = typeof raw === "object" && raw !== null ? raw : null;
+  const issuesUnknown = rec && Object.prototype.hasOwnProperty.call(rec, "issues") ? rec.issues : void 0;
+  if (Array.isArray(issuesUnknown) && issuesUnknown.every((issue) => issue && typeof issue.message === "string")) {
+    const issues2 = Array.from(
+      issuesUnknown
+    ).map((issue) => ({
+      message: issue.message,
+      path: normalizeStandardSchemaPathSegments(issue.path ?? [])
+    }));
+    return issues2.length > 0 ? { ok: false, issues: issues2 } : { ok: true, issues: [] };
+  }
+  const issues = normalizeStandardSchemaIssues(raw);
+  return issues.length > 0 ? { ok: false, issues } : { ok: true, issues: [] };
+};
+
+// src/primitives/collect-form-value.ts
+var isPlainObject = (v) => !!v && typeof v === "object" && !Array.isArray(v);
+var isFieldNode = (value) => isPlainObject(value) && typeof value.$value?.value === "function" && typeof value.set === "function" && typeof value.bind === "function";
+var isFieldArrayNode = (value) => isPlainObject(value) && typeof value.$items?.value === "function" && typeof value.append === "function";
+var isFieldSetNode = (value) => isPlainObject(value) && isPlainObject(value.fields) && typeof value.validate === "function" && typeof value.reset === "function" && !isFieldNode(value);
+var collectFormValueFromFields = (node) => {
+  if (node == null) return node;
+  if (isFieldNode(node)) return node.$value.value();
+  if (isFieldArrayNode(node)) {
+    const raw = node.$items.value();
+    if (!Array.isArray(raw)) return [];
+    return raw.map((row) => collectFormValueFromFields(row));
+  }
+  if (isFieldSetNode(node)) return collectFormValueFromFields(node.fields);
+  if (isPlainObject(node)) {
+    const out = {};
+    for (const [key, value] of Object.entries(node)) {
+      out[key] = collectFormValueFromFields(value);
+    }
+    return out;
+  }
+  return node;
+};
+
+// src/primitives/hydrate.ts
+var isPlainObject2 = (v) => !!v && typeof v === "object" && !Array.isArray(v);
+var isField = (v) => isPlainObject2(v) && typeof v.set === "function" && typeof v.$value?.value === "function";
+var isFieldSetNode2 = (v) => isPlainObject2(v) && isPlainObject2(v.fields);
+var isFieldArrayNode2 = (v) => isPlainObject2(v) && typeof v.$items?.value === "function" && typeof v.append === "function";
+var readItems = (arr) => {
+  const v = arr.$items.value();
+  return Array.isArray(v) ? v : [];
+};
+var hydrateFormFields = (fields, partial, fieldArrayFactories) => {
+  if (!isPlainObject2(partial)) return;
+  for (const [key, raw] of Object.entries(partial)) {
+    if (!(key in fields)) continue;
+    const node = fields[key];
+    hydrateNode(node, raw, fieldArrayFactories?.[key]);
+  }
+};
+var hydrateNode = (node, partial, rowFactory) => {
+  if (isField(node)) {
+    node.set(partial);
+    return;
+  }
+  if (isFieldSetNode2(node)) {
+    if (!isPlainObject2(partial)) return;
+    hydrateFormFields(node.fields, partial, void 0);
+    return;
+  }
+  if (isFieldArrayNode2(node)) {
+    if (!Array.isArray(partial)) return;
+    const target = partial;
+    const arr = node;
+    while (readItems(arr).length > target.length) {
+      arr.removeAt(readItems(arr).length - 1);
+    }
+    while (readItems(arr).length < target.length) {
+      if (!rowFactory) break;
+      arr.append(rowFactory());
+    }
+    const rows = readItems(arr);
+    for (let i = 0; i < target.length && i < rows.length; i++) {
+      hydrateNode(rows[i], target[i], void 0);
+    }
+    return;
+  }
+  if (isPlainObject2(node) && isPlainObject2(partial)) {
+    hydrateFormFields(node, partial, void 0);
+  }
+};
+
+// src/primitives/validation-tree.ts
+var isPlainObject3 = (value) => !!value && typeof value === "object" && !Array.isArray(value);
+var hasValidateSync = (value) => isPlainObject3(value) && typeof value.validate === "function";
+var hasValidateAsync = (value) => isPlainObject3(value) && typeof value.validateAsync === "function";
+var maybeFieldSetNode = (value) => isPlainObject3(value) && isPlainObject3(value.fields);
+var maybeFieldArrayNode = (value) => isPlainObject3(value) && typeof value.$items?.value === "function";
+var deepValidateSync = (root) => {
+  if (maybeFieldArrayNode(root)) {
+    const items = root.$items.value();
+    if (!Array.isArray(items)) return items;
+    return items.map((row) => deepValidateSync(row));
+  }
+  if (maybeFieldSetNode(root)) {
+    const out2 = {};
+    for (const [key, child] of Object.entries(root.fields)) {
+      out2[key] = deepValidateSync(child);
+    }
+    return out2;
+  }
+  if (hasValidateSync(root)) return root.validate();
+  if (!isPlainObject3(root)) return root;
+  const out = {};
+  for (const [key, child] of Object.entries(root)) {
+    out[key] = deepValidateSync(child);
+  }
+  return out;
+};
+var deepValidateAsync = async (root) => {
+  if (maybeFieldArrayNode(root)) {
+    const items = root.$items.value();
+    if (!Array.isArray(items)) return items;
+    const entries2 = items.map((row, i) => deepValidateAsync(row).then((v) => [i, v]));
+    const resolved2 = await Promise.all(entries2);
+    return resolved2.sort((a, b) => a[0] - b[0]).map(([, v]) => v);
+  }
+  if (maybeFieldSetNode(root)) {
+    const entries2 = Object.entries(root.fields).map(
+      ([key, child]) => deepValidateAsync(child).then((v) => [key, v])
+    );
+    const resolved2 = await Promise.all(entries2);
+    return Object.fromEntries(resolved2);
+  }
+  if (hasValidateAsync(root)) return root.validateAsync();
+  if (hasValidateSync(root) && !hasValidateAsync(root)) return root.validate();
+  if (!isPlainObject3(root)) return root;
+  const entries = Object.entries(root).map(
+    ([key, child]) => deepValidateAsync(child).then((v) => [key, v])
+  );
+  const resolved = await Promise.all(entries);
+  return Object.fromEntries(resolved);
+};
+var deepReset = (root) => {
+  if (isPlainObject3(root) && typeof root.reset === "function") {
+    root.reset();
+    return;
+  }
+  if (maybeFieldArrayNode(root)) {
+    const items = root.$items.value();
+    if (Array.isArray(items)) for (const row of items) deepReset(row);
+    return;
+  }
+  if (maybeFieldSetNode(root)) {
+    for (const child of Object.values(root.fields)) deepReset(child);
+    return;
+  }
+  if (!isPlainObject3(root)) return;
+  for (const child of Object.values(root)) deepReset(child);
+};
+
+// src/primitives/create-form.ts
+var isPlainObject4 = (value) => !!value && typeof value === "object" && !Array.isArray(value);
+function createForm(fields, opts) {
+  const $submitting = signal(false);
+  const $submitCount = signal(0);
+  const $errors = signal(void 0);
+  const $schemaErrors = signal(void 0);
+  const resolvedFields = fields;
+  const rootSchema = opts.validationSchema ?? opts.schema;
+  const validationOn = opts.validationOn ?? "manual";
+  if (opts.defaultValues && Object.keys(opts.defaultValues).length > 0) {
+    hydrateFormFields(
+      resolvedFields,
+      opts.defaultValues,
+      opts.fieldArrayFactories
+    );
+  }
+  if (opts.defaultAsyncValues) {
+    void opts.defaultAsyncValues().then((extra) => {
+      hydrateFormFields(
+        resolvedFields,
+        extra
+      );
+    });
+  }
+  const snapshotValue = () => opts.getValue ? opts.getValue() : collectFormValueFromFields(resolvedFields);
+  const validate = () => {
+    if (opts.validate) return opts.validate(resolvedFields);
+    return deepValidateSync(resolvedFields);
+  };
+  const validateAsync = async () => {
+    const getFieldTree = (async () => {
+      if (opts.validateAsync) return await opts.validateAsync(resolvedFields);
+      if (opts.validate) return opts.validate(resolvedFields);
+      return await deepValidateAsync(resolvedFields);
+    });
+    if (!rootSchema) return await getFieldTree();
+    const value = snapshotValue();
+    const res = await standardSchemaIssuesForUnknown(rootSchema, value);
+    const schemaFlat = flattenFieldErrors(res.ok ? [] : res.issues);
+    const rootSchemaErrors = Object.keys(schemaFlat).length > 0 ? { $schema: schemaFlat } : {};
+    return { ...await getFieldTree(), ...rootSchemaErrors };
+  };
+  const updateErrorsSignals = (errs) => {
+    $errors.set(errs);
+    const flat = errs.$schema;
+    $schemaErrors.set(flat && Object.keys(flat).length ? flat : void 0);
+  };
+  const runValidation = async () => {
+    const errs = await validateAsync();
+    updateErrorsSignals(errs);
+    return errs;
+  };
+  const trackValidationTriggers = (node) => {
+    if (node == null) return;
+    if (isPlainObject4(node) && node.$value && node.$meta) {
+      if (validationOn === "onChange" || validationOn === "all") node.$value.value();
+      if (validationOn === "onBlur" || validationOn === "all") node.$meta.value().touched;
+      if (validationOn === "onFocus" || validationOn === "all") node.$meta.value().focused;
+      return;
+    }
+    if (isPlainObject4(node) && typeof node.$items?.value === "function") {
+      const items = node.$items.value();
+      if (Array.isArray(items)) for (const row of items) trackValidationTriggers(row);
+      return;
+    }
+    if (isPlainObject4(node) && isPlainObject4(node.fields)) {
+      for (const child of Object.values(node.fields)) trackValidationTriggers(child);
+      return;
+    }
+    if (!isPlainObject4(node)) return;
+    for (const child of Object.values(node)) trackValidationTriggers(child);
+  };
+  if (validationOn !== "manual") {
+    effect(() => {
+      trackValidationTriggers(resolvedFields);
+      void runValidation();
+    });
+  }
+  const reset = () => {
+    deepReset(resolvedFields);
+  };
+  const getValue = () => snapshotValue();
+  const hydrate = (partial) => {
+    hydrateFormFields(
+      resolvedFields,
+      partial
+    );
+  };
+  const submit = async (handler) => {
+    $submitCount.update((n) => n + 1);
+    const errors = await runValidation();
+    const hasErrors = (obj) => {
+      if (obj == null) return false;
+      if (Array.isArray(obj)) {
+        if (obj.length === 0) return false;
+        return obj.some(hasErrors);
+      }
+      if (typeof obj === "object") {
+        const entries = Object.values(obj);
+        return entries.some(hasErrors);
+      }
+      if (typeof obj === "string") return obj.length > 0;
+      return false;
+    };
+    if (hasErrors(errors)) {
+      return { ok: false, errors };
+    }
+    $submitting.set(true);
+    try {
+      const value = getValue();
+      await handler(value);
+      return { ok: true, value };
+    } catch (error) {
+      return { ok: false, errors: { submit: error } };
+    } finally {
+      $submitting.set(false);
+    }
+  };
+  const form = {
+    displayName: opts.name,
+    fields: resolvedFields,
+    $submitting,
+    $submitCount,
+    $errors,
+    $schemaErrors,
+    arrayActions: {},
+    validate,
+    validateAsync,
+    reset,
+    hydrate,
+    submit
+  };
+  if (opts.arrayActions) {
+    form.arrayActions = opts.arrayActions(form);
+  }
+  return form;
+}
+
+// src/primitives/generate-append-to-array.ts
+var isPlainObject5 = (v) => !!v && typeof v === "object" && !Array.isArray(v);
+var getFieldArray = (node) => {
+  if (!isPlainObject5(node)) throw new Error("generateAppendToArray: expected FieldArray node");
+  if (!("$items" in node) || typeof node.append !== "function") {
+    throw new Error("generateAppendToArray: path does not resolve to a FieldArray");
+  }
+  return node;
+};
+var generateAppendToArray = (form, makeRow, path) => {
+  const segments = path.split(".").filter(Boolean);
+  if (segments.length === 0) throw new Error("generateAppendToArray: empty path");
+  return (...indices) => {
+    if (indices.length !== Math.max(0, segments.length - 1)) {
+      throw new Error(
+        `generateAppendToArray: expected ${Math.max(0, segments.length - 1)} indices, got ${indices.length}`
+      );
+    }
+    let cursor = form.fields;
+    for (let index = 0; index < segments.length; index++) {
+      const key = segments[index];
+      const isTarget = index === segments.length - 1;
+      const next = cursor?.[key];
+      if (isTarget) {
+        getFieldArray(next).append(makeRow());
+        return;
+      }
+      const arr = getFieldArray(next);
+      const idx = indices[index];
+      const items = arr.$items.value();
+      const row = items[idx];
+      cursor = row;
+    }
+  };
+};
+
+// src/primitives/generate-remove-from-array.ts
+var isPlainObject6 = (v) => !!v && typeof v === "object" && !Array.isArray(v);
+var getFieldArray2 = (node) => {
+  if (!isPlainObject6(node)) throw new Error("generateRemoveFromArray: expected FieldArray node");
+  if (!("$items" in node) || typeof node.removeAt !== "function") {
+    throw new Error("generateRemoveFromArray: path does not resolve to a FieldArray");
+  }
+  return node;
+};
+var generateRemoveFromArray = (form, path) => {
+  const segments = path.split(".").filter(Boolean);
+  if (segments.length === 0) throw new Error("generateRemoveFromArray: empty path");
+  return (...indices) => {
+    if (indices.length !== segments.length) {
+      throw new Error(
+        `generateRemoveFromArray: expected ${segments.length} indices, got ${indices.length}`
+      );
+    }
+    let cursor = form.fields;
+    for (let index = 0; index < segments.length; index++) {
+      const key = segments[index];
+      const isTarget = index === segments.length - 1;
+      const next = cursor?.[key];
+      const arr = getFieldArray2(next);
+      if (isTarget) {
+        const removeIndex = indices[index];
+        arr.removeAt(removeIndex);
+        return;
+      }
+      const parentIndex = indices[index];
+      const items = arr.$items.value();
+      const row = items[parentIndex];
+      cursor = row;
+    }
+  };
+};
+
+// src/primitives/array-generator.ts
+var arrayGenerator = {
+  append(form, makeRow, path) {
+    return generateAppendToArray(form, makeRow, path);
+  },
+  remove(form, path) {
+    return generateRemoveFromArray(form, path);
+  }
+};
+
+// src/primitives/field-kit.ts
+var isPlainObject7 = (v) => typeof v === "object" && v !== null && !Array.isArray(v);
+var asRecord2 = (v) => v;
+var createFieldKit = (seed) => {
+  const str = (key, _schema, parent, _extra) => {
+    const src = asRecord2(parent ?? seed);
+    const raw = src[key];
+    const initial = String(raw ?? "");
+    return createField(initial);
+  };
+  const num = (key, _schema, parent, _extra) => {
+    const src = asRecord2(parent ?? seed);
+    const raw = src[key];
+    const n = typeof raw === "number" ? raw : Number.parseFloat(String(raw));
+    const initial = Number.isFinite(n) ? n : 0;
+    return createField(initial);
+  };
+  const bool = (key, _schema, parent, _extra) => {
+    const src = asRecord2(parent ?? seed);
+    const raw = src[key];
+    const initial = Boolean(raw);
+    return createField(initial);
+  };
+  function pick(key, _schema, parent, fallback, _extra) {
+    const src = asRecord2(parent ?? seed);
+    const raw = src[key];
+    const options = _schema.options;
+    const initial = typeof raw === "string" && options.includes(raw) ? raw : fallback;
+    return createField(initial);
+  }
+  const list = (key, rowFactory, parent) => {
+    const src = asRecord2(parent ?? seed);
+    const raw = src[key];
+    const arr = Array.isArray(raw) ? raw : [];
+    return createFieldArray(
+      arr.map((item, index) => rowFactory(isPlainObject7(item) ? item : {}, index))
+    );
+  };
+  return { str, num, bool, pick, list };
+};
+
+// src/validation/flatten-validation.ts
+var flattenValidationErrors = (node, prefix = "") => {
+  const out = {};
+  const join = (path) => prefix.length ? `${prefix}.${path}` : path;
+  const joinIdx = (index) => prefix.length ? `${prefix}.${index}` : String(index);
+  if (node == null) return out;
+  if (typeof node === "string") {
+    if (node.trim().length > 0) out[prefix.length ? prefix : "$root"] = [node];
+    return out;
+  }
+  if (Array.isArray(node)) {
+    if (node.length === 0) return out;
+    if (node.every((value) => typeof value === "string")) {
+      const msgs = node.filter((x) => typeof x === "string" && x.length > 0);
+      if (msgs.length > 0) out[prefix.length ? prefix : "$root"] = msgs;
+      return out;
+    }
+    for (let i = 0; i < node.length; i++) {
+      Object.assign(out, flattenValidationErrors(node[i], joinIdx(i)));
+    }
+    return out;
+  }
+  if (typeof node === "object") {
+    for (const [key, value] of Object.entries(node)) {
+      Object.assign(out, flattenValidationErrors(value, join(key)));
+    }
+    return out;
+  }
+  return out;
+};
+var filterRootSchemaErrorsDeferredToFieldErrors = (fieldFlat, schemaFlat) => {
+  const fieldKeysWithErrors = Object.entries(fieldFlat).filter(([, msgs]) => msgs.length > 0).map(([key]) => key);
+  const filtered = {};
+  for (const [schemaKey, msgs] of Object.entries(schemaFlat)) {
+    if (!msgs.length) continue;
+    const blocked = fieldKeysWithErrors.some((fk) => {
+      if (fk === schemaKey) return true;
+      if (fk.startsWith(`${schemaKey}.`)) return true;
+      if (schemaKey.startsWith(`${fk}.`)) return true;
+      return false;
+    });
+    if (!blocked) filtered[schemaKey] = msgs;
+  }
+  return filtered;
+};
+
+// src/bindings/hyperdom.ts
+var getBinding = (field) => field.handlers;
+var readFieldRef = (field) => field.value();
+var writeFieldRef = (field, next) => {
+  field.set(next);
+};
+var parseNumericInput = (raw) => {
+  const n = Number.parseFloat(raw);
+  return Number.isFinite(n) ? n : 0;
+};
+var controlledStringValue = (field) => {
+  return () => {
+    const v = readFieldRef(field);
+    if (v == null) return "";
+    return String(v);
+  };
+};
+var controlledNumericStringValue = (field, whenInvalid) => {
+  return () => {
+    const v = readFieldRef(field);
+    if (v == null || typeof v === "number" && Number.isNaN(v)) {
+      return whenInvalid === "empty" ? "" : "0";
+    }
+    return String(v);
+  };
+};
+var textLikeHandlers = (b) => ({
+  onInput: b.onInputText,
+  onChange: b.onChangeText,
+  onFocus: b.onFocus,
+  onBlur: b.onBlur
+});
+var domNumericInputHandlers = (field) => {
+  const sync = (e) => {
+    writeFieldRef(field, parseNumericInput(e.currentTarget.value));
+  };
+  return { onInput: sync, onChange: sync };
+};
+var bindField = (field, opts) => {
+  const b = getBinding(field);
+  switch (opts.variant) {
+    case "text":
+    case "email":
+    case "password":
+    case "search":
+    case "url": {
+      const base = { type: opts.variant, ...textLikeHandlers(b) };
+      if (!opts.controlledValue) return base;
+      return { ...base, value: controlledStringValue(field) };
+    }
+    case "textarea": {
+      const base = { ...textLikeHandlers(b) };
+      if (!opts.controlledValue) return base;
+      return { ...base, value: controlledStringValue(field) };
+    }
+    case "checkbox": {
+      return {
+        type: "checkbox",
+        checked: () => Boolean(readFieldRef(field)),
+        onChange: b.onChangeText,
+        onFocus: b.onFocus,
+        onBlur: b.onBlur
+      };
+    }
+    case "select": {
+      const onChange = (e) => {
+        writeFieldRef(field, e.currentTarget.value);
+      };
+      const base = {
+        onChange,
+        onFocus: b.onFocus,
+        onBlur: b.onBlur
+      };
+      if (opts.controlledValue === false) return base;
+      return {
+        ...base,
+        value: controlledStringValue(field)
+      };
+    }
+    case "number": {
+      const numeric = domNumericInputHandlers(field);
+      const base = {
+        type: "number",
+        ...numeric,
+        onFocus: b.onFocus,
+        onBlur: b.onBlur
+      };
+      if (!opts.controlledValue) return base;
+      return { ...base, value: controlledNumericStringValue(field, "empty") };
+    }
+    case "range": {
+      const numeric = domNumericInputHandlers(field);
+      const base = {
+        type: "range",
+        min: opts.min,
+        max: opts.max,
+        step: opts.step,
+        ...numeric,
+        onFocus: b.onFocus,
+        onBlur: b.onBlur
+      };
+      if (!opts.controlledValue) return base;
+      return { ...base, value: controlledNumericStringValue(field, "zero") };
+    }
+  }
+};
+
+export { arrayGenerator, bindField, collectFormValueFromFields, createField, createFieldArray, createFieldKit, createFieldSet, createForm, defineNestedFieldArrayOps, filterRootSchemaErrorsDeferredToFieldErrors, flattenFieldErrors, flattenValidationErrors, generateAppendToArray, generateRemoveFromArray, hydrateFormFields, normalizeStandardSchemaIssues, normalizeStandardSchemaPathSegments, standardSchemaIssuesForUnknown, standardSchemaIssuesForUnknownSync };
+//# sourceMappingURL=index.js.map
+//# sourceMappingURL=index.js.map