@explita/formly 0.1.0

package/dist/types/array.d.ts

@@ -0,0 +1,197 @@
+import { Path } from "./path";
+import { Compute, Computed, SetValues } from "./utils";
+export type ArrayItem<T, P extends string> = P extends `${infer Key}.${infer Rest}` ? Key extends keyof T ? T[Key] extends Record<string, any> ? ArrayItem<T[Key], Rest> : never : never : P extends keyof T ? T[P] extends Array<infer U> ? U : never : never;
+export type ArrayHelpers<T> = {
+    /**
+     * Returns the array of values for the specified path.
+     * @returns The array of values for the specified path.
+     */
+    get: () => T[];
+    /**
+     * Returns the array of values for the specified path.
+     * @returns The array of values for the specified path.
+     */
+    value: T[];
+    toObject: () => Record<number, T>;
+    /**
+     * Returns the length of the array for the specified path.
+     * @returns The length of the array for the specified path.
+     */
+    length: number;
+    /**
+     * Sets the array of values for the specified path.
+     * @param arr The array of values to set for the specified path.
+     */
+    /**
+     * Updates the item at the specified index.
+     * @param index The index of the item to update.
+     * @param item The new value for the item.
+     */
+    updateAt: (index: number, item: T) => ArrayHelpers<T>;
+    /**
+     * Replaces all items in the array for the specified path with the new array.
+     * @param newArray The new array of values to set for the specified path.
+     */
+    replaceAll: (newArray: T[]) => ArrayHelpers<T>;
+    /**
+     * Replaces the first item in the array that satisfies the provided testing function.
+     * @param fn The testing function to apply to each item in the array.
+     * @param newItem The new value for the item.
+     */
+    replaceWhere: (fn: (item: T) => boolean, newItem: T) => ArrayHelpers<T>;
+    /**
+     * Adds a new value to the array at the end.
+     * @param value The value to add to the array.
+     */
+    push: (value: T | T[]) => ArrayHelpers<T>;
+    /**
+     * Inserts a new value at the specified index.
+     * @param index The index at which to insert the value.
+     * @param value The value to insert into the array.
+     */
+    insert: (index: number, value: T) => ArrayHelpers<T>;
+    /**
+     * Inserts a new value at the begining of the array.
+     * @param value The value to insert into the array.
+     */
+    insertFirst: (value: T) => ArrayHelpers<T>;
+    /**
+     * Moves an item from one index to another.
+     * @param from The index of the item to move.
+     * @param to The index to move the item to.
+     */
+    move: (from: number, to: number) => ArrayHelpers<T>;
+    /**
+     * Moves an item up by one index.
+     * @param index The index of the item to move up.
+     */
+    moveUp: (index: number) => ArrayHelpers<T>;
+    /**
+     * Moves an item down by one index.
+     * @param index The index of the item to move down.
+     */
+    moveDown: (index: number) => ArrayHelpers<T>;
+    /**
+     * Swaps the items at the specified indices.
+     * @param a The index of the first item to swap.
+     * @param b The index of the second item to swap.
+     */
+    swap: (a: number, b: number) => ArrayHelpers<T>;
+    /**
+     * Merges the array with the new array.
+     * @param fn The callback function to apply to each item in the array.
+     */
+    merge: (fn: (old: T[]) => T[]) => ArrayHelpers<T>;
+    /**
+     * Removes all falsey values from the array.
+     */
+    compact: () => ArrayHelpers<T>;
+    /**
+     * Sorts the array.
+     * @param fn The callback function to apply to each item in the array.
+     */
+    sort: (fn: (a: T, b: T) => number) => ArrayHelpers<T>;
+    /**
+     * Removes the item at the specified index from the array for the specified path and updates the form values.
+     * @param index The index of the item to remove.
+     */
+    remove: (index: number) => void;
+    /**
+     * Removes all items from the array for the specified path and updates the form values.
+     */
+    removeIf: (fn: (item: T, index: number) => boolean) => ArrayHelpers<T>;
+    /**
+     * Removes all items from the array for the specified path and updates the form values.
+     */
+    clear: () => void;
+    /**
+     * Maps the array for the specified path and updates the form values.
+     * @param fn The callback function to apply to each item in the array.
+     */
+    map: (fn: (item: T, index: number) => T) => ArrayHelpers<T>;
+    /**
+     * Filters the array for the specified path and updates the form values.
+     * @param fn The testing function to apply to each item in the array.
+     */
+    filter: (fn: (item: T, index: number) => boolean) => ArrayHelpers<T>;
+    /**
+     * Finds the index of the first item in the array for the specified path that satisfies the provided testing function.
+     * @param fn The testing function to apply to each item in the array.
+     * @returns The index of the first item in the array for the specified path that satisfies the provided testing function, or -1 if no such item is found.
+     */
+    findIndex: (fn: (item: T) => boolean) => number;
+    /**
+     * Checks if the item at the specified index is the first item in the array.
+     * @param index The index of the item to check.
+     * @returns True if the item is the first item in the array, false otherwise.
+     */
+    isFirst: (index: number) => boolean;
+    /**
+     * Checks if the item at the specified index is the last item in the array.
+     * @param index The index of the item to check.
+     * @returns True if the item is the last item in the array, false otherwise.
+     */
+    isLast: (index: number) => boolean;
+    /**
+     * Returns the first item in the array for the specified path.
+     * @returns The first item in the array for the specified path.
+     */
+    first: () => T;
+    /**
+     * Returns the last item in the array for the specified path.
+     * @returns The last item in the array for the specified path.
+     */
+    last: () => T;
+    /**
+     * Checks if the array for the specified path contains at least one item that satisfies the provided testing function.
+     * @param fn The testing function to apply to each item in the array.
+     * @returns True if the array for the specified path contains at least one item that satisfies the provided testing function, false otherwise.
+     */
+    some: (fn: (item: T, index: number) => boolean) => boolean;
+    /**
+     * Checks if all items in the array for the specified path satisfy the provided testing function.
+     * @param fn The testing function to apply to each item in the array.
+     * @returns True if all items in the array for the specified path satisfy the provided testing function, false otherwise.
+     */
+    every: (fn: (item: T, index: number) => boolean) => boolean;
+};
+export type ArrayHelperProps<T> = {
+    path: Path<T>;
+    formValues: T;
+    setValues: SetValues<T>;
+    computed?: Computed<T>;
+    compute: Compute<T>;
+    getCurrentArrayValue: () => T[];
+};
+export type HandlerArrayHelpers<T> = {
+    /**
+     * Returns the modified form object.
+     * @returns Returns the modified form object.
+     */
+    snapshot: () => T;
+    /**
+     * Returns the array of values for the specified path.
+     * @returns The array of values for the specified path.
+     */
+    get: () => T[];
+    /**
+     * Returns the array of values for the specified path.
+     * @returns The array of values for the specified path.
+     */
+    value: T[];
+    /**
+     * Filters the array for the specified path and updates the form values.
+     * @param fn The testing function to apply to each item in the array.
+     */
+    filter: (fn: (item: T) => boolean) => HandlerArrayHelpers<T>;
+    /**
+     * Removes all items from the array for the specified path and updates the form values.
+     * @param fn The testing function to apply to each item in the array.
+     */
+    removeIf: (fn: (item: T) => boolean) => HandlerArrayHelpers<T>;
+    /**
+     * Maps the array for the specified path and updates the form values.
+     * @param fn The callback function to apply to each item in the array.
+     */
+    map: (fn: (item: T, index: number) => T) => HandlerArrayHelpers<T>;
+};

