@jcoreio/zod-forms 1.2.0 → 2.0.0-beta.1

package/reducers/submitSucceeded.js.map

@@ -1 +1 @@
-{"version":3,"file":"submitSucceeded.js","names":["submitSucceededReducer","state","_objectSpread","submitting","submitSucceeded","submitFailed","submitError","undefined","submitPromise","initialValues","submittedValues","rawInitialValues","rawSubmittedValues"],"sources":["../../src/reducers/submitSucceeded.ts"],"sourcesContent":["import z from 'zod'\nimport { FormState } from '../FormState'\n\nexport function submitSucceededReducer<T extends z.ZodTypeAny>(\n  state: FormState<T>\n) {\n  return {\n    ...state,\n    submitting: false,\n    submitSucceeded: true,\n    submitFailed: false,\n    submitError: undefined,\n    submitPromise: undefined,\n    initialValues: state.submittedValues,\n    rawInitialValues: state.rawSubmittedValues,\n  }\n}\n"],"mappings":";;;;;;;;;;AAGO,SAASA,sBAAsBA,CACpCC,KAAmB,EACnB;EACA,OAAAC,aAAA,CAAAA,aAAA,KACKD,KAAK;IACRE,UAAU,EAAE,KAAK;IACjBC,eAAe,EAAE,IAAI;IACrBC,YAAY,EAAE,KAAK;IACnBC,WAAW,EAAEC,SAAS;IACtBC,aAAa,EAAED,SAAS;IACxBE,aAAa,EAAER,KAAK,CAACS,eAAe;IACpCC,gBAAgB,EAAEV,KAAK,CAACW;EAAkB;AAE9C","ignoreList":[]}
+{"version":3,"file":"submitSucceeded.js","names":["submitSucceededReducer","state","_objectSpread","submitting","submitSucceeded","submitFailed","submitError","undefined","submitPromise","initialParsedValues","submittedParsedValues","initialValues","submittedValues"],"sources":["../../src/reducers/submitSucceeded.ts"],"sourcesContent":["import z from 'zod'\nimport { FormState } from '../FormState'\n\nexport function submitSucceededReducer<T extends z.ZodTypeAny>(\n  state: FormState<T>\n) {\n  return {\n    ...state,\n    submitting: false,\n    submitSucceeded: true,\n    submitFailed: false,\n    submitError: undefined,\n    submitPromise: undefined,\n    initialParsedValues: state.submittedParsedValues,\n    initialValues: state.submittedValues,\n  }\n}\n"],"mappings":";;;;;;;;;;AAGO,SAASA,sBAAsBA,CACpCC,KAAmB,EACnB;EACA,OAAAC,aAAA,CAAAA,aAAA,KACKD,KAAK;IACRE,UAAU,EAAE,KAAK;IACjBC,eAAe,EAAE,IAAI;IACrBC,YAAY,EAAE,KAAK;IACnBC,WAAW,EAAEC,SAAS;IACtBC,aAAa,EAAED,SAAS;IACxBE,mBAAmB,EAAER,KAAK,CAACS,qBAAqB;IAChDC,aAAa,EAAEV,KAAK,CAACW;EAAe;AAExC","ignoreList":[]}

package/reducers/submitSucceeded.mjs

@@ -6,8 +6,8 @@ export function submitSucceededReducer(state) {
     submitFailed: false,
     submitError: undefined,
     submitPromise: undefined,
-    initialValues: state.submittedValues,
-    rawInitialValues: state.rawSubmittedValues
+    initialParsedValues: state.submittedParsedValues,
+    initialValues: state.submittedValues
   };
 }
 //# sourceMappingURL=submitSucceeded.mjs.map

package/reducers/submitSucceeded.mjs.map

@@ -1 +1 @@
-{"version":3,"file":"submitSucceeded.mjs","names":["submitSucceededReducer","state","submitting","submitSucceeded","submitFailed","submitError","undefined","submitPromise","initialValues","submittedValues","rawInitialValues","rawSubmittedValues"],"sources":["../../src/reducers/submitSucceeded.ts"],"sourcesContent":["import z from 'zod'\nimport { FormState } from '../FormState'\n\nexport function submitSucceededReducer<T extends z.ZodTypeAny>(\n  state: FormState<T>\n) {\n  return {\n    ...state,\n    submitting: false,\n    submitSucceeded: true,\n    submitFailed: false,\n    submitError: undefined,\n    submitPromise: undefined,\n    initialValues: state.submittedValues,\n    rawInitialValues: state.rawSubmittedValues,\n  }\n}\n"],"mappings":"AAGA,OAAO,SAASA,sBAAsBA,CACpCC,KAAmB,EACnB;EACA,OAAO;IACL,GAAGA,KAAK;IACRC,UAAU,EAAE,KAAK;IACjBC,eAAe,EAAE,IAAI;IACrBC,YAAY,EAAE,KAAK;IACnBC,WAAW,EAAEC,SAAS;IACtBC,aAAa,EAAED,SAAS;IACxBE,aAAa,EAAEP,KAAK,CAACQ,eAAe;IACpCC,gBAAgB,EAAET,KAAK,CAACU;EAC1B,CAAC;AACH","ignoreList":[]}
+{"version":3,"file":"submitSucceeded.mjs","names":["submitSucceededReducer","state","submitting","submitSucceeded","submitFailed","submitError","undefined","submitPromise","initialParsedValues","submittedParsedValues","initialValues","submittedValues"],"sources":["../../src/reducers/submitSucceeded.ts"],"sourcesContent":["import z from 'zod'\nimport { FormState } from '../FormState'\n\nexport function submitSucceededReducer<T extends z.ZodTypeAny>(\n  state: FormState<T>\n) {\n  return {\n    ...state,\n    submitting: false,\n    submitSucceeded: true,\n    submitFailed: false,\n    submitError: undefined,\n    submitPromise: undefined,\n    initialParsedValues: state.submittedParsedValues,\n    initialValues: state.submittedValues,\n  }\n}\n"],"mappings":"AAGA,OAAO,SAASA,sBAAsBA,CACpCC,KAAmB,EACnB;EACA,OAAO;IACL,GAAGA,KAAK;IACRC,UAAU,EAAE,KAAK;IACjBC,eAAe,EAAE,IAAI;IACrBC,YAAY,EAAE,KAAK;IACnBC,WAAW,EAAEC,SAAS;IACtBC,aAAa,EAAED,SAAS;IACxBE,mBAAmB,EAAEP,KAAK,CAACQ,qBAAqB;IAChDC,aAAa,EAAET,KAAK,CAACU;EACvB,CAAC;AACH","ignoreList":[]}

