formstand 0.22.1 → 0.23.0

package/dist/index.cjs

@@ -210,11 +210,11 @@ var hasOwnSlot = (obj, path) => parsePath(path).reduce(
   },
   { ok: true, current: obj }
 ).ok;
-var writeIntoArray = (arr, index, rest, value) => {
+var writeIntoArray = (arr, index, rest, value, kindAt, prefix) => {
   const length = Math.max(arr.length, index + 1);
   return Array.from(
     { length },
-    (_, i) => i === index ? writeSegments(arr[i], rest, value) : arr[i]
+    (_, i) => i === index ? writeSegments(arr[i], rest, value, kindAt, [...prefix, index]) : arr[i]
   );
 };
 var refusesHugeIndex = (index) => {
@@ -226,7 +226,7 @@ var refusesHugeIndex = (index) => {
   }
   return false;
 };
-var writeSegments = (obj, segments, value) => {
+var writeSegments = (obj, segments, value, kindAt, prefix) => {
   const [head, ...rest] = segments;
   if (head === void 0) return value;
   if (Array.isArray(obj)) {
@@ -237,7 +237,7 @@ var writeSegments = (obj, segments, value) => {
       return obj;
     }
     if (refusesHugeIndex(head)) return obj;
-    return writeIntoArray(obj, head, rest, value);
+    return writeIntoArray(obj, head, rest, value, kindAt, prefix);
   }
   if (isPlainRecord(obj)) {
     if (!isPlainObject(obj)) {
@@ -246,16 +246,27 @@ var writeSegments = (obj, segments, value) => {
       );
       return obj;
     }
-    const key = String(head);
-    return { ...obj, [key]: writeSegments(obj[key], rest, value) };
+    const key2 = String(head);
+    return {
+      ...obj,
+      [key2]: writeSegments(obj[key2], rest, value, kindAt, [...prefix, key2])
+    };
   }
-  if (typeof head === "number") {
+  const kind = kindAt?.(prefix.map(String).join(".")) ?? (typeof head === "number" ? "array" : "record");
+  if (kind === "array") {
+    if (typeof head !== "number") {
+      console.warn(
+        `[formstand] cannot write string key "${head}" into an array; value left unchanged.`
+      );
+      return obj;
+    }
     if (refusesHugeIndex(head)) return obj;
-    return writeIntoArray([], head, rest, value);
+    return writeIntoArray([], head, rest, value, kindAt, prefix);
   }
-  return { [head]: writeSegments(void 0, rest, value) };
+  const key = String(head);
+  return { [key]: writeSegments(void 0, rest, value, kindAt, [...prefix, key]) };
 };
-var setAtPath = (obj, path, value) => writeSegments(obj, parsePath(path), value);
+var setAtPath = (obj, path, value, containerKindAt2) => writeSegments(obj, parsePath(path), value, containerKindAt2, []);
 var issuePathToFormPath = (path) => path.filter((segment) => typeof segment !== "symbol").join(".");
 var expandIssue = (issue, prefix) => {
   const at = [...prefix, ...issue.path];
@@ -356,6 +367,9 @@ var fieldSchemaForIntrospection = (schema, path) => {
     if (s instanceof zod.z.ZodTuple && typeof segment === "number") {
       return s.def.items[segment] ?? null;
     }
+    if (s instanceof zod.z.ZodRecord) {
+      return s.valueType;
+    }
     if (s instanceof zod.z.ZodDiscriminatedUnion || s instanceof zod.z.ZodUnion) {
       const options = s.def.options;
       return options.reduce(
@@ -370,6 +384,22 @@ var fieldSchemaForIntrospection = (schema, path) => {
     schema
   );
 };
+var containerKindAt = (schema) => (prefix) => {
+  const sub = fieldSchemaForIntrospection(schema, prefix);
+  if (sub === null) return null;
+  const unwrapAll = (s) => {
+    const inner2 = unwrapForWalk(s);
+    return inner2 === null ? s : unwrapAll(inner2);
+  };
+  const inner = unwrapAll(sub);
+  if (inner instanceof zod.z.ZodArray || inner instanceof zod.z.ZodTuple) {
+    return "array";
+  }
+  if (inner instanceof zod.z.ZodObject || inner instanceof zod.z.ZodRecord) {
+    return "record";
+  }
+  return null;
+};
 var fieldSchemaAtPath = (schema, path) => parsePath(path).reduce((current, segment) => {
   if (current === null || hasChecks(current)) return null;
   if (current instanceof zod.z.ZodObject && typeof segment === "string") {
@@ -473,6 +503,7 @@ var releaseChangedSlices = (server, prevValues, nextValues) => {
 };
 var createForm = (schema, options) => {
   const initialMode = options.mode ?? "onBlur";
+  const kindAt = containerKindAt(schema);
   const initialReValidateMode = options.reValidateMode ?? "onChange";
   const initial = {
     values: options.initialValues,
@@ -830,7 +861,7 @@ var createForm = (schema, options) => {
     }
     const arr = Array.isArray(current) ? current : [];
     const next = nextArray(arr);
-    const written = setAtPath(store.getState().values, path, next);
+    const written = setAtPath(store.getState().values, path, next, kindAt);
     clearArrayOpsUnder(store, path, true);
     if (Array.isArray(current) && getAtPath(written, path) === next) {
       recordArrayOp(store, path, {
@@ -992,7 +1023,7 @@ var createForm = (schema, options) => {
       clearArrayOpsUnder(store, path);
       store.setState((state) => ({
         ...state,
-        values: setAtPath(state.values, path, value),
+        values: setAtPath(state.values, path, value, kindAt),
         ...errorChannels(state, {
           serverErrors: releaseSpine(state.serverErrors, path)
         })
@@ -1139,7 +1170,7 @@ var createForm = (schema, options) => {
       }
       store.setState((state) => ({
         ...state,
-        values: initialSlot.exists ? setAtPath(state.values, path, initialSlot.value) : state.values,
+        values: initialSlot.exists ? setAtPath(state.values, path, initialSlot.value, kindAt) : state.values,
         // A runtime "" path scopes the whole form (the imperative surface is
         // string-typed even though FieldPath excludes ""). Server entries
         // follow the setValue release contract (releaseSpine).
@@ -2023,7 +2054,10 @@ function useFieldArray(form, pathArg) {
         items: Array.isArray(value) ? value : EMPTY_ITEMS,
         // Own-key read, like useField: an array named "constructor" must
         // not read Object as its error list.
-        error: entryAt(state.errors, path)
+        error: entryAt(state.errors, path),
+        touched: flagAt(state.touched, path),
+        dirty: isFieldDirty(value, getAtPath(state.initialValues, path)),
+        isValidating: flagAt(state.isValidating, path)
       };
     })
   );
@@ -2092,6 +2126,52 @@ function useFieldArray(form, pathArg) {
     [form, path]
   );
   const clearError = react.useCallback(() => form.clearErrors?.(path), [form, path]);
+  const setTouched = react.useCallback(
+    (touched) => form.setTouched?.(path, touched),
+    [form, path]
+  );
+  const onBlur = react.useCallback(() => {
+    form.setTouched?.(path, true);
+    const state = form.store.getState();
+    if (shouldValidateOn(
+      "blur",
+      state.mode,
+      state.reValidateMode,
+      state.submitCount > 0,
+      true
+    )) {
+      form.validateField?.(path);
+    }
+  }, [form, path]);
+  const validate = react.useCallback(
+    () => form.validateField?.(path) ?? { kind: "valid" },
+    [form, path]
+  );
+  const replace = react.useCallback(
+    (next) => {
+      form.setValue?.(path, next);
+      revalidate();
+    },
+    [form, path, revalidate]
+  );
+  const update = react.useCallback(
+    (index, item) => {
+      form.setValue?.(`${path}.${index}`, item);
+      revalidate();
+    },
+    [form, path, revalidate]
+  );
+  const prepend = react.useCallback(
+    (item) => {
+      form.arrayInsert(path, 0, item);
+      revalidate();
+    },
+    [form, path, revalidate]
+  );
+  const clear = react.useCallback(() => {
+    form.setValue?.(path, []);
+    revalidate();
+  }, [form, path, revalidate]);
   return react.useMemo(
     () => ({
       path,
@@ -2102,13 +2182,45 @@ function useFieldArray(form, pathArg) {
       firstError: error?.[0],
       setError,
       clearError,
+      touched: slice.touched,
+      dirty: slice.dirty,
+      isValidating: slice.isValidating,
+      setTouched,
+      onBlur,
+      validate,
       push,
       remove,
       insert,
       move,
-      swap
+      swap,
+      replace,
+      update,
+      prepend,
+      clear
     }),
-    [path, fields, items, error, setError, clearError, push, remove, insert, move, swap]
+    [
+      path,
+      fields,
+      items,
+      error,
+      setError,
+      clearError,
+      slice.touched,
+      slice.dirty,
+      slice.isValidating,
+      setTouched,
+      onBlur,
+      validate,
+      push,
+      remove,
+      insert,
+      move,
+      swap,
+      replace,
+      update,
+      prepend,
+      clear
+    ]
   );
 }
 var useFormError = (form) => react$1.useStore(