intelicoreact 1.8.68 → 2.0.0

package/dist/Functions/presets/inputMaskPresets.d.ts

@@ -0,0 +1,136 @@
+export namespace MASK_PRESETS {
+    export { BANK_ACCOUNT };
+    export { CC_EXPIRATION_DATE };
+    export { DATE_PRESET };
+    export { ZIP_PRESET };
+    export { SSN_PRESET };
+    export { MOBILE_PHONE_PRESET };
+    export { SHORT_SSN_PRESET };
+    export { ABA_PRESET };
+}
+declare namespace BANK_ACCOUNT {
+    let type: string;
+    let maskPattern: string;
+    let maskPlaceholder: string;
+    let isNumericMobileKeyboard: boolean;
+    let blinkErrors: boolean;
+    let showErrors: boolean;
+}
+declare namespace CC_EXPIRATION_DATE {
+    let type_1: string;
+    export { type_1 as type };
+    let maskPattern_1: string;
+    export { maskPattern_1 as maskPattern };
+    export let maskPatternPlaceholder: string;
+    export let usePatternPlaceholder: boolean;
+    let isNumericMobileKeyboard_1: boolean;
+    export { isNumericMobileKeyboard_1 as isNumericMobileKeyboard };
+    let blinkErrors_1: boolean;
+    export { blinkErrors_1 as blinkErrors };
+    let showErrors_1: boolean;
+    export { showErrors_1 as showErrors };
+    export let focusSelector: string;
+}
+declare namespace DATE_PRESET {
+    let type_2: string;
+    export { type_2 as type };
+    let maskPattern_2: string;
+    export { maskPattern_2 as maskPattern };
+    let maskPatternPlaceholder_1: string;
+    export { maskPatternPlaceholder_1 as maskPatternPlaceholder };
+    let usePatternPlaceholder_1: boolean;
+    export { usePatternPlaceholder_1 as usePatternPlaceholder };
+    let isNumericMobileKeyboard_2: boolean;
+    export { isNumericMobileKeyboard_2 as isNumericMobileKeyboard };
+    let blinkErrors_2: boolean;
+    export { blinkErrors_2 as blinkErrors };
+    let showErrors_2: boolean;
+    export { showErrors_2 as showErrors };
+    export let autocomplete: string;
+    let focusSelector_1: string;
+    export { focusSelector_1 as focusSelector };
+}
+declare namespace ZIP_PRESET {
+    let type_3: string;
+    export { type_3 as type };
+    let focusSelector_2: string;
+    export { focusSelector_2 as focusSelector };
+    let maskPattern_3: string;
+    export { maskPattern_3 as maskPattern };
+    let maskPlaceholder_1: string;
+    export { maskPlaceholder_1 as maskPlaceholder };
+    let isNumericMobileKeyboard_3: boolean;
+    export { isNumericMobileKeyboard_3 as isNumericMobileKeyboard };
+    let blinkErrors_3: boolean;
+    export { blinkErrors_3 as blinkErrors };
+    let showErrors_3: boolean;
+    export { showErrors_3 as showErrors };
+    let autocomplete_1: string;
+    export { autocomplete_1 as autocomplete };
+    export let rules: string;
+}
+declare namespace SSN_PRESET {
+    let type_4: string;
+    export { type_4 as type };
+    let maskPattern_4: string;
+    export { maskPattern_4 as maskPattern };
+    let maskPlaceholder_2: string;
+    export { maskPlaceholder_2 as maskPlaceholder };
+    let focusSelector_3: string;
+    export { focusSelector_3 as focusSelector };
+    let isNumericMobileKeyboard_4: boolean;
+    export { isNumericMobileKeyboard_4 as isNumericMobileKeyboard };
+    let blinkErrors_4: boolean;
+    export { blinkErrors_4 as blinkErrors };
+    let showErrors_4: boolean;
+    export { showErrors_4 as showErrors };
+}
+declare namespace MOBILE_PHONE_PRESET {
+    let type_5: string;
+    export { type_5 as type };
+    let maskPattern_5: string;
+    export { maskPattern_5 as maskPattern };
+    let maskPlaceholder_3: string;
+    export { maskPlaceholder_3 as maskPlaceholder };
+    let focusSelector_4: string;
+    export { focusSelector_4 as focusSelector };
+    let isNumericMobileKeyboard_5: boolean;
+    export { isNumericMobileKeyboard_5 as isNumericMobileKeyboard };
+    let blinkErrors_5: boolean;
+    export { blinkErrors_5 as blinkErrors };
+    let showErrors_5: boolean;
+    export { showErrors_5 as showErrors };
+    let autocomplete_2: string;
+    export { autocomplete_2 as autocomplete };
+}
+declare namespace SHORT_SSN_PRESET {
+    let type_6: string;
+    export { type_6 as type };
+    let maskPattern_6: string;
+    export { maskPattern_6 as maskPattern };
+    let maskPlaceholder_4: string;
+    export { maskPlaceholder_4 as maskPlaceholder };
+    let focusSelector_5: string;
+    export { focusSelector_5 as focusSelector };
+    let isNumericMobileKeyboard_6: boolean;
+    export { isNumericMobileKeyboard_6 as isNumericMobileKeyboard };
+    let blinkErrors_6: boolean;
+    export { blinkErrors_6 as blinkErrors };
+    let showErrors_6: boolean;
+    export { showErrors_6 as showErrors };
+}
+declare namespace ABA_PRESET {
+    let type_7: string;
+    export { type_7 as type };
+    let maskPattern_7: string;
+    export { maskPattern_7 as maskPattern };
+    let maskPlaceholder_5: string;
+    export { maskPlaceholder_5 as maskPlaceholder };
+    let isNumericMobileKeyboard_7: boolean;
+    export { isNumericMobileKeyboard_7 as isNumericMobileKeyboard };
+    let blinkErrors_7: boolean;
+    export { blinkErrors_7 as blinkErrors };
+    let showErrors_7: boolean;
+    export { showErrors_7 as showErrors };
+}
+export {};

