From f330a41562541f5baabf89640c02bbd741de3629 Mon Sep 17 00:00:00 2001
From: Miroslav Petrik <miroslavpetrik@outlook.com>
Date: Fri, 17 Oct 2025 09:47:04 +0200
Subject: [PATCH 1/2] fix(form-submit-values): drop superfluous extends

---
 src/components/form/FormSubmitValues.ts       | 16 +++----
 .../array-field/stringArrayField.test-d.ts    | 22 ++++------
 .../boolean-field/booleanField.test-d.ts      | 19 +++------
 .../checkbox-field/checkboxField.test-d.ts    | 21 ++++------
 src/fields/date-field/dateField.test-d.ts     | 19 +++------
 src/fields/digit-field/digitField.test-d.ts   | 19 +++------
 src/fields/files-field/filesField.test-d.ts   | 20 ++++-----
 src/fields/list-field/listField.test-d.ts     | 42 ++++++++-----------
 src/fields/number-field/numberField.test-d.ts | 19 +++------
 src/fields/string-field/stringField.test-d.ts | 20 ++++-----
 src/fields/text-field/textField.test-d.ts     | 19 +++------
 11 files changed, 86 insertions(+), 150 deletions(-)

diff --git a/src/components/form/FormSubmitValues.ts b/src/components/form/FormSubmitValues.ts
index 0a93a05..f13a4fb 100644
--- a/src/components/form/FormSubmitValues.ts
+++ b/src/components/form/FormSubmitValues.ts
@@ -1,6 +1,6 @@
-import { FieldAtom, FormAtom } from "form-atoms";
+import type { FieldAtom, FormAtom } from "form-atoms";
 
