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

package/src/createFormReducer.ts

@@ -5,8 +5,8 @@ import { FormState } from './FormState'
 import { initFormState } from './initFormState'
 import { addHandlersReducer } from './reducers/addHandlers'
 import { removeHandlersReducer } from './reducers/removeHandlers'
+import { createSetParsedValueReducer } from './reducers/setParsedValue'
 import { createSetValueReducer } from './reducers/setValue'
-import { createSetRawValueReducer } from './reducers/setRawValue'
 import { setMetaReducer } from './reducers/setMeta'
 import { submitSucceededReducer } from './reducers/submitSucceeded'
 import { setSubmitStatusReducer } from './reducers/setSubmitStatus'
@@ -17,22 +17,22 @@ import { arrayRemoveReducer } from './reducers/arrayRemove'
 import { arrayRemoveAllReducer } from './reducers/arrayRemoveAll'
 import { arrayShiftReducer } from './reducers/arrayShift'
 import { arraySwapReducer } from './reducers/arraySwap'
-import { arrayPushRawReducer } from './reducers/arrayPushRaw'
-import { arrayInsertRawReducer } from './reducers/arrayInsertRaw'
-import { arraySpliceRawReducer } from './reducers/arraySpliceRaw'
-import { arrayUnshiftRawReducer } from './reducers/arrayUnshiftRaw'
 import { arrayPushReducer } from './reducers/arrayPush'
-import { arrayUnshiftReducer } from './reducers/arrayUnshift'
 import { arrayInsertReducer } from './reducers/arrayInsert'
 import { arraySpliceReducer } from './reducers/arraySplice'
