lutra 0.0.20 → 0.1.0

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

@@ -1,97 +0,0 @@
-import { SvelteComponent } from "svelte";
-declare const __propDef: {
-    props: {
-        attrs?: Record<string, string> | undefined;
-        children?: ((this: void) => typeof import("svelte").SnippetReturn & {
-            _: "functions passed to {@render ...} tags must use the `Snippet` type imported from \"svelte\"";
-        }) | undefined;
-        disabled?: boolean | undefined;
-        help?: string | ((this: void) => typeof import("svelte").SnippetReturn & {
-            _: "functions passed to {@render ...} tags must use the `Snippet` type imported from \"svelte\"";
-        }) | undefined;
-        id?: import("svelte").Bindable<string | undefined>;
-        label?: string | ((this: void) => typeof import("svelte").SnippetReturn & {
-            _: "functions passed to {@render ...} tags must use the `Snippet` type imported from \"svelte\"";
-        }) | undefined;
-        labelTip?: string | ((this: void) => typeof import("svelte").SnippetReturn & {
-            _: "functions passed to {@render ...} tags must use the `Snippet` type imported from \"svelte\"";
-        }) | undefined;
-        name: string;
-        onblur?: ((e: FocusEvent) => void) | undefined;
-        onchange?: ((e: Event) => void) | undefined;
-        onclick?: ((e: MouseEvent) => void) | undefined;
-        onfocus?: ((e: FocusEvent) => void) | undefined;
-        onkeyup?: ((e: KeyboardEvent) => void) | undefined;
-        onkeydown?: ((e: KeyboardEvent) => void) | undefined;
-        onkeypress?: ((e: KeyboardEvent) => void) | undefined;
-        options?: string[] | {
-            value: string;
-            label: string;
-        }[] | undefined;
-        placeholder?: string | undefined;
-        suffix?: string | ((this: void) => typeof import("svelte").SnippetReturn & {
-            _: "functions passed to {@render ...} tags must use the `Snippet` type imported from \"svelte\"";
-        }) | undefined;
-        prefix?: string | ((this: void) => typeof import("svelte").SnippetReturn & {
-            _: "functions passed to {@render ...} tags must use the `Snippet` type imported from \"svelte\"";
-        }) | undefined;
-        required?: boolean | undefined;
-        results?: number | undefined;
-        shape?: "default" | "circle" | "rounded" | "pill" | undefined;
-        src?: string | undefined;
-        tabindex?: number | undefined;
-        value?: import("svelte").Bindable<string | undefined>;
-    };
-    events: {
-        [evt: string]: CustomEvent<any>;
-    };
-    slots: {};
-};
-export type SelectProps = typeof __propDef.props;
-export type SelectEvents = typeof __propDef.events;
-export type SelectSlots = typeof __propDef.slots;
-export default class Select extends SvelteComponent<SelectProps, SelectEvents, SelectSlots> {
-    constructor(options?: import("svelte").ComponentConstructorOptions<{
-        attrs?: Record<string, string> | undefined;
-        children?: ((this: void) => typeof import("svelte").SnippetReturn & {
-            _: "functions passed to {@render ...} tags must use the `Snippet` type imported from \"svelte\"";
-        }) | undefined;
-        disabled?: boolean | undefined;
-        help?: string | ((this: void) => typeof import("svelte").SnippetReturn & {
-            _: "functions passed to {@render ...} tags must use the `Snippet` type imported from \"svelte\"";
-        }) | undefined;
-        id?: import("svelte").Bindable<string | undefined>;
-        label?: string | ((this: void) => typeof import("svelte").SnippetReturn & {
-            _: "functions passed to {@render ...} tags must use the `Snippet` type imported from \"svelte\"";
-        }) | undefined;
-        labelTip?: string | ((this: void) => typeof import("svelte").SnippetReturn & {
-            _: "functions passed to {@render ...} tags must use the `Snippet` type imported from \"svelte\"";
-        }) | undefined;
-        name: string;
-        onblur?: ((e: FocusEvent) => void) | undefined;
-        onchange?: ((e: Event) => void) | undefined;
-        onclick?: ((e: MouseEvent) => void) | undefined;
-        onfocus?: ((e: FocusEvent) => void) | undefined;
-        onkeyup?: ((e: KeyboardEvent) => void) | undefined;
-        onkeydown?: ((e: KeyboardEvent) => void) | undefined;
-        onkeypress?: ((e: KeyboardEvent) => void) | undefined;
-        options?: string[] | {
-            value: string;
-            label: string;
-        }[] | undefined;
-        placeholder?: string | undefined;
-        suffix?: string | ((this: void) => typeof import("svelte").SnippetReturn & {
-            _: "functions passed to {@render ...} tags must use the `Snippet` type imported from \"svelte\"";
-        }) | undefined;
-        prefix?: string | ((this: void) => typeof import("svelte").SnippetReturn & {
-            _: "functions passed to {@render ...} tags must use the `Snippet` type imported from \"svelte\"";
-        }) | undefined;
-        required?: boolean | undefined;
-        results?: number | undefined;
-        shape?: "default" | "circle" | "rounded" | "pill" | undefined;
-        src?: string | undefined;
-        tabindex?: number | undefined;
-        value?: import("svelte").Bindable<string | undefined>;
-    }>);
-}
-export {};

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