package/reducers/util/updateRawArray.d.ts

@@ -1,7 +1,7 @@
 import z from 'zod';
 import { Reducer } from 'react';
-import { FieldPath, FieldPathForRawValue } from '../../FieldPath';
+import { FieldPath, FieldPathForValue } from '../../FieldPath';
 import { FormState } from '../../FormState';
 import { FormAction } from '../../FormAction';
-export declare function updateRawArray<T extends z.ZodTypeAny, Field extends FieldPathForRawValue<any[]>>(reducer: Reducer<FormState<T>, FormAction<T>>, state: FormState<T>, field: FieldPath, updater: (array: z.input<Field['schema']> | undefined) => z.input<Field['schema']> | undefined): FormState<T>;
+export declare function updateRawArray<T extends z.ZodTypeAny, Field extends FieldPathForValue<any[]>>(reducer: Reducer<FormState<T>, FormAction<T>>, state: FormState<T>, field: FieldPath, updater: (array: z.input<Field['schema']> | undefined) => z.input<Field['schema']> | undefined): FormState<T>;
 //# sourceMappingURL=updateRawArray.d.ts.map

package/reducers/util/updateRawArray.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"updateRawArray.d.ts","sourceRoot":"","sources":["../../../src/reducers/util/updateRawArray.ts"],"names":[],"mappings":"AAAA,OAAO,CAAC,MAAM,KAAK,CAAA;AACnB,OAAO,EAAE,OAAO,EAAE,MAAM,OAAO,CAAA;AAC/B,OAAO,EAAE,SAAS,EAAE,oBAAoB,EAAE,MAAM,iBAAiB,CAAA;AACjE,OAAO,EAAE,SAAS,EAAE,MAAM,iBAAiB,CAAA;AAC3C,OAAO,EAAE,UAAU,EAAE,MAAM,kBAAkB,CAAA;AAI7C,wBAAgB,cAAc,CAC5B,CAAC,SAAS,CAAC,CAAC,UAAU,EACtB,KAAK,SAAS,oBAAoB,CAAC,GAAG,EAAE,CAAC,EAEzC,OAAO,EAAE,OAAO,CAAC,SAAS,CAAC,CAAC,CAAC,EAAE,UAAU,CAAC,CAAC,CAAC,CAAC,EAC7C,KAAK,EAAE,SAAS,CAAC,CAAC,CAAC,EACnB,KAAK,EAAE,SAAS,EAChB,OAAO,EAAE,CACP,KAAK,EAAE,CAAC,CAAC,KAAK,CAAC,KAAK,CAAC,QAAQ,CAAC,CAAC,GAAG,SAAS,KACxC,CAAC,CAAC,KAAK,CAAC,KAAK,CAAC,QAAQ,CAAC,CAAC,GAAG,SAAS,gBAO1C"}
+{"version":3,"file":"updateRawArray.d.ts","sourceRoot":"","sources":["../../../src/reducers/util/updateRawArray.ts"],"names":[],"mappings":"AAAA,OAAO,CAAC,MAAM,KAAK,CAAA;AACnB,OAAO,EAAE,OAAO,EAAE,MAAM,OAAO,CAAA;AAC/B,OAAO,EAAE,SAAS,EAAE,iBAAiB,EAAE,MAAM,iBAAiB,CAAA;AAC9D,OAAO,EAAE,SAAS,EAAE,MAAM,iBAAiB,CAAA;AAC3C,OAAO,EAAE,UAAU,EAAE,MAAM,kBAAkB,CAAA;AAI7C,wBAAgB,cAAc,CAC5B,CAAC,SAAS,CAAC,CAAC,UAAU,EACtB,KAAK,SAAS,iBAAiB,CAAC,GAAG,EAAE,CAAC,EAEtC,OAAO,EAAE,OAAO,CAAC,SAAS,CAAC,CAAC,CAAC,EAAE,UAAU,CAAC,CAAC,CAAC,CAAC,EAC7C,KAAK,EAAE,SAAS,CAAC,CAAC,CAAC,EACnB,KAAK,EAAE,SAAS,EAChB,OAAO,EAAE,CACP,KAAK,EAAE,CAAC,CAAC,KAAK,CAAC,KAAK,CAAC,QAAQ,CAAC,CAAC,GAAG,SAAS,KACxC,CAAC,CAAC,KAAK,CAAC,KAAK,CAAC,QAAQ,CAAC,CAAC,GAAG,SAAS,gBAO1C"}

