lutra 0.1.0 → 0.1.5

package/dist/form/Textarea.svelte.d.ts

@@ -0,0 +1,95 @@
+import { type Snippet } from "svelte";
+import type { Autocomplete } from "./types.js";
+type $$ComponentProps = {
+    /** Whether the input should be autofocused. */
+    autofocus?: boolean;
+    /** Whether the input should be autocapitalized. */
+    autocapitalize?: boolean | 'off' | 'none' | 'on' | 'sentences' | 'words' | 'characters';
+    /** Specifies whether autocomplete is enabled for the input. */
+    autocomplete?: Autocomplete;
+    /** Whether the input should resize automatically. */
+    autoresize?: boolean;
+    /** A hint to the browser for which capture method to use. */
+    capture?: 'user' | 'environment';
+    /** Whether the input should be checked. */
+    checked?: boolean;
+    /** Whether the input should be contained. */
+    contained?: boolean;
+    /** Whether the input should be copyable. */
+    copyable?: boolean;
+    /** The default value of the input element. */
+    defaultValue?: string;
+    /** Form field name for the directionality of the element's text content during form submission */
+    dirname?: string;
+    /** Whether the input should be disabled. */
+    disabled?: boolean;
+    /** A hint to the browser for which enter key to display for the input. */
+    enterkeyhint?: 'enter' | 'done' | 'go' | 'next' | 'previous' | 'search' | 'send';
+    /** The height of the input element. Valid for image inputs. */
+    height?: number;
+    /** Help text to display below the input. */
+    help?: string | Snippet;
+    /** A random id is generated if not provided. */
+    id?: string;
+    /** Whether the input should be indeterminate. */
+    indeterminate?: boolean;
+    /** A hint to the browser for which keyboard to display. This is only used for type="text" inputs. Strongly consider using type="email" or type="url" etc. instead */
+    inputmode?: 'none' | 'text' | 'tel' | 'url' | 'email' | 'numeric' | 'decimal' | 'search';
+    /** The label for the input */
+    label?: string | Snippet;
+    /** Context tooltip for a label. Renders with a questionmark using ContextTip. */
+    labelTip?: string | Snippet;
+    /** The id of a datalist element that contains pre-defined options for the input element. */
+    list?: string;
+    /** The maximum number of characters (as UTF-16 code units) the user can enter into the input. Valid for text, search, url, tel, email, and password. */
+    maxlength?: number;
+    /** The minimum number of characters (as UTF-16 code units) the user can enter into the input. Valid for text, search, url, tel, email, and password. */
+    minlength?: number;
+    /** The name of the input element. */
+    name: string;
+    /** The onblur event handler */
+    onblur?: (e: FocusEvent) => void;
+    /** Onchange event handler */
+    onchange?: (e: Event) => void;
+    /** Onclick event handler */
+    onclick?: (e: MouseEvent) => void;
+    /** Onfocus event handler */
+    onfocus?: (e: FocusEvent) => void;
+    /** Keyup event handler */
+    onkeyup?: (e: KeyboardEvent) => void;
+    /** Keydown event handler */
+    onkeydown?: (e: KeyboardEvent) => void;
+    /** Keypress event handler */
+    onkeypress?: (e: KeyboardEvent) => void;
+    /** A regular expression that the input's value is checked against. Valid for text, search, url, tel, email, and password. */
+    pattern?: string;
+    /** Placeholder text to display when the input is empty. */
+    placeholder?: string;
+    /** Suffix content, to display after the input. */
+    suffix?: string | Snippet;
+    /** Prefix content, to display before the input. */
+    prefix?: string | Snippet;
+    /** Whether the input should be read-only. */
+    readonly?: boolean;
+    /** Whether the input should be required. */
+    required?: boolean;
+    /** Whether the textarea is resizable. */
+    resize?: boolean | 'both' | 'horizontal' | 'vertical' | 'none';
+    /** The shape of the input element. */
+    shape?: 'default' | 'rounded' | 'pill' | 'circle';
+    /** Spellcheck the input. */
+    spellcheck?: boolean;
+    /** A number that specifies the granularity that the value must adhere to. Valid for date, month, week, time, datetime-local, number, and range. */
+    step?: number;
+    /** Inline styles to apply to the input element. */
+    style?: string;
+    /** An integer attribute indicating if the element can take input focus (is focusable), if it should participate to sequential keyboard navigation. */
+    tabindex?: number;
+    /** A string that defines the title of the input element. */
+    title?: string;
+    /** The value of the input element. */
+    value?: string | null;
+};
+declare const Textarea: import("svelte").Component<$$ComponentProps, {}, "id" | "value">;
+type Textarea = ReturnType<typeof Textarea>;
+export default Textarea;

