react-hook-toolkit 1.1.0 → 1.1.1

package/LICENSE

@@ -1,6 +1,6 @@
 MIT License
 
-Copyright © 2022 Shivaji Surwase. All rights reserved.
+Copyright © 2025 Shivaji Surwase. All rights reserved.
 
 Permission is hereby granted, free of charge, to any person obtaining a copy
 

package/README.md

@@ -29,6 +29,40 @@ Here's the properly structured documentation with clear purpose explanations:
 
 ------------------------------------------ **Custom Hooks**  ------------------------------------------------
 
+📌 **useBrowser**  
+Provides comprehensive browser control and environment detection with a unified API for navigation, window management, and system interactions.
+
+```ts
+const {
+    currentUrl,
+    currentPath,
+    currentHash,
+    currentSearchParams,
+    goBack,
+    goForward,
+    reload,
+    navigateTo,
+    clearBrowserData,
+    historyState,
+    isOnline,
+    copyCurrentUrl,
+    openNewTab,
+    getFaviconUrl,
+    getPageTitle,
+    setPageTitle,
+    isSecureContext,
+    viewportSize,
+    screenSize,
+    enableFullscreen,
+    disableFullscreen,
+    isFullscreen,
+    printPage,
+    getUserAgent,
+    shareContent,
+    isShareSupported,
+    closeCurrentTab
+  } = useBrowser();
+```
 
 📌 **useAxios**   
 A custom hook for making API requests using Axios. It manages request states (`loading`, `error`, `data`) and provides a function (`makeRequest`) to initiate a request.