@@ -1,45 +0,0 @@
-import type { ZodType } from "zod";
-import type { Form } from "./types.js";
-/**
- * Use a form in a Svelte component.
- * @param {Form} form - The form to use.
- * @returns
- */
-export declare function useForm(form: Form<any>): {
-    form: {
-        originalData: any;
-        data: any;
-    } & Form<any>;
-};
-/**
- * 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: Form<any>, name: string, el?: HTMLInputElement | 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: Form<any>, name: string, el: () => HTMLInputElement | 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: Form<any>, name: string, el: () => HTMLInputElement | 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

@@ -1,90 +0,0 @@
-/**
- * Use a form in a Svelte component.
- * @param {Form} form - The form to use.
- * @returns
- */
-export function useForm(form) {
-    let _form = Object.assign({
-        originalData: JSON.parse(JSON.stringify(form.data ?? {})),
-        data: form.data ?? {},
-    }, form);
-    // 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: __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(el?.value);
-    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);
-    };
-}
-/**
- * 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) {
-            console.log('fieldChange', name, el()?.value, validator);
-            form.data[name] = el()?.value || '';
-            form.fields[name].tainted = true;
-            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

@@ -1,52 +0,0 @@
-import { Bodyguard, type BodyguardFormConfig, type BodyguardResult, type GenericIssue, type JSONLike } from "@auth70/bodyguard";
-import type { RequestEvent } from "@sveltejs/kit";
-import type { ZodType, infer as Infer } from "zod";
-import type { Form, FormField, FormIssue, ZodTypes } from "./types.js";
-export declare const bodyguard: Bodyguard;
-/**
- * Get fields from a Zod schema.
- * @param {ZodObject<any>} schema - The schema to get fields from.
- * @returns {Record<string, any>} - The fields from the schema.
- */
-export declare function getFieldsFromSchema(schema: ZodType, 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 {ZodType} schema - The schema to parse the form with.
- * @param {RequestEvent} event - The event to load the (possible) form from.
- * @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, obj?: JSONLike): Promise<Form<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 {ZodType} schema - The schema to parse the form with.
- * @param {Request} request - The request to parse.
- * @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 ZodType>(schema: Z, event: RequestEvent, opts?: BodyguardFormConfig): Promise<Form<Z>>;
-/**
- * Convert an array path from a Zod issue to a string path for a form field.
- * @param {(string | number)[]} path - The path to convert.
- * @returns {string} - The string path.
- */
-export declare function arrayPathToStringPath(path: (string | number)[]): 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?: Form<T>): Record<keyof Infer<T>, (value: any) => boolean>;

package/dist/form/form.js