package/dist/types/array.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/types/field.d.ts

@@ -0,0 +1,61 @@
+export type FieldHelpers<T> = {
+    /**
+     * Retrieves the value of the form field.
+     *
+     * @returns The value of the form field.
+     */
+    get: () => T;
+    /**
+     * Sets the value of the form field.
+     *
+     * @param value - The value to set for the form field.
+     */
+    set: (value: T) => void;
+    /**
+     * Transforms the value of the form field using the provided function.
+     *
+     * @param fn - The function to transform the value of the form field.
+     */
+    transform(fn: (val: T) => unknown): void;
+    /**
+     * Validates a specific form field value using the provided schema. If validation fails,
+     * the error is parsed and set in the form errors. The function is debounced to prevent
+     * excessive validation calls.
+     *
+     * @param name - The name of the form field to validate.
+     * @param inputValue - The value of the form field to be validated.
+     */
+    validate: () => void;
+    /**
+     * Focuses the form field.
+     */
+    focus: () => void;
+    /**
+     * Resets the form field to its default value.
+     */
+    reset: () => void;
+    /**
+     * Retrieves the error of the form field.
+     *
+     * @returns The error of the form field.
+     */
+    error: string;
+    /**
+     * Indicates whether the form field has an error.
+     *
+     * @returns `true` if the form field has an error, `false` otherwise.
+     */
+    hasError: boolean;
+    /**
+     * Indicates whether the form field has been touched.
+     *
+     * @returns `true` if the form field has been touched, `false` otherwise.
+     */
+    isTouched: boolean;
+    /**
+     * Indicates whether the form field has been modified.
+     *
+     * @returns `true` if the form field has been modified, `false` otherwise.
+     */
+    isDirty: boolean;
+};

