@bookjane2/bookjane-design-library 7.2.9 → 7.3.1

package/lib/hooks/useDimensionsRef/index.js

@@ -1,2 +1,2 @@
-export * from './useDimensionsRef.js';
+export * from './useDimensionsRef.js';
 //# sourceMappingURL=index.js.map

package/lib/hooks/useDimensionsRef/useDimensionRef.types.d.ts

@@ -1,9 +1,9 @@
-import { MutableRefObject } from 'react';
-export declare type UseDimensionsRefType<T> = [
-    i0: MutableRefObject<T>,
-    i1: {
-        height: number;
-        width: number;
-    }
-];
+import { MutableRefObject } from 'react';
+export declare type UseDimensionsRefType<T> = [
+    i0: MutableRefObject<T>,
+    i1: {
+        height: number;
+        width: number;
+    }
+];
 //# sourceMappingURL=useDimensionRef.types.d.ts.map

package/lib/hooks/useDimensionsRef/useDimensionRef.types.js

@@ -1,2 +1,2 @@
-export {};
+export {};
 //# sourceMappingURL=useDimensionRef.types.js.map

package/lib/hooks/useDimensionsRef/useDimensionsRef.d.ts

@@ -1,3 +1,3 @@
-import { UseDimensionsRefType } from './useDimensionRef.types.js';
-export declare function useDimensionsRef<T = Element>(): UseDimensionsRefType<T>;
+import { UseDimensionsRefType } from './useDimensionRef.types.js';
+export declare function useDimensionsRef<T = Element>(): UseDimensionsRefType<T>;
 //# sourceMappingURL=useDimensionsRef.d.ts.map

package/lib/hooks/useDimensionsRef/useDimensionsRef.js

@@ -1,27 +1,27 @@
-import { useEffect, useRef, useState } from 'react';
-import ResizeObserver from 'resize-observer-polyfill';
-export function useDimensionsRef() {
-    const [height, setHeight] = useState(0);
-    const [width, setWidth] = useState(0);
-    const ref = useRef(null);
-    useEffect(() => {
-        const currentRef = ref.current;
-        function handleObservableResizeEvent(nodeList) {
-            const _height = nodeList[0]?.contentRect.height || height;
-            const _width = nodeList[0]?.contentRect.width || width;
-            if (_height !== height)
-                setHeight(_height);
-            if (_width !== width)
-                setWidth(_width);
-        }
-        const resizeObserver = new ResizeObserver(handleObservableResizeEvent);
-        if (currentRef)
-            resizeObserver.observe(currentRef);
-        return () => {
-            if (currentRef)
-                resizeObserver.unobserve(currentRef);
-        };
-    }, []); // eslint-disable-line
-    return [ref, { height, width }];
-}
+import { useEffect, useRef, useState } from 'react';
+import ResizeObserver from 'resize-observer-polyfill';
+export function useDimensionsRef() {
+    const [height, setHeight] = useState(0);
+    const [width, setWidth] = useState(0);
+    const ref = useRef(null);
+    useEffect(() => {
+        const currentRef = ref.current;
+        function handleObservableResizeEvent(nodeList) {
+            const _height = nodeList[0]?.contentRect.height || height;
+            const _width = nodeList[0]?.contentRect.width || width;
+            if (_height !== height)
+                setHeight(_height);
+            if (_width !== width)
+                setWidth(_width);
+        }
+        const resizeObserver = new ResizeObserver(handleObservableResizeEvent);
+        if (currentRef)
+            resizeObserver.observe(currentRef);
+        return () => {
+            if (currentRef)
+                resizeObserver.unobserve(currentRef);
+        };
+    }, []); // eslint-disable-line
+    return [ref, { height, width }];
+}
 //# sourceMappingURL=useDimensionsRef.js.map

package/lib/hooks/useFormBehaviors/index.d.ts

@@ -1,3 +1,3 @@
-import { useFormBehaviors } from './useFormBehaviors.js';
-export { useFormBehaviors };
+import { useFormBehaviors } from './useFormBehaviors.js';
+export { useFormBehaviors };
 //# sourceMappingURL=index.d.ts.map

package/lib/hooks/useFormBehaviors/index.js