-import {
+import type {
   ListField,
   ListFieldSubmitValue,
   ZodField,
@@ -15,12 +15,12 @@ type Identity<T> = T;
 
 type FormFields = {
   [key: string | number]:
-    | FieldAtom<any>
-    | ZodField<any>
+    | FieldAtom<unknown>
+    | ZodField
     | FormFields
     | FormFields[]
-    | FieldAtom<any>[]
-    | ZodField<any>[];
+    | FieldAtom<unknown>[]
+    | ZodField[];
 };
 
 export type FormFieldSubmitValues<Fields extends FormFields> = Flatten<{
@@ -36,7 +36,7 @@ export type FormFieldSubmitValues<Fields extends FormFields> = Flatten<{
         : Fields[Key] extends FormFields
           ? FormFieldSubmitValues<Fields[Key]>
           : Fields[Key] extends Array<infer Item>
-            ? Item extends ZodField<any>
+            ? Item extends ZodField
               ? ZodFieldSubmitValue<Fields[Key]>[]
               : Item extends FieldAtom<infer Value>
                 ? Value[]
@@ -46,5 +46,5 @@ export type FormFieldSubmitValues<Fields extends FormFields> = Flatten<{
             : never;
 }>;
 
-export type FormSubmitValues<Form extends FormAtom<any>> =
+export type FormSubmitValues<Form> =
   Form extends FormAtom<infer Fields> ? FormFieldSubmitValues<Fields> : never;
diff --git a/src/fields/array-field/stringArrayField.test-d.ts b/src/fields/array-field/stringArrayField.test-d.ts
index df5c6d4..59b0b9f 100644
--- a/src/fields/array-field/stringArrayField.test-d.ts
+++ b/src/fields/array-field/stringArrayField.test-d.ts
@@ -1,25 +1,21 @@
-import { formAtom } from "form-atoms";
 import { expectTypeOf, test } from "vitest";
 
-import { stringArrayField } from "./stringArrayField";
-import { FormSubmitValues } from "../../components/form";
+import { FormFieldSubmitValues } from "../../components/form";
 
-test("required stringArrayField has '[string, ...string[]]' submit value", () => {
-  const form = formAtom({
-    field: stringArrayField(),
-  });
+import type { StringArrayField } from "./stringArrayField";
 
-  expectTypeOf<FormSubmitValues<typeof form>>().toEqualTypeOf<{
+test("required stringArrayField has '[string, ...string[]]' submit value", () => {
+  expectTypeOf<
+    FormFieldSubmitValues<{ field: StringArrayField }>
+  >().toEqualTypeOf<{
     field: [string, ...string[]];
   }>();
 });
 
 test("optional stringArrayField has 'string[]' submit value", () => {
-  const form = formAtom({
-    field: stringArrayField().optional(),
-  });
-
-  expectTypeOf<FormSubmitValues<typeof form>>().toEqualTypeOf<{
+  expectTypeOf<
+    FormFieldSubmitValues<{ field: ReturnType<StringArrayField["optional"]> }>
+  >().toEqualTypeOf<{
     // TODO: narrow?
     field: [string, ...string[]] | string[];
   }>();
diff --git a/src/fields/boolean-field/booleanField.test-d.ts b/src/fields/boolean-field/booleanField.test-d.ts
index 9d7c3bb..bd02176 100644
--- a/src/fields/boolean-field/booleanField.test-d.ts
+++ b/src/fields/boolean-field/booleanField.test-d.ts
@@ -1,25 +1,18 @@
-import { formAtom } from "form-atoms";
 import { expectTypeOf, test } from "vitest";
 
-import { booleanField } from "./booleanField";
-import { FormSubmitValues } from "../../components/form";
+import type { FormFieldSubmitValues } from "../../components/form";
+import type { BooleanField } from "./booleanField";
 
 test("required booleanField has 'boolean' submit value", () => {
-  const form = formAtom({
-    field: booleanField(),
-  });
-
-  expectTypeOf<FormSubmitValues<typeof form>>().toEqualTypeOf<{
+  expectTypeOf<FormFieldSubmitValues<{ field: BooleanField }>>().toEqualTypeOf<{
     field: boolean;
   }>();
 });
 
 test("optional booleanField has 'boolean | undefined' submit value", () => {
-  const form = formAtom({
-    field: booleanField().optional(),
-  });
-
-  expectTypeOf<FormSubmitValues<typeof form>>().toEqualTypeOf<{
+  expectTypeOf<
+    FormFieldSubmitValues<{ field: ReturnType<BooleanField["optional"]> }>
+  >().toEqualTypeOf<{
     field: boolean | undefined;
   }>();
 });
diff --git a/src/fields/checkbox-field/checkboxField.test-d.ts b/src/fields/checkbox-field/checkboxField.test-d.ts
index 642fcd9..0a0c6e6 100644
--- a/src/fields/checkbox-field/checkboxField.test-d.ts
+++ b/src/fields/checkbox-field/checkboxField.test-d.ts
@@ -1,25 +1,20 @@
-import { formAtom } from "form-atoms";
 import { expectTypeOf, test } from "vitest";
 
-import { checkboxField } from "./checkboxField";
-import { FormSubmitValues } from "../../components/form";
+import type { FormFieldSubmitValues } from "../../components/form";
+import type { CheckboxField } from "./checkboxField";
 
 test("required checkboxField has 'true' submit value", () => {
-  const form = formAtom({
-    field: checkboxField(),
-  });
-
-  expectTypeOf<FormSubmitValues<typeof form>>().toEqualTypeOf<{
+  expectTypeOf<
+    FormFieldSubmitValues<{ field: CheckboxField }>
+  >().toEqualTypeOf<{
     field: true;
   }>();
 });
 
 test("optional checkboxField has 'boolean' submit value", () => {
-  const form = formAtom({
-    field: checkboxField().optional(),
-  });
-
-  expectTypeOf<FormSubmitValues<typeof form>>().toEqualTypeOf<{
+  expectTypeOf<
+    FormFieldSubmitValues<{ field: ReturnType<CheckboxField["optional"]> }>
+  >().toEqualTypeOf<{
     field: boolean;
   }>();
 });
diff --git a/src/fields/date-field/dateField.test-d.ts b/src/fields/date-field/dateField.test-d.ts
index 5228909..c114917 100644
--- a/src/fields/date-field/dateField.test-d.ts
+++ b/src/fields/date-field/dateField.test-d.ts
@@ -1,25 +1,18 @@
-import { formAtom } from "form-atoms";
 import { expectTypeOf, test } from "vitest";
 
-import { dateField } from "./dateField";
-import { FormSubmitValues } from "../../components/form";
+import type { FormFieldSubmitValues } from "../../components/form";
+import type { DateField } from "./dateField";
 
 test("required dateField has 'Date' submit value", () => {
-  const form = formAtom({
-    field: dateField(),
-  });
-
-  expectTypeOf<FormSubmitValues<typeof form>>().toEqualTypeOf<{
+  expectTypeOf<FormFieldSubmitValues<{ field: DateField }>>().toEqualTypeOf<{
     field: Date;
   }>();
 });
 
 test("optional dateField has 'Date | undefined' submit value", () => {
-  const form = formAtom({
-    field: dateField().optional(),
-  });
-
-  expectTypeOf<FormSubmitValues<typeof form>>().toEqualTypeOf<{
+  expectTypeOf<
+    FormFieldSubmitValues<{ field: ReturnType<DateField["optional"]> }>
+  >().toEqualTypeOf<{
     field: Date | undefined;
   }>();
 });
diff --git a/src/fields/digit-field/digitField.test-d.ts b/src/fields/digit-field/digitField.test-d.ts
index 3157f70..b49a04c 100644
--- a/src/fields/digit-field/digitField.test-d.ts
+++ b/src/fields/digit-field/digitField.test-d.ts
@@ -1,25 +1,18 @@
-import { formAtom } from "form-atoms";
 import { expectTypeOf, test } from "vitest";
 
-import { digitField } from "./digitField";
-import { FormSubmitValues } from "../../components/form";
+import type { FormFieldSubmitValues } from "../../components/form";
+import type { DigitField } from "./digitField";
 
 test("required digitField has '0 | 1 | 2 | 3 | 4 | 5 | 6 | 7 | 8 | 9' submit value", () => {
-  const form = formAtom({
-    field: digitField(),
-  });
-
-  expectTypeOf<FormSubmitValues<typeof form>>().toEqualTypeOf<{
+  expectTypeOf<FormFieldSubmitValues<{ field: DigitField }>>().toEqualTypeOf<{
     field: 0 | 1 | 2 | 3 | 4 | 5 | 6 | 7 | 8 | 9;
   }>();
 });
 
 test("optional digitField has '0 | 1 | 2 | 3 | 4 | 5 | 6 | 7 | 8 | 9 | undefined' submit value", () => {
-  const form = formAtom({
-    field: digitField().optional(),
-  });
-
-  expectTypeOf<FormSubmitValues<typeof form>>().toEqualTypeOf<{
+  expectTypeOf<
+    FormFieldSubmitValues<{ field: ReturnType<DigitField["optional"]> }>
+  >().toEqualTypeOf<{
     field: 0 | 1 | 2 | 3 | 4 | 5 | 6 | 7 | 8 | 9 | undefined;
   }>();
 });
diff --git a/src/fields/files-field/filesField.test-d.ts b/src/fields/files-field/filesField.test-d.ts
index 9cb4ef5..821a9a1 100644
--- a/src/fields/files-field/filesField.test-d.ts
+++ b/src/fields/files-field/filesField.test-d.ts
@@ -1,24 +1,18 @@
-import { formAtom } from "form-atoms";
 import { expectTypeOf, test } from "vitest";
 
-import { filesField } from "./filesField";
-import { FormSubmitValues } from "../../components/form";
-test("required filesField has '[File, ...File[]]' submit value", () => {
-  const form = formAtom({
-    field: filesField(),
-  });
+import type { FormFieldSubmitValues } from "../../components/form";
+import type { FilesField } from "./filesField";
 
-  expectTypeOf<FormSubmitValues<typeof form>>().toEqualTypeOf<{
+test("required filesField has '[File, ...File[]]' submit value", () => {
+  expectTypeOf<FormFieldSubmitValues<{ field: FilesField }>>().toEqualTypeOf<{
     field: [File, ...File[]];
   }>();
 });
 
 test("optional filesField has 'File[]' submit value", () => {
-  const form = formAtom({
-    field: filesField().optional(),
-  });
-
-  expectTypeOf<FormSubmitValues<typeof form>>().toEqualTypeOf<{
+  expectTypeOf<
+    FormFieldSubmitValues<{ field: ReturnType<FilesField["optional"]> }>
+  >().toEqualTypeOf<{
     // TODO: narrow
     field: [File, ...File[]] | File[];
   }>();
diff --git a/src/fields/list-field/listField.test-d.ts b/src/fields/list-field/listField.test-d.ts
index 05c1939..9f42fa2 100644
--- a/src/fields/list-field/listField.test-d.ts
+++ b/src/fields/list-field/listField.test-d.ts
@@ -1,23 +1,9 @@
-import { ListAtom } from "@form-atoms/list-atom";
-import { formAtom } from "form-atoms";
 import { expectTypeOf, test } from "vitest";
 
-import { ListField, listField } from "./listField";
-import { FormSubmitValues } from "../../components/form";
-import { NumberField, numberField } from "../number-field";
-
-// test("required listField has '[itemType, ...itemType[]]' submit value", () => {
-//   const form = formAtom({
-//     field: listField({
-//       value: [],
-//       fields: ({ age }) => ({ age: numberField({ value: age }) }),
-//     }),
-//   });
-
-//   expectTypeOf<FormSubmitValues<typeof form>>().toEqualTypeOf<{
-//     field: [{ age: number }, ...{ age: number }[]];
-//   }>();
-// });
+import type { ListAtom } from "@form-atoms/list-atom";
+import type { FormFieldSubmitValues } from "../../components/form";
+import type { ListField } from "./listField";
+import type { NumberField } from "../number-field";
 
 test("ListField is assignable to ListAtom", () => {
   type Fields = { age: NumberField };
@@ -27,14 +13,20 @@ test("ListField is assignable to ListAtom", () => {
   >().toEqualTypeOf<true>();
 });
 
-test("optional listField has 'itemType[]' submit value", () => {
-  const form = formAtom({
-    field: listField({
-      fields: () => ({ age: numberField({ value: 0 }) }),
-    }).optional(),
-  });
+// test("required listField has '[itemType, ...itemType[]]' submit value", () => {
+//   expectTypeOf<
+//     FormFieldSubmitValues<{ field: ListField<{ age: NumberField }> }>
+//   >().toEqualTypeOf<{
+//     field: [{ age: number }, ...{ age: number }[]];
+//   }>();
+// });
 
-  expectTypeOf<FormSubmitValues<typeof form>>().toEqualTypeOf<{
+test("optional listField has 'itemType[]' submit value", () => {
+  expectTypeOf<
+    FormFieldSubmitValues<{
+      field: ReturnType<ListField<{ age: NumberField }>["optional"]>;
+    }>
+  >().toEqualTypeOf<{
     field: { age: number }[];
   }>();
 });
diff --git a/src/fields/number-field/numberField.test-d.ts b/src/fields/number-field/numberField.test-d.ts
index 0d2560d..0ce34b0 100644
--- a/src/fields/number-field/numberField.test-d.ts
+++ b/src/fields/number-field/numberField.test-d.ts
@@ -1,25 +1,18 @@
-import { formAtom } from "form-atoms";
 import { expectTypeOf, test } from "vitest";
 
-import { numberField } from "./numberField";
-import { FormSubmitValues } from "../../components/form";
+import type { FormFieldSubmitValues } from "../../components/form";
+import type { NumberField } from "./numberField";
 
 test("required numberField has 'number' submit value", () => {
-  const form = formAtom({
-    field: numberField(),
-  });
-
-  expectTypeOf<FormSubmitValues<typeof form>>().toEqualTypeOf<{
+  expectTypeOf<FormFieldSubmitValues<{ field: NumberField }>>().toEqualTypeOf<{
     field: number;
   }>();
 });
 
 test("optional numberField has 'number | undefined' submit value", () => {
-  const form = formAtom({
-    field: numberField().optional(),
-  });
-
-  expectTypeOf<FormSubmitValues<typeof form>>().toEqualTypeOf<{
+  expectTypeOf<
+    FormFieldSubmitValues<{ field: ReturnType<NumberField["optional"]> }>
+  >().toEqualTypeOf<{
     field: number | undefined;
   }>();
 });
diff --git a/src/fields/string-field/stringField.test-d.ts b/src/fields/string-field/stringField.test-d.ts
index 6dbdc5e..ca3e57d 100644
--- a/src/fields/string-field/stringField.test-d.ts
+++ b/src/fields/string-field/stringField.test-d.ts
@@ -1,25 +1,19 @@
-import { formAtom } from "form-atoms";
 import { expectTypeOf, test } from "vitest";
 
-import { stringField } from "./stringField";
-import { FormSubmitValues } from "../../components/form";
+import type { FormFieldSubmitValues } from "../../components/form";
 
-test("required stringField has 'string' submit value", () => {
-  const form = formAtom({
-    field: stringField(),
-  });
+import type { StringField } from "./stringField";
 
-  expectTypeOf<FormSubmitValues<typeof form>>().toEqualTypeOf<{
+test("required stringField has 'string' submit value", () => {
+  expectTypeOf<FormFieldSubmitValues<{ field: StringField }>>().toEqualTypeOf<{
     field: string;
   }>();
 });
 
 test("optional stringField has 'string | undefined' submit value", () => {
-  const form = formAtom({
-    field: stringField().optional(),
-  });
-
-  expectTypeOf<FormSubmitValues<typeof form>>().toEqualTypeOf<{
+  expectTypeOf<
+    FormFieldSubmitValues<{ field: ReturnType<StringField["optional"]> }>
+  >().toEqualTypeOf<{
     field: string | undefined;
   }>();
 });
diff --git a/src/fields/text-field/textField.test-d.ts b/src/fields/text-field/textField.test-d.ts
index abb609e..1f92608 100644
--- a/src/fields/text-field/textField.test-d.ts
+++ b/src/fields/text-field/textField.test-d.ts
@@ -1,26 +1,19 @@
-import { formAtom } from "form-atoms";
 import { expectTypeOf, test } from "vitest";
 
-import { textField } from "./textField";
-import { FormSubmitValues } from "../../components/form";
+import type { FormFieldSubmitValues } from "../../components/form";
+import type { TextField } from "./textField";
 
 // could be stricter? e.g. matching pattern by min length
 test("required textField has 'string' submit value", () => {
-  const form = formAtom({
-    field: textField(),
-  });
-
-  expectTypeOf<FormSubmitValues<typeof form>>().toEqualTypeOf<{
+  expectTypeOf<FormFieldSubmitValues<{ field: TextField }>>().toEqualTypeOf<{
     field: string;
   }>();
 });
 
 test("optional textField has 'string' submit value", () => {
-  const form = formAtom({
-    field: textField().optional(),
-  });
-
-  expectTypeOf<FormSubmitValues<typeof form>>().toEqualTypeOf<{
+  expectTypeOf<
+    FormFieldSubmitValues<{ field: ReturnType<TextField["optional"]> }>
+  >().toEqualTypeOf<{
     field: string;
   }>();
 });

From bdcc426c198a5cab0458585a04f9eb756dcdb483 Mon Sep 17 00:00:00 2001
From: semantic-release-bot <semantic-release-bot@martynus.net>
Date: Fri, 17 Oct 2025 07:48:21 +0000
Subject: [PATCH 2/2] chore(release): 5.3.1

## [5.3.1](https://github.com/form-atoms/field/compare/v5.3.0...v5.3.1) (2025-10-17)

### Bug Fixes

* **form-submit-values:** drop superfluous extends ([f330a41](https://github.com/form-atoms/field/commit/f330a41562541f5baabf89640c02bbd741de3629))
---
 CHANGELOG.md | 7 +++++++
 1 file changed, 7 insertions(+)

diff --git a/CHANGELOG.md b/CHANGELOG.md
index 2d4cda5..a58a10b 100644
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -1,3 +1,10 @@
+## [5.3.1](https://github.com/form-atoms/field/compare/v5.3.0...v5.3.1) (2025-10-17)
+
+
+### Bug Fixes
+
+* **form-submit-values:** drop superfluous extends ([f330a41](https://github.com/form-atoms/field/commit/f330a41562541f5baabf89640c02bbd741de3629))
+
 # [5.3.0](https://github.com/form-atoms/field/compare/v5.2.0...v5.3.0) (2025-10-16)