package/dist/form/Toggle.svelte

@@ -0,0 +1,4 @@
+<script lang="ts">
+
+</script>
+

package/dist/form/Toggle.svelte.d.ts

@@ -0,0 +1,18 @@
+interface $$__sveltets_2_IsomorphicComponent<Props extends Record<string, any> = any, Events extends Record<string, any> = any, Slots extends Record<string, any> = any, Exports = {}, Bindings = string> {
+    new (options: import('svelte').ComponentConstructorOptions<Props>): import('svelte').SvelteComponent<Props, Events, Slots> & {
+        $$bindings?: Bindings;
+    } & Exports;
+    (internal: unknown, props: {
+        $$events?: Events;
+        $$slots?: Slots;
+    }): Exports & {
+        $set?: any;
+        $on?: any;
+    };
+    z_$$bindings?: Bindings;
+}
+declare const Toggle: $$__sveltets_2_IsomorphicComponent<Record<string, never>, {
+    [evt: string]: CustomEvent<any>;
+}, {}, {}, string>;
+type Toggle = InstanceType<typeof Toggle>;
+export default Toggle;

package/dist/form/client.svelte.d.ts

@@ -0,0 +1,45 @@
+import type { ZodType } from "zod";
+import type { LutraForm } from "./types.js";
+/**
+ * Use a form in a Svelte component.
+ * @param {Form} form - The form to use.
+ * @returns
+ */
+export declare function useForm(form: LutraForm<any>): LutraForm<any> & {
+    originalData: any;
+    domForm: null;
+    data: any;
+    state: string;
+};
+/**
+ * Validate a single field.
+ * @param {Form} form - The form to validate.
+ * @param {string} name - The name of the field to validate.
+ * @param {HTMLInputElement | HTMLSelectElement} el - The element to validate.
+ * @param {ZodType} validator - The validator to use.
+ */
+export declare function fieldValidate(form: LutraForm<any>, name: string, el?: HTMLInputElement | HTMLTextAreaElement | HTMLSelectElement, validator?: ZodType<any, any>): void;
+/**
+ * Keydown event handler for a field.
+ * @param {KeyboardEvent} e - The event.
+ * @param {Form} form - The form to use.
+ * @param {string} name - The name of the field.
+ * @param {HTMLInputElement | HTMLSelectElement} el - The element to validate.
+ * @param {ZodType} validator - The validator to use.
+ * @param {(e: KeyboardEvent) => void} onkeydown - The onkeydown event handler.
+ */
+export declare function fieldKeydown(form: LutraForm<any>, name: string, el: () => HTMLInputElement | HTMLTextAreaElement | HTMLSelectElement | undefined, validator?: ZodType<any, any>, onkeydown?: (e: KeyboardEvent) => void): (e: KeyboardEvent) => Promise<void>;
+/**
+ * Change event handler for a field.
+ * @param {Event} e - The event.
+ * @param {Form} form - The form to use.
+ * @param {string} name - The name of the field.
+ * @param {HTMLInputElement | HTMLSelectElement} el - The element to validate.
+ * @param {ZodType} validator - The validator to use.
+ * @param {(e: Event) => void} onchange - The onchange event handler.
+ */
+export declare function fieldChange(form: LutraForm<any>, name: string, el: () => HTMLInputElement | HTMLTextAreaElement | HTMLSelectElement | undefined, validator?: ZodType<any, any>, onchange?: (e: Event) => void): (e: Event) => Promise<void>;
+/**
+ * Keys that should be ignored when marking a field as tainted.
+ */
+export declare const ignoreKeys: string[];

package/dist/form/client.svelte.js