package/dist/Functions/presets/inputPresets.d.ts

@@ -0,0 +1,16 @@
+export namespace NAME_SYMBOLS_EXCLUDER {
+    function fieldChangesMiddleware(value: string): string;
+    namespace blurTrim {
+        let trimStart: boolean;
+        let trimEnd: boolean;
+        let characters: string[];
+    }
+}
+export namespace ONLY_STRING_AND_DASH {
+    export function fieldChangesMiddleware_1(value: string): string;
+    export { fieldChangesMiddleware_1 as fieldChangesMiddleware };
+}
+export namespace INPUT_PRESETS {
+    export { NAME_SYMBOLS_EXCLUDER };
+    export { ONLY_STRING_AND_DASH };
+}

package/dist/Functions/presets/mobileKeyboardTypesPresets.d.ts

@@ -0,0 +1,17 @@
+export namespace ALL_KEYBOARD_TYPES {
+    namespace numeric {
+        let inputMode: string;
+    }
+    namespace email {
+        let inputMode_1: string;
+        export { inputMode_1 as inputMode };
+    }
+}
+export namespace NUMERIC_KEYBOARD {
+    import attributesOfNativeInput = ALL_KEYBOARD_TYPES.numeric;
+    export { attributesOfNativeInput };
+}
+export namespace EMAIL_KEYBOARD {
+    import attributesOfNativeInput_1 = ALL_KEYBOARD_TYPES.email;
+    export { attributesOfNativeInput_1 as attributesOfNativeInput };
+}

package/dist/Functions/schemas.d.ts

@@ -0,0 +1,3 @@
+export const forgotSchema: any;
+export const loginSchema: any;
+export const registerSchema: any;

package/dist/Functions/useBodyScrollLock.d.ts

@@ -0,0 +1,2 @@
+export default useBodyScrollLock;
+declare function useBodyScrollLock(isScrollBodyLocked: any): void;

package/dist/Functions/useClickOutside.d.ts

