Variable FormConst

Type Declaration

• array: <T>(
      formdata: FormData,
      name: string,
      mapper?: (
          item: FormDataEntryValue,
          index: number,
          array: FormDataEntryValue[],
      ) => T,
  ) => T[] | undefined

• array$: <T>(
      formdata: FormData,
      name: string,
      mapper?: (
          item: FormDataEntryValue,
          index: number,
          array: FormDataEntryValue[],
      ) => T,
  ) => T[]

• boolean: (formdata: FormData, name: string) => boolean | undefined

• boolean$: (formdata: FormData, name: string) => boolean

• date: (
      formdata: FormData,
      name: string,
      parser?: (
          formdata: FormData,
          name: string,
      ) => string | number | Date | undefined,
  ) => Date | undefined

• date$: (
      formdata: FormData,
      name: string,
      parser: (formdata: FormData, name: string) => string | number | Date,
  ) => Date

• enhance: (
      input: EnhanceInput,
  ) => Promise<
      {
          form: {
              _string: (name: string) => string | null | undefined;
              array: <T>(
                  name: string,
                  mapper?: (
                      item: FormDataEntryValue,
                      index: number,
                      array: FormDataEntryValue[],
                  ) => T,
              ) => T[] | undefined;
              array$: <T>(
                  name: string,
                  mapper?: (
                      item: FormDataEntryValue,
                      index: number,
                      array: FormDataEntryValue[],
                  ) => T,
              ) => T[];
              basedOn: <T = unknown, R = unknown>(
                  val: T,
                  processor?: (val: T) => R,
              ) => R;
              boolean: (name: string) => boolean | undefined;
              boolean$: (name: string) => boolean;
              date: (
                  name: string,
                  parser?: (
                      formdata: FormData,
                      name: string,
                  ) => string | number | Date | undefined,
              ) => Date | undefined;
              date$: (
                  name: string,
                  parser?: (formdata: FormData, name: string) => string | number | Date,
              ) => Date;
              enum: <E extends Record<string, any>>(
                  name: string,
                  _enum: E,
              ) => keyof E | undefined;
              enum$: <E extends Record<string, any>>(
                  name: string,
                  _enum: E,
              ) => E[keyof E];
              file: (name: string) => File | null | undefined;
              file$: (name: string) => File | undefined;
              fileRecord: (
                  prefix: string,
                  removePrefix?: boolean,
              ) => Record<string, File[]>;
              files: (name: string) => File[];
              has: (...names: string[]) => boolean;
              hasOneOf: (...name: string[]) => boolean;
              json: <T = unknown, F = T>(
                  name: string,
                  transformer?: (val: F) => T,
              ) => T | undefined;
              json$: <T = unknown, F = T>(
                  name: string,
                  transformer?: (val: F) => T,
              ) => T;
              jsond: (
                  options: {
                      processor?: (input: any) => any;
                      transform?: (
                          value: FormDataEntryValue,
                          key: string,
                          data: FormData,
                      ) => any;
                  } & (
                      | { prefix_name: string; unpack_prefixed?: true }
                      | { prefix_name?: undefined }
                  ),
              ) => any;
              number: (name: string) => number | undefined;
              number$: (name: string) => number;
              onlyIf: <T = never>(
                  condition: boolean,
                  TRUE: T,
                  FALSE?: undefined,
              ) => T | undefined;
              onlyIfArrayPresent: <T, R>(
                  key: string,
                  TRUE: (entries: FormDataEntryValue[]) => T,
                  FALSE: R,
              ) => T | R;
              onlyIfPresent: <T = never>(
                  key: string,
                  TRUE: (entry: FormDataEntryValue) => T,
                  FALSE?: undefined,
              ) => T | undefined;
              pattern$: (name: string, pattern: string | RegExp) => string;
              process: <T, R>(
                  name: string,
                  parser:
                      | ((formdata: FormData, name: string) => T)
                      | ((name: string) => T),
                  processor: (val: T, name: string) => R,
              ) => R;
              record: <T = any>(
                  options?: Partial<
                      {
                          filter: (value: [(...), (...)]) => boolean;
                          transformer: (value: [(...), (...)]) => [(...), (...)];
                      },
                  >,
              ) => T;
              selector: <
                  C extends
                      (
                          | { [key: string]: (entries: (...)[], key: string) => T }
                          | { [key: string]: (entry: FormDataEntryValue, key: string) => T }
                      ) & {
                          $default?: (data: FormData) => T;
                          $error?: (error: unknown) => never;
                      },
                  A extends boolean = false,
                  T = any,
              >(
                  cases: C,
                  useArray?: A,
              ) => ReturnType<C[keyof C]> | undefined;
              selector$: <
                  C extends
                      (
                          | { [key: string]: (entries: (...)[], key: string) => T }
                          | { [key: string]: (entry: FormDataEntryValue, key: string) => T }
                      ) & {
                          $default?: (data: FormData) => T;
                          $error?: (error: unknown) => never;
                      },
                  A extends boolean = false,
                  T = any,
              >(
                  cases: C,
                  useArray?: A,
              ) => ReturnType<C[keyof C]>;
              string: (name: string) => string | undefined;
              string$: (name: string) => string;
              validate: <T extends Validator<any>>(
                  schema: T,
                  options?: SchemaOptions,
              ) => InferValidator<T>;
              get data(): FormData;
          };
      },
  >