@@ -1,326 +0,0 @@
-import { Bodyguard } from "@auth70/bodyguard";
-import { ZodArray, ZodNullable, ZodOptional, ZodEffects, ZodObject, ZodDefault, ZodString, ZodNumber, ZodBoolean, ZodDate, array } from "zod";
-import { zerialize, dezerialize } from "@auth70/zodex-esm";
-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 ZodEffects) {
-        return mapZodTypeToFieldType(schema._def?.schema ?? schema);
-    }
-    if (schema instanceof ZodArray) {
-        return `Array<${mapZodTypeToFieldType(schema.element)}>`;
-    }
-    if (schema instanceof ZodObject) {
-        return 'object';
-    }
-    if (schema instanceof ZodDefault) {
-        return mapZodTypeToFieldType(schema._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 {ZodObject<any>} 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 ZodEffects) {
-        return getFieldsFromSchema(schema._def.schema, data);
-    }
-    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 ZodEffects || type instanceof ZodOptional || type instanceof ZodDefault || type instanceof ZodNullable) {
-            if (type instanceof ZodOptional || type instanceof ZodNullable) {
-                required = false;
-                type = type._def.innerType;
-            }
-            if (type instanceof ZodDefault) {
-                defaultValue = type._def.defaultValue();
-                type = type._def.innerType;
-            }
-            else {
-                type = type._def.innerType ? type._def.innerType : type;
-            }
-        }
-        // Check for min/max/regex checks
-        if (type._def.checks) {
-            for (const check of type._def.checks) {
-                if (check.kind === 'min') {
-                    if (field instanceof ZodString || field._def?.innerType instanceof ZodString) {
-                        minlength = check.value;
-                    }
-                    else {
-                        min = check.value;
-                    }
-                }
-                if (check.kind === 'max') {
-                    if (field instanceof ZodString || field._def?.innerType instanceof ZodString) {
-                        maxlength = check.value;
-                    }
-                    else {
-                        max = check.value;
-                    }
-                }
-                if (check.kind === 'regex') {
-                    pattern = check.regex.source;
-                }
-                if (check.kind === 'email') {
-                    // ...
-                }
-            }
-        }
-        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 {ZodType} schema - The schema to parse the form with.
- * @param {RequestEvent} event - The event to load the (possible) form from.
- * @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, obj) {
-    // If there is a form in locals, it's been passed in from parseForm. Return it.
-    if (event.locals.form) {
-        return event.locals.form;
-    }
-    // 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 {
-        valid: form ? form.valid : (obj ? true : false),
-        tainted: form ? form.tainted : false,
-        schema: serializedSchema,
-        posted: form ? form.posted : false,
-        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 {ZodType} schema - The schema to parse the form with.
- * @param {Request} request - The request to parse.
- * @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, opts) {
-    // Use bodyguard to parse the form.
-    const data = await bodyguard.softForm(event.request, schema.parse, 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 = {
-        valid: data.success,
-        tainted: !data.success,
-        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.hasOwnProperty(key),
-                }];
-        })),
-        data: data.value ? 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.form = form;
-    return form;
-}
-/**
- * Convert an array path from a Zod issue to a string path for a form field.
- * @param {(string | number)[]} path - The path to convert.
- * @returns {string} - The string path.
- */
-export function arrayPathToStringPath(path) {
-    // Joins the path with dots. For arrays, it adds brackets.
-    return path.map((p) => {
-        if (p.toString().match(/^\d+$/)) {
-            return `${p}[]`;
-        }
-        return p;
-    }).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;
-    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;
-}

package/dist/form/index.d.ts

@@ -1,15 +0,0 @@
-export { default as Button } from './Button.svelte';
-export { default as FieldContainer } from './FieldContainer.svelte';
-export { default as FieldSection } from './FieldSection.svelte';
-export { default as FieldActions } from './FieldActions.svelte';
-export { default as FieldError } from './FieldError.svelte';
-export { default as FieldContent } from './FieldContent.svelte';
-export { default as Fieldset } from './Fieldset.svelte';
-export { default as Form } from './Form.svelte';
-export { default as Input } from './Input.svelte';
-export { default as InputLength } from './InputLength.svelte';
-export { default as Label } from './Label.svelte';
-export { default as Select } from './Select.svelte';
-export * from './types.js';
-export * from './form.js';
-export * from './client.svelte.js';

package/dist/form/index.js

@@ -1,15 +0,0 @@
-export { default as Button } from './Button.svelte';
-export { default as FieldContainer } from './FieldContainer.svelte';
-export { default as FieldSection } from './FieldSection.svelte';
-export { default as FieldActions } from './FieldActions.svelte';
-export { default as FieldError } from './FieldError.svelte';
-export { default as FieldContent } from './FieldContent.svelte';
-export { default as Fieldset } from './Fieldset.svelte';
-export { default as Form } from './Form.svelte';
-export { default as Input } from './Input.svelte';
-export { default as InputLength } from './InputLength.svelte';
-export { default as Label } from './Label.svelte';
-export { default as Select } from './Select.svelte';
-export * from './types.js';
-export * from './form.js';
-export * from './client.svelte.js';