+import { arrayUnshiftReducer } from './reducers/arrayUnshift'
+import { arrayPushParsedReducer } from './reducers/arrayPushParsed'
+import { arrayUnshiftParsedReducer } from './reducers/arrayUnshiftParsed'
+import { arrayInsertParsedReducer } from './reducers/arrayInsertParsed'
+import { arraySpliceParsedReducer } from './reducers/arraySpliceParsed'
 
 export function createFormReducer<T extends z.ZodTypeAny>(options: {
   schema: T
   inverseSchema: z.ZodType<z.input<T>, any, z.output<T>>
 }): Reducer<FormState<T>, FormAction<T>> {
   const initializeReducer = createInitializeReducer(options)
+  const setParsedValueReducer = createSetParsedValueReducer(options)
   const setValueReducer = createSetValueReducer(options)
-  const setRawValueReducer = createSetRawValueReducer(options)
   const formReducer = (
     state: FormState<T> = initFormState(),
     action: FormAction<T>
@@ -50,40 +50,40 @@ export function createFormReducer<T extends z.ZodTypeAny>(options: {
         return setSubmitStatusReducer(state, action)
       case 'submitSucceeded':
         return submitSucceededReducer(state)
+      case 'setParsedValue':
+        return setParsedValueReducer(state, action)
       case 'setValue':
         return setValueReducer(state, action)
-      case 'setRawValue':
-        return setRawValueReducer(state, action)
       case 'setMeta':
         return setMetaReducer(state, action)
+      case 'arrayInsertParsed':
+        return arrayInsertParsedReducer(formReducer, state, action)
       case 'arrayInsert':
         return arrayInsertReducer(formReducer, state, action)
-      case 'arrayInsertRaw':
-        return arrayInsertRawReducer(formReducer, state, action)
       case 'arrayMove':
         return arrayMoveReducer(formReducer, state, action)
       case 'arrayPop':
         return arrayPopReducer(formReducer, state, action)
+      case 'arrayPushParsed':
+        return arrayPushParsedReducer(formReducer, state, action)
       case 'arrayPush':
         return arrayPushReducer(formReducer, state, action)
-      case 'arrayPushRaw':
-        return arrayPushRawReducer(formReducer, state, action)
       case 'arrayRemove':
         return arrayRemoveReducer(formReducer, state, action)
       case 'arrayRemoveAll':
         return arrayRemoveAllReducer(formReducer, state, action)
       case 'arrayShift':
         return arrayShiftReducer(formReducer, state, action)
+      case 'arraySpliceParsed':
+        return arraySpliceParsedReducer(formReducer, state, action)
       case 'arraySplice':
         return arraySpliceReducer(formReducer, state, action)
-      case 'arraySpliceRaw':
-        return arraySpliceRawReducer(formReducer, state, action)
       case 'arraySwap':
         return arraySwapReducer(formReducer, state, action)
+      case 'arrayUnshiftParsed':
+        return arrayUnshiftParsedReducer(formReducer, state, action)
       case 'arrayUnshift':
         return arrayUnshiftReducer(formReducer, state, action)
-      case 'arrayUnshiftRaw':
-        return arrayUnshiftRawReducer(formReducer, state, action)
     }
     return state
   }

package/src/createSelectFormStatus.ts

@@ -22,20 +22,20 @@ export function createSelectFormStatus() {
     [
       createSelector(
         [
-          (state: FormState<any>) => state.values,
-          (state: FormState<any>) => state.initialValues,
+          (state: FormState<any>) => state.parsedValues,
+          (state: FormState<any>) => state.initialParsedValues,
         ],
         isEqual
       ),
       createSelector(
         [
-          (state: FormState<any>) => state.rawValues,
-          (state: FormState<any>) => state.rawInitialValues,
+          (state: FormState<any>) => state.values,
+          (state: FormState<any>) => state.initialValues,
         ],
         isEqual
       ),
     ],
-    (pristine, rawPristine) => pristine && rawPristine
+    (parsedPristine, pristine) => parsedPristine && pristine
   )
 
   return createStructuredSelector({

package/src/createSelectFormValues.ts

@@ -8,9 +8,9 @@ export type SelectFormValues<T extends z.ZodTypeAny> = ReturnType<
 
 export function createSelectFormValues<T extends z.ZodTypeAny>() {
   return createStructuredSelector({
+    parsedValues: (state: FormState<T>) => state.parsedValues,
     values: (state: FormState<T>) => state.values,
-    rawValues: (state: FormState<T>) => state.rawValues,
+    initialParsedValues: (state: FormState<T>) => state.initialParsedValues,
     initialValues: (state: FormState<T>) => state.initialValues,
-    rawInitialValues: (state: FormState<T>) => state.rawInitialValues,
   })
 }

package/src/index.ts

@@ -7,8 +7,8 @@ export {
 } from './FormState'
 export {
   FieldPath,
+  type FieldPathForParsedValue,
   type FieldPathForValue,
-  type FieldPathForRawValue,
 } from './FieldPath'
 export { useField, type UseFieldProps, type TypedUseField } from './useField'
 export {

package/src/initFormState.ts

@@ -6,8 +6,8 @@ export function initFormState<T extends z.ZodTypeAny>(): FormState<T> {
     mounted: true,
     initialized: false,
     fieldMeta: {},
-    rawInitialValues: undefined,
     initialValues: undefined,
+    initialParsedValues: undefined,
     submitting: false,
     submitFailed: false,
     submitSucceeded: false,

package/src/reducers/arrayInsert.ts

@@ -1,9 +1,9 @@
 import z from 'zod'
 import { FormState } from '../FormState'
-import { arrayInsertRaw, ArrayInsertAction } from '../actions/arrayActions'
+import { ArrayInsertAction } from '../actions/arrayActions'
 import { Reducer } from 'redux'
 import { FormAction } from '../FormAction'
-import { getInverseArrayElementSchema } from './util/getInverseArrayElementSchema'
+import { updateRawArray } from './util/updateRawArray'
 
 export function arrayInsertReducer<T extends z.ZodTypeAny>(
   reducer: Reducer<FormState<T>, FormAction<T>>,
@@ -11,9 +11,12 @@ export function arrayInsertReducer<T extends z.ZodTypeAny>(
   action: ArrayInsertAction
 ) {
   const { field, index, value } = action
-  const inverseSchema = getInverseArrayElementSchema(field.schema)
-  return reducer(
-    state,
-    arrayInsertRaw(field, index, inverseSchema.parse(value))
+  return updateRawArray(reducer, state, field, (array) =>
+    insert(array ?? [], index, value)
   )
 }
+
+function insert<T>(array: T[], index: number, parsedValue: T) {
+  if (index < 0 || index > array.length) throw new Error(`index out of range`)
+  return [...array.slice(0, index), parsedValue, ...array.slice(index)]
+}

package/src/reducers/arrayInsertParsed.ts

@@ -0,0 +1,19 @@
+import z from 'zod'
+import { FormState } from '../FormState'
+import { arrayInsert, ArrayInsertParsedAction } from '../actions/arrayActions'
+import { Reducer } from 'redux'
+import { FormAction } from '../FormAction'
+import { getInverseArrayElementSchema } from './util/getInverseArrayElementSchema'
+
+export function arrayInsertParsedReducer<T extends z.ZodTypeAny>(
+  reducer: Reducer<FormState<T>, FormAction<T>>,
+  state: FormState<T>,
+  action: ArrayInsertParsedAction
+) {
+  const { field, index, parsedValue } = action
+  const inverseSchema = getInverseArrayElementSchema(field.schema)
+  return reducer(
+    state,
+    arrayInsert(field, index, inverseSchema.parse(parsedValue))
+  )
+}

package/src/reducers/arrayPush.ts

@@ -3,8 +3,7 @@ import { FormState } from '../FormState'
 import { ArrayPushAction } from '../actions/arrayActions'
 import { Reducer } from 'redux'
 import { FormAction } from '../FormAction'
-import { setValue } from '../actions/setValue'
-import { get } from '../util/get'
+import { updateRawArray } from './util/updateRawArray'
 
 export function arrayPushReducer<T extends z.ZodTypeAny>(
   reducer: Reducer<FormState<T>, FormAction<T>>,
@@ -12,9 +11,8 @@ export function arrayPushReducer<T extends z.ZodTypeAny>(
   action: ArrayPushAction
 ) {
   const { field, value } = action
-  const array = get(state.rawValues, field.path)
-  return reducer(
-    state,
-    setValue(field.get([Array.isArray(array) ? array.length : 0]), value)
-  )
+  return updateRawArray(reducer, state, field, (array) => [
+    ...(array ?? []),
+    value,
+  ])
 }

package/src/reducers/arrayPushParsed.ts

@@ -0,0 +1,23 @@
+import z from 'zod'
+import { FormState } from '../FormState'
+import { ArrayPushParsedAction } from '../actions/arrayActions'
+import { Reducer } from 'redux'
+import { FormAction } from '../FormAction'
+import { setParsedValue } from '../actions/setParsedValue'
+import { get } from '../util/get'
+
+export function arrayPushParsedReducer<T extends z.ZodTypeAny>(
+  reducer: Reducer<FormState<T>, FormAction<T>>,
+  state: FormState<T>,
+  action: ArrayPushParsedAction
+) {
+  const { field, parsedValue } = action
+  const array = get(state.values, field.path)
+  return reducer(
+    state,
+    setParsedValue(
+      field.get([Array.isArray(array) ? array.length : 0]),
+      parsedValue
+    )
+  )
+}

package/src/reducers/arraySplice.ts

@@ -1,9 +1,9 @@
 import z from 'zod'
 import { FormState } from '../FormState'
-import { ArraySpliceAction, arraySpliceRaw } from '../actions/arrayActions'
+import { ArraySpliceAction } from '../actions/arrayActions'
 import { Reducer } from 'redux'
 import { FormAction } from '../FormAction'
-import { getInverseArrayElementSchema } from './util/getInverseArrayElementSchema'
+import { updateRawArray } from './util/updateRawArray'
 
 export function arraySpliceReducer<T extends z.ZodTypeAny>(
   reducer: Reducer<FormState<T>, FormAction<T>>,
@@ -11,7 +11,20 @@ export function arraySpliceReducer<T extends z.ZodTypeAny>(
   action: ArraySpliceAction
 ) {
   const { field, index, deleteCount, values } = action
-  const inverseSchema = getInverseArrayElementSchema(field.schema)
-  const rawValues = values.map((v) => inverseSchema.parse(v))
-  return reducer(state, arraySpliceRaw(field, index, deleteCount, rawValues))
+  return updateRawArray(reducer, state, field, (array) =>
+    splice(array ?? [], index, deleteCount, values)
+  )
+}
+
+function splice<T>(
+  array: T[],
+  index: number,
+  deleteCount: number,
+  parsedValues: T[]
+) {
+  if (index < 0 || index > array.length) throw new Error(`index out of range`)
+  if (!deleteCount && !parsedValues.length) return array
+  const result = [...array]
+  result.splice(index, deleteCount, ...parsedValues)
+  return result
 }

package/src/reducers/arraySpliceParsed.ts

@@ -0,0 +1,17 @@
+import z from 'zod'
+import { FormState } from '../FormState'
+import { ArraySpliceParsedAction, arraySplice } from '../actions/arrayActions'
+import { Reducer } from 'redux'
+import { FormAction } from '../FormAction'
+import { getInverseArrayElementSchema } from './util/getInverseArrayElementSchema'
+
+export function arraySpliceParsedReducer<T extends z.ZodTypeAny>(
+  reducer: Reducer<FormState<T>, FormAction<T>>,
+  state: FormState<T>,
+  action: ArraySpliceParsedAction
+) {
+  const { field, index, deleteCount, parsedValues } = action
+  const inverseSchema = getInverseArrayElementSchema(field.schema)
+  const values = parsedValues.map((v) => inverseSchema.parse(v))
+  return reducer(state, arraySplice(field, index, deleteCount, values))
+}

package/src/reducers/arrayUnshift.ts

@@ -1,9 +1,9 @@
 import z from 'zod'
 import { FormState } from '../FormState'
-import { ArrayUnshiftAction, arrayUnshiftRaw } from '../actions/arrayActions'
+import { ArrayUnshiftAction } from '../actions/arrayActions'
 import { Reducer } from 'redux'
 import { FormAction } from '../FormAction'
-import { getInverseArrayElementSchema } from './util/getInverseArrayElementSchema'
+import { updateRawArray } from './util/updateRawArray'
 
 export function arrayUnshiftReducer<T extends z.ZodTypeAny>(
   reducer: Reducer<FormState<T>, FormAction<T>>,
@@ -11,6 +11,8 @@ export function arrayUnshiftReducer<T extends z.ZodTypeAny>(
   action: ArrayUnshiftAction
 ) {
   const { field, value } = action
-  const inverseSchema = getInverseArrayElementSchema(field.schema)
-  return reducer(state, arrayUnshiftRaw(field, inverseSchema.parse(value)))
+  return updateRawArray(reducer, state, field, (array) => [
+    value,
+    ...(array ?? []),
+  ])
 }

package/src/reducers/arrayUnshiftParsed.ts

@@ -0,0 +1,16 @@
+import z from 'zod'
+import { FormState } from '../FormState'
+import { ArrayUnshiftParsedAction, arrayUnshift } from '../actions/arrayActions'
+import { Reducer } from 'redux'
+import { FormAction } from '../FormAction'
+import { getInverseArrayElementSchema } from './util/getInverseArrayElementSchema'
+
+export function arrayUnshiftParsedReducer<T extends z.ZodTypeAny>(
+  reducer: Reducer<FormState<T>, FormAction<T>>,
+  state: FormState<T>,
+  action: ArrayUnshiftParsedAction
+) {
+  const { field, parsedValue } = action
+  const inverseSchema = getInverseArrayElementSchema(field.schema)
+  return reducer(state, arrayUnshift(field, inverseSchema.parse(parsedValue)))
+}

package/src/reducers/initialize.ts

@@ -12,12 +12,14 @@ export const createInitializeReducer = <T extends z.ZodTypeAny>({
   function initializeReducer(state: FormState<T>, action: InitializeAction<T>) {
     const { keepSubmitSucceeded } = action
     try {
-      const rawValues =
-        action.rawValues ??
-        (action.values ? inverseSchema.parse(action.values) : undefined)
       const values =
         action.values ??
-        (action.rawValues ? schema.parse(action.rawValues) : undefined)
+        (action.parsedValues
+          ? inverseSchema.parse(action.parsedValues)
+          : undefined)
+      const parsedValues =
+        action.parsedValues ??
+        (action.values ? schema.parse(action.values) : undefined)
       return {
         ...state,
         validationError: undefined,
@@ -25,10 +27,10 @@ export const createInitializeReducer = <T extends z.ZodTypeAny>({
         submitting: false,
         submitFailed: false,
         submitSucceeded: keepSubmitSucceeded ? state.submitSucceeded : false,
-        rawValues,
         values,
-        rawInitialValues: rawValues,
+        parsedValues,
         initialValues: values,
+        initialParsedValues: parsedValues,
       }
     } catch (error) {
       return {
@@ -38,10 +40,10 @@ export const createInitializeReducer = <T extends z.ZodTypeAny>({
         submitting: false,
         submitFailed: false,
         submitSucceeded: keepSubmitSucceeded ? state.submitSucceeded : false,
-        rawValues: action.rawValues,
         values: action.values,
-        rawInitialValues: action.rawValues,
+        parsedValues: action.parsedValues,
         initialValues: action.values,
+        initialParsedValues: action.parsedValues,
       }
     }
   }

package/src/reducers/setParsedValue.ts

@@ -0,0 +1,61 @@
+import z from 'zod'
+import { FormState } from '../FormState'
+import { SetParsedValueAction } from '../actions/setParsedValue'
+import { set } from '../util/set'
+import { FieldPath } from '../FieldPath'
+import { invert } from 'zod-invertible'
+
+export const createSetParsedValueReducer = <T extends z.ZodTypeAny>({
+  schema,
+  inverseSchema,
+}: {
+  schema: T
+  inverseSchema: z.ZodType<z.input<T>, any, z.output<T>>
+}) =>
+  function setParsedValueReducer<Field extends FieldPath>(
+    state: FormState<T>,
+    action: SetParsedValueAction<Field>
+  ) {
+    const newParsedValues = set(
+      state.parsedValues,
+      action.field.path,
+      action.parsedValue
+    ) as (typeof state)['parsedValues']
+    try {
+      const newValues = inverseSchema.parse(newParsedValues)
+      schema.parse(newValues)
+      return {
+        ...state,
+        submitError: undefined,
+        validationError: undefined,
+        values: newValues,
+        parsedValues: newParsedValues,
+      }
+    } catch (error) {
+      const newParsed = invert(action.field.schema).safeParse(
+        action.parsedValue
+      )
+      const values = newParsed.success
+        ? (set(
+            state.values,
+            action.field.path,
+            newParsed.data
+          ) as (typeof state)['values'])
+        : state.values
+      const newValidatedParsed = schema.safeParse(values)
+      const result = {
+        ...state,
+        submitError: undefined,
+        validationError: !newParsed.success
+          ? newParsed.error
+          : newValidatedParsed.success
+          ? undefined
+          : newValidatedParsed.error,
+        values,
+        parsedValues: newValidatedParsed.success
+          ? newValidatedParsed.data
+          : state.parsedValues,
+      }
+      return result
+    }
+  }

package/src/reducers/setValue.ts

@@ -3,47 +3,38 @@ import { FormState } from '../FormState'
 import { SetValueAction } from '../actions/setValue'
 import { set } from '../util/set'
 import { FieldPath } from '../FieldPath'
-import { invert } from 'zod-invertible'
 
 export const createSetValueReducer = <T extends z.ZodTypeAny>({
   schema,
-  inverseSchema,
 }: {
   schema: T
-  inverseSchema: z.ZodType<z.input<T>, any, z.output<T>>
 }) =>
   function setValueReducer<Field extends FieldPath>(
     state: FormState<T>,
     action: SetValueAction<Field>
   ) {
-    const newValues = set(state.values, action.field.path, action.value)
+    const newValues = set(
+      state.values,
+      action.field.path,
+      action.value
+    ) as (typeof state)['values']
+    if (newValues === state.values) return state
     try {
-      const newRawValues = inverseSchema.parse(newValues)
-      schema.parse(newRawValues)
+      const newParsedValues = schema.parse(newValues)
       return {
         ...state,
         submitError: undefined,
         validationError: undefined,
-        rawValues: newRawValues,
         values: newValues,
+        parsedValues: newParsedValues,
       }
     } catch (error) {
-      const newRawParsed = invert(action.field.schema).safeParse(action.value)
-      const rawValues = newRawParsed.success
-        ? set(state.rawValues, action.field.path, newRawParsed.data)
-        : state.rawValues
-      const newParsed = schema.safeParse(rawValues)
-      const result = {
+      return {
         ...state,
         submitError: undefined,
-        validationError: !newRawParsed.success
-          ? newRawParsed.error
-          : newParsed.success
-          ? undefined
-          : newParsed.error,
-        rawValues,
-        values: newParsed.success ? newParsed.data : state.values,
+        validationError: error,
+        values: newValues,
+        parsedValues: undefined,
       }
-      return result
     }
   }

package/src/reducers/submitSucceeded.ts

@@ -11,7 +11,7 @@ export function submitSucceededReducer<T extends z.ZodTypeAny>(
     submitFailed: false,
     submitError: undefined,
     submitPromise: undefined,
+    initialParsedValues: state.submittedParsedValues,
     initialValues: state.submittedValues,
-    rawInitialValues: state.rawSubmittedValues,
   }
 }

package/src/reducers/util/updateRawArray.ts

@@ -1,14 +1,14 @@
 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'
 import { get } from '../../util/get'
-import { setRawValue } from '../../actions/setRawValue'
+import { setValue } from '../../actions/setValue'
 
 export function updateRawArray<
   T extends z.ZodTypeAny,
-  Field extends FieldPathForRawValue<any[]>
+  Field extends FieldPathForValue<any[]>
 >(
   reducer: Reducer<FormState<T>, FormAction<T>>,
   state: FormState<T>,
@@ -17,9 +17,9 @@ export function updateRawArray<
     array: z.input<Field['schema']> | undefined
   ) => z.input<Field['schema']> | undefined
 ) {
-  const oldValue = get(state.rawValues, field.path)
+  const oldValue = get(state.values, field.path)
   const newValue = updater(oldValue as any)
   return newValue === oldValue
     ? state
-    : reducer(state, setRawValue(field, newValue))
+    : reducer(state, setValue(field, newValue))
 }

package/src/useArrayField.ts

@@ -1,5 +1,5 @@
 import z from 'zod'
-import { BasePath, FieldPath, FieldPathForRawValue } from './FieldPath'
+import { BasePath, FieldPath, FieldPathForValue } from './FieldPath'
 import React from 'react'
 import { useFormContext } from './useFormContext'
 import { PathInSchema, PathstringInSchema } from './util/PathInSchema'
@@ -15,10 +15,11 @@ import {
   useFormSelector as untypedUseFormSelector,
 } from './useFormSelector'
 import { shallowEqual } from 'react-redux'
+import { setParsedValue } from './actions/setParsedValue'
 import { setValue } from './actions/setValue'
-import { setRawValue } from './actions/setRawValue'
 import { setMeta } from './actions/setMeta'
 import { FieldMeta } from './FormState'
+import { DeepPartial } from './util/DeepPartial'
 
 export type UseArrayFieldProps<Field extends FieldPath> = NonNullable<
   z.input<Field['schema']>
@@ -27,8 +28,8 @@ export type UseArrayFieldProps<Field extends FieldPath> = NonNullable<
       ReturnType<
         typeof bindActionsToField<
           typeof arrayActions & {
+            setParsedValue: typeof setParsedValue
             setValue: typeof setValue
-            setRawValue: typeof setRawValue
             setMeta: typeof setMeta
           }
         >
@@ -43,7 +44,7 @@ export type UseArrayFieldProps<Field extends FieldPath> = NonNullable<
   : { ERROR: 'not an array field' }
 
 export interface TypedUseArrayField<T extends z.ZodTypeAny> {
-  <Field extends FieldPathForRawValue<any[] | null | undefined>>(
+  <Field extends FieldPathForValue<any[] | null | undefined>>(
     field: Field
   ): UseArrayFieldProps<Field>
   <Path extends PathInSchema<T>>(path: Path): UseArrayFieldProps<
@@ -61,8 +62,8 @@ function useArrayFieldBase<Field extends FieldPath>(
 
   const {
     arrayActions,
+    setParsedValue,
     setValue,
-    setRawValue,
     setMeta,
     selectFormValues,
     selectFieldErrorMap,
@@ -77,21 +78,23 @@ function useArrayFieldBase<Field extends FieldPath>(
         createSelector(
           [
             createStructuredSelector({
+              parsedValue: ({ parsedValues }) =>
+                get(parsedValues, field.path) as
+                  | DeepPartial<z.output<T>>
+                  | undefined,
               value: ({ values }) =>
-                get(values, field.path) as z.output<T> | undefined,
-              rawValue: ({ rawValues }) =>
-                get(rawValues, field.path) as unknown,
-              initialValue: ({ initialValues }) =>
-                get(initialValues, field.path) as z.output<T> | undefined,
+                get(values, field.path) as DeepPartial<z.input<T>> | undefined,
+              initialParsedValue: ({ initialParsedValues }) =>
+                get(initialParsedValues, field.path) as z.output<T> | undefined,
             }),
           ],
-          ({ rawValue, value, initialValue }) => {
-            const dirty = !isEqual(value, initialValue)
+          ({ value, parsedValue, initialParsedValue }) => {
+            const dirty = !isEqual(parsedValue, initialParsedValue)
             const pristine = !dirty
             return {
               dirty,
               pristine,
-              length: Array.isArray(rawValue) ? rawValue.length : 0,
+              length: Array.isArray(value) ? value.length : 0,
             }
           }
         )
@@ -113,7 +116,7 @@ function useArrayFieldBase<Field extends FieldPath>(
   const boundActions = React.useMemo(
     () =>
       bindActionsToField(
-        { ...arrayActions, setValue, setRawValue, setMeta },
+        { ...arrayActions, setParsedValue, setValue, setMeta },
         field
       ),
     [field.pathstring]