package/dist/types/field.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/types/group.d.ts

@@ -0,0 +1,16 @@
+import { Path, PathValue } from "./path";
+import { SetValues } from "./utils";
+export type GroupHelpersProps<T> = {
+    path: Path<T>;
+    defaultValues: T;
+    formValues: T;
+    setValues: SetValues<T>;
+    getCurrentValue: () => PathValue<T, Path<T>>;
+    validatePartial: (values: Partial<T>) => Promise<void>;
+};
+export type GroupHelpers<T> = {
+    get: () => T;
+    set: (value: Partial<T>) => void;
+    reset: () => void;
+    validate: () => void;
+};

package/dist/types/group.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/types/path.d.ts

@@ -0,0 +1,8 @@
+type DotPrefix<T extends string> = T extends "" ? "" : `.${T}`;
+type PathImpl<T, D extends number = 5> = D extends 0 ? never : T extends object ? {
+    [K in Extract<keyof T, string>]: T[K] extends Array<infer U> ? `${K}` | `${K}.${number}` | (D extends 1 ? never : `${K}.${number}${DotPrefix<PathImpl<U, Prev[D]>>}`) : `${K}` | (D extends 1 ? never : `${K}${DotPrefix<PathImpl<T[K], Prev[D]>>}`);
+}[Extract<keyof T, string>] : "";
+type Prev = [never, 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10];
+export type Path<T> = PathImpl<T>;
+export type PathValue<T, P extends string | undefined> = string extends P ? unknown : P extends keyof NonNullable<T> ? NonNullable<T>[P] : P extends `${infer Key}.${infer Rest}` ? Key extends keyof NonNullable<T> ? PathValue<NonNullable<T>[Key], Rest> : Key extends `${number}` ? NonNullable<T> extends ReadonlyArray<infer U> ? PathValue<U, Rest> : never : never : P extends `${number}` ? NonNullable<T> extends ReadonlyArray<infer U> ? U : never : never;
+export {};

package/dist/types/path.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/types/pub-sub.d.ts

@@ -0,0 +1,2 @@
+import { Path } from "./path";
+export type ChannelEvent<T> = "validate:before" | "validate:after" | "submit:before" | "submit:after" | "field:mount" | "field:unmount" | "schema:ready" | "settings:ready" | "value:*" | `value:${Path<T>}`;

package/dist/types/pub-sub.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/types/utils.d.ts