@@ -1,3 +1,3 @@
-import { useFormBehaviors } from './useFormBehaviors.js';
-export { useFormBehaviors };
+import { useFormBehaviors } from './useFormBehaviors.js';
+export { useFormBehaviors };
 //# sourceMappingURL=index.js.map

package/lib/hooks/useFormBehaviors/useFormBehaviors.constants.d.ts

@@ -1,2 +1,2 @@
-export declare const USEFORMBEHAVIORS_VALIDATION_TIMEOUT = 300;
+export declare const USEFORMBEHAVIORS_VALIDATION_TIMEOUT = 300;
 //# sourceMappingURL=useFormBehaviors.constants.d.ts.map

package/lib/hooks/useFormBehaviors/useFormBehaviors.constants.js

@@ -1,2 +1,2 @@
-export const USEFORMBEHAVIORS_VALIDATION_TIMEOUT = 300;
+export const USEFORMBEHAVIORS_VALIDATION_TIMEOUT = 300;
 //# sourceMappingURL=useFormBehaviors.constants.js.map

package/lib/hooks/useFormBehaviors/useFormBehaviors.d.ts

@@ -1,7 +1,7 @@
-import { UseFormBehaviors, UseFormBehaviors_Options } from './useFormBehaviors.types.js';
-/**
- * BookJane's Form Handler Abstraction
- * @authors [David Zahiri](https://github.com/twistedrc1017)
- */
-export declare function useFormBehaviors<TState, TApiErrors = undefined>(options: UseFormBehaviors_Options<TState>): UseFormBehaviors<TState, TApiErrors>;
+import { UseFormBehaviors, UseFormBehaviors_Options } from './useFormBehaviors.types.js';
+/**
+ * BookJane's Form Handler Abstraction
+ * @authors [David Zahiri](https://github.com/twistedrc1017)
+ */
+export declare function useFormBehaviors<TState, TApiErrors = undefined>(options: UseFormBehaviors_Options<TState>): UseFormBehaviors<TState, TApiErrors>;
 //# sourceMappingURL=useFormBehaviors.d.ts.map

package/lib/hooks/useFormBehaviors/useFormBehaviors.js

