react-hook-toolkit 1.0.23 → 1.1.1

package/dist/chunk1516/chunk0022.js

@@ -0,0 +1,381 @@
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+var __generator = (this && this.__generator) || function (thisArg, body) {
+    var _ = { label: 0, sent: function() { if (t[0] & 1) throw t[1]; return t[1]; }, trys: [], ops: [] }, f, y, t, g = Object.create((typeof Iterator === "function" ? Iterator : Object).prototype);
+    return g.next = verb(0), g["throw"] = verb(1), g["return"] = verb(2), typeof Symbol === "function" && (g[Symbol.iterator] = function() { return this; }), g;
+    function verb(n) { return function (v) { return step([n, v]); }; }
+    function step(op) {
+        if (f) throw new TypeError("Generator is already executing.");
+        while (g && (g = 0, op[0] && (_ = 0)), _) try {
+            if (f = 1, y && (t = op[0] & 2 ? y["return"] : op[0] ? y["throw"] || ((t = y["return"]) && t.call(y), 0) : y.next) && !(t = t.call(y, op[1])).done) return t;
+            if (y = 0, t) op = [op[0] & 2, t.value];
+            switch (op[0]) {
+                case 0: case 1: t = op; break;
+                case 4: _.label++; return { value: op[1], done: false };
+                case 5: _.label++; y = op[1]; op = [0]; continue;
+                case 7: op = _.ops.pop(); _.trys.pop(); continue;
+                default:
+                    if (!(t = _.trys, t = t.length > 0 && t[t.length - 1]) && (op[0] === 6 || op[0] === 2)) { _ = 0; continue; }
+                    if (op[0] === 3 && (!t || (op[1] > t[0] && op[1] < t[3]))) { _.label = op[1]; break; }
+                    if (op[0] === 6 && _.label < t[1]) { _.label = t[1]; t = op; break; }
+                    if (t && _.label < t[2]) { _.label = t[2]; _.ops.push(op); break; }
+                    if (t[2]) _.ops.pop();
+                    _.trys.pop(); continue;
+            }
+            op = body.call(thisArg, _);
+        } catch (e) { op = [6, e]; y = 0; } finally { f = t = 0; }
+        if (op[0] & 5) throw op[1]; return { value: op[0] ? op[1] : void 0, done: true };
+    }
+};
+var __spreadArray = (this && this.__spreadArray) || function (to, from, pack) {
+    if (pack || arguments.length === 2) for (var i = 0, l = from.length, ar; i < l; i++) {
+        if (ar || !(i in from)) {
+            if (!ar) ar = Array.prototype.slice.call(from, 0, i);
+            ar[i] = from[i];
+        }
+    }
+    return to.concat(ar || Array.prototype.slice.call(from));
+};
+import { useCallback, useEffect, useState } from "react";
+export var useBrowser = function () {
+    var _a, _b;
+    var _c = useState(new URL(window.location.href)), currentUrl = _c[0], setCurrentUrl = _c[1];
+    var _d = useState({
+        canGoBack: ((_a = window.history.state) === null || _a === void 0 ? void 0 : _a.idx) > 0,
+        canGoForward: ((_b = window.history.state) === null || _b === void 0 ? void 0 : _b.idx) < window.history.length - 1,
+        historyLength: window.history.length,
+    }), historyState = _d[0], setHistoryState = _d[1];
+    var _e = useState(navigator.onLine), isOnline = _e[0], setIsOnline = _e[1];
+    var _f = useState(false), isFullscreen = _f[0], setIsFullscreen = _f[1];
+    var _g = useState({
+        width: window.innerWidth,
+        height: window.innerHeight,
+    }), viewportSize = _g[0], setViewportSize = _g[1];
+    var _h = useState({
+        width: window.screen.width,
+        height: window.screen.height,
+    }), screenSize = _h[0], setScreenSize = _h[1];
+    // Update URL and history state when changes occur
+    var updateState = useCallback(function () {
+        var _a, _b;
+        setCurrentUrl(new URL(window.location.href));
+        setHistoryState({
+            canGoBack: ((_a = window.history.state) === null || _a === void 0 ? void 0 : _a.idx) > 0,
+            canGoForward: ((_b = window.history.state) === null || _b === void 0 ? void 0 : _b.idx) < window.history.length - 1,
+            historyLength: window.history.length,
+        });
+    }, []);
+    // Event listeners setup
+    useEffect(function () {
+        var handlePopState = function () { return updateState(); };
+        var handleOnline = function () { return setIsOnline(true); };
+        var handleOffline = function () { return setIsOnline(false); };
+        var handleResize = function () {
+            setViewportSize({
+                width: window.innerWidth,
+                height: window.innerHeight,
+            });
+            setScreenSize({
+                width: window.screen.width,
+                height: window.screen.height,
+            });
+        };
+        var handleFullscreenChange = function () {
+            setIsFullscreen(!!document.fullscreenElement);
+        };
+        window.addEventListener('popstate', handlePopState);
+        window.addEventListener('online', handleOnline);
+        window.addEventListener('offline', handleOffline);
+        window.addEventListener('resize', handleResize);
+        document.addEventListener('fullscreenchange', handleFullscreenChange);
+        return function () {
+            window.removeEventListener('popstate', handlePopState);
+            window.removeEventListener('online', handleOnline);
+            window.removeEventListener('offline', handleOffline);
+            window.removeEventListener('resize', handleResize);
+            document.removeEventListener('fullscreenchange', handleFullscreenChange);
+        };
+    }, [updateState]);
+    var goBack = useCallback(function () {
+        try {
+            if (historyState.canGoBack) {
+                window.history.back();
+            }
+            else {
+                console.warn('Cannot go back - no history available');
+            }
+        }
+        catch (error) {
+            console.error('Error going back:', error);
+            window.location.href = '/';
+        }
+    }, [historyState.canGoBack]);
+    var goForward = useCallback(function () {
+        try {
+            if (historyState.canGoForward) {
+                window.history.forward();
+            }
+            else {
+                console.warn('Cannot go forward - no history available');
+            }
+        }
+        catch (error) {
+            console.error('Error going forward:', error);
+        }
+    }, [historyState.canGoForward]);
+    var reload = useCallback(function (hardReload, scrollToTop) {
+        if (hardReload === void 0) { hardReload = false; }
+        if (scrollToTop === void 0) { scrollToTop = false; }
+        try {
+            if (scrollToTop) {
+                window.scrollTo(0, 0);
+            }
+            if (hardReload) {
+                window.location.href = window.location.href;
+            }
+            else {
+                window.location.reload();
+            }
+        }
+        catch (error) {
+            console.error('Error reloading page:', error);
+        }
+    }, []);
+    var navigateTo = useCallback(function (url, replace) {
+        if (replace === void 0) { replace = false; }
+        try {
+            var urlObj = typeof url === 'string' ? new URL(url, window.location.origin) : url;
+            if (replace) {
+                window.location.replace(urlObj.href);
+            }
+            else {
+                window.location.href = urlObj.href;
+            }
+        }
+        catch (error) {
+            console.error("Error navigating to ".concat(url, ":"), error);
+        }
+    }, []);
+    var clearBrowserData = useCallback(function () {
+        var args_1 = [];
+        for (var _i = 0; _i < arguments.length; _i++) {
+            args_1[_i] = arguments[_i];
+        }
+        return __awaiter(void 0, __spreadArray([], args_1, true), void 0, function (settings) {
+            var _a, clearCache, _b, clearCookies, _c, clearLocalStorage, _d, clearSessionStorage, cacheKeys, error_1;
+            if (settings === void 0) { settings = {}; }
+            return __generator(this, function (_e) {
+                switch (_e.label) {
+                    case 0:
+                        _a = settings.clearCache, clearCache = _a === void 0 ? false : _a, _b = settings.clearCookies, clearCookies = _b === void 0 ? false : _b, _c = settings.clearLocalStorage, clearLocalStorage = _c === void 0 ? false : _c, _d = settings.clearSessionStorage, clearSessionStorage = _d === void 0 ? false : _d;
+                        _e.label = 1;
+                    case 1:
+                        _e.trys.push([1, 5, , 6]);
+                        if (clearLocalStorage) {
+                            localStorage.clear();
+                        }
+                        if (clearSessionStorage) {
+                            sessionStorage.clear();
+                        }
+                        if (clearCookies) {
+                            document.cookie.split(';').forEach(function (cookie) {
+                                var name = cookie.split('=')[0];
+                                document.cookie = "".concat(name, "=; expires=Thu, 01 Jan 1970 00:00:00 GMT; path=/");
+                            });
+                        }
+                        if (!(clearCache && 'caches' in window)) return [3 /*break*/, 4];
+                        return [4 /*yield*/, caches.keys()];
+                    case 2:
+                        cacheKeys = _e.sent();
+                        return [4 /*yield*/, Promise.all(cacheKeys.map(function (key) { return caches.delete(key); }))];
+                    case 3:
+                        _e.sent();
+                        _e.label = 4;
+                    case 4: return [3 /*break*/, 6];
+                    case 5:
+                        error_1 = _e.sent();
+                        console.error('Error clearing browser data:', error_1);
+                        throw error_1;
+                    case 6: return [2 /*return*/];
+                }
+            });
+        });
+    }, []);
+    var copyCurrentUrl = useCallback(function () { return __awaiter(void 0, void 0, void 0, function () {
+        var error_2, textArea;
+        return __generator(this, function (_a) {
+            switch (_a.label) {
+                case 0:
+                    _a.trys.push([0, 2, , 3]);
+                    return [4 /*yield*/, navigator.clipboard.writeText(window.location.href)];
+                case 1:
+                    _a.sent();
+                    return [3 /*break*/, 3];
+                case 2:
+                    error_2 = _a.sent();
+                    console.error('Error copying URL to clipboard:', error_2);
+                    textArea = document.createElement('textarea');
+                    textArea.value = window.location.href;
+                    document.body.appendChild(textArea);
+                    textArea.select();
+                    document.execCommand('copy');
+                    document.body.removeChild(textArea);
+                    return [3 /*break*/, 3];
+                case 3: return [2 /*return*/];
+            }
+        });
+    }); }, []);
+    var openNewTab = useCallback(function (url) {
+        try {
+            window.open(url || window.location.href, '_blank', 'noopener,noreferrer');
+        }
+        catch (error) {
+            console.error('Error opening new tab:', error);
+        }
+    }, []);
+    var getFaviconUrl = useCallback(function (size) {
+        if (size === void 0) { size = 32; }
+        var url = new URL(window.location.origin);
+        url.pathname = '/favicon.ico';
+        url.searchParams.set('size', size.toString());
+        return url.href;
+    }, []);
+    var getPageTitle = useCallback(function () {
+        return document.title;
+    }, []);
+    var setPageTitle = useCallback(function (title) {
+        document.title = title;
+    }, []);
+    var enableFullscreen = useCallback(function () { return __awaiter(void 0, void 0, void 0, function () {
+        var error_3;
+        return __generator(this, function (_a) {
+            switch (_a.label) {
+                case 0:
+                    _a.trys.push([0, 7, , 8]);
+                    if (!document.documentElement.requestFullscreen) return [3 /*break*/, 2];
+                    return [4 /*yield*/, document.documentElement.requestFullscreen()];
+                case 1:
+                    _a.sent();
+                    return [3 /*break*/, 6];
+                case 2:
+                    if (!document.documentElement.webkitRequestFullscreen) return [3 /*break*/, 4];
+                    return [4 /*yield*/, document.documentElement.webkitRequestFullscreen()];
+                case 3:
+                    _a.sent();
+                    return [3 /*break*/, 6];
+                case 4:
+                    if (!document.documentElement.msRequestFullscreen) return [3 /*break*/, 6];
+                    return [4 /*yield*/, document.documentElement.msRequestFullscreen()];
+                case 5:
+                    _a.sent();
+                    _a.label = 6;
+                case 6: return [3 /*break*/, 8];
+                case 7:
+                    error_3 = _a.sent();
+                    console.error('Error enabling fullscreen:', error_3);
+                    throw error_3;
+                case 8: return [2 /*return*/];
+            }
+        });
+    }); }, []);
+    var disableFullscreen = useCallback(function () { return __awaiter(void 0, void 0, void 0, function () {
+        var error_4;
+        return __generator(this, function (_a) {
+            switch (_a.label) {
+                case 0:
+                    _a.trys.push([0, 7, , 8]);
+                    if (!document.exitFullscreen) return [3 /*break*/, 2];
+                    return [4 /*yield*/, document.exitFullscreen()];
+                case 1:
+                    _a.sent();
+                    return [3 /*break*/, 6];
+                case 2:
+                    if (!document.webkitExitFullscreen) return [3 /*break*/, 4];
+                    return [4 /*yield*/, document.webkitExitFullscreen()];
+                case 3:
+                    _a.sent();
+                    return [3 /*break*/, 6];
+                case 4:
+                    if (!document.msExitFullscreen) return [3 /*break*/, 6];
+                    return [4 /*yield*/, document.msExitFullscreen()];
+                case 5:
+                    _a.sent();
+                    _a.label = 6;
+                case 6: return [3 /*break*/, 8];
+                case 7:
+                    error_4 = _a.sent();
+                    console.error('Error disabling fullscreen:', error_4);
+                    throw error_4;
+                case 8: return [2 /*return*/];
+            }
+        });
+    }); }, []);
+    var printPage = useCallback(function () {
+        window.print();
+    }, []);
+    var getUserAgent = useCallback(function () {
+        return navigator.userAgent;
+    }, []);
+    var shareContent = useCallback(function (data) { return __awaiter(void 0, void 0, void 0, function () {
+        return __generator(this, function (_a) {
+            switch (_a.label) {
+                case 0:
+                    if (!navigator.share) {
+                        throw new Error('Web Share API not supported');
+                    }
+                    return [4 /*yield*/, navigator.share(data)];
+                case 1:
+                    _a.sent();
+                    return [2 /*return*/];
+            }
+        });
+    }); }, []);
+    var closeCurrentTab = useCallback(function () {
+        try {
+            // Note: This will only work if the tab was opened by JavaScript
+            // Browsers typically prevent closing windows/tabs not opened by script
+            window.close();
+        }
+        catch (error) {
+            console.error('Error closing tab:', error);
+            // Fallback: Redirect to about:blank
+            window.location.href = 'about:blank';
+        }
+    }, []);
+    return {
+        currentUrl: currentUrl,
+        currentPath: currentUrl.pathname,
+        currentHash: currentUrl.hash,
+        currentSearchParams: currentUrl.searchParams,
+        goBack: goBack,
+        goForward: goForward,
+        reload: reload,
+        navigateTo: navigateTo,
+        clearBrowserData: clearBrowserData,
+        historyState: historyState,
+        isOnline: isOnline,
+        copyCurrentUrl: copyCurrentUrl,
+        openNewTab: openNewTab,
+        getFaviconUrl: getFaviconUrl,
+        getPageTitle: getPageTitle,
+        setPageTitle: setPageTitle,
+        isSecureContext: window.isSecureContext,
+        viewportSize: viewportSize,
+        screenSize: screenSize,
+        enableFullscreen: enableFullscreen,
+        disableFullscreen: disableFullscreen,
+        isFullscreen: isFullscreen,
+        printPage: printPage,
+        getUserAgent: getUserAgent,
+        shareContent: shareContent,
+        isShareSupported: 'share' in navigator,
+        closeCurrentTab: closeCurrentTab,
+    };
+};