@@ -0,0 +1,310 @@
+import type { z, ZodObject } from "zod";
+import { Path, PathValue } from "./path";
+import { ArrayHelpers, ArrayItem, HandlerArrayHelpers } from "./array";
+import { GroupHelpers } from "./group";
+import { FieldHelpers } from "./field";
+import { Field } from "../components";
+import { createFormBus } from "../lib/pub-sub";
+export type FormShape<F> = F extends FormInstance<infer T> ? T : never;
+export type FormValues<TSchema extends z.ZodObject | undefined = undefined, DefaultValues = TSchema extends undefined ? Record<string, any> : Partial<z.infer<TSchema>>> = TSchema extends z.ZodObject<any> ? FormOptions<TSchema, Partial<z.infer<TSchema>>> : FormOptions<TSchema, DefaultValues>;
+export type SchemaType<TSchema, TValues> = TSchema extends ZodObject<any> ? z.infer<TSchema> : TValues;
+export type InputValue = string | undefined;
+export type InputEvent = React.FormEvent<HTMLInputElement | HTMLTextAreaElement | HTMLSelectElement | HTMLButtonElement>;
+export type InputChangeEvent = React.ChangeEvent<HTMLInputElement | HTMLTextAreaElement | HTMLSelectElement | HTMLButtonElement> | React.FormEvent<HTMLButtonElement>;
+type InputMeta = {
+    name?: string;
+    value: string;
+    error?: string;
+    hasError: boolean;
+    onChange: (value: any) => void;
+    internalRef: string;
+};
+export type FieldRegistration = {
+    name: string;
+    id: string;
+    value: string;
+    onChange: (e: InputChangeEvent) => void;
+    onBlur: () => void;
+    "data-input-error": boolean;
+    "data-input-ref": string;
+};
+export type FieldRegistrationOptions<T, P extends Path<T>> = {
+    defaultValue?: PathValue<T, P>;
+    transform?: ((val: PathValue<T, P>) => unknown) | ((val: PathValue<T, P>) => unknown)[];
+    validate?: (value: PathValue<T, P>) => string | undefined;
+};
+export type FieldProps<T, P extends Path<T> = Path<T>> = {
+    id?: string;
+    name: P;
+    label?: string;
+    as?: "checkbox" | "select" | "date";
+    required?: boolean;
+    hideError?: boolean;
+    className?: string;
+    render?: (props: FieldRegistration, meta: InputMeta) => React.ReactNode;
+    children?: (props: FieldRegistration, meta: InputMeta) => React.ReactNode;
+    transform?: ((val: PathValue<T, P>) => unknown) | ((val: PathValue<T, P>) => unknown)[];
+    validate?: (value: PathValue<T, P>) => string | undefined;
+    defaultValue?: PathValue<T, P>;
+};
+export type FieldContextType = {
+    name?: string;
+    label?: string;
+    id?: string;
+    message?: string;
+    required?: boolean;
+    hasError: boolean;
+};
+export type HandlerContext<T> = {
+    setErrors: SetErrors<T>;
+    mapErrors: MapErrors;
+    setValues: SetValues<T>;
+    reset: () => void;
+    focus: (name: Path<T>) => void;
+    array: <P extends Path<T>>(path: P) => HandlerArrayHelpers<ArrayItem<T, P>>;
+};
+export type FormInstance<T> = {
+    /**
+     * Indicates whether the form is currently submitting.
+     */
+    isSubmitting: boolean;
+    /**
+     * Indicates whether the form is validated.
+     */
+    isValidated: boolean;
+    /**
+     * Retrieves the current values of the form.
+     */
+    values: T;
+    /**
+     * Retrieves the errors of the form.
+     */
+    errors: Partial<Record<Path<T>, string>>;
+    /**
+     * Retrieves the current values of the form.
+     */
+    getValues: () => T;
+    /**
+     * Validates the form using the current schema.
+     * @returns void
+     */
+    validate: () => void;
+    /**
+     * Validates a partial set of form field values using the provided schema. If validation fails,
+     * the error is parsed and set in the form errors. The function is debounced to prevent
+     * excessive validation calls.
+     *
+     * @param values - An object containing key-value pairs to validate.
+     */
+    validatePartial: <V extends Path<T>>(values: Record<V, any>) => void;
+    /**
+     * Updates the value of a specific form field. If the form is in uncontrolled mode
+     * or the field name is not provided, the function exits without making changes.
+     *
+     * @param name - The name of the form field to update.
+     * @param value - The new value to set for the specified form field.
+     */
+    setValue: <P extends Path<T>>(name: P, value: PathValue<T, P>) => void;
+    /**
+     * Merges the provided values into the current form values. This function does not
+     * update values in uncontrolled mode.
+     *
+     * @param values - An object containing key-value pairs to update the form with.
+     */
+    setValues: (values: Partial<T>, options?: {
+        overwrite?: boolean;
+    }) => void;
+    /**
+     * Retrieves the value of a single form field.
+     */
+    getValue: <P extends Path<T>>(name: P) => PathValue<T, P>;
+    /**
+     * Updates the form errors with the provided errors. If the form is in uncontrolled mode
+     * or the field name is not provided, the function exits without making changes.
+     *
+     * @param errors - The errors to set for the form.
+     */
+    setErrors: SetErrors<T>;
+    /**
+     * Retrieves the error of a single form field.
+     */
+    getError: <P extends Path<T>>(name: P) => string | undefined;
+    /**
+     * Retrieves the errors of the form.
+     */
+    getErrors: () => Partial<Record<Path<T>, string>>;
+    /**
+     * Clears the form values and errors, and if persistKey is provided, it will
+     * also remove the persisted state from localStorage.
+     */
+    reset: () => void;
+    /**
+     * Resets the value of a specific form field to its default value.
+     *
+     * @param name - The name of the form field to reset.
+     */
+    /**
+     * A utility function to be used as a form's `onSubmit` handler.
+     *
+     * When called, it will validate the form using the current schema, if provided.
+     * If the form is valid, it will call the `onValid` function with the validated form values.
+     * If the form is invalid, it will set the `isValidated` state to `false` and update the `formErrors` state.
+     *
+     * If no schema is provided, it will simply call the `onValid` function with the current `formValues`.
+     *
+     * @param onValid - A function that will be called with the validated form values if the form is valid.
+     * @returns A function that can be used as a form's `onSubmit` handler.
+     */
+    handleSubmit: (onValid: (data: T, ctx: HandlerContext<T>) => void | Promise<void>) => (event: React.FormEvent<HTMLFormElement>) => void | Promise<void>;
+    /**
+     * A utility function to register a form field.
+     *
+     * @param name - The name of the form field to register.
+     * @returns An object containing the form field properties.
+     */
+    register: <P extends Path<T>>(name: P, options?: FieldRegistrationOptions<T, P>) => FieldRegistration;
+    /**
+     * A utility function to access and modify a specific form field.
+     *
+     * @param name - The name of the form field to access.
+     * @returns An object containing field helper functions.
+     */
+    field: <P extends Path<T>>(name: P) => FieldHelpers<PathValue<T, P>>;
+    /**
+     * A utility function to access and modify array fields in the form.
+     *
+     * @param path - The path to the array field in the form values.
+     * @returns An object containing array helper functions.
+     */
+    array: <P extends Path<T>>(path: P) => ArrayHelpers<ArrayItem<T, P>>;
+    /**
+     * A utility function to access and modify group fields in the form.
+     *
+     * @param path - The path to the group field in the form values.
+     * @returns An object containing group helper functions.
+     */
+    group: <P extends Path<T>>(path: P) => GroupHelpers<PathValue<T, P>>;
+    isDirty: (name?: Path<T>) => boolean;
+    focus: (name: Path<T>) => void;
+    /**
+     * A utility function to compute a value based on the form values.
+     *
+     * @param name - The name of the form field to compute.
+     * @param depsOrFn - The dependencies of the form field or a function to compute the value.
+     * @param maybeFn - A function to compute the value.
+     */
+    compute: Compute<T>;
+    /**
+     * Watches specified fields for changes and returns reactive values.
+     *
+     * @param field(s) - The name of the form field(s) to watch
+     * @returns The value(s) of the watched field(s)
+     */
+    watch: WatchFn<T>;
+    /**
+     * Subscribes to changes in the form values.
+     *
+     * @param nameOrCallback - The name/names of the form field/fields to subscribe to or a callback function.
+     * @param callback - A callback function that will be called with the value of the subscribed field.
+     * @returns A function that can be called to unsubscribe from the changes.
+     */
+    subscribe: <P extends Path<T> | undefined = undefined>(nameOrCallback: P | P[] | Subscriber<T, P>, callback?: Subscriber<T, P>) => () => void;
+    /**
+     * Transforms the value of a specific form field using the provided function.
+     *
+     * @param name - The name of the form field to transform.
+     * @param fn - The function to transform the value of the form field.
+     */
+    transform: <P extends Path<T>>(name: P, fn: (val: PathValue<T, P>) => unknown) => void;
+    /**
+     * A utility function to conditionally show or hide a form field.
+     *
+     * @param name - The name of the form field to conditionally show or hide.
+     * @param deps - The dependencies of the form field.
+     * @param fn - The function to conditionally show or hide the form field.
+     */
+    debug: () => {
+        values: T;
+        errors: Record<Path<T>, string>;
+        dirty: Record<Path<T>, boolean>;
+        touched: Record<Path<T>, boolean>;
+        computed: Record<Path<T>, any>;
+        subscriptions: {
+            fields: Record<Path<T>, Subscriber<T, Path<T>>>;
+            errors: Record<Path<T>, Subscriber<T, Path<T>>>;
+        };
+        state: {
+            isSubmitting: boolean;
+            isValidated: boolean;
+        };
+    };
+    Field: typeof Field<T>;
+    channel: ReturnType<typeof createFormBus<T>>["channel"];
+    meta: {
+        get<T = unknown>(key: string): T | undefined;
+        set: (key: string, value: unknown) => void;
+        delete: (key: string) => void;
+        has: (key: string) => boolean;
+        keys: () => MapIterator<string>;
+        values: () => MapIterator<unknown>;
+        clear: () => void;
+    };
+};
+export type SetValues<T> = (values: Partial<T>, options?: {
+    overwrite?: boolean;
+}) => void;
+export type SetErrors<T> = (errors?: Partial<Record<Path<T>, string>> | z.ZodError["issues"]) => void;
+export type FormOptions<TSchema extends ZodObject<any> | undefined, TValues> = {
+    schema?: TSchema;
+    defaultValues?: TValues;
+    errors?: Partial<Record<Path<SchemaType<TSchema, TValues>>, string>>;
+    errorParser?: (message: string) => string;
+    check?: CheckFn<SchemaType<TSchema, TValues>>;
+    computed?: Record<string, Computed<SchemaType<TSchema, TValues>>>;
+    onSubmit?: (values: SchemaType<TSchema, TValues>, ctx: HandlerContext<SchemaType<TSchema, TValues>>) => void;
+    onReady?: (values: SchemaType<TSchema, TValues>) => void;
+    mode?: "controlled" | "uncontrolled";
+    /**
+     * The validation trigger.
+     *
+     * @default "change-submit"
+     */
+    validateOn?: "change" | "blur" | "submit" | "change-submit";
+    /**
+     * Used to register the form so it can be accessed outside the hook.
+     */
+    id?: string;
+    persistKey?: string;
+    autoFocusOnError?: boolean;
+    savedFormFirst?: boolean;
+};
+type CheckFn<T> = (data: T, ctx: {
+    multiPathError: (paths: Path<T>[], message: string) => void;
+    focus: (name: Path<T>) => void;
+}) => Promise<Partial<Record<Path<T>, string>> | void> | Partial<Record<Path<T>, string>> | void;
+type MapErrors = <E extends Record<string, any>>(errObj: E, path?: string) => void;
+export type Compute<T> = <P extends Path<T>>(name: string, depsOrFn: P[] | ((values: T, index: number) => any), maybeFn?: (values: T, index: number) => any) => void;
+export type ComputedField<T> = {
+    deps?: Path<T>[];
+    fn: (values: T, index: number) => any;
+};
+export type Computed<T> = ComputedField<T>;
+export type Subscriber<T, P extends Path<T> | undefined = undefined> = (value: P extends undefined ? T : PathValue<T, P>) => void;
+type WatchFn<T> = {
+    (): T;
+    <P extends Path<T>>(fields: P[]): {
+        [K in P]: PathValue<T, K>;
+    } & Array<PathValue<T, P[number]>>;
+    <P extends Path<T>>(field: P): PathValue<T, P>;
+};
+type ConditionalEffects = {
+    visible?: boolean;
+    clear?: boolean;
+    unregister?: boolean;
+};
+export type ConditionalConfig<T> = {
+    when: (values: T) => boolean;
+    then?: Partial<ConditionalEffects>;
+    else?: Partial<ConditionalEffects>;
+};
+export {};