• file: (formdata: FormData, name: string) => File | null | undefined

• file$: (formdata: FormData, name: string) => File | undefined

• files: (formdata: FormData, name: string) => File[]

• handle: <T>(
      data: Request | MaybePromise<FormData>,
      fn: (
          input: {
              data: FormData;
              form: {
                  _string: (name: string) => string | null | undefined;
                  array: <T>(
                      name: string,
                      mapper?: (
                          item: FormDataEntryValue,
                          index: number,
                          array: FormDataEntryValue[],
                      ) => T,
                  ) => T[] | undefined;
                  array$: <T>(
                      name: string,
                      mapper?: (
                          item: FormDataEntryValue,
                          index: number,
                          array: FormDataEntryValue[],
                      ) => T,
                  ) => T[];
                  basedOn: <T = unknown, R = unknown>(
                      val: T,
                      processor?: (val: T) => R,
                  ) => R;
                  boolean: (name: string) => boolean | undefined;
                  boolean$: (name: string) => boolean;
                  date: (
                      name: string,
                      parser?: (
                          formdata: FormData,
                          name: string,
                      ) => string | number | Date | undefined,
                  ) => Date | undefined;
                  date$: (
                      name: string,
                      parser?: (formdata: FormData, name: string) => string | number | Date,
                  ) => Date;
                  enum: <E extends Record<string, any>>(
                      name: string,
                      _enum: E,
                  ) => keyof E | undefined;
                  enum$: <E extends Record<string, any>>(
                      name: string,
                      _enum: E,
                  ) => E[keyof E];
                  file: (name: string) => File | null | undefined;
                  file$: (name: string) => File | undefined;
                  fileRecord: (
                      prefix: string,
                      removePrefix?: boolean,
                  ) => Record<string, File[]>;
                  files: (name: string) => File[];
                  has: (...names: string[]) => boolean;
                  hasOneOf: (...name: string[]) => boolean;
                  json: <T = unknown, F = T>(
                      name: string,
                      transformer?: (val: F) => T,
                  ) => T | undefined;
                  json$: <T = unknown, F = T>(
                      name: string,
                      transformer?: (val: F) => T,
                  ) => T;
                  jsond: (
                      options: {
                          processor?: (input: any) => any;
                          transform?: (
                              value: FormDataEntryValue,
                              key: string,
                              data: FormData,
                          ) => any;
                      } & (
                          | { prefix_name: string; unpack_prefixed?: true }
                          | { prefix_name?: undefined }
                      ),
                  ) => any;
                  number: (name: string) => number | undefined;
                  number$: (name: string) => number;
                  onlyIf: <T = never>(
                      condition: boolean,
                      TRUE: T,
                      FALSE?: undefined,
                  ) => T | undefined;
                  onlyIfArrayPresent: <T, R>(
                      key: string,
                      TRUE: (entries: FormDataEntryValue[]) => T,
                      FALSE: R,
                  ) => T | R;
                  onlyIfPresent: <T = never>(
                      key: string,
                      TRUE: (entry: FormDataEntryValue) => T,
                      FALSE?: undefined,
                  ) => T | undefined;
                  pattern$: (name: string, pattern: string | RegExp) => string;
                  process: <T, R>(
                      name: string,
                      parser:
                          | ((formdata: FormData, name: string) => T)
                          | ((name: string) => T),
                      processor: (val: T, name: string) => R,
                  ) => R;
                  record: <T = any>(
                      options?: Partial<
                          {
                              filter: (value: [(...), (...)]) => boolean;
                              transformer: (value: [(...), (...)]) => [(...), (...)];
                          },
                      >,
                  ) => T;
                  selector: <
                      C extends
                          (
                              | { [key: string]: (entries: (...)[], key: string) => T }
                              | { [key: string]: (entry: FormDataEntryValue, key: string) => T }
                          ) & {
                              $default?: (data: FormData) => T;
                              $error?: (error: unknown) => never;
                          },
                      A extends boolean = false,
                      T = any,
                  >(
                      cases: C,
                      useArray?: A,
                  ) => ReturnType<C[keyof C]> | undefined;
                  selector$: <
                      C extends
                          (
                              | { [key: string]: (entries: (...)[], key: string) => T }
                              | { [key: string]: (entry: FormDataEntryValue, key: string) => T }
                          ) & {
                              $default?: (data: FormData) => T;
                              $error?: (error: unknown) => never;
                          },
                      A extends boolean = false,
                      T = any,
                  >(
                      cases: C,
                      useArray?: A,
                  ) => ReturnType<C[keyof C]>;
                  string: (name: string) => string | undefined;
                  string$: (name: string) => string;
                  validate: <T extends Validator<any>>(
                      schema: T,
                      options?: SchemaOptions,
                  ) => InferValidator<T>;
                  get data(): FormData;
              };
          },
      ) => MaybePromise<T>,
      ...errorHandlers: EnhanceErrorHandler[],
  ) => Promise<T>