package/dist/chunk1516/chunk613852.d.ts

@@ -1,70 +1,10 @@
 import React, { FC } from 'react';
+import { FileComponentProps, AlertPropsType, DetailsCardProps, UploadButtonProps, DownloadFileProps, ContextMenuProps } from '../type';
 export declare const DynamicLoader: (Component: any) => (props: any) => import("react/jsx-runtime").JSX.Element;
-interface PropsType {
-    type: string;
-    msg: string;
-    duration?: number;
-}
-export declare const AlertMessage: FC<PropsType>;
-interface DetailsCardProps {
-    isLoading?: boolean;
-    title: string;
-    details: any[];
-    spacing?: number;
-    boxShadow?: string;
-    background?: string;
-    loaderType?: 'skeleton' | 'circular';
-    displayType?: 'flex' | 'block';
-}
+export declare const AlertMessage: FC<AlertPropsType>;
 export declare const DetailsCard: ({ isLoading, title, details, spacing, boxShadow, background, loaderType, displayType, }: DetailsCardProps) => import("react/jsx-runtime").JSX.Element;
 export declare const LabeledValue: ({ label, value, style }: any) => import("react/jsx-runtime").JSX.Element;
-interface FileComponentProps {
-    primaryKey: string | number;
-    filename: string;
-    size: string | number;
-    onDownload?: any;
-    width?: number;
-    borderColor?: string;
-    fileColor?: 'inherit' | 'primary' | 'secondary' | 'error' | 'disabled' | 'action';
-    isDownloading: boolean;
-}
 export declare const FilePreview: ({ primaryKey, filename, size, onDownload, width, borderColor, fileColor, isDownloading, }: FileComponentProps) => import("react/jsx-runtime").JSX.Element;