package/dist/types/utils.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/utils/index.d.ts

@@ -0,0 +1,4 @@
+export { debounce } from "../lib/debounce";
+export { validateForm } from "../lib/validation";
+export { writeDraft, writeDraftImmediate, readDraft, deleteDraft, } from "../lib/drafts-helpter";
+export { cn } from "../lib/utils";

package/dist/utils/index.js

@@ -0,0 +1,14 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.cn = exports.deleteDraft = exports.readDraft = exports.writeDraftImmediate = exports.writeDraft = exports.validateForm = exports.debounce = void 0;
+var debounce_1 = require("../lib/debounce");
+Object.defineProperty(exports, "debounce", { enumerable: true, get: function () { return debounce_1.debounce; } });
+var validation_1 = require("../lib/validation");
+Object.defineProperty(exports, "validateForm", { enumerable: true, get: function () { return validation_1.validateForm; } });
+var drafts_helpter_1 = require("../lib/drafts-helpter");
+Object.defineProperty(exports, "writeDraft", { enumerable: true, get: function () { return drafts_helpter_1.writeDraft; } });
+Object.defineProperty(exports, "writeDraftImmediate", { enumerable: true, get: function () { return drafts_helpter_1.writeDraftImmediate; } });
+Object.defineProperty(exports, "readDraft", { enumerable: true, get: function () { return drafts_helpter_1.readDraft; } });
+Object.defineProperty(exports, "deleteDraft", { enumerable: true, get: function () { return drafts_helpter_1.deleteDraft; } });
+var utils_1 = require("../lib/utils");
+Object.defineProperty(exports, "cn", { enumerable: true, get: function () { return utils_1.cn; } });