@@ -0,0 +1 @@
+export function useClickOutside(ref: any, setOut: any, open: any): void;

package/dist/Functions/useDebounce.d.ts

@@ -0,0 +1,4 @@
+export function useDebounce({ searchValue, delay }: {
+    searchValue: any;
+    delay: any;
+}): any;

package/dist/Functions/useFieldFocus.d.ts

@@ -0,0 +1,7 @@
+export default function useFieldsFocus({ form, setForm }: {
+    form: any;
+    setForm: any;
+}): {
+    setFocusTo: (key: any) => false | undefined;
+    setFocusToErroredField: () => false | undefined;
+};

package/dist/Functions/useFormTools/form-drivers/ArrayWithObjects.d.ts

@@ -0,0 +1,15 @@
+export default function ArrayWithObjects({ form, setForm, FormFields }: {
+    form: any;
+    setForm: any;
+    FormFields: any;
+}): {
+    joinData: (...args: any[]) => any;
+    getFieldData: (key: any) => any;
+    getFormFields: (argForm?: any) => any;
+    getFormField: (key: any, argForm?: any) => any;
+    setFormFields: (data: any) => void;
+    setFormField: (data: any, key?: null) => void;
+    getFormFieldsAsArray: (fields: any) => any;
+    getFormFieldsKeys: (fields: any) => any;
+    removeAllFormFields: () => void;
+};

package/dist/Functions/useFormTools/form-drivers/ObjectWithIterableObjects.d.ts

@@ -0,0 +1,12 @@
+export default function ObjectWithIterableObjects({ form, setForm, FormFields, }: {
+    form: any;
+    setForm: any;
+    FormFields: any;
+}): {
+    joinData: (...args: any[]) => any;
+    getFieldData: (key: any) => any;
+    getFormFields: () => any;
+    getFormField: (key: any) => any;
+    setFormFields: (data: any) => void;
+    setFormField: (data: any, key?: null) => void;
+};

package/dist/Functions/useFormTools/form-drivers/ObjectWithNamedKeyObjects.d.ts

@@ -0,0 +1,15 @@
+export default function ObjectWithNamedKeyObjects({ form, setForm, FormFields, }?: {
+    setForm?: (() => void) | undefined;
+}): {
+    joinData: (...args: any[]) => any;
+    getFieldData: (key: any) => any;
+    getFormField: (key: any, argForm?: any) => any;
+    setFormFields: (data: any) => void;
+    setFormField: (data: any, key?: null) => void;
+    getFormFields: () => any;
+    getFormFieldsAsArray: () => any;
+    getFormFieldsKeys: () => any;
+    removeAllFormFields: () => void;
+    removeFormField: (key: any) => void;
+    removeFormFields: ([...keys]: Iterable<any, void, undefined>) => void;
+};

package/dist/Functions/useFormTools/functions/General.d.ts

@@ -0,0 +1,15 @@
+export default function General({ form, FormFields }?: {
+    FormFields?: never[] | undefined;
+}): {
+    joinData: (...args: any[]) => any;
+    getFieldData: (key: any) => any;
+    popFormField: (fields: any, key: any) => {
+        item: undefined;
+        itemIndex: undefined;
+    };
+    updateFormField: (fields: any, data: any, key: any) => any;
+    getFormFields: (argForm?: any) => any;
+    getFormFieldsAsArray: (fields: any) => any;
+    getFieldClassName: (key: any, type: any) => string;
+    getFormFieldsKeys: (fields?: any) => any;
+};

package/dist/Functions/useFormTools/functions/RenderFields.d.ts

@@ -0,0 +1,7 @@
+export default function RenderFields({ form, fields, cols, FormDataDriver, RenderFieldComponent, onFieldChange, onFieldBlur, }?: {
+    cols?: number | undefined;
+    FormDataDriver?: (() => null) | undefined;
+    RenderFieldComponent?: (() => null) | undefined;
+    onFieldChange?: (() => null) | undefined;
+    onFieldBlur?: (() => null) | undefined;
+}): any;