-interface UploadButtonProps {
-    isUpload?: boolean;
-    color?: 'inherit' | 'primary' | 'secondary' | 'success' | 'error' | 'info' | 'warning';
-    state?: {
-        isUploaded?: boolean;
-        isUploadError?: boolean;
-        isLoadingUpload?: boolean;
-    };
-    onFileSelect: (file: File) => void;
-}
 export declare const UploadFile: React.FC<UploadButtonProps>;
-interface DownloadButtonState {
-    isDownloaded?: boolean;
-    isDownloadError?: boolean;
-    isLoadingDownload?: boolean;
-}
-interface DownloadFileProps {
-    isDownload?: boolean;
-    color?: 'inherit' | 'primary' | 'secondary' | 'success' | 'error' | 'info' | 'warning';
-    state?: DownloadButtonState;
-    onDownload: () => void;
-}
 export declare const DownloadFile: React.FC<DownloadFileProps>;
-type MenuPosition = 'auto' | 'fixed';
-type ThemeMode = 'light' | 'dark';
-interface ContextMenuProps {
-    options: any;
-    children: React.ReactNode;
-    disabled?: boolean;
-    className?: string;
-    menuClassName?: string;
-    position?: MenuPosition;
-    onShow?: () => void;
-    onHide?: () => void;
-    currentInstance?: any;
-    theme?: ThemeMode;
-}
 export declare const ContextMenuWrapper: React.FC<ContextMenuProps>;