@@ -0,0 +1,102 @@
+/**
+ * Use a form in a Svelte component.
+ * @param {Form} form - The form to use.
+ * @returns
+ */
+export function useForm(form) {
+    let _form = Object.assign(form, {
+        originalData: JSON.parse(JSON.stringify(form.data ?? {})),
+        domForm: null,
+        data: form.data ?? {},
+        state: 'idle',
+    });
+    // Have to declare a variable separately to use in the return object
+    // as the compiler is looking for a declaration.
+    let __form = $state(_form);
+    return __form;
+}
+/**
+ * Validate a single field.
+ * @param {Form} form - The form to validate.
+ * @param {string} name - The name of the field to validate.
+ * @param {HTMLInputElement | HTMLSelectElement} el - The element to validate.
+ * @param {ZodType} validator - The validator to use.
+ */
+export function fieldValidate(form, name, el, validator) {
+    if (!validator)
+        return;
+    const result = validator.safeParse(getTypedValue(el));
+    if (result.success) {
+        form.issues = (form.issues || []).filter((issue) => issue.name !== name);
+        form.valid = form.issues.length === 0;
+    }
+    else {
+        form.valid = false;
+        form.issues = (form.issues || []).filter((issue) => issue.name !== name);
+        form.issues?.push({
+            name, // Include the path of the field.
+            ...((result.error?.issues?.length ? result.error.issues : [])?.[0]), // Include the first issue as we only care about one at a time.
+        });
+    }
+}
+/**
+ * Keydown event handler for a field.
+ * @param {KeyboardEvent} e - The event.
+ * @param {Form} form - The form to use.
+ * @param {string} name - The name of the field.
+ * @param {HTMLInputElement | HTMLSelectElement} el - The element to validate.
+ * @param {ZodType} validator - The validator to use.
+ * @param {(e: KeyboardEvent) => void} onkeydown - The onkeydown event handler.
+ */
+export function fieldKeydown(form, name, el, validator, onkeydown) {
+    return async function (e) {
+        setTimeout(() => {
+            if (form) {
+                const possibleKey = e?.key;
+                if (ignoreKeys.includes(possibleKey))
+                    return;
+                form.data[name] = el()?.value || '';
+                fieldValidate(form, name, el(), validator);
+            }
+        }, 0); // Wait for the key to be updated in the input.
+        if (onkeydown)
+            return onkeydown(e);
+    };
+}
+function getTypedValue(el) {
+    if (el?.type === 'number') {
+        const parsed = parseFloat(el.value);
+        // Zod v4 no longer accepts infinite values
+        return isFinite(parsed) ? parsed : el.value;
+    }
+    if (el?.type === 'checkbox')
+        return el.checked;
+    return el?.value;
+}
+/**
+ * Change event handler for a field.
+ * @param {Event} e - The event.
+ * @param {Form} form - The form to use.
+ * @param {string} name - The name of the field.
+ * @param {HTMLInputElement | HTMLSelectElement} el - The element to validate.
+ * @param {ZodType} validator - The validator to use.
+ * @param {(e: Event) => void} onchange - The onchange event handler.
+ */
+export function fieldChange(form, name, el, validator, onchange) {
+    return async function (e) {
+        if (form && form.fields[name]) {
+            console.log('fieldChange', name, el()?.value, form.data[name]);
+            // Update the form data with the new value.
+            form.data[name] = getTypedValue(el());
+            // if the value is the same as the original value, then the field is not tainted
+            form.fields[name].tainted = form.data[name] !== form.originalData[name];
+            fieldValidate(form, name, el(), validator);
+        }
+        if (onchange)
+            return onchange(e);
+    };
+}
+/**
+ * Keys that should be ignored when marking a field as tainted.
+ */
+export const ignoreKeys = ['Tab', 'Shift', 'Control', 'Alt', 'Meta', 'ArrowUp', 'ArrowDown', 'ArrowLeft', 'ArrowRight', 'Home', 'End', 'PageUp', 'PageDown', 'Escape', 'CapsLock', 'NumLock', 'ScrollLock', 'Pause', 'ContextMenu', 'PrintScreen', 'Help', 'Clear', 'OS', 'F1', 'F2', 'F3', 'F4', 'F5', 'F6', 'F7', 'F8', 'F9', 'F10', 'F12'];

package/dist/form/form.d.ts