package/dist/Functions/useFormTools/functions/usePrevious.d.ts

@@ -0,0 +1,2 @@
+export default usePrevious;
+declare function usePrevious(value: any): undefined;

package/dist/Functions/useFormTools/index.d.ts

@@ -0,0 +1,86 @@
+export default function useFormTools({ form, setForm, FormType, FormFields, FormDataDriverName, FormDataDriver, FocusControllerProps, goToNextFieldOnEnterPressed, }?: {
+    FormDataDriverName?: string | undefined;
+    FormDataDriver?: null | undefined;
+    FocusControllerProps?: {
+        setAutoFocus: boolean;
+        onlyEmptyFieldAutoFocus: boolean;
+    } | undefined;
+    goToNextFieldOnEnterPressed?: boolean | undefined;
+}): {
+    FormDataDrivers: {
+        ArrayWithObjects: {
+            handlers: typeof ArrayWithObjects;
+            default: boolean;
+        };
+        ObjectWithIterableObjects: {
+            handlers: typeof ObjectWithIterableObjects;
+        };
+        ObjectWithNamedKeyObjects: {
+            handlers: typeof ObjectWithNamedKeyObjects;
+        };
+    };
+    addOnChangeObserver: (key: any, cb: any) => null;
+    removeOnChangeObserver: (key: any, id: any) => void;
+    onChangeObservers: {};
+    onFieldChange: (key: any, value: any) => false | undefined;
+    toggleFormSubmitBlock: (key: any, value: any) => void;
+    clearFormSubmitBlockers: () => void;
+    isFormSubmitBlocked: boolean;
+    renderFormFields: never[];
+    setRenderFormFields: (data: any) => void;
+    addRenderFields: (fields: any) => void;
+    removeRenderFields: (fields: any) => void;
+    getFieldClassName: (key: any, type: any) => string;
+    isInitFocused: boolean;
+    setFirstFieldInitFocused: () => void;
+    resetIsInitFocused: () => void;
+    setFieldFocus: ({ key, cb, form: argForm, field }: {
+        key: any;
+        cb?: (() => void) | undefined;
+        form: any;
+        field: any;
+    }) => false | null | undefined;
+    setFieldBlur: ({ key, cb, form: argForm, field }: {
+        key: any;
+        cb?: (() => void) | undefined;
+        form: any;
+        field: any;
+    }) => false | null | undefined;
+    setFirstFieldFocus: () => false | undefined;
+    autoFocusedField: null;
+    addFocusFieldOnRender: (key: any, cb: any) => void;
+    removeFocusFieldOnRender: (key: any) => void;
+    addOnFieldRenderedObserver: (key: any, cb: any, isOnceCallable?: boolean) => null;
+    removeOnFieldRenderedObserver: (key: any, id: any) => void;
+    onFieldRenderedObservers: {};
+    updateFormField: (fields: any, data: any, key: any) => any;
+    addOnFormRenderObserver: (cb: any, { once }?: {
+        once?: boolean | undefined;
+    }) => void;
+    submitIsFormRendered: () => void;
+    resetIsFormRendered: () => void;
+    renderFields: ({ form: argForm, fields: argFields, cols: argCols, RenderFieldComponent, }: {
+        form?: any;
+        fields?: never[] | undefined;
+        cols?: number | undefined;
+        RenderFieldComponent: any;
+    }) => any;
+    scrollToField: ({ key, field, form: argForm }: {
+        key?: null | undefined;
+        field?: null | undefined;
+        form: any;
+    }) => false | undefined;
+    getFieldData: any;
+    getFormField: any;
+    setFormFields: any;
+    setFormField: (data: any, key: any) => any;
+    getFormFieldsAsArray: any;
+    getFormFieldsKeys: any;
+    removeAllFormFields: any;
+    removeFormField: any;
+    removeFormFields: any;
+    addErrorsToForm: (errors: any, argForm?: any) => void;
+};
+import ArrayWithObjects from "./form-drivers/ArrayWithObjects";
+import ObjectWithIterableObjects from "./form-drivers/ObjectWithIterableObjects";
+import ObjectWithNamedKeyObjects from "./form-drivers/ObjectWithNamedKeyObjects";