package/reducers/util/updateRawArray.js

@@ -5,10 +5,10 @@ Object.defineProperty(exports, "__esModule", {
 });
 exports.updateRawArray = updateRawArray;
 var _get = require("../../util/get.js");
-var _setRawValue = require("../../actions/setRawValue.js");
+var _setValue = require("../../actions/setValue.js");
 function updateRawArray(reducer, state, field, updater) {
-  var oldValue = (0, _get.get)(state.rawValues, field.path);
+  var oldValue = (0, _get.get)(state.values, field.path);
   var newValue = updater(oldValue);
-  return newValue === oldValue ? state : reducer(state, (0, _setRawValue.setRawValue)(field, newValue));
+  return newValue === oldValue ? state : reducer(state, (0, _setValue.setValue)(field, newValue));
 }
 //# sourceMappingURL=updateRawArray.js.map

package/reducers/util/updateRawArray.js.map

@@ -1 +1 @@
-{"version":3,"file":"updateRawArray.js","names":["_get","require","_setRawValue","updateRawArray","reducer","state","field","updater","oldValue","get","rawValues","path","newValue","setRawValue"],"sources":["../../../src/reducers/util/updateRawArray.ts"],"sourcesContent":["import z from 'zod'\nimport { Reducer } from 'react'\nimport { FieldPath, FieldPathForRawValue } from '../../FieldPath'\nimport { FormState } from '../../FormState'\nimport { FormAction } from '../../FormAction'\nimport { get } from '../../util/get'\nimport { setRawValue } from '../../actions/setRawValue'\n\nexport function updateRawArray<\n  T extends z.ZodTypeAny,\n  Field extends FieldPathForRawValue<any[]>\n>(\n  reducer: Reducer<FormState<T>, FormAction<T>>,\n  state: FormState<T>,\n  field: FieldPath,\n  updater: (\n    array: z.input<Field['schema']> | undefined\n  ) => z.input<Field['schema']> | undefined\n) {\n  const oldValue = get(state.rawValues, field.path)\n  const newValue = updater(oldValue as any)\n  return newValue === oldValue\n    ? state\n    : reducer(state, setRawValue(field, newValue))\n}\n"],"mappings":";;;;;;AAKA,IAAAA,IAAA,GAAAC,OAAA;AACA,IAAAC,YAAA,GAAAD,OAAA;AAEO,SAASE,cAAcA,CAI5BC,OAA6C,EAC7CC,KAAmB,EACnBC,KAAgB,EAChBC,OAEyC,EACzC;EACA,IAAMC,QAAQ,GAAG,IAAAC,QAAG,EAACJ,KAAK,CAACK,SAAS,EAAEJ,KAAK,CAACK,IAAI,CAAC;EACjD,IAAMC,QAAQ,GAAGL,OAAO,CAACC,QAAe,CAAC;EACzC,OAAOI,QAAQ,KAAKJ,QAAQ,GACxBH,KAAK,GACLD,OAAO,CAACC,KAAK,EAAE,IAAAQ,wBAAW,EAACP,KAAK,EAAEM,QAAQ,CAAC,CAAC;AAClD","ignoreList":[]}
+{"version":3,"file":"updateRawArray.js","names":["_get","require","_setValue","updateRawArray","reducer","state","field","updater","oldValue","get","values","path","newValue","setValue"],"sources":["../../../src/reducers/util/updateRawArray.ts"],"sourcesContent":["import z from 'zod'\nimport { Reducer } from 'react'\nimport { FieldPath, FieldPathForValue } from '../../FieldPath'\nimport { FormState } from '../../FormState'\nimport { FormAction } from '../../FormAction'\nimport { get } from '../../util/get'\nimport { setValue } from '../../actions/setValue'\n\nexport function updateRawArray<\n  T extends z.ZodTypeAny,\n  Field extends FieldPathForValue<any[]>\n>(\n  reducer: Reducer<FormState<T>, FormAction<T>>,\n  state: FormState<T>,\n  field: FieldPath,\n  updater: (\n    array: z.input<Field['schema']> | undefined\n  ) => z.input<Field['schema']> | undefined\n) {\n  const oldValue = get(state.values, field.path)\n  const newValue = updater(oldValue as any)\n  return newValue === oldValue\n    ? state\n    : reducer(state, setValue(field, newValue))\n}\n"],"mappings":";;;;;;AAKA,IAAAA,IAAA,GAAAC,OAAA;AACA,IAAAC,SAAA,GAAAD,OAAA;AAEO,SAASE,cAAcA,CAI5BC,OAA6C,EAC7CC,KAAmB,EACnBC,KAAgB,EAChBC,OAEyC,EACzC;EACA,IAAMC,QAAQ,GAAG,IAAAC,QAAG,EAACJ,KAAK,CAACK,MAAM,EAAEJ,KAAK,CAACK,IAAI,CAAC;EAC9C,IAAMC,QAAQ,GAAGL,OAAO,CAACC,QAAe,CAAC;EACzC,OAAOI,QAAQ,KAAKJ,QAAQ,GACxBH,KAAK,GACLD,OAAO,CAACC,KAAK,EAAE,IAAAQ,kBAAQ,EAACP,KAAK,EAAEM,QAAQ,CAAC,CAAC;AAC/C","ignoreList":[]}

