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

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>(

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

@@ -21,35 +21,35 @@ import { setMeta } from './actions/setMeta'
 import { FieldMeta } from './FormState'
 import { DeepPartial } from './util/DeepPartial'
 
-export type UseArrayFieldProps<Field extends ArrayFieldPath = ArrayFieldPath> =
-  NonNullable<z.input<Field['schema']>> extends any[]
-    ? FieldMeta &
-        ReturnType<
-          typeof bindActionsToField<
-            Field,
-            arrayActions<Field> & {
-              setParsedValue: typeof setParsedValue<Field>
-              setValue: typeof setValue<Field>
-              setMeta: typeof setMeta<Field>
-            }
-          >
-        > & {
-          elements: FieldPath<SchemaAt<Field['schema'], [number]>>[]
-          error?: string
-          dirty: boolean
-          pristine: boolean
-          valid: boolean
-          invalid: boolean
-        }
-    : { ERROR: 'not an array field' }
+export type UseArrayFieldProps<Field extends FieldPath> =
+  NonNullable<z.input<Field['schema']>> extends any[] ?
+    FieldMeta &
+      ReturnType<
+        typeof bindActionsToField<
+          Field,
+          arrayActions<Field> & {
+            setParsedValue: typeof setParsedValue<Field>
+            setValue: typeof setValue<Field>
+            setMeta: typeof setMeta<Field>
+          }
+        >
+      > & {
+        elements: FieldPath<SchemaAt<Field['schema'], [number]>>[]
+        error?: string
+        dirty: boolean
+        pristine: boolean
+        valid: boolean
+        invalid: boolean
+      }
+  : { ERROR: 'not an array field' }
 
 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>>>>
@@ -154,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>>

package/src/useHtmlField.ts

@@ -26,10 +26,11 @@ export type ValidUseHtmlFieldProps<Field extends FieldPath> = {
   meta: UseFieldProps<Field>
 }
 
-export type UseHtmlFieldProps<Field extends FieldPath> = z.input<
-  Field['schema']
-> extends string | number | bigint | boolean | null | undefined
-  ? {
+export type UseHtmlFieldProps<Field extends FieldPath> =
+  z.input<Field['schema']> extends (
+    string | number | bigint | boolean | null | undefined
+  ) ?
+    {
       input: HtmlFieldInputProps
       meta: UseFieldProps<Field>
     }
@@ -39,14 +40,12 @@ export type UseHtmlFieldProps<Field extends FieldPath> = z.input<
 
 export type UseHtmlFieldOptions<
   Field,
-  Schema extends z.ZodTypeAny = Field extends FieldPath<infer S>
-    ? S
-    : z.ZodTypeAny
+  Schema extends z.ZodTypeAny = Field extends FieldPath<infer S> ? S
+  : z.ZodTypeAny,
 > = {
   field: Field
-  type: z.input<Schema> extends boolean | null | undefined
-    ? 'checkbox'
-    : Exclude<HTMLInputTypeAttribute, 'checkbox'>
+  type: z.input<Schema> extends boolean | null | undefined ? 'checkbox'
+  : Exclude<HTMLInputTypeAttribute, 'checkbox'>
   normalizeOnBlur?: boolean
 }
 
@@ -121,8 +120,9 @@ function useHtmlFieldBase<Field extends FieldPath>(
       })
       if (normalizeOnBlur) {
         const parsed = field.schema.safeParse(value)
-        const formatted = parsed.success
-          ? invert(field.schema).safeParse(parsed.data)
+        const formatted =
+          parsed.success ?
+            invert(field.schema).safeParse(parsed.data)
           : undefined
         if (formatted?.success) value = formatted.data
         setValue(value)
@@ -139,11 +139,9 @@ function useHtmlFieldBase<Field extends FieldPath>(
         name: field.pathstring,
         type,
         value:
-          typeof value === 'boolean'
-            ? String(value)
-            : typeof value === 'string'
-            ? value || tempValue || ''
-            : tempValue || (value == null ? '' : String(value) || ''),
+          typeof value === 'boolean' ? String(value)
+          : typeof value === 'string' ? value || tempValue || ''
+          : tempValue || (value == null ? '' : String(value) || ''),
         ...(type === 'checkbox' && { checked: Boolean(value) }),
         onChange,
         onFocus,
@@ -181,7 +179,7 @@ function normalizeBlank(schema: z.ZodTypeAny): any {
 function safeBigInt(value: string): bigint | undefined {
   try {
     return BigInt(value)
-  } catch (error) {
+  } catch {
     return undefined
   }
 }
@@ -219,7 +217,7 @@ export function useHtmlField<
     z.ZodNever,
     'cast to TypedUseHtmlField<T> to pass a path array'
   >,
-  Path extends PathInSchema<T> = any
+  Path extends PathInSchema<T> = any,
 >(
   options: UseHtmlFieldOptions<Path, SchemaAt<T, Path>>
 ): UseHtmlFieldProps<FieldPath<SchemaAt<T, Path>>>
@@ -228,7 +226,7 @@ export function useHtmlField<
     z.ZodNever,
     'cast to TypedUseHtmlField<T> to pass a pathstring'
   >,
-  Path extends PathstringInSchema<T> = any
+  Path extends PathstringInSchema<T> = any,
 >(
   options: UseHtmlFieldOptions<Path, SchemaAt<T, parsePathstring<Path>>>
 ): UseHtmlFieldProps<FieldPath<SchemaAt<T, parsePathstring<Path>>>>

package/src/useInitialize.ts

@@ -7,7 +7,7 @@ export function useInitialize<
   T extends z.ZodTypeAny = z.ZodBranded<
     z.ZodNever,
     'you must pass a schema type'
-  >
+  >,
 >(
   options: Omit<InitializeAction<T>, 'type'>,
   deps: DependencyList = [options.parsedValues, options.values]

package/src/util/DeepPartial.ts

@@ -1,3 +1,2 @@
-export type DeepPartial<T> = T extends object | any[]
-  ? { [K in keyof T]?: DeepPartial<T[K]> }
-  : T
+export type DeepPartial<T> =
+  T extends object | any[] ? { [K in keyof T]?: DeepPartial<T[K]> } : T

package/src/util/PathInType.ts

@@ -3,22 +3,22 @@ import { pathstring } from './pathstring'
 
 export type PathInType<T> = [] | SubPathInType<T>
 
-type SubPathInType<T> = 0 extends 1 & T
-  ? BasePath
-  : T extends
-      | string
-      | number
-      | boolean
-      | bigint
-      | symbol
-      | null
-      | undefined
-      | void
-      | never
-      | ((...args: any[]) => any)
-  ? []
-  : T extends readonly any[]
-  ? { [K in keyof T & number]-?: [K, ...PathInType<T[K]>] }[keyof T & number]
+type SubPathInType<T> =
+  0 extends 1 & T ? BasePath
+  : T extends (
+    | string
+    | number
+    | boolean
+    | bigint
+    | symbol
+    | null
+    | undefined
+    | void
+    | ((...args: any[]) => any)
+  ) ?
+    []
+  : T extends readonly any[] ?
+    { [K in keyof T & number]-?: [K, ...PathInType<T[K]>] }[keyof T & number]
   : {
       [K in keyof T]-?: K extends symbol ? never : [K, ...PathInType<T[K]>]
     }[keyof T]