• json: <T = unknown, F = T>(
      formdata: FormData,
      name: string,
      transformer?: (val: F) => T,
  ) => T | undefined

• json$: <T = unknown, F = T>(
      formdata: FormData,
      name: string,
      transformer?: (val: F) => T,
  ) => T

• jsond: (
      formdata: FormData,
      options?: {
          prefix_name?: string;
          processor?: (input: any) => any;
          transform?: (
              value: FormDataEntryValue,
              key: string,
              data: FormData,
          ) => any;
          unpack_prefixed?: boolean;
      },
  ) => any

• number: (formdata: FormData, name: string) => number | undefined

• number$: (formdata: FormData, name: string) => number

• onlyIf: <T = never>(condition: boolean, TRUE: T, FALSE?: undefined) => T | undefined

• onlyIfArrayPresent: <T, R>(
      formdata: FormData,
      key: string,
      TRUE: (entries: FormDataEntryValue[]) => T,
      FALSE: R,
  ) => T | R

• onlyIfPresent: <T = never>(
      formdata: FormData,
      key: string,
      TRUE: (entry: FormDataEntryValue) => T,
      FALSE?: undefined,
  ) => T | undefined

• process: <T, R>(
      formdata: FormData,
      name: string,
      parser: (formdata: FormData, name: string) => T,
      processor: (val: T, name: string) => R,
  ) => R