@@ -0,0 +1,55 @@
+import { Bodyguard, type BodyguardFormConfig, type BodyguardResult, type GenericIssue, type JSONLike } from "@auth70/bodyguard";
+import type { RequestEvent } from "@sveltejs/kit";
+import type { infer as Infer } from "zod";
+import { type ZodTypes } from "zodex";
+import type { LutraForm, FormField, FormIssue } from "./types.js";
+export declare const bodyguard: Bodyguard;
+/**
+ * Get fields from a Zod schema.
+ * @param {ZodTypes} schema - The schema to get fields from.
+ * @returns {Record<string, any>} - The fields from the schema.
+ */
+export declare function getFieldsFromSchema<Z extends ZodTypes>(schema: Z, data?: BodyguardResult<any>, parents?: string[]): Record<string, FormField>;
+/**
+ * Server page load call. Optionally with a default object to populate the form with from locals.
+ * @param {ZodTypes} schema - The schema to parse the form with.
+ * @param {RequestEvent} event - The event to load the (possible) form from.
+ * @param {JSONLike | string} objOrName - The default object to populate the form with, or the name of the object in locals.
+ * @param {JSONLike} obj - The default object to populate the form with.
+ * @returns {Promise<Form<Z>>} - The form to use.
+ */
+export declare function loadForm<Z extends ZodTypes>(schema: Z, event: RequestEvent, objOrName?: JSONLike | string, obj?: JSONLike): Promise<LutraForm<Z>>;
+/**
+ * Parse zod issues into form issues (with a path string).
+ * @param {ZodIssue[]} issues - The issues to parse.
+ * @returns {FormIssue[]} - The parsed issues.
+ */
+export declare function parseFormIssues(issues: GenericIssue[]): FormIssue[];
+/**
+ * Parse a form using a schema.
+ * @param {ZodTypes} schema - The schema to parse the form with.
+ * @param {Request} request - The request to parse.
+ * @param {BodyguardFormConfig | string} optsOrName - The options for the form validation, or the name of the form in locals.
+ * @param {BodyguardFormConfig} opts - The options for the form validation.
+ * @returns {Promise<{ valid: false } | { valid: true, data: Infer<Z> }>} - The result of the form validation.
+ */
+export declare function parseForm<Z extends ZodTypes>(schema: Z, event: RequestEvent, optsOrName?: BodyguardFormConfig | string, opts?: BodyguardFormConfig): Promise<LutraForm<Z>>;
+/**
+ * Convert an array path from a Zod issue to a string path for a form field.
+ * @param {PropertyKey[]} path - The path to convert.
+ * @returns {string} - The string path.
+ */
+export declare function arrayPathToStringPath(path: PropertyKey[]): string;
+/**
+ * Get a value from an object using a string path.
+ * @param {any} obj - The object to get the value from.
+ * @param {string} path - The path to get the value from.
+ * @returns {string | number | Date | boolean | object | undefined} - The value from the object.
+ */
+export declare function getFromObjWithStringPath(obj: any, path: string): string | number | Date | boolean | object | undefined;
+/**
+ * Get individual validators for each field in a form.
+ * @param {Form} form - The form to get the validators from.
+ * @returns {Record<keyof Infer<T>, (value: any) => boolean>} - The validators for each field.
+ */
+export declare function getIndividualValidators<T extends ZodTypes>(form?: LutraForm<T>): Record<keyof Infer<T>, (value: any) => boolean>;

package/dist/form/form.js