package/dist/Functions/useInputHighlightError.d.ts

@@ -0,0 +1,12 @@
+export function useInputHighlightError({ value, blinkTime, isUseErrorsBlink, }: {
+    value: any;
+    blinkTime: any;
+    isUseErrorsBlink: any;
+}): {
+    isToHighlightError: boolean;
+    setPreviousValue: React.Dispatch<any>;
+    setIsToHighlightError: React.Dispatch<React.SetStateAction<boolean>>;
+    hasHighlightError: (e: any) => void;
+};
+export default useInputHighlightError;
+import React from "react";

package/dist/Functions/useIsMobile/index.d.ts

@@ -0,0 +1,2 @@
+import useIsMobile from './useIsMobile';
+export default useIsMobile;

package/dist/Functions/useIsMobile/useIsMobile.d.ts

@@ -0,0 +1,18 @@
+interface UseIsMobileProps {
+    isWithoutWidthCheck?: boolean;
+}
+interface UseIsMobileProps {
+    isWithoutWidthCheck?: boolean;
+}
+/**
+ * Hook to detect if the current device is a mobile device
+ * @param props - Configuration options
+ * @param props.isWithoutWidthCheck - If true, only checks user agent without width verification
+ * @returns Object containing isMobile flag
+ */
+declare function useIsMobile({ isWithoutWidthCheck }?: UseIsMobileProps): {
+    isMobile: boolean;
+    isMobilePortrait: boolean;
+    isMobileLandscape: boolean;
+};
+export default useIsMobile;

package/dist/Functions/useKeyPress/useHandleKeyPress.d.ts

@@ -0,0 +1,35 @@
+import type TWithEventManagementAsObj from '../../types/declaration/TWithEventManagementAsObj';
+import type { ISuspendProcessing } from './useKeyPress';
+interface UseHandleKeyPressProps {
+    /** Callback function to be called when Escape key is pressed */
+    escCallback?: () => void;
+    /** Callback function to be called when Enter key is pressed */
+    enterCallback?: () => void;
+    /** Whether to allow key repeat events */
+    withClamping?: boolean;
+    withEventManagementStructure?: TWithEventManagementAsObj<'Modal'>;
+    /** Array of Keys (ev.key) to exclude from processing */
+    suspendProcessing?: null | ISuspendProcessing;
+}
+/**
+ * A hook that handles Enter and Escape key press events
+ *
+ * @param props - Configuration object for key press handling
+ * @param props.escCallback - Function to be called when Escape key is pressed
+ * @param props.enterCallback - Function to be called when Enter key is pressed
+ * @param props.withClamping - Whether to allow key repeat events (default: true)
+ * @param props.withEventManagementStructure - Structure for event management (e.g. Modal)
+ * @param props.suspendProcessing - Optional map of key -> predicate to suspend processing for specific keys
+ *
+ * @example
+ * ```tsx
+ * function Component() {
+ *   useHandleKeyPress({
+ *     escCallback: () => console.log('Esc pressed'),
+ *     enterCallback: () => console.log('Enter pressed'),
+ *   });
+ * }
+ * ```
+ */
+declare function useHandleKeyPress({ escCallback, enterCallback, withClamping, withEventManagementStructure, suspendProcessing, }: UseHandleKeyPressProps): void;
+export default useHandleKeyPress;

package/dist/Functions/useKeyPress/useKeyPress.d.ts

@@ -0,0 +1,12 @@
+/**
+ * A hook that detects when a specific key is pressed
+ * @param targetKey - The key to listen for
+ * @param clamping - Whether to allow key repeat events
+ * @returns boolean indicating if the target key is currently pressed
+ */
+export interface ISuspendProcessing {
+    [key: string]: (event: globalThis.KeyboardEvent) => boolean;
+}
+export declare function isISuspendProcessing(x: unknown): x is ISuspendProcessing;
+declare function useKeyPress(targetKey: string, clamping?: boolean, isForbidden?: boolean, suspendProcessing?: null | ISuspendProcessing): boolean;
+export default useKeyPress;