• schema: <const T extends AnyValidator>(
      validator: T,
      options?: SchemaOptions,
  ) => (
      input: EnhanceInput,
  ) => Promise<
      {
          form: {
              _string: (name: string) => string | null | undefined;
              array: <T>(
                  name: string,
                  mapper?: (
                      item: FormDataEntryValue,
                      index: number,
                      array: FormDataEntryValue[],
                  ) => T,
              ) => T[] | undefined;
              array$: <T>(
                  name: string,
                  mapper?: (
                      item: FormDataEntryValue,
                      index: number,
                      array: FormDataEntryValue[],
                  ) => T,
              ) => T[];
              basedOn: <T = unknown, R = unknown>(
                  val: T,
                  processor?: (val: T) => R,
              ) => R;
              boolean: (name: string) => boolean | undefined;
              boolean$: (name: string) => boolean;
              date: (
                  name: string,
                  parser?: (
                      formdata: FormData,
                      name: string,
                  ) => string | number | Date | undefined,
              ) => Date | undefined;
              date$: (
                  name: string,
                  parser?: (formdata: FormData, name: string) => string | number | Date,
              ) => Date;
              enum: <E extends Record<string, any>>(
                  name: string,
                  _enum: E,
              ) => keyof E | undefined;
              enum$: <E extends Record<string, any>>(
                  name: string,
                  _enum: E,
              ) => E[keyof E];
              file: (name: string) => File | null | undefined;
              file$: (name: string) => File | undefined;
              fileRecord: (
                  prefix: string,
                  removePrefix?: boolean,
              ) => Record<string, File[]>;
              files: (name: string) => File[];
              has: (...names: string[]) => boolean;
              hasOneOf: (...name: string[]) => boolean;
              json: <T = unknown, F = T>(
                  name: string,
                  transformer?: (val: F) => T,
              ) => T | undefined;
              json$: <T = unknown, F = T>(
                  name: string,
                  transformer?: (val: F) => T,
              ) => T;
              jsond: (
                  options: {
                      processor?: (input: ...) => ...;
                      transform?: (value: ..., key: ..., data: ...) => ...;
                  } & (
                      | { prefix_name: string; unpack_prefixed?: (...)
                      | (...) }
                      | { prefix_name?: undefined }
                  ),
              ) => any;
              number: (name: string) => number | undefined;
              number$: (name: string) => number;
              onlyIf: <T = never>(
                  condition: boolean,
                  TRUE: T,
                  FALSE?: undefined,
              ) => T | undefined;
              onlyIfArrayPresent: <T, R>(
                  key: string,
                  TRUE: (entries: FormDataEntryValue[]) => T,
                  FALSE: R,
              ) => T | R;
              onlyIfPresent: <T = never>(
                  key: string,
                  TRUE: (entry: FormDataEntryValue) => T,
                  FALSE?: undefined,
              ) => T | undefined;
              pattern$: (name: string, pattern: string | RegExp) => string;
              process: <T, R>(
                  name: string,
                  parser:
                      | ((formdata: FormData, name: string) => T)
                      | ((name: string) => T),
                  processor: (val: T, name: string) => R,
              ) => R;
              record: <T = any>(
                  options?: Partial<
                      { filter: (value: ...) => ...; transformer: (value: ...) => ... },
                  >,
              ) => T;
              result: InferValidator<T>;
              selector: <
                  C extends
                      (
                          | { [key: string]: (entries: ..., key: ...) => ... }
                          | { [key: string]: (entry: ..., key: ...) => ... }
                      ) & { $default?: (data: ...) => ...; $error?: (error: ...) => ... },
                  A extends boolean = false,
                  T = any,
              >(
                  cases: C,
                  useArray?: A,
              ) => ReturnType<C[keyof (...)]> | undefined;
              selector$: <
                  C extends
                      (
                          | { [key: string]: (entries: ..., key: ...) => ... }
                          | { [key: string]: (entry: ..., key: ...) => ... }
                      ) & { $default?: (data: ...) => ...; $error?: (error: ...) => ... },
                  A extends boolean = false,
                  T = any,
              >(
                  cases: C,
                  useArray?: A,
              ) => ReturnType<C[keyof C]>;
              string: (name: string) => string | undefined;
              string$: (name: string) => string;
              validate: <T extends Validator<any>>(
                  schema: T,
                  options?: SchemaOptions,
              ) => InferValidator<T>;
              get data(): FormData;
          };
      },
  >

• selector: <
      C extends
          (
              | { [key: string]: (entries: FormDataEntryValue[], key: string) => T }
              | { [key: string]: (entry: FormDataEntryValue, key: string) => T }
          ) & {
              $default?: (data: FormData) => T;
              $error?: (error: unknown) => never;
          },
      A extends boolean = false,
      T = any,
  >(
      formData: FormData,
      cases: C,
      useArray?: A,
  ) => ReturnType<C[keyof C]> | undefined

• selector$: <
      C extends
          (
              | { [key: string]: (entries: FormDataEntryValue[], key: string) => T }
              | { [key: string]: (entry: FormDataEntryValue, key: string) => T }
          ) & {
              $default?: (data: FormData) => T;
              $error?: (error: unknown) => never;
          },
      A extends boolean = false,
      T = any,
  >(
      formData: FormData,
      cases: C,
      useArray?: A,
  ) => NonNullable<ReturnType<C[keyof C]>>

• string: (formdata: FormData, name: string) => string | null | undefined

• string$: (formdata: FormData, name: string) => string

• validate: <const T extends AnyValidator>(
      formdata: FormData,
      validator: T,
      options?: SchemaOptions,
  ) => InferValidator<T>