@@ -0,0 +1,345 @@
+import { Bodyguard } from "@auth70/bodyguard";
+import { ZodArray, ZodNullable, ZodOptional, ZodObject, ZodDefault, ZodString, ZodNumber, ZodBoolean, ZodDate } from "zod";
+import { zerialize, dezerialize } from "zodex";
+export const bodyguard = new Bodyguard();
+/**
+ * Map a Zod type to a field type as a string.
+ * @param {Zod.ZodType} schema - The Zod schema to map to a field type.
+ * @returns {string} - The field type as a string.
+ */
+function mapZodTypeToFieldType(schema) {
+    if (schema instanceof ZodNullable) {
+        return mapZodTypeToFieldType(schema.unwrap());
+    }
+    if (schema instanceof ZodOptional) {
+        return mapZodTypeToFieldType(schema.unwrap());
+    }
+    if (schema instanceof ZodArray) {
+        return `Array<${mapZodTypeToFieldType(schema.element)}>`;
+    }
+    if (schema instanceof ZodObject) {
+        return 'object';
+    }
+    if (schema instanceof ZodDefault) {
+        return mapZodTypeToFieldType(schema._zod.def.innerType);
+    }
+    if (schema instanceof ZodDate) {
+        return 'date';
+    }
+    if (schema instanceof ZodString) {
+        return 'string';
+    }
+    if (schema instanceof ZodNumber) {
+        return 'number';
+    }
+    if (schema instanceof ZodBoolean) {
+        return 'boolean';
+    }
+    return schema.constructor.name;
+}
+/**
+ * Get fields from a Zod schema.
+ * @param {ZodTypes} schema - The schema to get fields from.
+ * @returns {Record<string, any>} - The fields from the schema.
+ */
+export function getFieldsFromSchema(schema, data, parents) {
+    if (!parents)
+        parents = [];
+    else
+        parents = [...parents];
+    const fields = {};
+    if (!(schema instanceof ZodObject)) {
+        console.error('[lutra] getFieldsFromSchema: Schema is not an object:', schema.constructor.name);
+        return fields;
+    }
+    for (const key in schema.shape) {
+        const field = schema.shape[key];
+        // Fields can be wrapped like ZodDefault.def.innerType.def.InnerType, etc. We want the last inner type's definition.
+        // On the way, let's check if any of the def include a defaultValue.
+        let required = true;
+        let defaultValue = undefined;
+        let min = undefined;
+        let max = undefined;
+        let pattern = undefined;
+        let minlength = undefined;
+        let maxlength = undefined;
+        let type = field;
+        while (type instanceof ZodOptional || type instanceof ZodDefault || type instanceof ZodNullable) {
+            if (type instanceof ZodOptional || type instanceof ZodNullable) {
+                required = false;
+                type = type._zod.def.innerType;
+            }
+            if (type instanceof ZodDefault) {
+                defaultValue = typeof type._zod.def.defaultValue === 'function'
+                    ? type._zod.def.defaultValue()
+                    : type._zod.def.defaultValue;
+                type = type._zod.def.innerType;
+            }
+            else {
+                type = type._zod.def.innerType ? type._zod.def.innerType : type;
+            }
+        }
+        // Check for min/max/regex checks
+        if ((type._zod.def).checks) {
+            for (const check of type._zod.def.checks) {
+                if (check.kind === 'min') {
+                    if (field instanceof ZodString || field._zod?.def?.innerType instanceof ZodString) {
+                        minlength = check.value;
+                    }
+                    else {
+                        min = check.value;
+                    }
+                }
+                if (check.kind === 'max') {
+                    if (field instanceof ZodString || field._zod?.def?.innerType instanceof ZodString) {
+                        maxlength = check.value;
+                    }
+                    else {
+                        max = check.value;
+                    }
+                }
+                if (check.kind === 'regex') {
+                    pattern = check.regex.source;
+                }
+                if (check.kind === 'email') {
+                    pattern = /^[^\s@]+@[^\s@]+\.[^\s@]+$/;
+                }
+                if (check.kind === 'url') {
+                    pattern = /^(https?:\/\/)?[^\s/$.?#].[^\s]*$/;
+                }
+                if (check.kind === 'uuid') {
+                    pattern = /^[0-9a-fA-F]{8}-[0-9a-fA-F]{4}-[0-9a-fA-F]{4}-[0-9a-fA-F]{4}-[0-9a-fA-F]{12}$/;
+                }
+            }
+        }
+        if (type instanceof ZodObject) {
+            const children = getFieldsFromSchema(type, data, [...parents, key]);
+            Object.entries(children).forEach(([childKey, childField]) => {
+                const name = [...parents, key, childKey].join('.');
+                fields[name] = {
+                    name,
+                    tainted: childField.tainted,
+                    coerce: childField.coerce,
+                    min: childField.min,
+                    max: childField.max,
+                    minlength: childField.minlength,
+                    maxlength: childField.maxlength,
+                    pattern: childField.pattern,
+                    required: childField.required,
+                    defaultValue: childField.defaultValue,
+                    isArray: childField.isArray,
+                    type: childField.type,
+                };
+            });
+        }
+        else {
+            fields[key] = {
+                name: [...parents, key].join('.'),
+                tainted: false,
+                min,
+                max,
+                minlength,
+                maxlength,
+                pattern,
+                required,
+                defaultValue,
+                isArray: field instanceof ZodArray,
+                type: mapZodTypeToFieldType(field instanceof ZodArray ? field.element : field),
+            };
+        }
+    }
+    return fields;
+}
+/**
+ * Server page load call. Optionally with a default object to populate the form with from locals.
+ * @param {ZodTypes} schema - The schema to parse the form with.
+ * @param {RequestEvent} event - The event to load the (possible) form from.
+ * @param {JSONLike | string} objOrName - The default object to populate the form with, or the name of the object in locals.
+ * @param {JSONLike} obj - The default object to populate the form with.
+ * @returns {Promise<Form<Z>>} - The form to use.
+ */
+export async function loadForm(schema, event, objOrName = 'form', obj) {
+    let name = typeof objOrName === 'string' ? objOrName : 'form';
+    let _obj = typeof objOrName === 'string' ? obj : objOrName;
+    // If there is a form in locals, it's been passed down from a form action using parseForm. Return it.
+    if (event.locals[name]) {
+        return Promise.resolve(event.locals[name]);
+    }
+    // Serialize the schema to send over the wire.
+    const serializedSchema = zerialize(schema);
+    // Get the fields from the schema.
+    const fields = getFieldsFromSchema(schema);
+    // Create the form object.
+    const form = event.locals.form;
+    return {
+        name,
+        valid: form ? form.valid : (obj ? true : false),
+        tainted: form ? form.tainted : false,
+        schema: serializedSchema,
+        posted: form ? form.posted : false,
+        state: form ? form.state : 'idle',
+        fields,
+        data: Object.assign(Object.fromEntries(Object.entries(fields).map(([key, value]) => {
+            // If the key is in the passed object, use that value. Otherwise, try to use the default value.
+            return [key, value.defaultValue];
+        })), _obj ? _obj : {}),
+    };
+}
+/**
+ * Parse zod issues into form issues (with a path string).
+ * @param {ZodIssue[]} issues - The issues to parse.
+ * @returns {FormIssue[]} - The parsed issues.
+ */
+export function parseFormIssues(issues) {
+    return JSON.parse(JSON.stringify((issues || []).map((issue) => {
+        return {
+            ...issue,
+            name: arrayPathToStringPath(issue.path),
+        };
+    })));
+}
+/**
+ * Parse a form using a schema.
+ * @param {ZodTypes} schema - The schema to parse the form with.
+ * @param {Request} request - The request to parse.
+ * @param {BodyguardFormConfig | string} optsOrName - The options for the form validation, or the name of the form in locals.
+ * @param {BodyguardFormConfig} opts - The options for the form validation.
+ * @returns {Promise<{ valid: false } | { valid: true, data: Infer<Z> }>} - The result of the form validation.
+ */
+export async function parseForm(schema, event, optsOrName = 'form', opts) {
+    let name = typeof optsOrName === 'string' ? optsOrName : 'form';
+    opts = typeof optsOrName === 'string' ? opts : optsOrName;
+    // Use bodyguard to parse the form.
+    const data = await bodyguard.softForm(event.request, (input) => schema.parse(input), opts);
+    // Get the fields from the schema.
+    const fields = getFieldsFromSchema(schema, data);
+    // Serialize the schema to send over the wire.
+    const serializedSchema = zerialize(schema);
+    // Create the form object.
+    const form = {
+        name: name,
+        valid: data.success,
+        tainted: !data.success,
+        state: data.success ? 'success' : 'error',
+        schema: serializedSchema,
+        posted: true,
+        fields: Object.fromEntries(Object.entries(fields).map(([key, field]) => {
+            // Mark fields as tainted if they were in the request.
+            return [key, {
+                    ...field,
+                    tainted: data.success ? false : (data.value && typeof data.value === 'object' && 'hasOwnProperty' in data.value ? data.value.hasOwnProperty(key) : false),
+                }];
+        })),
+        // ensure all fields are present by populating `data` from `fields` instead of trusting `data` to have all fields
+        data: Object.assign(Object.fromEntries(Object.entries(fields).map(([key, value]) => {
+            const dataValue = data.value && typeof data.value === 'object' ? data.value[key] : undefined;
+            return [key, value.isArray ? (dataValue || []) : (dataValue !== undefined ? dataValue : (value.defaultValue ?? null))];
+        })), data.value || {}),
+        issues: data.success ? undefined : parseFormIssues(data.error.issues),
+    };
+    // Attach the form to the locals to pass it to the client via loadForm.
+    event.locals[name] = form;
+    return form;
+}
+/**
+ * Convert an array path from a Zod issue to a string path for a form field.
+ * @param {PropertyKey[]} path - The path to convert.
+ * @returns {string} - The string path.
+ */
+export function arrayPathToStringPath(path) {
+    // Joins the path with dots. For arrays, it adds brackets.
+    // Symbols are converted to strings using String()
+    return path.map((p) => {
+        const pStr = typeof p === 'symbol' ? String(p) : p.toString();
+        if (pStr.match(/^\d+$/)) {
+            return `${pStr}[]`;
+        }
+        return pStr;
+    }).join('.');
+}
+/**
+ * Get a value from an object using a string path.
+ * @param {any} obj - The object to get the value from.
+ * @param {string} path - The path to get the value from.
+ * @returns {string | number | Date | boolean | object | undefined} - The value from the object.
+ */
+export function getFromObjWithStringPath(obj, path) {
+    if (!obj)
+        return undefined;
+    const parts = path.split('.');
+    let current = obj;
+    for (let i = 0; i < parts.length; i++) {
+        const part = parts[i];
+        // Support for array access patterns: foo[] or foo[0]
+        const arrayMatch = part.match(/^(.+?)(\[\d*\])?$/);
+        if (arrayMatch) {
+            const [, key, indexPart] = arrayMatch;
+            // Navigate into 'properties' if it exists
+            if (current.properties && current.properties[key]) {
+                current = current.properties[key];
+            }
+            else if (current[key]) {
+                current = current[key];
+            }
+            else {
+                // The path is invalid for the given structure or the index is not a number
+                return undefined;
+            }
+            // If indexPart is defined, it means we're dealing with an array index
+            if (indexPart) {
+                // Dealing with an array index, e.g., [0]
+                const index = parseInt(indexPart.slice(1, -1), 10);
+                if (!Array.isArray(current) || isNaN(index)) {
+                    return undefined;
+                }
+                current = current[index];
+            }
+        }
+        else {
+            // Direct property access
+            if (current.properties && current.properties[part]) {
+                current = current.properties[part];
+            }
+            else if (current[part]) {
+                current = current[part];
+            }
+            else {
+                return undefined;
+            }
+        }
+        if (current === undefined) {
+            return undefined;
+        }
+    }
+    // The value must be directly returnable without checking type,
+    // as we might be looking for an object structure.
+    return current;
+}
+/**
+ * Get individual validators for each field in a form.
+ * @param {Form} form - The form to get the validators from.
+ * @returns {Record<keyof Infer<T>, (value: any) => boolean>} - The validators for each field.
+ */
+export function getIndividualValidators(form) {
+    if (!form)
+        return {};
+    const schema = form.schema;
+    const fields = form.fields;
+    //console.log('[lutra] getIndividualValidators:', schema, fields, form)
+    if (!schema || !fields) {
+        console.error('[lutra] getIndividualValidators: Schema or fields not found:', schema, fields);
+        return {};
+    }
+    // Match the dot-notation form fields with the object schema fields.
+    // For each field, create a validator function by dezerilizing the schema for that field from the schema.
+    // Return the validators, not the parsed data.
+    const validators = Object.fromEntries(Object.entries(fields).map(([key, field]) => {
+        const schemaField = getFromObjWithStringPath(schema, key);
+        if (!schemaField) {
+            console.error('[lutra] getIndividualValidators: Schema field not found:', key);
+            return [key, (value) => true];
+        }
+        return [key, dezerialize(schemaField)];
+    }));
+    return validators;
+}