@sourceregistry/sveltekit-enhance 1.0.0

package/dist/helpers/form.d.ts

@@ -0,0 +1,314 @@
+import type { EnhanceErrorHandler, EnhanceInput, MaybePromise } from "../index.js";
+/**
+ * A single validation issue produced by a validator.
+ */
+export type ValidationIssue = {
+    path: string;
+    message: string;
+    code?: string;
+};
+/**
+ * Successful validation result.
+ */
+export type ValidationSuccess<T> = {
+    success: true;
+    data: T;
+};
+/**
+ * Failed validation result.
+ */
+export type ValidationFailure = {
+    success: false;
+    errors: ValidationIssue[];
+};
+/**
+ * The result returned by all validators.
+ */
+export type ValidationResult<T> = ValidationSuccess<T> | ValidationFailure;
+/**
+ * Internal path representation used while walking nested values.
+ */
+export type ValidationPath = Array<string | number>;
+export type Validator<T> = (value: unknown, path?: ValidationPath) => ValidationResult<T>;
+type AnyValidator = Validator<any>;
+export type InferValidator<V> = V extends Validator<infer T> ? T : never;
+type SchemaOptions = {
+    prefix_name?: string;
+    unpack_prefixed?: boolean;
+    transform?: (value: FormDataEntryValue, key: string, data: FormData) => any;
+    processor?: (input: any) => any;
+};
+export declare const reviver: (key: string | undefined, value: any) => any;
+declare const createContext: (data: FormData) => {
+    readonly data: FormData;
+    has: (...names: string[]) => boolean;
+    hasOneOf: (...name: string[]) => boolean;
+    string: (name: string) => string | undefined;
+    _string: (name: string) => string | null | undefined;
+    string$: (name: string) => string;
+    pattern$: (name: string, pattern: string | RegExp) => string;
+    enum: <E extends Record<string, string | number | any>>(name: string, _enum: E) => keyof E | undefined;
+    enum$: <E extends Record<string, string | number | any>>(name: string, _enum: E) => E[keyof E];
+    date: (name: string, parser?: (formdata: FormData, name: string) => number | string | Date | undefined) => Date | undefined;
+    date$: (name: string, parser?: (formdata: FormData, name: string) => number | string | Date) => Date;
+    process: <T, R>(name: string, parser: ((formdata: FormData, name: string) => T) | ((name: string) => T), processor: (val: T, name: string) => R) => R;
+    number: (name: string) => number | undefined;
+    number$: (name: string) => number | undefined;
+    boolean: (name: string) => boolean | undefined;
+    boolean$: (name: string) => boolean;
+    json: <T = unknown, F = T>(name: string, transformer?: (val: F) => T) => T | undefined;
+    jsond: (options: {
+        transform?: (value: FormDataEntryValue, key: string, data: FormData) => any;
+        processor?: (input: any) => any;
+    } & ({
+        prefix_name: string;
+        unpack_prefixed?: true;
+    } | {
+        prefix_name?: undefined;
+    })) => any;
+    json$: <T = unknown, F = T>(name: string, transformer?: (val: F) => T) => T;
+    file: (name: string) => File | null | undefined;
+    file$: (name: string) => File | undefined;
+    files: (name: string) => File[];
+    fileRecord: (prefix: string, removePrefix?: boolean) => Record<string, File[]>;
+    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[];
+    onlyIf: <T = never>(condition: boolean, TRUE: T, FALSE?: undefined) => T | undefined;
+    onlyIfPresent: <T = never>(key: string, TRUE: (entry: FormDataEntryValue) => T, FALSE?: undefined) => T | undefined;
+    onlyIfArrayPresent: <T, R>(key: string, TRUE: (entries: FormDataEntryValue[]) => T, FALSE: R) => T | R;
+    selector: <C extends (A extends true ? { [K in string]: (entries: FormDataEntryValue[], key: K) => T; } : { [K in string]: (entry: FormDataEntryValue, key: K) => T; }) & {
+        $error?: (error: unknown) => never;
+        $default?: (data: FormData) => T;
+    }, A extends boolean = false, T = any>(cases: C, useArray?: A) => ReturnType<C[keyof C]> | undefined;
+    selector$: <C extends (A extends true ? { [K in string]: (entries: FormDataEntryValue[], key: K) => T; } : { [K in string]: (entry: FormDataEntryValue, key: K) => T; }) & {
+        $error?: (error: unknown) => never;
+        $default?: (data: FormData) => T;
+    }, A extends boolean = false, T = any>(cases: C, useArray?: A) => ReturnType<C[keyof C]>;
+    basedOn: <T = unknown, R = unknown>(val: T, processor?: (val: T) => R) => R;
+    record: <T = any>(options?: Partial<{
+        transformer: (value: [string, FormDataEntryValue | FormDataEntryValue[]]) => [string, any | any[]];
+        filter: (value: [string, FormDataEntryValue[]]) => boolean;
+    }>) => T;
+    validate: <T extends Validator<any>>(schema: T, options?: SchemaOptions) => InferValidator<T>;
+};
+export type FormContext = ReturnType<typeof createContext>;
+export declare function hasOneOf(formdata: FormData, names: string[]): boolean;
+export declare function string(formdata: FormData, name: string): string | null | undefined;
+export declare function string$(formdata: FormData, name: string): string;
+/**
+ * Reads a required string and validates it against a regex pattern.
+ * Accepts either a prebuilt `RegExp` or a pattern string.
+ * Throws a SvelteKit `fail(400)` callback when required checks fail.
+ */
+export declare function pattern$(formdata: FormData, name: string, pattern: string | RegExp): string;
+export declare function number(formdata: FormData, name: string): number | undefined;
+export declare function number$(formdata: FormData, name: string): number | undefined;
+export declare function boolean(formdata: FormData, name: string): boolean | undefined;
+export declare function boolean$(formdata: FormData, name: string): boolean;
+export declare function date(formdata: FormData, name: string, parser?: (formdata: FormData, name: string) => number | string | Date | undefined): Date | undefined;
+export declare function date$(formdata: FormData, name: string, parser: (formdata: FormData, name: string) => number | string | Date): Date;
+export declare function json<T = unknown, F = T>(formdata: FormData, name: string, transformer?: (val: F) => T): T | undefined;
+export declare function record(formdata: FormData, options?: Partial<{
+    transformer: (value: [string, FormDataEntryValue | FormDataEntryValue[]]) => [string, any | any[]];
+    filter: (value: [string, FormDataEntryValue[]]) => boolean;
+}>): {
+    [k: string]: FormDataEntryValue | FormDataEntryValue[];
+};
+export declare function json$<T = unknown, F = T>(formdata: FormData, name: string, transformer?: (val: F) => T): T;
+export declare function jsond(formdata: FormData, options?: {
+    prefix_name?: string;
+    unpack_prefixed?: boolean;
+    transform?: (value: FormDataEntryValue, key: string, data: FormData) => any;
+    processor?: (input: any) => any;
+}): any;
+export declare function file(formdata: FormData, name: string): File | null | undefined;
+export declare function fileRecord(formdata: FormData, prefix: string, removePrefix?: boolean): Record<string, File[]>;
+export declare function file$(formdata: FormData, name: string): File | undefined;
+export declare function files(formdata: FormData, name: string): File[];
+export declare function array<T>(formdata: FormData, name: string, mapper?: (item: FormDataEntryValue, index: number, array: FormDataEntryValue[]) => T): T[] | undefined;
+export declare function array$<T>(formdata: FormData, name: string, mapper?: (item: FormDataEntryValue, index: number, array: FormDataEntryValue[]) => T): T[];
+/**
+ * TODO not compliant with enum standard but works for now
+ * @param formdata
+ * @param name
+ * @param _enum
+ */
+export declare function Enum<E extends Record<string, string | number | any>>(formdata: FormData, name: string, _enum: E): keyof E | undefined;
+/**
+ * TODO not compliant with enum standard but works for now
+ * @param formdata
+ * @param name
+ * @param _enum
+ */
+export declare function Enum$<E extends Record<string, string | number | any>>(formdata: FormData, name: string, _enum: E): E[keyof E];
+export declare function OldArray<T = string>(formdata: FormData, name: string, parser: (input: {
+    data: string;
+}) => T[]): T[];
+export declare function arrayString<T = string>(formdata: FormData, name: string, delimiter: string, mapper?: (item: string) => T): T[];
+export declare function onlyIf<T = never>(condition: boolean, TRUE: T, FALSE?: undefined): T | undefined;
+export declare function onlyIfPresent<T = never>(formdata: FormData, key: string, TRUE: (entry: FormDataEntryValue) => T, FALSE?: undefined): T | undefined;
+export declare function onlyIfArrayPresent<T, R>(formdata: FormData, key: string, TRUE: (entries: FormDataEntryValue[]) => T, FALSE: R): T | R;
+export declare function basedOn<T = unknown, R = unknown>(val: T, processor?: (val: T) => R): R;
+export declare function selector<C extends (A extends true ? {
+    [K in string]: (entries: FormDataEntryValue[], key: K) => T;
+} : {
+    [K in string]: (entry: FormDataEntryValue, key: K) => T;
+}) & {
+    $error?: (error: unknown) => never;
+    $default?: (data: FormData) => T;
+}, A extends boolean = false, T = any>(formData: FormData, cases: C, useArray?: A): ReturnType<C[keyof C]> | undefined;
+export declare function selector$<C extends (A extends true ? {
+    [K in string]: (entries: FormDataEntryValue[], key: K) => T;
+} : {
+    [K in string]: (entry: FormDataEntryValue, key: K) => T;
+}) & {
+    $error?: (error: unknown) => never;
+    $default?: (data: FormData) => T;
+}, A extends boolean = false, T = any>(formData: FormData, cases: C, useArray?: A): NonNullable<ReturnType<C[keyof C]>>;
+export declare function handle<T>(data: MaybePromise<FormData> | Request, fn: (input: {
+    data: FormData;
+    form: FormContext;
+}) => MaybePromise<T>, ...errorHandlers: EnhanceErrorHandler[]): Promise<T>;
+export declare function enhance(input: EnhanceInput): Promise<{
+    form: FormContext;
+}>;
+export declare function process<T, R>(formdata: FormData, name: string, parser: (formdata: FormData, name: string) => T, processor: (val: T, name: string) => R): R;
+export declare function validate<const T extends AnyValidator>(formdata: FormData, validator: T, options?: SchemaOptions): InferValidator<T>;
+export declare const schema: <const T extends AnyValidator>(validator: T, options?: SchemaOptions) => (input: EnhanceInput) => Promise<{
+    readonly form: {
+        readonly result: InferValidator<T>;
+        readonly data: FormData;
+        readonly has: (...names: string[]) => boolean;
+        readonly hasOneOf: (...name: string[]) => boolean;
+        readonly string: (name: string) => string | undefined;
+        readonly _string: (name: string) => string | null | undefined;
+        readonly string$: (name: string) => string;
+        readonly pattern$: (name: string, pattern: string | RegExp) => string;
+        readonly enum: <E extends Record<string, string | number | any>>(name: string, _enum: E) => keyof E | undefined;
+        readonly enum$: <E extends Record<string, string | number | any>>(name: string, _enum: E) => E[keyof E];
+        readonly date: (name: string, parser?: (formdata: FormData, name: string) => number | string | Date | undefined) => Date | undefined;
+        readonly date$: (name: string, parser?: (formdata: FormData, name: string) => number | string | Date) => Date;
+        readonly process: <T_1, R>(name: string, parser: ((formdata: FormData, name: string) => T_1) | ((name: string) => T_1), processor: (val: T_1, name: string) => R) => R;
+        readonly number: (name: string) => number | undefined;
+        readonly number$: (name: string) => number | undefined;
+        readonly boolean: (name: string) => boolean | undefined;
+        readonly boolean$: (name: string) => boolean;
+        readonly json: <T_1 = unknown, F = T_1>(name: string, transformer?: (val: F) => T_1) => T_1 | undefined;
+        readonly jsond: (options: {
+            transform?: (value: FormDataEntryValue, key: string, data: FormData) => any;
+            processor?: (input: any) => any;
+        } & ({
+            prefix_name: string;
+            unpack_prefixed?: true;
+        } | {
+            prefix_name?: undefined;
+        })) => any;
+        readonly json$: <T_1 = unknown, F_1 = T_1>(name: string, transformer?: (val: F_1) => T_1) => T_1;
+        readonly file: (name: string) => File | null | undefined;
+        readonly file$: (name: string) => File | undefined;
+        readonly files: (name: string) => File[];
+        readonly fileRecord: (prefix: string, removePrefix?: boolean) => Record<string, File[]>;
+        readonly array: <T_1>(name: string, mapper?: (item: FormDataEntryValue, index: number, array: FormDataEntryValue[]) => T_1) => T_1[] | undefined;
+        readonly array$: <T_1>(name: string, mapper?: (item: FormDataEntryValue, index: number, array: FormDataEntryValue[]) => T_1) => T_1[];
+        readonly onlyIf: <T_1 = never>(condition: boolean, TRUE: T_1, FALSE?: undefined) => T_1 | undefined;
+        readonly onlyIfPresent: <T_1 = never>(key: string, TRUE: (entry: FormDataEntryValue) => T_1, FALSE?: undefined) => T_1 | undefined;
+        readonly onlyIfArrayPresent: <T_1, R_1>(key: string, TRUE: (entries: FormDataEntryValue[]) => T_1, FALSE: R_1) => T_1 | R_1;
+        readonly selector: <C extends (A extends true ? { [K in string]: (entries: FormDataEntryValue[], key: K) => T_1; } : { [K in string]: (entry: FormDataEntryValue, key: K) => T_1; }) & {
+            $error?: (error: unknown) => never;
+            $default?: (data: FormData) => T_1;
+        }, A extends boolean = false, T_1 = any>(cases: C, useArray?: A) => ReturnType<C[keyof C]> | undefined;
+        readonly selector$: <C extends (A_1 extends true ? { [K in string]: (entries: FormDataEntryValue[], key: K) => T_2; } : { [K in string]: (entry: FormDataEntryValue, key: K) => T_2; }) & {
+            $error?: (error: unknown) => never;
+            $default?: (data: FormData) => T_2;
+        }, A_1 extends boolean = false, T_2 = any>(cases: C, useArray?: A_1) => ReturnType<C[keyof C]>;
+        readonly basedOn: <T_3 = unknown, R_2 = unknown>(val: T_3, processor?: (val: T_3) => R_2) => R_2;
+        readonly record: <T_3 = any>(options?: Partial<{
+            transformer: (value: [string, FormDataEntryValue | FormDataEntryValue[]]) => [string, any | any[]];
+            filter: (value: [string, FormDataEntryValue[]]) => boolean;
+        }>) => T_3;
+        readonly validate: <T_3 extends Validator<any>>(schema: T_3, options?: SchemaOptions) => InferValidator<T_3>;
+    };
+}>;
+export declare const Form: {
+    string: typeof string;
+    string$: typeof string$;
+    number: typeof number;
+    number$: typeof number$;
+    boolean: typeof boolean;
+    boolean$: typeof boolean$;
+    date: typeof date;
+    date$: typeof date$;
+    file: typeof file;
+    file$: typeof file$;
+    files: typeof files;
+    array: typeof array;
+    array$: typeof array$;
+    json: typeof json;
+    json$: typeof json$;
+    jsond: typeof jsond;
+    process: typeof process;
+    validate: typeof validate;
+    onlyIf: typeof onlyIf;
+    onlyIfPresent: typeof onlyIfPresent;
+    onlyIfArrayPresent: typeof onlyIfArrayPresent;
+    selector: typeof selector;
+    selector$: typeof selector$;
+    enhance: typeof enhance;
+    schema: <const T extends AnyValidator>(validator: T, options?: SchemaOptions) => (input: EnhanceInput) => Promise<{
+        readonly form: {
+            readonly result: InferValidator<T>;
+            readonly data: FormData;
+            readonly has: (...names: string[]) => boolean;
+            readonly hasOneOf: (...name: string[]) => boolean;
+            readonly string: (name: string) => string | undefined;
+            readonly _string: (name: string) => string | null | undefined;
+            readonly string$: (name: string) => string;
+            readonly pattern$: (name: string, pattern: string | RegExp) => string;
+            readonly enum: <E extends Record<string, string | number | any>>(name: string, _enum: E) => keyof E | undefined;
+            readonly enum$: <E extends Record<string, string | number | any>>(name: string, _enum: E) => E[keyof E];
+            readonly date: (name: string, parser?: (formdata: FormData, name: string) => number | string | Date | undefined) => Date | undefined;
+            readonly date$: (name: string, parser?: (formdata: FormData, name: string) => number | string | Date) => Date;
+            readonly process: <T_1, R>(name: string, parser: ((formdata: FormData, name: string) => T_1) | ((name: string) => T_1), processor: (val: T_1, name: string) => R) => R;
+            readonly number: (name: string) => number | undefined;
+            readonly number$: (name: string) => number | undefined;
+            readonly boolean: (name: string) => boolean | undefined;
+            readonly boolean$: (name: string) => boolean;
+            readonly json: <T_1 = unknown, F = T_1>(name: string, transformer?: (val: F) => T_1) => T_1 | undefined;
+            readonly jsond: (options: {
+                transform?: (value: FormDataEntryValue, key: string, data: FormData) => any;
+                processor?: (input: any) => any;
+            } & ({
+                prefix_name: string;
+                unpack_prefixed?: true;
+            } | {
+                prefix_name?: undefined;
+            })) => any;
+            readonly json$: <T_1 = unknown, F_1 = T_1>(name: string, transformer?: (val: F_1) => T_1) => T_1;
+            readonly file: (name: string) => File | null | undefined;
+            readonly file$: (name: string) => File | undefined;
+            readonly files: (name: string) => File[];
+            readonly fileRecord: (prefix: string, removePrefix?: boolean) => Record<string, File[]>;
+            readonly array: <T_1>(name: string, mapper?: (item: FormDataEntryValue, index: number, array: FormDataEntryValue[]) => T_1) => T_1[] | undefined;
+            readonly array$: <T_1>(name: string, mapper?: (item: FormDataEntryValue, index: number, array: FormDataEntryValue[]) => T_1) => T_1[];
+            readonly onlyIf: <T_1 = never>(condition: boolean, TRUE: T_1, FALSE?: undefined) => T_1 | undefined;
+            readonly onlyIfPresent: <T_1 = never>(key: string, TRUE: (entry: FormDataEntryValue) => T_1, FALSE?: undefined) => T_1 | undefined;
+            readonly onlyIfArrayPresent: <T_1, R_1>(key: string, TRUE: (entries: FormDataEntryValue[]) => T_1, FALSE: R_1) => T_1 | R_1;
+            readonly selector: <C extends (A extends true ? { [K in string]: (entries: FormDataEntryValue[], key: K) => T_1; } : { [K in string]: (entry: FormDataEntryValue, key: K) => T_1; }) & {
+                $error?: (error: unknown) => never;
+                $default?: (data: FormData) => T_1;
+            }, A extends boolean = false, T_1 = any>(cases: C, useArray?: A) => ReturnType<C[keyof C]> | undefined;
+            readonly selector$: <C extends (A_1 extends true ? { [K in string]: (entries: FormDataEntryValue[], key: K) => T_2; } : { [K in string]: (entry: FormDataEntryValue, key: K) => T_2; }) & {
+                $error?: (error: unknown) => never;
+                $default?: (data: FormData) => T_2;
+            }, A_1 extends boolean = false, T_2 = any>(cases: C, useArray?: A_1) => ReturnType<C[keyof C]>;
+            readonly basedOn: <T_3 = unknown, R_2 = unknown>(val: T_3, processor?: (val: T_3) => R_2) => R_2;
+            readonly record: <T_3 = any>(options?: Partial<{
+                transformer: (value: [string, FormDataEntryValue | FormDataEntryValue[]]) => [string, any | any[]];
+                filter: (value: [string, FormDataEntryValue[]]) => boolean;
+            }>) => T_3;
+            readonly validate: <T_3 extends Validator<any>>(schema: T_3, options?: SchemaOptions) => InferValidator<T_3>;
+        };
+    }>;
+    handle: typeof handle;
+};
+export {};