package/reducers/util/updateRawArray.mjs

@@ -1,8 +1,8 @@
 import { get } from "../../util/get.mjs";
-import { setRawValue } from "../../actions/setRawValue.mjs";
+import { setValue } from "../../actions/setValue.mjs";
 export function updateRawArray(reducer, state, field, updater) {
-  const oldValue = get(state.rawValues, field.path);
+  const oldValue = get(state.values, field.path);
   const newValue = updater(oldValue);
-  return newValue === oldValue ? state : reducer(state, setRawValue(field, newValue));
+  return newValue === oldValue ? state : reducer(state, setValue(field, newValue));
 }
 //# sourceMappingURL=updateRawArray.mjs.map

package/reducers/util/updateRawArray.mjs.map

@@ -1 +1 @@
-{"version":3,"file":"updateRawArray.mjs","names":["get","setRawValue","updateRawArray","reducer","state","field","updater","oldValue","rawValues","path","newValue"],"sources":["../../../src/reducers/util/updateRawArray.ts"],"sourcesContent":["import z from 'zod'\nimport { Reducer } from 'react'\nimport { FieldPath, FieldPathForRawValue } from '../../FieldPath'\nimport { FormState } from '../../FormState'\nimport { FormAction } from '../../FormAction'\nimport { get } from '../../util/get'\nimport { setRawValue } from '../../actions/setRawValue'\n\nexport function updateRawArray<\n  T extends z.ZodTypeAny,\n  Field extends FieldPathForRawValue<any[]>\n>(\n  reducer: Reducer<FormState<T>, FormAction<T>>,\n  state: FormState<T>,\n  field: FieldPath,\n  updater: (\n    array: z.input<Field['schema']> | undefined\n  ) => z.input<Field['schema']> | undefined\n) {\n  const oldValue = get(state.rawValues, field.path)\n  const newValue = updater(oldValue as any)\n  return newValue === oldValue\n    ? state\n    : reducer(state, setRawValue(field, newValue))\n}\n"],"mappings":"AAKA,SAASA,GAAG;AACZ,SAASC,WAAW;AAEpB,OAAO,SAASC,cAAcA,CAI5BC,OAA6C,EAC7CC,KAAmB,EACnBC,KAAgB,EAChBC,OAEyC,EACzC;EACA,MAAMC,QAAQ,GAAGP,GAAG,CAACI,KAAK,CAACI,SAAS,EAAEH,KAAK,CAACI,IAAI,CAAC;EACjD,MAAMC,QAAQ,GAAGJ,OAAO,CAACC,QAAe,CAAC;EACzC,OAAOG,QAAQ,KAAKH,QAAQ,GACxBH,KAAK,GACLD,OAAO,CAACC,KAAK,EAAEH,WAAW,CAACI,KAAK,EAAEK,QAAQ,CAAC,CAAC;AAClD","ignoreList":[]}
+{"version":3,"file":"updateRawArray.mjs","names":["get","setValue","updateRawArray","reducer","state","field","updater","oldValue","values","path","newValue"],"sources":["../../../src/reducers/util/updateRawArray.ts"],"sourcesContent":["import z from 'zod'\nimport { Reducer } from 'react'\nimport { FieldPath, FieldPathForValue } from '../../FieldPath'\nimport { FormState } from '../../FormState'\nimport { FormAction } from '../../FormAction'\nimport { get } from '../../util/get'\nimport { setValue } from '../../actions/setValue'\n\nexport function updateRawArray<\n  T extends z.ZodTypeAny,\n  Field extends FieldPathForValue<any[]>\n>(\n  reducer: Reducer<FormState<T>, FormAction<T>>,\n  state: FormState<T>,\n  field: FieldPath,\n  updater: (\n    array: z.input<Field['schema']> | undefined\n  ) => z.input<Field['schema']> | undefined\n) {\n  const oldValue = get(state.values, field.path)\n  const newValue = updater(oldValue as any)\n  return newValue === oldValue\n    ? state\n    : reducer(state, setValue(field, newValue))\n}\n"],"mappings":"AAKA,SAASA,GAAG;AACZ,SAASC,QAAQ;AAEjB,OAAO,SAASC,cAAcA,CAI5BC,OAA6C,EAC7CC,KAAmB,EACnBC,KAAgB,EAChBC,OAEyC,EACzC;EACA,MAAMC,QAAQ,GAAGP,GAAG,CAACI,KAAK,CAACI,MAAM,EAAEH,KAAK,CAACI,IAAI,CAAC;EAC9C,MAAMC,QAAQ,GAAGJ,OAAO,CAACC,QAAe,CAAC;EACzC,OAAOG,QAAQ,KAAKH,QAAQ,GACxBH,KAAK,GACLD,OAAO,CAACC,KAAK,EAAEH,QAAQ,CAACI,KAAK,EAAEK,QAAQ,CAAC,CAAC;AAC/C","ignoreList":[]}

