@jcoreio/zod-forms 2.0.0-beta.3 → 2.0.0

package/src/FieldPath.ts

@@ -55,45 +55,31 @@ export class FieldPath<T extends z.ZodTypeAny = z.ZodTypeAny> {
 
 export type BasePath = (string | number)[]
 
-export type SubpathKey<T extends z.ZodTypeAny> = 0 extends 1 & T
-  ? any
-  : 0 extends 1 & z.input<T>
-  ? any
-  : T extends z.ZodObject<infer Shape, infer UnknownKeys>
-  ? UnknownKeys extends 'passthrough'
-    ? string
+export type SubpathKey<T extends z.ZodTypeAny> =
+  0 extends 1 & T ? any
+  : 0 extends 1 & z.input<T> ? any
+  : T extends z.ZodObject<infer Shape, infer UnknownKeys> ?
+    UnknownKeys extends 'passthrough' ?
+      string
     : keyof Shape
-  : T extends z.ZodRecord<infer Key, any>
-  ? z.input<Key>
-  : T extends z.ZodMap<infer Key, any>
-  ? z.input<Key>
-  : T extends z.ZodArray<any>
-  ? number
-  : T extends z.ZodTuple<any, any>
-  ? number
-  : T extends z.ZodLazy<infer U>
-  ? SubpathKey<U>
-  : T extends z.ZodUnion<infer Options>
-  ? SubpathKey<Options[number]>
-  : T extends z.ZodDiscriminatedUnion<any, infer Options>
-  ? SubpathKey<Options[number]>
-  : T extends z.ZodOptional<infer U>
-  ? SubpathKey<U>
-  : T extends z.ZodNullable<infer U>
-  ? SubpathKey<U>
-  : T extends z.ZodDefault<infer U>
-  ? SubpathKey<U>
-  : T extends z.ZodCatch<infer U>
-  ? SubpathKey<U>
-  : T extends z.ZodEffects<infer U, any>
-  ? SubpathKey<U>
-  : T extends z.ZodBranded<infer U, any>
-  ? SubpathKey<U>
+  : T extends z.ZodRecord<infer Key, any> ? z.input<Key>
+  : T extends z.ZodMap<infer Key, any> ? z.input<Key>
+  : T extends z.ZodArray<any> ? number
+  : T extends z.ZodTuple<any, any> ? number
+  : T extends z.ZodLazy<infer U> ? SubpathKey<U>
+  : T extends z.ZodUnion<infer Options> ? SubpathKey<Options[number]>
+  : T extends z.ZodDiscriminatedUnion<any, infer Options> ?
+    SubpathKey<Options[number]>
+  : T extends z.ZodOptional<infer U> ? SubpathKey<U>
+  : T extends z.ZodNullable<infer U> ? SubpathKey<U>
+  : T extends z.ZodDefault<infer U> ? SubpathKey<U>
+  : T extends z.ZodCatch<infer U> ? SubpathKey<U>
+  : T extends z.ZodEffects<infer U, any> ? SubpathKey<U>
+  : T extends z.ZodBranded<infer U, any> ? SubpathKey<U>
   : never
 
-export type AllPaths<T extends z.ZodTypeAny> = SubpathKey<T> extends never
-  ? []
-  : [] | ValuesOf<SubpathKeyMap<T>>
+export type AllPaths<T extends z.ZodTypeAny> =
+  SubpathKey<T> extends never ? [] : [] | ValuesOf<SubpathKeyMap<T>>
 
 type ValuesOf<O> = O[keyof O]
 
@@ -117,8 +103,8 @@ function subschema(
       } = schema as z.AnyZodObject
       if (key in shape) return shape[key]
       if (unknownKeys === 'passthrough') {
-        return catchall._def.typeName === z.ZodFirstPartyTypeKind.ZodNever
-          ? z.unknown()
+        return catchall._def.typeName === z.ZodFirstPartyTypeKind.ZodNever ?
+            z.unknown()
           : catchall
       }
       break
@@ -129,11 +115,11 @@ function subschema(
       ).options
         .map((opt) => subschema(opt, key))
         .filter((opt): opt is z.ZodTypeAny => opt != null)
-      return options.length > 1
-        ? z.union(options as any)
-        : options.length === 1
-        ? options[0]
+      return (
+        options.length > 1 ? z.union(options as any)
+        : options.length === 1 ? options[0]
         : undefined
+      )
     }
     case 'ZodDiscriminatedUnion': {
       const discUnion = schema as z.ZodDiscriminatedUnion<
@@ -143,11 +129,11 @@ function subschema(
       const options = discUnion.options
         .map((opt) => subschema(opt, key))
         .filter((opt): opt is z.ZodTypeAny => opt != null)
-      return options.length > 1
-        ? z.union(options as any)
-        : options.length === 1
-        ? options[0]
+      return (
+        options.length > 1 ? z.union(options as any)
+        : options.length === 1 ? options[0]
         : undefined
+      )
       break
     }
     case 'ZodIntersection':
@@ -164,18 +150,12 @@ function subschema(
       break
     }
     case 'ZodRecord': {
-      const { keySchema, valueSchema } = schema as z.ZodRecord<
-        z.ZodTypeAny,
-        z.ZodTypeAny
-      >
+      const { keySchema, valueSchema } = schema as z.ZodRecord<z.ZodTypeAny>
       if (keySchema.safeParse(key).success) return valueSchema
       break
     }
     case 'ZodMap': {
-      const { keySchema, valueSchema } = schema as z.ZodMap<
-        z.ZodTypeAny,
-        z.ZodTypeAny
-      >
+      const { keySchema, valueSchema } = schema as z.ZodMap
       if (keySchema.safeParse(key).success) return valueSchema
       break
     }

package/src/FormContext.ts

@@ -33,7 +33,7 @@ export type FormContextProps<T extends z.ZodTypeAny> = {
   setParsedValue: typeof setParsedValue
   submit: typeof submit
   setSubmitStatus: typeof setSubmitStatus<T>
-  arrayActions: typeof arrayActions
+  arrayActions: arrayActions
   selectFormStatus: SelectFormStatus
   selectFieldErrorMap: SelectFieldErrorMap
   selectFormValues: SelectFormValues<T>

package/src/FormState.ts

@@ -14,14 +14,14 @@ export type SubmitHandler<T extends z.ZodTypeAny> = (
   }
 ) => void | Promise<void>
 
-export type SubmitSuccededHandler = () => void
+export type SubmitSuccededHandler = () => void | Promise<void>
 
-export type SubmitFailedHandler = (error: Error) => void
+export type SubmitFailedHandler = (error: unknown) => void | Promise<void>
 
 export type FormState<T extends z.ZodTypeAny> = {
   mounted: boolean
   initialized: boolean
-  fieldMeta: Record<string, FieldMeta>
+  fieldMeta: { [K in string]?: FieldMeta }
   values?: DeepPartial<z.input<T>>
   parsedValues?: z.output<T>
   submittedParsedValues?: z.output<T>
@@ -36,5 +36,5 @@ export type FormState<T extends z.ZodTypeAny> = {
   submitting: boolean
   submitSucceeded: boolean
   submitFailed: boolean
-  submitError?: Error
+  submitError?: unknown
 }

package/src/actions/arrayActions.ts

@@ -16,7 +16,7 @@ type ValueFor<Field extends ArrayFieldPath> = DeepPartial<
 >
 
 export type ArrayInsertParsedAction<
-  Field extends ArrayFieldPath = ArrayFieldPath
+  Field extends ArrayFieldPath = ArrayFieldPath,
 > = ReturnType<typeof arrayInsertParsed<Field>>
 
 export function arrayInsertParsed<Field extends ArrayFieldPath>(
@@ -51,7 +51,7 @@ export function arrayPop(field: ArrayFieldPath) {
 }
 
 export type ArrayPushParsedAction<
-  Field extends ArrayFieldPath = ArrayFieldPath
+  Field extends ArrayFieldPath = ArrayFieldPath,
 > = ReturnType<typeof arrayPushParsed<Field>>
 
 export function arrayPushParsed<Field extends ArrayFieldPath>(
@@ -90,7 +90,7 @@ export function arrayShift(field: ArrayFieldPath) {
 }
 
 export type ArraySpliceParsedAction<
-  Field extends ArrayFieldPath = ArrayFieldPath
+  Field extends ArrayFieldPath = ArrayFieldPath,
 > = ReturnType<typeof arraySpliceParsed<Field>>
 
 export function arraySpliceParsed<Field extends ArrayFieldPath>(
@@ -137,7 +137,7 @@ export function arraySwap(
 }
 
 export type ArrayUnshiftParsedAction<
-  Field extends ArrayFieldPath = ArrayFieldPath
+  Field extends ArrayFieldPath = ArrayFieldPath,
 > = ReturnType<typeof arrayUnshiftParsed<Field>>
 
 export function arrayUnshiftParsed<Field extends ArrayFieldPath>(
@@ -173,6 +173,23 @@ export type ArrayAction<Field extends ArrayFieldPath = ArrayFieldPath> =
   | ArrayUnshiftParsedAction<Field>
   | ArrayUnshiftAction<Field>
 
+export type arrayActions<Field extends ArrayFieldPath = ArrayFieldPath> = {
+  insertParsed: typeof arrayInsertParsed<Field>
+  insert: typeof arrayInsert<Field>
+  move: typeof arrayMove
+  pop: typeof arrayPop
+  pushParsed: typeof arrayPushParsed<Field>
+  push: typeof arrayPush<Field>
+  remove: typeof arrayRemove
+  removeAll: typeof arrayRemoveAll
+  shift: typeof arrayShift
+  spliceParsed: typeof arraySpliceParsed<Field>
+  splice: typeof arraySplice<Field>
+  swap: typeof arraySwap
+  unshiftParsed: typeof arrayUnshiftParsed<Field>
+  unshift: typeof arrayUnshift<Field>
+}
+
 export const arrayActions = {
   insertParsed: arrayInsertParsed,
   insert: arrayInsert,

package/src/createFormMiddleware.ts

@@ -7,7 +7,7 @@ import { setSubmitStatus } from './actions/setSubmitStatus'
 import { submitSucceeded } from './actions/submitSucceeded'
 
 export function createFormMiddleware<T extends z.ZodTypeAny>(): Middleware<
-  // eslint-disable-next-line @typescript-eslint/ban-types
+  // eslint-disable-next-line @typescript-eslint/no-empty-object-type
   {},
   FormState<T>,
   Dispatch<FormAction<T>>
@@ -49,7 +49,7 @@ export function createFormMiddleware<T extends z.ZodTypeAny>(): Middleware<
           store.dispatch(submitSucceeded())
           for (const fn of onSubmitSucceeded) await fn()
         },
-        async (error) => {
+        async (error: unknown) => {
           if (store.getState().submitPromise !== submitPromise) return
           store.dispatch(
             setSubmitStatus({

package/src/createFormProvider.tsx

@@ -1,5 +1,10 @@
 import React from 'react'
-import { Store, applyMiddleware, bindActionCreators, createStore } from 'redux'
+import {
+  Store,
+  applyMiddleware,
+  bindActionCreators,
+  legacy_createStore as createStore,
+} from 'redux'
 import z from 'zod'
 import { setMounted } from './actions/setMounted'
 import { createFormReducer } from './createFormReducer'
@@ -18,6 +23,7 @@ import { setMeta } from './actions/setMeta'
 import { addHandlers } from './actions/addHandlers'
 import { removeHandlers } from './actions/removeHandlers'
 import { arrayActions } from './actions/arrayActions'
+import PropTypes from 'prop-types'
 
 export const createFormProvider = <T extends z.ZodTypeAny>(
   props: Pick<
@@ -29,7 +35,7 @@ export const createFormProvider = <T extends z.ZodTypeAny>(
     | 'selectFieldErrorMap'
     | 'selectFormValues'
   >
-) =>
+) => {
   function FormProvider({ children }: { children: React.ReactElement }) {
     const storeRef = React.useRef<Store<FormState<T>, FormAction<T>>>()
     if (!storeRef.current) {
@@ -55,6 +61,7 @@ export const createFormProvider = <T extends z.ZodTypeAny>(
       []
     )
     const getStatus = React.useCallback(
+      // eslint-disable-next-line react/prop-types
       () => props.selectFormStatus(store.getState()),
       []
     )
@@ -102,3 +109,8 @@ export const createFormProvider = <T extends z.ZodTypeAny>(
       </FormContext.Provider>
     )
   }
+  FormProvider.propTypes = {
+    children: PropTypes.node,
+  }
+  return FormProvider
+}

package/src/createSelectFieldErrorMap.ts

@@ -14,12 +14,12 @@ export function createSelectFieldErrorMap() {
     (...errors: any[]): { [K in string]?: string } =>
       Object.fromEntries(
         errors.flatMap((e) =>
-          isZodError(e)
-            ? e.issues.map((issue) => [
-                pathstring(issue.path),
-                messageForIssue(issue),
-              ])
-            : []
+          isZodError(e) ?
+            e.issues.map((issue) => [
+              pathstring(issue.path),
+              messageForIssue(issue),
+            ])
+          : []
         )
       )
   )
@@ -34,14 +34,16 @@ function isZodError(error: any): error is z.ZodError {
  */
 function messageForIssue(issue: z.ZodIssue): string {
   if (issue.code === 'invalid_type') {
-    return issue.received === 'null' || issue.received === 'undefined'
-      ? // Without this, the error would say "Expected <type>, received null"
+    return (
+      issue.received === 'null' || issue.received === 'undefined' ?
+        // Without this, the error would say "Expected <type>, received null"
         // or "Invalid number" as below
         'Required'
-      : issue.expected === 'number' || issue.expected === 'bigint'
-      ? // Without this, invalid text input for z.number() would say "Expected number, received string"
+      : issue.expected === 'number' || issue.expected === 'bigint' ?
+        // Without this, invalid text input for z.number() would say "Expected number, received string"
         'Invalid number'
       : issue.message
+    )
   }
   return issue.message
 }

package/src/reducers/arrayMove.ts

@@ -20,8 +20,8 @@ export function arrayMoveReducer<T extends z.ZodTypeAny>(
 export function move<T>(array: T[], from: number, to: number): T[] {
   if (from < 0 || from >= array.length) throw new Error(`from out of range`)
   if (to < 0 || to >= array.length) throw new Error(`to out of range`)
-  return from < to
-    ? [
+  return from < to ?
+      [
         ...array.slice(0, from),
         ...array.slice(from + 1, to),
         array[from],

package/src/reducers/initialize.ts

@@ -14,9 +14,9 @@ export const createInitializeReducer = <T extends z.ZodTypeAny>({
     try {
       const values =
         action.values ??
-        (action.parsedValues
-          ? inverseSchema.parse(action.parsedValues)
-          : undefined)
+        (action.parsedValues ?
+          inverseSchema.parse(action.parsedValues)
+        : undefined)
       const parsedValues =
         action.parsedValues ??
         (action.values ? schema.parse(action.values) : undefined)

package/src/reducers/setMeta.ts

@@ -20,7 +20,10 @@ export function setMetaReducer<T extends z.ZodTypeAny>(
     ...state,
     fieldMeta: {
       ...state.fieldMeta,
-      [field.pathstring]: { ...oldMeta, ...meta },
+      [field.pathstring]: {
+        ...(oldMeta || { touched: false, visited: false }),
+        ...meta,
+      },
     },
   }
 }

package/src/reducers/setParsedValue.ts

@@ -31,12 +31,13 @@ export const createSetParsedValueReducer = <T extends z.ZodTypeAny>({
         values: newValues,
         parsedValues: newParsedValues,
       }
-    } catch (error) {
+    } catch {
       const newParsed = invert(action.field.schema).safeParse(
         action.parsedValue
       )
-      const values = newParsed.success
-        ? (set(
+      const values =
+        newParsed.success ?
+          (set(
             state.values,
             action.field.path,
             newParsed.data
@@ -46,14 +47,14 @@ export const createSetParsedValueReducer = <T extends z.ZodTypeAny>({
       const result = {
         ...state,
         submitError: undefined,
-        validationError: !newParsed.success
-          ? newParsed.error
-          : newValidatedParsed.success
-          ? undefined
+        validationError:
+          !newParsed.success ? newParsed.error
+          : newValidatedParsed.success ? undefined
           : newValidatedParsed.error,
         values,
-        parsedValues: newValidatedParsed.success
-          ? newValidatedParsed.data
+        parsedValues:
+          newValidatedParsed.success ?
+            newValidatedParsed.data
           : state.parsedValues,
       }
       return result

package/src/reducers/util/updateRawArray.ts

@@ -8,7 +8,7 @@ import { setValue } from '../../actions/setValue'
 
 export function updateRawArray<
   T extends z.ZodTypeAny,
-  Field extends FieldPathForValue<any[]>
+  Field extends FieldPathForValue<any[]>,
 >(
   reducer: Reducer<FormState<T>, FormAction<T>>,
   state: FormState<T>,
@@ -19,7 +19,7 @@ export function updateRawArray<
 ) {
   const oldValue = get(state.values, field.path)
   const newValue = updater(oldValue as any)
-  return newValue === oldValue
-    ? state
-    : reducer(state, setValue(field, newValue))
+  return newValue === oldValue ? state : (
+      reducer(state, setValue(field, newValue))
+    )
 }

package/src/useArrayField.ts

@@ -6,7 +6,7 @@ import { PathInSchema, PathstringInSchema } from './util/PathInSchema'
 import { parsePathstring } from './util/parsePathstring'
 import { SchemaAt } from './util/SchemaAt'
 import { bindActionsToField } from './util/bindActionsToField'
-import { arrayActions } from './actions/arrayActions'
+import { arrayActions, ArrayFieldPath } from './actions/arrayActions'
 import { createSelector, createStructuredSelector } from 'reselect'
 import { get } from './util/get'
 import isEqual from 'fast-deep-equal'
@@ -21,14 +21,13 @@ 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']>
-> extends any[]
-  ? FieldMeta &
+export type UseArrayFieldProps<Field extends FieldPath> =
+  NonNullable<z.input<Field['schema']>> extends any[] ?
+    FieldMeta &
       ReturnType<
         typeof bindActionsToField<
           Field,
-          typeof arrayActions & {
+          arrayActions<Field> & {
             setParsedValue: typeof setParsedValue<Field>
             setValue: typeof setValue<Field>
             setMeta: typeof setMeta<Field>
@@ -48,15 +47,15 @@ export interface TypedUseArrayField<T extends z.ZodTypeAny> {
   <Field extends FieldPathForValue<any[] | null | undefined>>(
     field: Field
   ): UseArrayFieldProps<Field>
-  <Path extends PathInSchema<T>>(path: Path): UseArrayFieldProps<
-    FieldPath<SchemaAt<T, Path>>
-  >
+  <Path extends PathInSchema<T>>(
+    path: Path
+  ): UseArrayFieldProps<FieldPath<SchemaAt<T, Path>>>
   <Pathstring extends PathstringInSchema<T>>(
     path: Pathstring
   ): UseArrayFieldProps<FieldPath<SchemaAt<T, parsePathstring<Pathstring>>>>
 }
 
-function useArrayFieldBase<Field extends FieldPath>(
+function useArrayFieldBase<Field extends ArrayFieldPath>(
   field: Field
 ): UseArrayFieldProps<Field> {
   type T = Field['schema']
@@ -121,7 +120,13 @@ function useArrayFieldBase<Field extends FieldPath>(
     [field.pathstring]
   )
   const elements = React.useMemo(
-    () => [...new Array(length).keys()].map((index) => field.subfield(index)),
+    () =>
+      [...new Array(length).keys()].map((index) =>
+        field.subfield(
+          // @ts-expect-error doesn't work on this type parameter
+          index
+        )
+      ),
     [length]
   )
 
@@ -149,14 +154,14 @@ export function useArrayField<
     z.ZodNever,
     'cast to TypedUseArrayField<T> to pass a path array'
   >,
-  Path extends PathInSchema<T> = any
+  Path extends PathInSchema<T> = any,
 >(field: Path): UseArrayFieldProps<FieldPath<SchemaAt<T, Path>>>
 export function useArrayField<
   T extends z.ZodTypeAny = z.ZodBranded<
     z.ZodNever,
     'cast to TypedUseArrayField<T> to pass a pathstring'
   >,
-  Pathstring extends PathstringInSchema<T> = any
+  Pathstring extends PathstringInSchema<T> = any,
 >(
   field: Pathstring
 ): UseArrayFieldProps<FieldPath<SchemaAt<T, parsePathstring<Pathstring>>>>

package/src/useField.ts

@@ -45,17 +45,19 @@ export type UseFieldProps<Field extends FieldPath> = FieldMeta &
 
 export interface TypedUseField<T extends z.ZodTypeAny> {
   <Field extends FieldPath>(field: Field): UseFieldProps<Field>
-  <Path extends PathInSchema<T>>(path: Path): UseFieldProps<
-    FieldPath<SchemaAt<T, Path>>
-  >
-  <Pathstring extends PathstringInSchema<T>>(path: Pathstring): UseFieldProps<
-    FieldPath<SchemaAt<T, parsePathstring<Pathstring>>>
-  >
+  <Path extends PathInSchema<T>>(
+    path: Path
+  ): UseFieldProps<FieldPath<SchemaAt<T, Path>>>
+  <Pathstring extends PathstringInSchema<T>>(
+    path: Pathstring
+  ): UseFieldProps<FieldPath<SchemaAt<T, parsePathstring<Pathstring>>>>
 }
 
-function useFieldBase<T extends z.ZodTypeAny, Field extends FieldPath>(
-  field: Field
-): UseFieldProps<Field> {
+function useFieldBase<
+  // eslint-disable-next-line @typescript-eslint/no-unnecessary-type-parameters
+  T extends z.ZodTypeAny,
+  Field extends FieldPath,
+>(field: Field): UseFieldProps<Field> {
   type Schema = Field['schema']
 
   const {
@@ -77,13 +79,13 @@ function useFieldBase<T extends z.ZodTypeAny, Field extends FieldPath>(
             createStructuredSelector({
               parsedValue: ({ parsedValues }) =>
                 get(parsedValues, field.path) as z.output<Schema> | undefined,
-              value: ({ values }) => get(values, field.path) as unknown,
+              value: ({ values }) => get(values, field.path),
               initialParsedValue: ({ initialParsedValues }) =>
                 get(initialParsedValues, field.path) as
                   | z.output<Schema>
                   | undefined,
               initialValue: ({ initialValues }) =>
-                get(initialValues, field.path) as unknown,
+                get(initialValues, field.path),
             }),
           ],
           ({
@@ -143,14 +145,14 @@ export function useField<
     z.ZodNever,
     'cast to TypedUseArray<T> to pass a path array'
   >,
-  Path extends PathInSchema<T> = any
+  Path extends PathInSchema<T> = any,
 >(field: Path): UseFieldProps<FieldPath<SchemaAt<T, Path>>>
 export function useField<
   T extends z.ZodTypeAny = z.ZodBranded<
     z.ZodNever,
     'cast to TypedUseArray<T> to pass a pathstring'
   >,
-  Pathstring extends PathstringInSchema<T> = any
+  Pathstring extends PathstringInSchema<T> = any,
 >(
   field: Pathstring
 ): UseFieldProps<FieldPath<SchemaAt<T, parsePathstring<Pathstring>>>>

package/src/useFormContext.ts

@@ -6,9 +6,9 @@ export function useFormContext<
   T extends z.ZodTypeAny = z.ZodBranded<
     z.ZodNever,
     'you must pass a schema type'
-  >
+  >,
 >(): FormContextProps<T> {
-  const props: FormContextProps<T> = React.useContext(FormContext) as any
+  const props: FormContextProps<T> | null = React.useContext(FormContext) as any
   if (!props) {
     throw new Error(`must be used inside a <FormProvider>`)
   }

package/src/useFormDispatch.ts

@@ -4,13 +4,9 @@ import z from 'zod'
 import { FormAction } from './FormAction'
 import { Dispatch } from 'redux'
 
-export const useFormDispatch = createDispatchHook(
-  FormStateContext
-) as typeof useFormDispatchType
-
-declare function useFormDispatchType<
+export const useFormDispatch = createDispatchHook(FormStateContext) as <
   T extends z.ZodTypeAny = z.ZodBranded<
     z.ZodNever,
     'you must pass a schema type'
-  >
->(): Dispatch<FormAction<T>>
+  >,
+>() => Dispatch<FormAction<T>>