package/dist/Functions/useLocalStorage.d.ts

@@ -0,0 +1,2 @@
+export default useLocalStorage;
+declare function useLocalStorage(key: any, initialValue: any): any[];

package/dist/Functions/useLocationParams.d.ts

@@ -0,0 +1 @@
+export default function useLocationParams(): {};

package/dist/Functions/useMediaQuery.d.ts

@@ -0,0 +1,2 @@
+export default useMediaQuery;
+declare function useMediaQuery(query: any): boolean;

package/dist/Functions/useMetaInfo.d.ts

@@ -0,0 +1,8 @@
+export function useMetaInfo(): {
+    browser: string;
+    device: string;
+    isiOS: boolean;
+    chromeVersion: null;
+    iOSVersion: null;
+};
+export default useMetaInfo;

package/dist/Functions/useMouseUpOutside.d.ts

@@ -0,0 +1 @@
+export default function useMouseUpOutside(ref: any, setOut: any, open: any): void;

package/dist/Functions/useOnlineStatus.d.ts

@@ -0,0 +1,2 @@
+export default useOnlineStatus;
+declare function useOnlineStatus(): boolean;

package/dist/Functions/usePasswordChecker.d.ts

@@ -0,0 +1,7 @@
+export default function usePasswordChecker({ label }?: {
+    label?: string | undefined;
+}): {
+    addCheckRule: (data: any) => void;
+    testCheckRules: (value: any) => boolean;
+    renderPasswordChecker: () => JSX.Element;
+};

package/dist/Functions/usePrevious.d.ts

@@ -0,0 +1,2 @@
+export default usePrevious;
+declare function usePrevious(value: any): undefined;

package/dist/Functions/useResize.d.ts

@@ -0,0 +1,3 @@
+export function useResize(element: any): {
+    elemPosition: string;
+};

package/dist/Functions/useScrollTo.d.ts

@@ -0,0 +1,2 @@
+export default useScrollTo;
+declare function useScrollTo(reference: any): (import("react").Dispatch<import("react").SetStateAction<boolean>> | import("react").MutableRefObject<any>)[];

package/dist/Functions/useToggle.d.ts

@@ -0,0 +1,7 @@
+export default useToggle;
+declare function useToggle(initialState: any): {
+    isToggled: boolean;
+    toggle: () => void;
+    toggleOn: () => void;
+    toggleOff: () => void;
+};

package/dist/Functions/utils/disableDefaultBehavior/disableDefaultBehavior.d.ts

@@ -0,0 +1,4 @@
+import type { ChangeEvent } from 'react';
+type InputEvent = Event | ChangeEvent<HTMLInputElement>;
+export declare function disableDefaultBehavior(e: InputEvent): void;
+export {};

package/dist/Functions/utils/disableDefaultBehavior/index.d.ts

@@ -0,0 +1 @@
+export { disableDefaultBehavior } from './disableDefaultBehavior';

package/dist/Functions/utils/getLimitedMask/getLimitedMask.d.ts

@@ -0,0 +1,18 @@
+interface GetLimitedMaskParams {
+    mask: string;
+    significantChars: string[];
+    limit: number;
+    isOnlyMask?: boolean;
+}
+interface GetLimitedMaskStats {
+    mask: string;
+    countOfSignificantChars: number;
+    countOfNotSignificantChars: number;
+}
+export declare function getLimitedMask(props: GetLimitedMaskParams & {
+    isOnlyMask?: true;
+}): string;
+export declare function getLimitedMask(props: GetLimitedMaskParams & {
+    isOnlyMask?: false;
+}): GetLimitedMaskStats;
+export {};

package/dist/Functions/utils/getLimitedMask/index.d.ts

@@ -0,0 +1 @@
+export { getLimitedMask } from './getLimitedMask';