package/src/ConditionalValidator.ts

@@ -1,4 +1,5 @@
 import z from 'zod'
+import { IgnoreEffect } from 'zod-invertible'
 import { DeepPartial } from './util/DeepPartial'
 
 type ConditionalCheck<T extends z.ZodTypeAny> = {
@@ -38,7 +39,9 @@ export class ConditionalValidator<
   Output = z.output<T>,
   Input = z.input<T>
 > extends z.ZodEffects<T, Output, Input> {
-  declare _def: ConditionalValidatorDef<T>
+  declare _def: ConditionalValidatorDef<T>;
+
+  [IgnoreEffect] = true
 
   constructor(schema: T, checks: ConditionalCheck<any>[]) {
     super({

package/src/FieldPath.ts

@@ -4,12 +4,10 @@ import { SchemaAt } from './util/SchemaAt'
 import { PathInSchema, PathstringInSchema } from './util/PathInSchema'
 import { parsePathstring } from './util/parsePathstring'
 
-export type FieldPathForValue<Value, RawValue = any> = FieldPath<
-  z.ZodType<Value, any, RawValue>
->
-export type FieldPathForRawValue<RawValue> = FieldPath<
-  z.ZodType<any, any, RawValue>
+export type FieldPathForParsedValue<ParsedValue, Value = any> = FieldPath<
+  z.ZodType<ParsedValue, any, Value>
 >
+export type FieldPathForValue<Value> = FieldPath<z.ZodType<any, any, Value>>
 
 export class FieldPath<T extends z.ZodTypeAny = z.ZodTypeAny> {
   readonly path: BasePath

package/src/FormAction.ts

@@ -1,8 +1,8 @@
 import z from 'zod'
 import { SetMountedAction } from './actions/setMounted'
 import { InitializeAction } from './actions/initialize'
+import { SetParsedValueAction } from './actions/setParsedValue'
 import { SetValueAction } from './actions/setValue'
-import { SetRawValueAction } from './actions/setRawValue'
 import { SetMetaAction } from './actions/setMeta'
 import { FieldPath } from './FieldPath'
 import { SubmitAction } from './actions/submit'
@@ -15,8 +15,8 @@ import { ArrayAction } from './actions/arrayActions'
 export type FormAction<T extends z.ZodTypeAny> =
   | SetMountedAction
   | InitializeAction<T>
+  | SetParsedValueAction<FieldPath>
   | SetValueAction<FieldPath>
-  | SetRawValueAction<FieldPath>
   | SetMetaAction<FieldPath>
   | AddHandlersAction<T>
   | RemoveHandlersAction<T>

package/src/FormContext.ts

@@ -2,8 +2,8 @@ import React from 'react'
 import z from 'zod'
 import { FieldPath } from './FieldPath'
 import { initialize } from './actions/initialize'
-import { setRawValue } from './actions/setRawValue'
 import { setValue } from './actions/setValue'
+import { setParsedValue } from './actions/setParsedValue'
 import { submit } from './actions/submit'
 import { setSubmitStatus } from './actions/setSubmitStatus'
 import { SelectFormValues } from './createSelectFormValues'
@@ -16,6 +16,7 @@ import { setMeta } from './actions/setMeta'
 import { addHandlers } from './actions/addHandlers'
 import { removeHandlers } from './actions/removeHandlers'
 import { arrayActions } from './actions/arrayActions'
+import { DeepPartial } from './util/DeepPartial'
 
 export const FormContext =
   React.createContext<FormContextProps<z.ZodTypeAny> | null>(null)
@@ -28,17 +29,17 @@ export type FormContextProps<T extends z.ZodTypeAny> = {
   addHandlers: typeof addHandlers<T>
   removeHandlers: typeof removeHandlers<T>
   setMeta: typeof setMeta
-  setRawValue: typeof setRawValue
   setValue: typeof setValue
+  setParsedValue: typeof setParsedValue
   submit: typeof submit
   setSubmitStatus: typeof setSubmitStatus<T>
   arrayActions: typeof arrayActions
   selectFormStatus: SelectFormStatus
   selectFieldErrorMap: SelectFieldErrorMap
   selectFormValues: SelectFormValues<T>
-  getValues: () => z.output<T> | undefined
-  getRawValues: () => unknown
-  getInitialValues: () => z.output<T> | undefined
-  getRawInitialValues: () => unknown
+  getParsedValues: () => DeepPartial<z.output<T>> | undefined
+  getValues: () => DeepPartial<z.input<T>> | undefined
+  getInitialParsedValues: () => DeepPartial<z.output<T>> | undefined
+  getInitialValues: () => DeepPartial<z.input<T>> | undefined
   getStatus: () => ReturnType<ReturnType<typeof createSelectFormStatus>>
 }

package/src/FormState.ts

@@ -1,4 +1,5 @@
 import z from 'zod'
+import { DeepPartial } from './util/DeepPartial'
 
 export type FieldMeta = {
   touched: boolean
@@ -6,8 +7,11 @@ export type FieldMeta = {
 }
 
 export type SubmitHandler<T extends z.ZodTypeAny> = (
-  values: z.output<T>,
-  options: { initialValues: z.output<T> }
+  parsedValues: z.output<T>,
+  options: {
+    initialValues?: DeepPartial<z.input<T>>
+    initialParsedValues?: DeepPartial<z.output<T>>
+  }
 ) => void | Promise<void>
 
 export type SubmitSuccededHandler = () => void
@@ -18,12 +22,12 @@ export type FormState<T extends z.ZodTypeAny> = {
   mounted: boolean
   initialized: boolean
   fieldMeta: Record<string, FieldMeta>
-  rawValues?: unknown
-  values?: z.output<T>
-  submittedValues?: z.output<T>
-  rawSubmittedValues?: z.input<T>
-  rawInitialValues?: unknown
-  initialValues?: z.output<T>
+  values?: DeepPartial<z.input<T>>
+  parsedValues?: DeepPartial<z.output<T>>
+  submittedParsedValues?: z.output<T>
+  submittedValues?: z.input<T>
+  initialValues?: DeepPartial<z.input<T>>
+  initialParsedValues?: DeepPartial<z.output<T>>
   validationError?: any
   submitPromise?: Promise<void>
   onSubmit: Set<SubmitHandler<T>>

package/src/actions/arrayActions.ts

@@ -1,40 +1,41 @@
-import { FieldPathForValue } from '../FieldPath'
+import { FieldPathForParsedValue } from '../FieldPath'
 import z from 'zod'
+import { DeepPartial } from '../util/DeepPartial'
 
-export type ArrayFieldPath<V = any, R = any> = FieldPathForValue<
+export type ArrayFieldPath<V = any, R = any> = FieldPathForParsedValue<
   V[] | null | undefined,
   R[] | null | undefined
 >
 
-type ValueFor<Field extends ArrayFieldPath> = NonNullable<
+type ParsedValueFor<Field extends ArrayFieldPath> = NonNullable<
   z.output<Field['schema']>
 >[number]
 
-type RawValueFor<Field extends ArrayFieldPath> = NonNullable<
-  z.input<Field['schema']>
->[number]
+type ValueFor<Field extends ArrayFieldPath> = DeepPartial<
+  NonNullable<z.input<Field['schema']>>[number]
+>
 
-export type ArrayInsertAction<Field extends ArrayFieldPath = ArrayFieldPath> =
-  ReturnType<typeof arrayInsert<Field>>
+export type ArrayInsertParsedAction<
+  Field extends ArrayFieldPath = ArrayFieldPath
+> = ReturnType<typeof arrayInsertParsed<Field>>
 
-export function arrayInsert<Field extends ArrayFieldPath>(
+export function arrayInsertParsed<Field extends ArrayFieldPath>(
   field: Field,
   index: number,
-  value: ValueFor<Field>
+  parsedValue: ParsedValueFor<Field>
 ) {
-  return { type: 'arrayInsert', field, index, value } as const
+  return { type: 'arrayInsertParsed', field, index, parsedValue } as const
 }
 
-export type ArrayInsertRawAction<
-  Field extends ArrayFieldPath = ArrayFieldPath
-> = ReturnType<typeof arrayInsertRaw<Field>>
+export type ArrayInsertAction<Field extends ArrayFieldPath = ArrayFieldPath> =
+  ReturnType<typeof arrayInsert<Field>>
 
-export function arrayInsertRaw<Field extends ArrayFieldPath>(
+export function arrayInsert<Field extends ArrayFieldPath>(
   field: Field,
   index: number,
-  rawValue: RawValueFor<Field>
+  value: ValueFor<Field>
 ) {
-  return { type: 'arrayInsertRaw', field, index, rawValue } as const
+  return { type: 'arrayInsert', field, index, value } as const
 }
 
 export type ArrayMoveAction = ReturnType<typeof arrayMove>
@@ -49,24 +50,25 @@ export function arrayPop(field: ArrayFieldPath) {
   return { type: 'arrayPop', field } as const
 }
 
-export type ArrayPushAction<Field extends ArrayFieldPath = ArrayFieldPath> =
-  ReturnType<typeof arrayPush<Field>>
+export type ArrayPushParsedAction<
+  Field extends ArrayFieldPath = ArrayFieldPath
+> = ReturnType<typeof arrayPushParsed<Field>>
 
-export function arrayPush<Field extends ArrayFieldPath>(
+export function arrayPushParsed<Field extends ArrayFieldPath>(
   field: Field,
-  value: ValueFor<Field>
+  parsedValue: ParsedValueFor<Field>
 ) {
-  return { type: 'arrayPush', field, value } as const
+  return { type: 'arrayPushParsed', field, parsedValue } as const
 }
 
-export type ArrayPushRawAction<Field extends ArrayFieldPath = ArrayFieldPath> =
-  ReturnType<typeof arrayPushRaw<Field>>
+export type ArrayPushAction<Field extends ArrayFieldPath = ArrayFieldPath> =
+  ReturnType<typeof arrayPush<Field>>
 
-export function arrayPushRaw<Field extends ArrayFieldPath>(
+export function arrayPush<Field extends ArrayFieldPath>(
   field: Field,
-  rawValue: RawValueFor<Field>
+  value: ValueFor<Field>
 ) {
-  return { type: 'arrayPushRaw', field, rawValue } as const
+  return { type: 'arrayPush', field, value } as const
 }
 
 export type ArrayRemoveAction = ReturnType<typeof arrayRemove>
@@ -87,34 +89,40 @@ export function arrayShift(field: ArrayFieldPath) {
   return { type: 'arrayShift', field } as const
 }
 
-export type ArraySpliceAction<Field extends ArrayFieldPath = ArrayFieldPath> =
-  ReturnType<typeof arraySplice<Field>>
+export type ArraySpliceParsedAction<
+  Field extends ArrayFieldPath = ArrayFieldPath
+> = ReturnType<typeof arraySpliceParsed<Field>>
 
-export function arraySplice<Field extends ArrayFieldPath>(
+export function arraySpliceParsed<Field extends ArrayFieldPath>(
   field: Field,
   index: number,
   deleteCount: number,
-  ...values: ValueFor<Field>[]
+  ...parsedValues: ParsedValueFor<Field>[]
 ) {
-  return { type: 'arraySplice', field, index, deleteCount, values } as const
+  return {
+    type: 'arraySpliceParsed',
+    field,
+    index,
+    deleteCount,
+    parsedValues,
+  } as const
 }
 
-export type ArraySpliceRawAction<
-  Field extends ArrayFieldPath = ArrayFieldPath
-> = ReturnType<typeof arraySpliceRaw<Field>>
+export type ArraySpliceAction<Field extends ArrayFieldPath = ArrayFieldPath> =
+  ReturnType<typeof arraySplice<Field>>
 
-export function arraySpliceRaw<Field extends ArrayFieldPath>(
+export function arraySplice<Field extends ArrayFieldPath>(
   field: Field,
   index: number,
   deleteCount: number,
-  ...rawValues: RawValueFor<Field>[]
+  ...values: ValueFor<Field>[]
 ) {
   return {
-    type: 'arraySpliceRaw',
+    type: 'arraySplice',
     field,
     index,
     deleteCount,
-    rawValues,
+    values,
   } as const
 }
 
@@ -128,56 +136,56 @@ export function arraySwap(
   return { type: 'arraySwap', field, indexA, indexB } as const
 }
 
-export type ArrayUnshiftAction<Field extends ArrayFieldPath = ArrayFieldPath> =
-  ReturnType<typeof arrayUnshift<Field>>
+export type ArrayUnshiftParsedAction<
+  Field extends ArrayFieldPath = ArrayFieldPath
+> = ReturnType<typeof arrayUnshiftParsed<Field>>
 
-export function arrayUnshift<Field extends ArrayFieldPath>(
+export function arrayUnshiftParsed<Field extends ArrayFieldPath>(
   field: Field,
-  value: ValueFor<Field>
+  parsedValue: ParsedValueFor<Field>
 ) {
-  return { type: 'arrayUnshift', field, value } as const
+  return { type: 'arrayUnshiftParsed', field, parsedValue } as const
 }
 
-export type ArrayUnshiftRawAction<
-  Field extends ArrayFieldPath = ArrayFieldPath
-> = ReturnType<typeof arrayUnshiftRaw<Field>>
+export type ArrayUnshiftAction<Field extends ArrayFieldPath = ArrayFieldPath> =
+  ReturnType<typeof arrayUnshift<Field>>
 
-export function arrayUnshiftRaw<Field extends ArrayFieldPath>(
+export function arrayUnshift<Field extends ArrayFieldPath>(
   field: Field,
-  rawValue: RawValueFor<Field>
+  value: ValueFor<Field>
 ) {
-  return { type: 'arrayUnshiftRaw', field, rawValue } as const
+  return { type: 'arrayUnshift', field, value } as const
 }
 
 export type ArrayAction<Field extends ArrayFieldPath = ArrayFieldPath> =
+  | ArrayInsertParsedAction<Field>
   | ArrayInsertAction<Field>
-  | ArrayInsertRawAction<Field>
   | ArrayMoveAction
   | ArrayPopAction
+  | ArrayPushParsedAction<Field>
   | ArrayPushAction<Field>
-  | ArrayPushRawAction<Field>
   | ArrayRemoveAction
   | ArrayRemoveAllAction
   | ArrayShiftAction
+  | ArraySpliceParsedAction<Field>
   | ArraySpliceAction<Field>
-  | ArraySpliceRawAction<Field>
   | ArraySwapAction
+  | ArrayUnshiftParsedAction<Field>
   | ArrayUnshiftAction<Field>
-  | ArrayUnshiftRawAction<Field>
 
 export const arrayActions = {
+  insertParsed: arrayInsertParsed,
   insert: arrayInsert,
-  insertRaw: arrayInsertRaw,
   move: arrayMove,
   pop: arrayPop,
+  pushParsed: arrayPushParsed,
   push: arrayPush,
-  pushRaw: arrayPushRaw,
   remove: arrayRemove,
   removeAll: arrayRemoveAll,
   shift: arrayShift,
+  spliceParsed: arraySpliceParsed,
   splice: arraySplice,
-  spliceRaw: arraySpliceRaw,
   swap: arraySwap,
+  unshiftParsed: arrayUnshiftParsed,
   unshift: arrayUnshift,
-  unshiftRaw: arrayUnshiftRaw,
 }

package/src/actions/initialize.ts

@@ -1,12 +1,13 @@
 import z from 'zod'
+import { DeepPartial } from '../util/DeepPartial'
 
 export type InitializeAction<T extends z.ZodTypeAny> = ReturnType<
   typeof initialize<T>
 >
 
 export function initialize<T extends z.ZodTypeAny>(props: {
-  rawValues?: z.input<T>
-  values?: z.output<T>
+  values?: DeepPartial<z.input<T>>
+  parsedValues?: z.output<T>
   keepSubmitSucceeded?: boolean
 }) {
   return {

package/src/actions/setParsedValue.ts

@@ -0,0 +1,21 @@
+import z from 'zod'
+import { FieldPath } from '../FieldPath'
+
+export type SetParsedValueAction<Field extends FieldPath> = ReturnType<
+  typeof setParsedValue<Field>
+>
+
+export function setParsedValue<Field extends FieldPath>(
+  field: Field,
+  parsedValue: z.output<Field['schema']>,
+  options?: {
+    normalize?: boolean
+  }
+) {
+  return {
+    type: 'setParsedValue',
+    field,
+    parsedValue,
+    ...options,
+  } as const
+}

package/src/actions/setSubmitStatus.ts

@@ -14,8 +14,8 @@ export function setSubmitStatus<T extends z.ZodTypeAny>(
       | 'submitPromise'
       | 'submitSucceeded'
       | 'submitFailed'
+      | 'submittedParsedValues'
       | 'submittedValues'
-      | 'rawSubmittedValues'
     >
   >
 ) {

package/src/actions/setValue.ts

@@ -1,5 +1,6 @@
 import z from 'zod'
 import { FieldPath } from '../FieldPath'
+import { DeepPartial } from '../util/DeepPartial'
 
 export type SetValueAction<Field extends FieldPath> = ReturnType<
   typeof setValue<Field>
@@ -7,15 +8,11 @@ export type SetValueAction<Field extends FieldPath> = ReturnType<
 
 export function setValue<Field extends FieldPath>(
   field: Field,
-  value: z.output<Field['schema']>,
-  options?: {
-    normalize?: boolean
-  }
+  value: DeepPartial<z.input<Field['schema']>>
 ) {
   return {
     type: 'setValue',
     field,
     value,
-    ...options,
   } as const
 }

package/src/createFormMiddleware.ts

@@ -22,19 +22,21 @@ export function createFormMiddleware<T extends z.ZodTypeAny>(): Middleware<
         onSubmit,
         onSubmitSucceeded,
         onSubmitFailed,
+        parsedValues,
         values,
-        rawValues,
         initialValues,
+        initialParsedValues,
       } = nextState
       const submitPromise = (async () => {
         if (nextState.validationError) throw nextState.validationError
-        for (const fn of onSubmit) await fn(values, { initialValues })
+        for (const fn of onSubmit)
+          await fn(parsedValues, { initialValues, initialParsedValues })
       })()
       store.dispatch(
         setSubmitStatus({
           submitting: true,
+          submittedParsedValues: parsedValues,
           submittedValues: values,
-          rawSubmittedValues: rawValues,
           submitError: undefined,
           submitSucceeded: false,
           submitFailed: false,

package/src/createFormProvider.tsx

@@ -7,8 +7,8 @@ import { FormAction } from './FormAction'
 import { FormState } from './FormState'
 import { Provider } from 'react-redux'
 import { initialize } from './actions/initialize'
-import { setRawValue } from './actions/setRawValue'
 import { setValue } from './actions/setValue'
+import { setParsedValue } from './actions/setParsedValue'
 import { FormContext, FormContextProps } from './FormContext'
 import { FormStateContext } from './FormStateContext'
 import { createFormMiddleware } from './createFormMiddleware'
@@ -41,14 +41,17 @@ export const createFormProvider = <T extends z.ZodTypeAny>(
     const store = storeRef.current
     const { dispatch } = store
 
+    const getParsedValues = React.useCallback(
+      () => store.getState().parsedValues,
+      []
+    )
     const getValues = React.useCallback(() => store.getState().values, [])
-    const getRawValues = React.useCallback(() => store.getState().rawValues, [])
-    const getInitialValues = React.useCallback(
-      () => store.getState().initialValues,
+    const getInitialParsedValues = React.useCallback(
+      () => store.getState().initialParsedValues,
       []
     )
-    const getRawInitialValues = React.useCallback(
-      () => store.getState().rawInitialValues,
+    const getInitialValues = React.useCallback(
+      () => store.getState().initialValues,
       []
     )
     const getStatus = React.useCallback(
@@ -65,10 +68,10 @@ export const createFormProvider = <T extends z.ZodTypeAny>(
     const formContext = React.useMemo(
       (): FormContextProps<T> => ({
         ...props,
+        getParsedValues,
         getValues,
-        getRawValues,
+        getInitialParsedValues,
         getInitialValues,
-        getRawInitialValues,
         getStatus,
         ...bindActionCreators(
           {
@@ -78,8 +81,8 @@ export const createFormProvider = <T extends z.ZodTypeAny>(
             submit,
             setSubmitStatus: setSubmitStatus<T>,
             setMeta: setMeta as any,
-            setRawValue: setRawValue as any,
             setValue: setValue as any,
+            setParsedValue: setParsedValue as any,
           },
           dispatch
         ),