@@ -1,199 +1,199 @@
-import { unwrapResult } from '@reduxjs/toolkit';
-import { useCallback, useEffect, useMemo, useRef, useState } from 'react';
-import { unstable_batchedUpdates } from 'react-dom';
-import { isArray, isBKJChangeEventType, isString } from '../../common.types.js';
-import { deepEquals } from '../../utils/deepEquals.js';
-import { USEFORMBEHAVIORS_VALIDATION_TIMEOUT } from './useFormBehaviors.constants.js';
-import { checkForError, getInitFieldErrState } from './useFormBehaviors.utils.js';
-/**
- * BookJane's Form Handler Abstraction
- * @authors [David Zahiri](https://github.com/twistedrc1017)
- */
-export function useFormBehaviors(options) {
-    const { onSubmit, validations = {}, isDirtyCheckEnabled = false, type = 'CREATE', } = options;
-    /* --------------------------------------------------------------------------- */
-    /*                                    STATE                                    */
-    /* --------------------------------------------------------------------------- */
-    const [isSubmitting, setSubmitting] = useState(false);
-    const [values, setValues] = useState(options.initialState);
-    const [fieldErrors, setFieldErrors] = useState(getInitFieldErrState(options.initialState));
-    const [apiErrors, setApiErrors] = useState(null);
-    const [disabled, setDisabled] = useState(false);
-    /* --------------------------------------------------------------------------- */
-    /*                                 MUTABLE REFS                                */
-    /* --------------------------------------------------------------------------- */
-    const debounceRef = useRef(null);
-    const mountedRef = useRef(false);
-    const valuesRef = useRef(values);
-    const dirtyFieldsRef = useRef({});
-    const initialStateRef = useRef(options.initialState);
-    /* --------------------------------------------------------------------------- */
-    /*                            COMPOSITE HELPER VARS                            */
-    /* --------------------------------------------------------------------------- */
-    const hasValidations = useMemo(() => Object.keys(validations).length > 0, [validations]);
-    const hasFieldErrors = useMemo(() => {
-        const fieldErrorValues = Object.values(fieldErrors);
-        return fieldErrorValues.some(checkForError);
-    }, [fieldErrors]);
-    const hasApiErrors = useMemo(() => !!apiErrors, [apiErrors]);
-    const hasErrors = useMemo(() => hasFieldErrors || hasApiErrors, [hasApiErrors, hasFieldErrors]);
-    const isDisabled = useMemo(() => {
-        const hasDirtyFields = Object.keys(dirtyFieldsRef.current).length > 0;
-        switch (type) {
-            // Use deep-equals to prevent submit if user has not changed the old form data
-            case 'EDIT': {
-                if (deepEquals(initialStateRef.current, values))
-                    return true;
-                if (isDirtyCheckEnabled)
-                    return !hasDirtyFields || hasFieldErrors || disabled;
-                return hasFieldErrors || disabled;
-            }
-            case 'CREATE': {
-                if (isDirtyCheckEnabled)
-                    if (!hasDirtyFields || hasFieldErrors || disabled)
-                        return true;
-                return hasFieldErrors || disabled;
-            }
-        }
-    }, [disabled, hasFieldErrors, isDirtyCheckEnabled, type, values]);
-    /* --------------------------------------------------------------------------- */
-    /*                            EVENT HANDLER METHODS                            */
-    /* --------------------------------------------------------------------------- */
-    const applyValidations = useCallback((fn, key, __fieldErrors__) => {
-        const result = fn(valuesRef.current[key], valuesRef.current);
-        if (isArray(result) && result.length === 0)
-            return;
-        if (isString(result) && result === '')
-            return;
-        __fieldErrors__[key] = result;
-    }, []);
-    const handleValidations = useCallback((forceValidations) => {
-        const __fieldErrors__ = getInitFieldErrState(initialStateRef.current);
-        if (hasValidations) {
-            const entries = Object.entries(validations);
-            entries.forEach(([__key__, fn]) => {
-                const func = fn;
-                const key = __key__;
-                if (forceValidations)
-                    applyValidations(func, key, __fieldErrors__);
-                else {
-                    if (isDirtyCheckEnabled && dirtyFieldsRef.current[key])
-                        applyValidations(func, key, __fieldErrors__);
-                    if (!isDirtyCheckEnabled)
-                        applyValidations(func, key, __fieldErrors__);
-                }
-            });
-        }
-        if (mountedRef.current)
-            unstable_batchedUpdates(() => {
-                setFieldErrors(__fieldErrors__);
-                setDisabled(false);
-                setSubmitting(false);
-            });
-        return __fieldErrors__;
-    }, [hasValidations, validations, applyValidations, isDirtyCheckEnabled]);
-    const handleChange = useCallback((event) => {
-        let __values__ = {};
-        if (mountedRef.current)
-            setDisabled(true);
-        if (isArray(event)) {
-            __values__ = { ...values };
-            event.forEach((event) => {
-                const name = event.target.name;
-                __values__[name] = event.target.value;
-                if (!dirtyFieldsRef.current[name])
-                    dirtyFieldsRef.current[name] = true;
-            });
-        }
-        if (!isArray(event) && isBKJChangeEventType(event)) {
-            const name = event.target.name;
-            __values__ = { ...values, [name]: event.target.value };
-            if (!dirtyFieldsRef.current[name])
-                dirtyFieldsRef.current[name] = true;
-        }
-        if (mountedRef.current)
-            setValues(__values__);
-        if (mountedRef.current)
-            setFieldErrors(getInitFieldErrState(initialStateRef.current));
-        if (debounceRef.current)
-            window.clearTimeout(debounceRef.current);
-        const timeout_id = window.setTimeout(() => {
-            // We set the force value to false here
-            // because we don't want to bypass the dirtyFieldCheck condition
-            if (mountedRef.current)
-                handleValidations(false);
-        }, USEFORMBEHAVIORS_VALIDATION_TIMEOUT);
-        debounceRef.current = timeout_id;
-    }, [handleValidations, values]);
-    const handleSubmit = useCallback(async (event) => {
-        event.preventDefault();
-        if (!onSubmit)
-            return void 0;
-        // We set the force value to true here because we want to
-        // force all validations to run regardless of any arguments passed in
-        // and make sure there are none before we attempt to submit
-        const fieldErrorValues = Object.values(fieldErrors);
-        const __hasErrors__ = fieldErrorValues.some(checkForError);
-        if (!__hasErrors__) {
-            if (mountedRef.current)
-                unstable_batchedUpdates(() => {
-                    setApiErrors(null);
-                    setSubmitting(true);
-                    setDisabled(true);
-                });
-            try {
-                const result = await onSubmit(valuesRef.current);
-                if (mountedRef.current)
-                    unstable_batchedUpdates(() => {
-                        setSubmitting(false);
-                        setDisabled(false);
-                    });
-                return unwrapResult(result);
-            }
-            catch (err) {
-                if (mountedRef.current)
-                    unstable_batchedUpdates(() => {
-                        setSubmitting(false);
-                        setDisabled(false);
-                        setApiErrors(err);
-                    });
-            }
-        }
-    }, [fieldErrors, onSubmit]);
-    const handleReset = useCallback((resetValue = options.initialState) => {
-        setValues(resetValue);
-        setFieldErrors(getInitFieldErrState(initialStateRef.current));
-        dirtyFieldsRef.current = {};
-    }, [options.initialState]);
-    const onApiErrorsReset = useCallback(() => setApiErrors(null), []);
-    /* --------------------------------------------------------------------------- */
-    /*                                 SIDE EFFECTS                                */
-    /* --------------------------------------------------------------------------- */
-    useEffect(() => {
-        if (mountedRef.current)
-            valuesRef.current = values;
-    }, [values]);
-    useEffect(() => {
-        mountedRef.current = true;
-        return () => {
-            mountedRef.current = false;
-            if (debounceRef.current)
-                window.clearTimeout(debounceRef.current);
-        };
-    }, []);
-    return {
-        hasFieldErrors,
-        hasApiErrors,
-        hasErrors,
-        apiErrors,
-        fieldErrors,
-        isDisabled,
-        isSubmitting,
-        onChange: handleChange,
-        onReset: handleReset,
-        onApiErrorsReset,
-        onSubmit: handleSubmit,
-        values,
-    };
-}
+import { unwrapResult } from '@reduxjs/toolkit';
+import { useCallback, useEffect, useMemo, useRef, useState } from 'react';
+import { unstable_batchedUpdates } from 'react-dom';
+import { isArray, isBKJChangeEventType, isString } from '../../common.types.js';
+import { deepEquals } from '../../utils/deepEquals.js';
+import { USEFORMBEHAVIORS_VALIDATION_TIMEOUT } from './useFormBehaviors.constants.js';
+import { checkForError, getInitFieldErrState } from './useFormBehaviors.utils.js';
+/**
+ * BookJane's Form Handler Abstraction
+ * @authors [David Zahiri](https://github.com/twistedrc1017)
+ */
+export function useFormBehaviors(options) {
+    const { onSubmit, validations = {}, isDirtyCheckEnabled = false, type = 'CREATE', } = options;
+    /* --------------------------------------------------------------------------- */
+    /*                                    STATE                                    */
+    /* --------------------------------------------------------------------------- */
+    const [isSubmitting, setSubmitting] = useState(false);
+    const [values, setValues] = useState(options.initialState);
+    const [fieldErrors, setFieldErrors] = useState(getInitFieldErrState(options.initialState));
+    const [apiErrors, setApiErrors] = useState(null);
+    const [disabled, setDisabled] = useState(false);
+    /* --------------------------------------------------------------------------- */
+    /*                                 MUTABLE REFS                                */
+    /* --------------------------------------------------------------------------- */
+    const debounceRef = useRef(null);
+    const mountedRef = useRef(false);
+    const valuesRef = useRef(values);
+    const dirtyFieldsRef = useRef({});
+    const initialStateRef = useRef(options.initialState);
+    /* --------------------------------------------------------------------------- */
+    /*                            COMPOSITE HELPER VARS                            */
+    /* --------------------------------------------------------------------------- */
+    const hasValidations = useMemo(() => Object.keys(validations).length > 0, [validations]);
+    const hasFieldErrors = useMemo(() => {
+        const fieldErrorValues = Object.values(fieldErrors);
+        return fieldErrorValues.some(checkForError);
+    }, [fieldErrors]);
+    const hasApiErrors = useMemo(() => !!apiErrors, [apiErrors]);
+    const hasErrors = useMemo(() => hasFieldErrors || hasApiErrors, [hasApiErrors, hasFieldErrors]);
+    const isDisabled = useMemo(() => {
+        const hasDirtyFields = Object.keys(dirtyFieldsRef.current).length > 0;
+        switch (type) {
+            // Use deep-equals to prevent submit if user has not changed the old form data
+            case 'EDIT': {
+                if (deepEquals(initialStateRef.current, values))
+                    return true;
+                if (isDirtyCheckEnabled)
+                    return !hasDirtyFields || hasFieldErrors || disabled;
+                return hasFieldErrors || disabled;
+            }
+            case 'CREATE': {
+                if (isDirtyCheckEnabled)
+                    if (!hasDirtyFields || hasFieldErrors || disabled)
+                        return true;
+                return hasFieldErrors || disabled;
+            }
+        }
+    }, [disabled, hasFieldErrors, isDirtyCheckEnabled, type, values]);
+    /* --------------------------------------------------------------------------- */
+    /*                            EVENT HANDLER METHODS                            */
+    /* --------------------------------------------------------------------------- */
+    const applyValidations = useCallback((fn, key, __fieldErrors__) => {
+        const result = fn(valuesRef.current[key], valuesRef.current);
+        if (isArray(result) && result.length === 0)
+            return;
+        if (isString(result) && result === '')
+            return;
+        __fieldErrors__[key] = result;
+    }, []);
+    const handleValidations = useCallback((forceValidations) => {
+        const __fieldErrors__ = getInitFieldErrState(initialStateRef.current);
+        if (hasValidations) {
+            const entries = Object.entries(validations);
+            entries.forEach(([__key__, fn]) => {
+                const func = fn;
+                const key = __key__;
+                if (forceValidations)
+                    applyValidations(func, key, __fieldErrors__);
+                else {
+                    if (isDirtyCheckEnabled && dirtyFieldsRef.current[key])
+                        applyValidations(func, key, __fieldErrors__);
+                    if (!isDirtyCheckEnabled)
+                        applyValidations(func, key, __fieldErrors__);
+                }
+            });
+        }
+        if (mountedRef.current)
+            unstable_batchedUpdates(() => {
+                setFieldErrors(__fieldErrors__);
+                setDisabled(false);
+                setSubmitting(false);
+            });
+        return __fieldErrors__;
+    }, [hasValidations, validations, applyValidations, isDirtyCheckEnabled]);
+    const handleChange = useCallback((event) => {
+        let __values__ = {};
+        if (mountedRef.current)
+            setDisabled(true);
+        if (isArray(event)) {
+            __values__ = { ...values };
+            event.forEach((event) => {
+                const name = event.target.name;
+                __values__[name] = event.target.value;
+                if (!dirtyFieldsRef.current[name])
+                    dirtyFieldsRef.current[name] = true;
+            });
+        }
+        if (!isArray(event) && isBKJChangeEventType(event)) {
+            const name = event.target.name;
+            __values__ = { ...values, [name]: event.target.value };
+            if (!dirtyFieldsRef.current[name])
+                dirtyFieldsRef.current[name] = true;
+        }
+        if (mountedRef.current)
+            setValues(__values__);
+        if (mountedRef.current)
+            setFieldErrors(getInitFieldErrState(initialStateRef.current));
+        if (debounceRef.current)
+            window.clearTimeout(debounceRef.current);
+        const timeout_id = window.setTimeout(() => {
+            // We set the force value to false here
+            // because we don't want to bypass the dirtyFieldCheck condition
+            if (mountedRef.current)
+                handleValidations(false);
+        }, USEFORMBEHAVIORS_VALIDATION_TIMEOUT);
+        debounceRef.current = timeout_id;
+    }, [handleValidations, values]);
+    const handleSubmit = useCallback(async (event) => {
+        event.preventDefault();
+        if (!onSubmit)
+            return void 0;
+        // We set the force value to true here because we want to
+        // force all validations to run regardless of any arguments passed in
+        // and make sure there are none before we attempt to submit
+        const fieldErrorValues = Object.values(fieldErrors);
+        const __hasErrors__ = fieldErrorValues.some(checkForError);
+        if (!__hasErrors__) {
+            if (mountedRef.current)
+                unstable_batchedUpdates(() => {
+                    setApiErrors(null);
+                    setSubmitting(true);
+                    setDisabled(true);
+                });
+            try {
+                const result = await onSubmit(valuesRef.current);
+                if (mountedRef.current)
+                    unstable_batchedUpdates(() => {
+                        setSubmitting(false);
+                        setDisabled(false);
+                    });
+                return unwrapResult(result);
+            }
+            catch (err) {
+                if (mountedRef.current)
+                    unstable_batchedUpdates(() => {
+                        setSubmitting(false);
+                        setDisabled(false);
+                        setApiErrors(err);
+                    });
+            }
+        }
+    }, [fieldErrors, onSubmit]);
+    const handleReset = useCallback((resetValue = options.initialState) => {
+        setValues(resetValue);
+        setFieldErrors(getInitFieldErrState(initialStateRef.current));
+        dirtyFieldsRef.current = {};
+    }, [options.initialState]);
+    const onApiErrorsReset = useCallback(() => setApiErrors(null), []);
+    /* --------------------------------------------------------------------------- */
+    /*                                 SIDE EFFECTS                                */
+    /* --------------------------------------------------------------------------- */
+    useEffect(() => {
+        if (mountedRef.current)
+            valuesRef.current = values;
+    }, [values]);
+    useEffect(() => {
+        mountedRef.current = true;
+        return () => {
+            mountedRef.current = false;
+            if (debounceRef.current)
+                window.clearTimeout(debounceRef.current);
+        };
+    }, []);
+    return {
+        hasFieldErrors,
+        hasApiErrors,
+        hasErrors,
+        apiErrors,
+        fieldErrors,
+        isDisabled,
+        isSubmitting,
+        onChange: handleChange,
+        onReset: handleReset,
+        onApiErrorsReset,
+        onSubmit: handleSubmit,
+        values,
+    };
+}
 //# sourceMappingURL=useFormBehaviors.js.map