-export {};

package/dist/chunk1516/chunk726433.d.ts

@@ -1,3 +1,5 @@
+import { RefObject } from "react";
+import { UseRecentSearchOptions, ISpeechOptions, ISpeechState, MotionSensorState, IPermissionDescriptor, IState } from "../type";
 export declare function useHistoryState<T>(initialPresent: T): {
     state: T;
     set: (newPresent: T) => void;
@@ -37,16 +39,20 @@ export declare function useLongPress(callback: (event: Event) => void, options?:
     onTouchStart: any;
     onTouchEnd: any;
 };
-type UseRecentSearchOptions = {
-    key?: string;
-    limit?: number;
-    uniqueKey?: string;
-    excludeEmpty?: boolean;
-};
 export declare const useRecentSearch: (options?: UseRecentSearchOptions) => {
     recentSearches: any;
     addSearch: (item: any) => void;
     clearSearch: () => void;
     hasSearch: (value: string) => any;
 };
+export declare const useUnmountedRef: () => import("react").MutableRefObject<boolean>;
+export declare function configResponsive(config: any): void;
+export declare const useResponsive: () => any;
+export declare const useClickAway: <E extends Event = Event>(ref: RefObject<HTMLElement | null>, onClickAway: (event: E) => void, events?: string[]) => void;
+export declare const useBeforeUnload: (enabled?: boolean | (() => boolean), message?: string) => void;
+export declare const useHoverDirty: (ref: RefObject<Element>, enabled?: boolean) => boolean;
+export declare const useMotion: (initialState?: MotionSensorState) => MotionSensorState;
+export declare const usePageLeave: (onPageLeave: any, args?: never[]) => void;
+export declare const usePermission: (permissionDesc: IPermissionDescriptor) => IState;
+export declare const useSpeech: (text: string, options: ISpeechOptions) => ISpeechState;
 export {};