@@ -790,6 +824,18 @@ Displays a customizable context menu with support for light/dark themes, keyboar
 </ContextMenu>
 ```
 
+✅ **RichTextEditor**  
+Provides a fully-featured WYSIWYG editor with HTML conversion, customizable toolbar, and responsive design for rich text input.
+
+```tsx
+<RichTextEditor 
+  initialHtml="<p>Initial content</p>"
+  onChange={(html) => console.log(html)}
+  placeholder="Type your text here..."
+  minHeight="300px"
+/>
+```
+
 ---
   ✅ **FilePreview**  
 Displays a styled file card with an icon based on file type, filename with ellipsis handling, file size, and an optional download action.

package/dist/chunk1516/chunk0022.d.ts

@@ -0,0 +1,2 @@
+import { UseBrowserControlsReturn } from "../type";
+export declare const useBrowser: () => UseBrowserControlsReturn;

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/chunk1617/chunk613556.d.ts

@@ -0,0 +1,4 @@
+import 'react-draft-wysiwyg/dist/react-draft-wysiwyg.css';
+import 'draft-js/dist/Draft.css';
+import { RichTextEditorProps } from '../type';
+export declare const RichTextEditor: React.FC<RichTextEditorProps>;

package/dist/chunk1617/chunk613556.js

@@ -0,0 +1,145 @@
+var __assign = (this && this.__assign) || function () {
+    __assign = Object.assign || function(t) {
+        for (var s, i = 1, n = arguments.length; i < n; i++) {
+            s = arguments[i];
+            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))
+                t[p] = s[p];
+        }
+        return t;
+    };
+    return __assign.apply(this, arguments);
+};
+var __rest = (this && this.__rest) || function (s, e) {
+    var t = {};
+    for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p) && e.indexOf(p) < 0)
+        t[p] = s[p];
+    if (s != null && typeof Object.getOwnPropertySymbols === "function")
+        for (var i = 0, p = Object.getOwnPropertySymbols(s); i < p.length; i++) {
+            if (e.indexOf(p[i]) < 0 && Object.prototype.propertyIsEnumerable.call(s, p[i]))
+                t[p[i]] = s[p[i]];
+        }
+    return t;
+};
+import { jsx as _jsx } from "react/jsx-runtime";
+import { useCallback, useEffect, useState, useRef } from 'react';
+import { convertToRaw, EditorState, ContentState } from 'draft-js';
+import { Editor } from 'react-draft-wysiwyg';
+import draftToHtml from 'draftjs-to-html';
+import htmlToDraft from 'html-to-draftjs';
+import 'react-draft-wysiwyg/dist/react-draft-wysiwyg.css';
+import 'draft-js/dist/Draft.css';
+export var RichTextEditor = function (_a) {
+    var _b = _a.initialHtml, initialHtml = _b === void 0 ? '' : _b, onChange = _a.onChange, _c = _a.wrapperClassName, wrapperClassName = _c === void 0 ? 'rich-text-wrapper' : _c, _d = _a.editorClassName, editorClassName = _d === void 0 ? 'rich-text-editor' : _d, _e = _a.toolbarClassName, toolbarClassName = _e === void 0 ? 'rich-text-toolbar' : _e, _f = _a.placeholder, placeholder = _f === void 0 ? 'Comment...' : _f, _g = _a.readOnly, readOnly = _g === void 0 ? false : _g, _h = _a.toolbar, toolbar = _h === void 0 ? undefined : _h, _j = _a.minHeight, minHeight = _j === void 0 ? '200px' : _j, _k = _a.editorStyle, editorStyle = _k === void 0 ? undefined : _k, _l = _a.wrapperStyle, wrapperStyle = _l === void 0 ? undefined : _l, _m = _a.toolbarStyle, toolbarStyle = _m === void 0 ? undefined : _m, restProps = __rest(_a, ["initialHtml", "onChange", "wrapperClassName", "editorClassName", "toolbarClassName", "placeholder", "readOnly", "toolbar", "minHeight", "editorStyle", "wrapperStyle", "toolbarStyle"]);
+    var editorRef = useRef(null);
+    var _o = useState(function () {
+        try {
+            if (initialHtml) {
+                var contentBlock = htmlToDraft(initialHtml);
+                if (contentBlock) {
+                    var contentState = ContentState.createFromBlockArray(contentBlock.contentBlocks, contentBlock.entityMap);
+                    return EditorState.createWithContent(contentState);
+                }
+            }
+        }
+        catch (error) {
+            console.error('Failed to parse initial HTML:', error);
+        }
+        return EditorState.createEmpty();
+    }), editorState = _o[0], setEditorState = _o[1];
+    useEffect(function () {
+        if (initialHtml && editorState.getCurrentContent().hasText() === false) {
+            try {
+                var contentBlock = htmlToDraft(initialHtml);
+                var contentState = ContentState.createFromBlockArray(contentBlock.contentBlocks, contentBlock.entityMap);
+                var newEditorState = EditorState.createWithContent(contentState);
+                var focusedState = EditorState.moveFocusToEnd(newEditorState);
+                setEditorState(focusedState);
+            }
+            catch (error) {
+                console.error('Error setting editor content:', error);
+            }
+        }
+    }, [initialHtml, editorState]);
+    var handleEditorStateChange = useCallback(function (newEditorState) {
+        setEditorState(newEditorState);
+        if (onChange) {
+            var html = draftToHtml(convertToRaw(newEditorState.getCurrentContent()));
+            onChange(html);
+        }
+    }, [onChange]);
+    var defaultToolbar = {
+        options: [
+            'inline',
+            'blockType',
+            'fontSize',
+            'fontFamily',
+            'list',
+            'textAlign',
+            'colorPicker',
+            'link',
+            'embedded',
+            'emoji',
+            'image',
+            'remove',
+            'history',
+        ],
+        inline: {
+            options: ['bold', 'italic', 'underline', 'strikethrough', 'monospace', 'superscript', 'subscript'],
+        },
+        blockType: {
+            inDropdown: true,
+            options: ['Normal', 'H1', 'H2', 'H3', 'H4', 'H5', 'H6', 'Blockquote', 'Code'],
+        },
+        fontSize: {
+            options: [8, 9, 10, 11, 12, 14, 16, 18, 24, 30, 36, 48, 60, 72, 96],
+        },
+        fontFamily: {
+            options: ['Arial', 'Georgia', 'Impact', 'Tahoma', 'Times New Roman', 'Verdana', 'Courier New'],
+        },
+        list: {
+            options: ['unordered', 'ordered'],
+        },
+        textAlign: {
+            options: ['left', 'center', 'right', 'justify'],
+        },
+        link: {
+            defaultTargetOption: '_blank',
+        },
+        image: {
+            uploadCallback: function (file) {
+                return new Promise(function (resolve) {
+                    var reader = new FileReader();
+                    reader.onload = function (e) {
+                        var _a;
+                        var dataUrl = (_a = e.target) === null || _a === void 0 ? void 0 : _a.result;
+                        resolve({ data: { link: dataUrl } });
+                    };
+                    reader.readAsDataURL(file);
+                });
+            },
+            previewImage: true,
+            alt: { present: true, mandatory: false },
+        },
+    };
+    return (_jsx("div", { className: wrapperClassName, style: {
+            border: '1px solid #e0e0e0',
+            borderRadius: '4px',
+            direction: 'ltr',
+        }, children: _jsx(Editor, __assign({ ref: editorRef, editorState: editorState, onEditorStateChange: handleEditorStateChange, wrapperClassName: wrapperClassName, editorClassName: editorClassName, toolbarClassName: toolbarClassName, placeholder: placeholder, readOnly: readOnly, toolbar: toolbar || defaultToolbar, wrapperStyle: wrapperStyle || {
+                padding: '0px',
+                backgroundColor: '#fff',
+                direction: 'ltr',
+            }, editorStyle: editorStyle || {
+                minHeight: minHeight,
+                padding: '10px',
+                lineHeight: '1.0',
+                fontSize: '16px',
+                direction: 'ltr',
+                textAlign: 'left',
+            }, toolbarStyle: toolbarStyle || {
+                marginBottom: '0',
+                borderBottom: '1px solid #e0e0e0',
+                backgroundColor: '#f5f5f5',
+                direction: 'ltr',
+            } }, restProps)) }));
+};

package/dist/index.d.ts

@@ -3,7 +3,9 @@ import { ReactHooksWrapper, getHook, setHook } from "./chunk1415/chunk143";
 import { DynamicLoader, AlertMessage, FilePreview, LabeledValue, DetailsCard, UploadFile, DownloadFile, ContextMenuWrapper } from './chunk1516/chunk613852';
 import { FileSkeleton, TableSkeleton, PieChartSkeleton, CardSkeleton, LineChartSkeleton, FieldSkeleton } from './chunk1617/chunk613555';
 import { useHistoryState, useIdle, useIsFirstRender, useList, useLockBodyScroll, useLongPress, useRecentSearch, useSpeech, usePermission, usePageLeave, useMotion, useHoverDirty, useBeforeUnload, useClickAway, useResponsive, useUnmountedRef } from './chunk1516/chunk726433';
+import { RichTextEditor } from './chunk1617/chunk613556';
+import { useBrowser } from './chunk1516/chunk0022';
 import { useGenericReducer, useArray, useAsync, useAxios, useClipboard, useCookie, useDarkMode, useDebounce, useDebouncedCallback, useDebouncedValue, useDelay, useRequest, useRequestRetry, useForm, useImageLoader, useIndexedDB, useInterval, useKeyPress, useLocalStorage, useMediaQuery, useMousePosition, useOnlineStatus, usePersistedState, usePrevious, useReducedMotion, useResizeObserver, useScrollDirection, useScrollLock, useScrollPosition, useScript, useStepper, useThrottle, useTimeout, useToggle, useVisibilityChange, useWindowSize } from './chunk1516/chunk940514';
 import { createOptimizedContext, useBattery, useCountDown, useCountUp, useCrossFieldValidation, useCss, useDragReorder, useEventListener, useEventListeners, useFieldArray, useFormSubmit, useFormWizard, useGeoLocation, useHistory, useInfiniteScroll, useIsMounted, usePersistedForm, usePreferredLanguage, useSessionStorage, useSmartForm, useSound, useSpeak, useTimer, useTouch, useUndo, useUpdateEffect, useWebSocket } from './chunk1516/chunk0021';
 export default ReactHooksWrapper;
-export { getHook, setHook, useGenericReducer, useArray, useAsync, useAxios, useBattery, useBeforeUnload, useClipboard, useCookie, useClickAway, useCountDown, useCountUp, useCrossFieldValidation, useCss, useDarkMode, useDebounce, useDebouncedCallback, useDebouncedValue, useDelay, useDragReorder, useEventListener, useEventListeners, useRequest, useRequestRetry, useFieldArray, useForm, useFormSubmit, useFormWizard, useGeoLocation, useHoverDirty, useHistory, useHistoryState, useIdle, useImageLoader, useIndexedDB, useInfiniteScroll, useInterval, useIsFirstRender, useIsMounted, useKeyPress, useList, useLocalStorage, useLockBodyScroll, useLongPress, useMotion, useMediaQuery, useMousePosition, useOnlineStatus, usePersistedForm, usePersistedState, usePreferredLanguage, usePrevious, usePermission, usePageLeave, useReducedMotion, useRecentSearch, useResponsive, useResizeObserver, useScript, useScrollDirection, useScrollLock, useScrollPosition, useSessionStorage, useSmartForm, useSound, useSpeech, useSpeak, useStepper, useThrottle, useTimeout, useTimer, useToggle, useTouch, useUnmountedRef, useUndo, useUpdateEffect, useVisibilityChange, useWebSocket, useWindowSize, AlertMessage, CardSkeleton, ContextMenuWrapper, DetailsCard, DownloadFile, DynamicLoader, FieldSkeleton, FilePreview, FileSkeleton, LineChartSkeleton, LabeledValue, PieChartSkeleton, TableSkeleton, UploadFile, createOptimizedContext, };
+export { getHook, setHook, useGenericReducer, useArray, useAsync, useAxios, useBrowser, useBattery, useBeforeUnload, useClipboard, useCookie, useClickAway, useCountDown, useCountUp, useCrossFieldValidation, useCss, useDarkMode, useDebounce, useDebouncedCallback, useDebouncedValue, useDelay, useDragReorder, useEventListener, useEventListeners, useRequest, useRequestRetry, useFieldArray, useForm, useFormSubmit, useFormWizard, useGeoLocation, useHoverDirty, useHistory, useHistoryState, useIdle, useImageLoader, useIndexedDB, useInfiniteScroll, useInterval, useIsFirstRender, useIsMounted, useKeyPress, useList, useLocalStorage, useLockBodyScroll, useLongPress, useMotion, useMediaQuery, useMousePosition, useOnlineStatus, usePersistedForm, usePersistedState, usePreferredLanguage, usePrevious, usePermission, usePageLeave, useReducedMotion, useRecentSearch, useResponsive, useResizeObserver, useScript, useScrollDirection, useScrollLock, useScrollPosition, useSessionStorage, useSmartForm, useSound, useSpeech, useSpeak, useStepper, useThrottle, useTimeout, useTimer, useToggle, useTouch, useUnmountedRef, useUndo, useUpdateEffect, useVisibilityChange, useWebSocket, useWindowSize, AlertMessage, CardSkeleton, ContextMenuWrapper, DetailsCard, DownloadFile, DynamicLoader, FieldSkeleton, FilePreview, FileSkeleton, LineChartSkeleton, LabeledValue, PieChartSkeleton, RichTextEditor, TableSkeleton, UploadFile, createOptimizedContext, };

package/dist/index.js

@@ -3,7 +3,9 @@ import { ReactHooksWrapper, getHook, setHook } from "./chunk1415/chunk143";
 import { DynamicLoader, AlertMessage, FilePreview, LabeledValue, DetailsCard, UploadFile, DownloadFile, ContextMenuWrapper } from './chunk1516/chunk613852';
 import { FileSkeleton, TableSkeleton, PieChartSkeleton, CardSkeleton, LineChartSkeleton, FieldSkeleton } from './chunk1617/chunk613555';
 import { useHistoryState, useIdle, useIsFirstRender, useList, useLockBodyScroll, useLongPress, useRecentSearch, useSpeech, usePermission, usePageLeave, useMotion, useHoverDirty, useBeforeUnload, useClickAway, useResponsive, useUnmountedRef } from './chunk1516/chunk726433';
+import { RichTextEditor } from './chunk1617/chunk613556';
+import { useBrowser } from './chunk1516/chunk0022';
 import { useGenericReducer, useArray, useAsync, useAxios, useClipboard, useCookie, useDarkMode, useDebounce, useDebouncedCallback, useDebouncedValue, useDelay, useRequest, useRequestRetry, useForm, useImageLoader, useIndexedDB, useInterval, useKeyPress, useLocalStorage, useMediaQuery, useMousePosition, useOnlineStatus, usePersistedState, usePrevious, useReducedMotion, useResizeObserver, useScrollDirection, useScrollLock, useScrollPosition, useScript, useStepper, useThrottle, useTimeout, useToggle, useVisibilityChange, useWindowSize, } from './chunk1516/chunk940514';
 import { createOptimizedContext, useBattery, useCountDown, useCountUp, useCrossFieldValidation, useCss, useDragReorder, useEventListener, useEventListeners, useFieldArray, useFormSubmit, useFormWizard, useGeoLocation, useHistory, useInfiniteScroll, useIsMounted, usePersistedForm, usePreferredLanguage, useSessionStorage, useSmartForm, useSound, useSpeak, useTimer, useTouch, useUndo, useUpdateEffect, useWebSocket } from './chunk1516/chunk0021';
 export default ReactHooksWrapper;
-export { getHook, setHook, useGenericReducer, useArray, useAsync, useAxios, useBattery, useBeforeUnload, useClipboard, useCookie, useClickAway, useCountDown, useCountUp, useCrossFieldValidation, useCss, useDarkMode, useDebounce, useDebouncedCallback, useDebouncedValue, useDelay, useDragReorder, useEventListener, useEventListeners, useRequest, useRequestRetry, useFieldArray, useForm, useFormSubmit, useFormWizard, useGeoLocation, useHoverDirty, useHistory, useHistoryState, useIdle, useImageLoader, useIndexedDB, useInfiniteScroll, useInterval, useIsFirstRender, useIsMounted, useKeyPress, useList, useLocalStorage, useLockBodyScroll, useLongPress, useMotion, useMediaQuery, useMousePosition, useOnlineStatus, usePersistedForm, usePersistedState, usePreferredLanguage, usePrevious, usePermission, usePageLeave, useReducedMotion, useRecentSearch, useResponsive, useResizeObserver, useScript, useScrollDirection, useScrollLock, useScrollPosition, useSessionStorage, useSmartForm, useSound, useSpeech, useSpeak, useStepper, useThrottle, useTimeout, useTimer, useToggle, useTouch, useUnmountedRef, useUndo, useUpdateEffect, useVisibilityChange, useWebSocket, useWindowSize, AlertMessage, CardSkeleton, ContextMenuWrapper, DetailsCard, DownloadFile, DynamicLoader, FieldSkeleton, FilePreview, FileSkeleton, LineChartSkeleton, LabeledValue, PieChartSkeleton, TableSkeleton, UploadFile, createOptimizedContext, };
+export { getHook, setHook, useGenericReducer, useArray, useAsync, useAxios, useBrowser, useBattery, useBeforeUnload, useClipboard, useCookie, useClickAway, useCountDown, useCountUp, useCrossFieldValidation, useCss, useDarkMode, useDebounce, useDebouncedCallback, useDebouncedValue, useDelay, useDragReorder, useEventListener, useEventListeners, useRequest, useRequestRetry, useFieldArray, useForm, useFormSubmit, useFormWizard, useGeoLocation, useHoverDirty, useHistory, useHistoryState, useIdle, useImageLoader, useIndexedDB, useInfiniteScroll, useInterval, useIsFirstRender, useIsMounted, useKeyPress, useList, useLocalStorage, useLockBodyScroll, useLongPress, useMotion, useMediaQuery, useMousePosition, useOnlineStatus, usePersistedForm, usePersistedState, usePreferredLanguage, usePrevious, usePermission, usePageLeave, useReducedMotion, useRecentSearch, useResponsive, useResizeObserver, useScript, useScrollDirection, useScrollLock, useScrollPosition, useSessionStorage, useSmartForm, useSound, useSpeech, useSpeak, useStepper, useThrottle, useTimeout, useTimer, useToggle, useTouch, useUnmountedRef, useUndo, useUpdateEffect, useVisibilityChange, useWebSocket, useWindowSize, AlertMessage, CardSkeleton, ContextMenuWrapper, DetailsCard, DownloadFile, DynamicLoader, FieldSkeleton, FilePreview, FileSkeleton, LineChartSkeleton, LabeledValue, PieChartSkeleton, RichTextEditor, TableSkeleton, UploadFile, createOptimizedContext, };

package/dist/type.d.ts

@@ -232,4 +232,65 @@ export declare enum VoiceStatus {
     pause = 2,
     end = 3
 }
+export interface RichTextEditorProps {
+    initialHtml?: string;
+    onChange?: any;
+    wrapperClassName?: string;
+    editorClassName?: string;
+    toolbarClassName?: string;
+    placeholder?: string;
+    readOnly?: boolean;
+    toolbar?: object;
+    minHeight?: string;
+    editorStyle?: object;
+    wrapperStyle?: object;
+    toolbarStyle?: object;
+    restProps?: any;
+}
+export interface BrowserHistoryState {
+    canGoBack: boolean;
+    canGoForward: boolean;
+    historyLength: number;
+}
+export interface BrowserSettings {
+    clearCache: boolean;
+    clearCookies: boolean;
+    clearLocalStorage: boolean;
+    clearSessionStorage: boolean;
+}
+export interface UseBrowserControlsReturn {
+    currentUrl: URL;
+    currentPath: string;
+    currentHash: string;
+    currentSearchParams: URLSearchParams;
+    goBack: () => void;
+    goForward: () => void;
+    reload: (hardReload?: boolean, scrollToTop?: boolean) => void;
+    navigateTo: (url: string | URL, replace?: boolean) => void;
+    clearBrowserData: (settings: Partial<BrowserSettings>) => Promise<void>;
+    historyState: BrowserHistoryState;
+    isOnline: boolean;
+    copyCurrentUrl: () => Promise<void>;
+    openNewTab: (url?: string) => void;
+    getFaviconUrl: (size?: number) => string;
+    getPageTitle: () => string;
+    setPageTitle: (title: string) => void;
+    isSecureContext: boolean;
+    viewportSize: {
+        width: number;
+        height: number;
+    };
+    screenSize: {
+        width: number;
+        height: number;
+    };
+    enableFullscreen: () => Promise<void>;
+    disableFullscreen: () => Promise<void>;
+    isFullscreen: boolean;
+    printPage: () => void;
+    getUserAgent: () => string;
+    shareContent: (data: ShareData) => Promise<void>;
+    isShareSupported: boolean;
+    closeCurrentTab: () => void;
+}
 export {};

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "react-hook-toolkit",
-  "version": "1.1.0",
+  "version": "1.1.1",
   "description": "Ultimate package for React developers, offering a powerful collection of hooks and components to enhance their development experience.",
   "main": "dist/index.js",
   "module": "dist/index.js",
@@ -32,9 +32,13 @@
   ],
   "license": "MIT",
   "devDependencies": {
+    "@types/draft-js": "^0.11.18",
+    "@types/draftjs-to-html": "^0.8.4",
+    "@types/html-to-draftjs": "^1.5.0",
     "@types/node": "^22.13.10",
     "@types/nprogress": "^0.2.3",
     "@types/react": "^18.2.14",
+    "@types/react-draft-wysiwyg": "^1.13.8",
     "tslib": "^2.6.3",
     "typescript": "^5.2.2"
   },
@@ -44,8 +48,12 @@
     "@mui/icons-material": "^7.0.1",
     "@mui/material": "^5.14.0",
     "axios": "^1.7.8",
+    "draft-js": "^0.11.7",
+    "draftjs-to-html": "^0.9.1",
+    "html-to-draftjs": "^1.5.0",
     "nprogress": "^0.2.0",
     "react": "^18.2.0",
+    "react-draft-wysiwyg": "^1.15.0",
     "react-error-boundary": "^4.0.13"
   }
 }