package/lib/hooks/useFormBehaviors/useFormBehaviors.types.d.ts

@@ -1,46 +1,46 @@
-import { ChangeEvent, FormEvent } from 'react';
-import { ChangeFunctionType } from '../../common.types.js';
-export declare type UseFormBehaviors_ErrorMessageType = string | string[] | boolean;
-export declare type UseFormBehaviors_ValidationFnType<TState> = (value: TState[keyof TState], allValues: TState, third?: UseFormBehaviors_ErrorMessageType) => UseFormBehaviors_ErrorMessageType;
-export declare type UseFormBehaviors_ValidationOptionsType<TState extends {}> = {
-    [key in keyof TState]?: UseFormBehaviors_ValidationFnType<TState>;
-};
-export declare type UseFormBehaviors_SubmitFnType<TState> = (e: FormEvent<HTMLFormElement>, values?: TState) => Promise<unknown | void> | void;
-export declare type FormBehaviorsType = 'EDIT' | 'CREATE';
-export declare type UseFormBehaviors_Options<TState> = {
-    type?: FormBehaviorsType;
-    validations?: UseFormBehaviors_ValidationOptionsType<TState>;
-    onSubmit?: (formValues: TState) => any;
-    initialState: TState;
-    isDirtyCheckEnabled?: boolean;
-};
-export interface UseFormBehaviorsOnChangeEventTargetType {
-    value?: string | string[] | number | number[] | boolean | File;
-    name: string;
-    checked?: boolean;
-    isSelected?: boolean;
-    label?: string;
-}
-export interface UseFormBehaviorsEventType extends Partial<Omit<ChangeEvent<HTMLInputElement | HTMLTextAreaElement | HTMLSelectElement>, 'target'>> {
-    target: UseFormBehaviorsOnChangeEventTargetType;
-}
-export declare type UseFormBehaviorsOnChangeFnType = (event: UseFormBehaviorsEventType | UseFormBehaviorsEventType[]) => void;
-export declare type UseFormBehaviors<TState extends {}, APIErrors = unknown> = {
-    apiErrors: APIErrors | null;
-    fieldErrors: {
-        [key in keyof TState]: UseFormBehaviors_ErrorMessageType;
-    };
-    isDisabled: boolean;
-    isSubmitting: boolean;
-    onChange: UseFormBehaviorsOnChangeFnType;
-    onSubmit: UseFormBehaviors_SubmitFnType<TState>;
-    onReset: (values?: TState) => void;
-    onApiErrorsReset: () => void;
-    values: TState;
-    hasFieldErrors: boolean;
-    hasApiErrors: boolean;
-    hasErrors: boolean;
-};
-export declare const isBKJChangeEventType: ChangeFunctionType;
-export declare type UseFormBehaviors_HandleValidationsFnType<TState> = (forceValidations: boolean) => UseFormBehaviors<TState>['fieldErrors'];
+import { ChangeEvent, FormEvent } from 'react';
+import { ChangeFunctionType } from '../../common.types.js';
+export declare type UseFormBehaviors_ErrorMessageType = string | string[] | boolean;
+export declare type UseFormBehaviors_ValidationFnType<TState> = (value: TState[keyof TState], allValues: TState, third?: UseFormBehaviors_ErrorMessageType) => UseFormBehaviors_ErrorMessageType;
+export declare type UseFormBehaviors_ValidationOptionsType<TState extends {}> = {
+    [key in keyof TState]?: UseFormBehaviors_ValidationFnType<TState>;
+};
+export declare type UseFormBehaviors_SubmitFnType<TState> = (e: FormEvent<HTMLFormElement>, values?: TState) => Promise<unknown | void> | void;
+export declare type FormBehaviorsType = 'EDIT' | 'CREATE';
+export declare type UseFormBehaviors_Options<TState> = {
+    type?: FormBehaviorsType;
+    validations?: UseFormBehaviors_ValidationOptionsType<TState>;
+    onSubmit?: (formValues: TState) => any;
+    initialState: TState;
+    isDirtyCheckEnabled?: boolean;
+};
+export interface UseFormBehaviorsOnChangeEventTargetType {
+    value?: string | string[] | number | number[] | boolean | File;
+    name: string;
+    checked?: boolean;
+    isSelected?: boolean;
+    label?: string;
+}
+export interface UseFormBehaviorsEventType extends Partial<Omit<ChangeEvent<HTMLInputElement | HTMLTextAreaElement | HTMLSelectElement>, 'target'>> {
+    target: UseFormBehaviorsOnChangeEventTargetType;
+}
+export declare type UseFormBehaviorsOnChangeFnType = (event: UseFormBehaviorsEventType | UseFormBehaviorsEventType[]) => void;
+export declare type UseFormBehaviors<TState extends {}, APIErrors = unknown> = {
+    apiErrors: APIErrors | null;
+    fieldErrors: {
+        [key in keyof TState]: UseFormBehaviors_ErrorMessageType;
+    };
+    isDisabled: boolean;
+    isSubmitting: boolean;
+    onChange: UseFormBehaviorsOnChangeFnType;
+    onSubmit: UseFormBehaviors_SubmitFnType<TState>;
+    onReset: (values?: TState) => void;
+    onApiErrorsReset: () => void;
+    values: TState;
+    hasFieldErrors: boolean;
+    hasApiErrors: boolean;
+    hasErrors: boolean;
+};
+export declare const isBKJChangeEventType: ChangeFunctionType;
+export declare type UseFormBehaviors_HandleValidationsFnType<TState> = (forceValidations: boolean) => UseFormBehaviors<TState>['fieldErrors'];
 //# sourceMappingURL=useFormBehaviors.types.d.ts.map

package/lib/hooks/useFormBehaviors/useFormBehaviors.types.js

@@ -1,9 +1,9 @@
-export const isBKJChangeEventType = (event) => {
-    if (typeof event !== 'undefined' &&
-        typeof event.target !== 'undefined' &&
-        typeof event.target.name !== 'undefined' &&
-        typeof event.target.value !== 'undefined')
-        return true;
-    return false;
-};
+export const isBKJChangeEventType = (event) => {
+    if (typeof event !== 'undefined' &&
+        typeof event.target !== 'undefined' &&
+        typeof event.target.name !== 'undefined' &&
+        typeof event.target.value !== 'undefined')
+        return true;
+    return false;
+};
 //# sourceMappingURL=useFormBehaviors.types.js.map