@ioca/react 1.4.66 → 1.4.69

package/lib/index.js

@@ -1,9 +1,8 @@
 import { jsxs, jsx, Fragment } from 'react/jsx-runtime';
 import classNames from 'classnames';
 import { debounce, uid, throttle, pick, title } from 'radash';
-import { useMemo, Children, cloneElement, useEffect, createElement, isValidElement, useState, useRef, Fragment as Fragment$1, useTransition, createContext, useContext, useLayoutEffect, useImperativeHandle } from 'react';
-import { SkipPreviousRound, CloseRound, MinusRound, PlusRound, InboxTwotone, FormatBoldRound, FormatItalicRound, FormatUnderlinedRound, StrikethroughSRound, RedoRound, UndoRound, ClearAllRound, PauseRound, PlayArrowRound, StopRound, VolumeOffRound, VolumeDownRound, FullscreenExitRound, FullscreenRound, FeedOutlined, AspectRatioRound, OpenInNewRound, FileDownloadOutlined, RotateRightRound, RotateLeftRound, KeyboardArrowLeftRound, KeyboardArrowRightRound, HideImageTwotone, SyncAltRound, VisibilityRound, VisibilityOffRound, MoreHorizRound, SearchRound, CheckRound, UnfoldMoreRound, CalendarMonthTwotone, AccessTimeRound, InfoOutlined, KeyboardArrowDownRound, ListAltRound, DriveFolderUploadOutlined, PlusSharp } from '@ricons/material';
-import { useReactive, useCreation, useSize, useLocalStorageState } from 'ahooks';
+import { useState, useRef, useEffect, useMemo, Children, cloneElement, createElement, isValidElement, Fragment as Fragment$1, useTransition, createContext, useContext, useLayoutEffect, useImperativeHandle } from 'react';
+import { SkipPreviousRound, CloseRound, MinusRound, PlusRound, InboxTwotone, ClearAllRound, UndoRound, RedoRound, StrikethroughSRound, FormatUnderlinedRound, FormatItalicRound, FormatBoldRound, PlayArrowRound, PauseRound, StopRound, VolumeDownRound, VolumeOffRound, FullscreenRound, FullscreenExitRound, FeedOutlined, AspectRatioRound, OpenInNewRound, FileDownloadOutlined, RotateRightRound, RotateLeftRound, KeyboardArrowLeftRound, KeyboardArrowRightRound, HideImageTwotone, KeyboardDoubleArrowUpRound, SyncAltRound, VisibilityRound, VisibilityOffRound, MoreHorizRound, SearchRound, CheckRound, UnfoldMoreRound, CalendarMonthTwotone, AccessTimeRound, InfoOutlined, KeyboardArrowDownRound, ListAltRound, DriveFolderUploadOutlined, PlusSharp } from '@ricons/material';
 import { createRoot } from 'react-dom/client';
 import { createPortal } from 'react-dom';
 import xss, { escapeAttrValue } from 'xss';
@@ -36,12 +35,12 @@ function triggerRipple(target, e) {
     const [$box, $ripple] = createRipple();
     const rect = target.getBoundingClientRect();
     const size = Math.max(rect.width, rect.height) * 2;
-    $ripple.style.cssText = `
-        left: ${e.pageX - rect.left}px;
-        top: ${e.pageY - rect.top}px;
-        width: ${size}px;
-        height: ${size}px;
-        transition: all ${TIMEOUT / 1000}s;
+    $ripple.style.cssText = `
+        left: ${e.pageX - rect.left}px;
+        top: ${e.pageY - rect.top}px;
+        width: ${size}px;
+        height: ${size}px;
+        transition: all ${TIMEOUT / 1000}s;
     `;
     target.insertAdjacentElement("afterbegin", $box);
     target.offsetHeight;
@@ -71,6 +70,300 @@ const Loading = (props) => {
                 }, children: jsx("circle", { cx: '12', cy: '12', r: '9.5', fill: 'none', strokeWidth: '3', strokeLinecap: 'round', strokeDasharray: 40, strokeDashoffset: 0 }) })), text] }));
 };
 
+const MouseMoveEvents = new Set();
+const MouseUpEvents = new Set();
+const KeydownEvents = new Set();
+let initialized = false;
+const initEvents = () => {
+    if (typeof document === "undefined" || initialized)
+        return;
+    initialized = true;
+    const touchable = "ontouchend" in document;
+    const EVENTS = {
+        MOVE: touchable ? "touchmove" : "mousemove",
+        UP: touchable ? "touchend" : "mouseup",
+        KEYDOWN: "keydown",
+    };
+    document.addEventListener(EVENTS.MOVE, (e) => {
+        for (const listener of MouseMoveEvents.values()) {
+            listener(e);
+        }
+    }, { passive: false });
+    document.addEventListener(EVENTS.UP, (e) => {
+        for (const listener of MouseUpEvents.values()) {
+            listener(e);
+        }
+    });
+    document.addEventListener(EVENTS.KEYDOWN, (e) => {
+        for (const listener of KeydownEvents.values()) {
+            listener(e);
+        }
+    });
+};
+function initEventsOnce() {
+    useEffect(initEvents, []);
+}
+function useMouseMove(listener, options) {
+    initEventsOnce();
+    useEffect(() => {
+        MouseMoveEvents.add(listener);
+        return () => {
+            MouseMoveEvents.delete(listener);
+        };
+    }, []);
+}
+function useMouseUp(listener, options) {
+    initEventsOnce();
+    useEffect(() => {
+        MouseUpEvents.add(listener);
+        return () => {
+            MouseUpEvents.delete(listener);
+        };
+    }, []);
+}
+function useKeydown(listener, options) {
+    initEventsOnce();
+    useEffect(() => {
+        if (options?.disabled)
+            return;
+        KeydownEvents.add(listener);
+        return () => {
+            KeydownEvents.delete(listener);
+        };
+    }, []);
+}
+function useCreation(factory, deps) {
+    return useMemo(factory, deps);
+}
+function useReactive(initialState) {
+    const [, setFlag] = useState(0);
+    const scheduledRef = useRef(false);
+    const proxyCacheRef = useRef(new WeakMap());
+    const rootRef = useRef(null);
+    const proxyRef = useRef(null);
+    const notify = () => {
+        if (scheduledRef.current)
+            return;
+        scheduledRef.current = true;
+        const flush = () => {
+            scheduledRef.current = false;
+            setFlag((n) => n + 1);
+        };
+        if (typeof queueMicrotask !== "undefined") {
+            queueMicrotask(flush);
+            return;
+        }
+        Promise.resolve().then(flush);
+    };
+    const createProxy = (target) => {
+        if (!target || typeof target !== "object")
+            return target;
+        if (!Array.isArray(target)) {
+            const proto = Object.getPrototypeOf(target);
+            const isPlainObject = proto === Object.prototype || proto === null;
+            if (!isPlainObject)
+                return target;
+        }
+        const cached = proxyCacheRef.current.get(target);
+        if (cached)
+            return cached;
+        const proxy = new Proxy(target, {
+            get(t, p, r) {
+                return createProxy(Reflect.get(t, p, r));
+            },
+            set(t, p, v, r) {
+                const prev = Reflect.get(t, p, r);
+                const ok = Reflect.set(t, p, v, r);
+                if (prev !== v)
+                    notify();
+                return ok;
+            },
+            deleteProperty(t, p) {
+                const had = Object.prototype.hasOwnProperty.call(t, p);
+                const ok = Reflect.deleteProperty(t, p);
+                if (had)
+                    notify();
+                return ok;
+            },
+        });
+        proxyCacheRef.current.set(target, proxy);
+        return proxy;
+    };
+    if (!proxyRef.current) {
+        rootRef.current = initialState;
+        proxyRef.current = createProxy(rootRef.current);
+    }
+    return proxyRef.current;
+}
+function useLocalStorageState(key, options) {
+    const { defaultValue, listenStorageChange } = options ?? {};
+    const getDefault = () => {
+        return typeof defaultValue === "function"
+            ? defaultValue()
+            : defaultValue;
+    };
+    const read = () => {
+        if (typeof window === "undefined")
+            return getDefault();
+        const raw = window.localStorage.getItem(key);
+        if (raw === null)
+            return getDefault();
+        try {
+            return JSON.parse(raw);
+        }
+        catch (e) {
+            return raw;
+        }
+    };
+    const [state, setState] = useState(() => read());
+    const set = (value) => {
+        setState((prev) => {
+            const next = typeof value === "function"
+                ? value(prev)
+                : value;
+            if (typeof window !== "undefined") {
+                if (next === undefined) {
+                    window.localStorage.removeItem(key);
+                }
+                else {
+                    window.localStorage.setItem(key, JSON.stringify(next));
+                }
+            }
+            return next;
+        });
+    };
+    useEffect(() => {
+        if (!listenStorageChange)
+            return;
+        if (typeof window === "undefined")
+            return;
+        const onStorage = (e) => {
+            if (e.key !== key)
+                return;
+            if (e.newValue === null) {
+                setState(getDefault());
+                return;
+            }
+            try {
+                setState(JSON.parse(e.newValue));
+            }
+            catch (err) {
+                setState(e.newValue);
+            }
+        };
+        window.addEventListener("storage", onStorage);
+        return () => {
+            window.removeEventListener("storage", onStorage);
+        };
+    }, [key, listenStorageChange]);
+    return [state, set];
+}
+function useSize(target) {
+    const [size, setSize] = useState();
+    useEffect(() => {
+        if (typeof window === "undefined")
+            return;
+        const resolveTarget = () => {
+            if (!target)
+                return null;
+            if (typeof target === "function")
+                return target();
+            if (typeof target === "object" && "current" in target) {
+                return target.current;
+            }
+            return target;
+        };
+        const el = resolveTarget();
+        if (!el)
+            return;
+        const update = () => {
+            const rect = el.getBoundingClientRect();
+            setSize({ width: rect.width, height: rect.height });
+        };
+        update();
+        let ro;
+        if (typeof ResizeObserver !== "undefined") {
+            ro = new ResizeObserver(update);
+            ro.observe(el);
+        }
+        window.addEventListener("resize", update);
+        return () => {
+            window.removeEventListener("resize", update);
+            ro?.disconnect();
+        };
+    }, [target]);
+    return size;
+}
+const defaultObserver = {
+    observe: undefined,
+    unobserve: undefined,
+    disconnect: undefined,
+};
+function useIntersectionObserver(configs) {
+    if (typeof window === "undefined") {
+        return {
+            ...defaultObserver,
+        };
+    }
+    const WM = new WeakMap();
+    const IO = new IntersectionObserver((entries) => {
+        entries.map((entry) => {
+            const callback = WM.get(entry.target);
+            callback?.(entry.target, entry.isIntersecting);
+        });
+    }, configs);
+    function observe(target, callback) {
+        if (WM.get(target))
+            return;
+        WM.set(target, callback);
+        target && IO.observe(target);
+    }
+    function unobserve(target) {
+        target && IO.unobserve(target);
+        WM.delete(target);
+    }
+    function disconnect() {
+        IO.disconnect();
+    }
+    return {
+        observe,
+        unobserve,
+        disconnect,
+    };
+}
+function useResizeObserver() {
+    if (typeof window === "undefined") {
+        return {
+            ...defaultObserver,
+        };
+    }
+    const WM = new WeakMap();
+    const IO = new ResizeObserver((entries) => {
+        entries.map((entry) => {
+            const callback = WM.get(entry.target);
+            callback?.(entry.target);
+        });
+    });
+    function observe(target, callback) {
+        if (WM.get(target))
+            return;
+        target && IO.observe(target);
+        WM.set(target, callback);
+    }
+    function unobserve(target) {
+        target && IO.unobserve(target);
+        WM.delete(target);
+    }
+    function disconnect() {
+        IO.disconnect();
+    }
+    return {
+        observe,
+        unobserve,
+        disconnect,
+    };
+}
+
 const defaultOk$1 = {
     children: "确定",
     className: "bg-error",
@@ -168,7 +461,7 @@ function Toggle(props) {
     }, [active]);
     return (jsx(Button, { ref: ref, className: classNames(className, { [activeClass || ""]: state.active }, "i-btn-toggle"), ...restProps, onClick: handleClick, children: jsx("div", { className: classNames("i-btn-toggle-content", {
                 "i-btn-toggle-active": state.done,
-            }), children: state.active ? after ?? children : children }) }));
+            }), children: state.active ? (after ?? children) : children }) }));
 }
 
 const formatClass = ({ outline, flat, loading, disabled, size = "normal", block, round, square, secondary, className, }) => classNames("i-btn", className, {
@@ -554,7 +847,7 @@ function exitFullScreen() {
 }
 function formatTime(time, options) {
     const result = [];
-    const { zero = true, units = ["", ":", ":"] } = options;
+    const { zero = true, units = ["", ":", ":"] } = options || {};
     const l = units.length;
     let i = 0;
     while (i < l) {
@@ -760,7 +1053,7 @@ function getCellStyle({ justify, col, row, colSpan = 1, rowSpan = 1, }) {
 function Cell(props) {
     const { column, row, col, data, cellEllipsis, onCellClick, onCellDoubleClick, } = props;
     const { id, fixed, justify, rowSpan, render } = column;
-    const style = getCellStyle({ justify, fixed, col, row, rowSpan });
+    const style = getCellStyle({ justify, col, row, rowSpan });
     return (jsx("div", { className: classNames("i-datagrid-cell", {
             [`i-datagrid-cell-fixed-${fixed}`]: fixed,
         }), "data-col": id, style: style, onClick: (e) => onCellClick?.(data, column, row, col, e), onDoubleClick: (e) => onCellDoubleClick?.(data, column, row, col, e), children: render?.(data[id], data, row, col) ?? (jsx("div", { className: classNames("i-datagrid-cell-content", {
@@ -768,138 +1061,6 @@ function Cell(props) {
             }), children: data[id] })) }));
 }
 
-const MouseMoveEvents = new Set();
-const MouseUpEvents = new Set();
-const KeydownEvents = new Set();
-let initialized = false;
-const initEvents = () => {
-    if (!document || initialized)
-        return;
-    initialized = true;
-    const touchable = "ontouchend" in document;
-    const EVENTS = {
-        MOVE: touchable ? "touchmove" : "mousemove",
-        UP: touchable ? "touchend" : "mouseup",
-        KEYDOWN: "keydown",
-    };
-    document.addEventListener(EVENTS.MOVE, (e) => {
-        for (const listener of MouseMoveEvents.values()) {
-            listener(e);
-        }
-    }, { passive: false });
-    document.addEventListener(EVENTS.UP, (e) => {
-        for (const listener of MouseUpEvents.values()) {
-            listener(e);
-        }
-    });
-    document.addEventListener(EVENTS.KEYDOWN, (e) => {
-        for (const listener of KeydownEvents.values()) {
-            listener(e);
-        }
-    });
-};
-function initEventsOnce() {
-    useEffect(initEvents, []);
-}
-function useMouseMove(listener, options) {
-    initEventsOnce();
-    useEffect(() => {
-        MouseMoveEvents.add(listener);
-        return () => {
-            MouseMoveEvents.delete(listener);
-        };
-    }, []);
-}
-function useMouseUp(listener, options) {
-    initEventsOnce();
-    useEffect(() => {
-        MouseUpEvents.add(listener);
-        return () => {
-            MouseUpEvents.delete(listener);
-        };
-    }, []);
-}
-function useKeydown(listener, options) {
-    initEventsOnce();
-    useEffect(() => {
-        if (options?.disabled)
-            return;
-        KeydownEvents.add(listener);
-        return () => {
-            KeydownEvents.delete(listener);
-        };
-    }, []);
-}
-const defaultObserver = {
-    observe: undefined,
-    unobserve: undefined,
-    disconnect: undefined,
-};
-function useIntersectionObserver(configs) {
-    if (typeof window === "undefined") {
-        return {
-            ...defaultObserver,
-        };
-    }
-    const WM = new WeakMap();
-    const IO = new IntersectionObserver((entries) => {
-        entries.map((entry) => {
-            const callback = WM.get(entry.target);
-            callback?.(entry.target, entry.isIntersecting);
-        });
-    }, configs);
-    function observe(target, callback) {
-        if (WM.get(target))
-            return;
-        WM.set(target, callback);
-        target && IO.observe(target);
-    }
-    function unobserve(target) {
-        target && IO.unobserve(target);
-        WM.delete(target);
-    }
-    function disconnect() {
-        IO.disconnect();
-    }
-    return {
-        observe,
-        unobserve,
-        disconnect,
-    };
-}
-function useResizeObserver() {
-    if (typeof window === "undefined") {
-        return {
-            ...defaultObserver,
-        };
-    }
-    const WM = new WeakMap();
-    const IO = new ResizeObserver((entries) => {
-        entries.map((entry) => {
-            const callback = WM.get(entry.target);
-            callback?.(entry.target);
-        });
-    });
-    function observe(target, callback) {
-        if (WM.get(target))
-            return;
-        target && IO.observe(target);
-        WM.set(target, callback);
-    }
-    function unobserve(target) {
-        target && IO.unobserve(target);
-        WM.delete(target);
-    }
-    function disconnect() {
-        IO.disconnect();
-    }
-    return {
-        observe,
-        unobserve,
-        disconnect,
-    };
-}
-
 function Resize(props) {
     const { index, onWidthChange } = props;
     const state = useReactive({
@@ -2678,7 +2839,7 @@ function InputContainer(props) {
 }
 
 const Number$1 = (props) => {
-    const { ref, label, name, value = "", labelInline, step = 1, min = -Infinity, max = Infinity, thousand, precision, type, className, width, status = "normal", append, border, prepend, disabled, message, tip, hideControl, style, onChange, onEnter, onInput, onBlur, ...restProps } = props;
+    const { ref, label, name, value = "", labelInline, step = 1, min = -Infinity, max = Infinity, thousand, precision, type, className, width, status = "normal", append, border, prepend, disabled, message, tip, hideControl, showMax, style, onChange, onEnter, onInput, onBlur, ...restProps } = props;
     const state = useReactive({
         value,
     });
@@ -2687,19 +2848,27 @@ const Number$1 = (props) => {
     const formatInputValue = (v) => {
         if (!v)
             return "";
-        if (typeof v === "number" || !thousand)
+        if (typeof v === "number")
+            return v.toString();
+        if (!thousand)
             return v;
-        return v.replaceAll(thousand, "");
+        return v.split(thousand).join("");
     };
     const handleChange = (e) => {
         const { value } = e.target;
-        const v = formatInputValue(value.replace(/[^\d\.-]/g, ""));
-        state.value = v;
-        onChange?.(+v, e);
+        const v = formatInputValue(value.replace(/[^\d\.-]/g, "")); // 保留负号和小数点
+        const numValue = clamp(+v, min, max); // 确保值在范围内
+        state.value = getFormatNumber(numValue); // 修复 thousand 格式化
+        onChange?.(numValue, e);
     };
     const handleOperate = (param) => {
-        const value = formatInputValue(state.value) ?? 0;
-        const result = getRangeNumber(+value + param);
+        const value = parseFloat(formatInputValue(state.value)) || 0; // 确保值为数字，默认值为 0
+        const result = getRangeNumber(value + param);
+        state.value = getFormatNumber(result);
+        onChange?.(result);
+    };
+    const handleMax = () => {
+        const result = getRangeNumber(max);
         state.value = getFormatNumber(result);
         onChange?.(result);
     };
@@ -2718,7 +2887,7 @@ const Number$1 = (props) => {
     return (jsx(InputContainer, { label: label, labelInline: labelInline, className: className, style: { width, ...style }, tip: message ?? tip, status: status, children: jsxs("div", { className: classNames("i-input-item", {
                 [`i-input-${status}`]: status !== "normal",
                 "i-input-borderless": !border,
-            }), children: [prepend && jsx("div", { className: 'i-input-prepend', children: prepend }), !hideControl && !disabled && (jsx(Helpericon, { active: true, icon: jsx(MinusRound, {}), onClick: () => handleOperate(-step) })), jsx("input", { ...inputProps }), !hideControl && !disabled && (jsx(Helpericon, { active: true, icon: jsx(PlusRound, {}), onClick: () => handleOperate(step) })), append && jsx("div", { className: 'i-input-append', children: append })] }) }));
+            }), children: [prepend && jsx("div", { className: 'i-input-prepend', children: prepend }), !hideControl && !disabled && (jsx(Helpericon, { active: true, icon: jsx(MinusRound, {}), onClick: () => handleOperate(-step) })), jsx("input", { ...inputProps }), !hideControl && !disabled && (jsx(Helpericon, { active: true, icon: jsx(PlusRound, {}), onClick: () => handleOperate(step) })), showMax && max && !disabled && (jsx(Helpericon, { active: true, icon: jsx(KeyboardDoubleArrowUpRound, {}), onClick: handleMax })), append && jsx("div", { className: 'i-input-append', children: append })] }) }));
 };
 
 const Range = (props) => {
@@ -2895,8 +3064,6 @@ const AlignMap = {
     right: "flex-end",
 };
 const GlobalConfig = {
-    align: "center",
-    offset: "12px",
     gap: 12,
 };
 const ItemDefaultConfig = {

package/lib/types/components/button/type.d.ts

@@ -1,4 +1,4 @@
-import { ForwardRefExoticComponent, RefAttributes, ButtonHTMLAttributes, AnchorHTMLAttributes, ReactNode, CSSProperties, RefObject } from 'react';
+import { ForwardRefExoticComponent, RefAttributes, RefObject, ReactNode, ButtonHTMLAttributes, AnchorHTMLAttributes, CSSProperties } from 'react';
 import { LinkProps } from 'react-router';
 import Confirm from './confirm.js';
 import Group from './group.js';

package/lib/types/components/dropdown/dropdown.d.ts

@@ -1,9 +1,9 @@
 import { IDropdown, IDropItem } from './type.js';
-import * as react_jsx_runtime from 'react/jsx-runtime';
 import * as react from 'react';
+import * as react_jsx_runtime from 'react/jsx-runtime';
 
 declare const Dropdown: {
-    (props: IDropdown): string | number | bigint | boolean | Iterable<react.ReactNode> | Promise<string | number | bigint | boolean | react.ReactPortal | react.ReactElement<unknown, string | react.JSXElementConstructor<any>> | Iterable<react.ReactNode>> | react_jsx_runtime.JSX.Element;
+    (props: IDropdown): string | number | bigint | boolean | react_jsx_runtime.JSX.Element | Iterable<react.ReactNode> | Promise<string | number | bigint | boolean | react.ReactPortal | react.ReactElement<unknown, string | react.JSXElementConstructor<any>> | Iterable<react.ReactNode>>;
     Item: (props: IDropItem) => react_jsx_runtime.JSX.Element;
 };
 

package/lib/types/components/input/type.d.ts

@@ -1,4 +1,4 @@
-import { ForwardRefExoticComponent, InputHTMLAttributes, ReactNode, TextareaHTMLAttributes, RefObject, ChangeEvent, MouseEvent } from 'react';
+import { InputHTMLAttributes, ReactNode, ForwardRefExoticComponent, TextareaHTMLAttributes, RefObject, ChangeEvent, MouseEvent } from 'react';
 import { BaseInput } from '../../type/index.js';
 import Number from './number.js';
 import Range from './range.js';
@@ -28,6 +28,7 @@ interface IInputNumber extends BaseInput, Omit<InputHTMLAttributes<HTMLInputElem
     thousand?: string;
     precision?: number;
     hideControl?: boolean;
+    showMax?: boolean;
 }
 interface IInputRange extends Omit<BaseInput, "value" | "onChange">, Omit<InputHTMLAttributes<HTMLInputElement>, "value" | "defaultValue" | "placeholder" | "onChange"> {
     value?: (number | string | undefined)[];

package/lib/types/components/modal/type.d.ts

@@ -1,4 +1,4 @@
-import { FC, HTMLAttributes, ReactNode } from 'react';
+import { HTMLAttributes, ReactNode, FC } from 'react';
 import { IButton } from '../button/type.js';
 import useModal from './useModal.js';
 

package/lib/types/components/radio/type.d.ts

@@ -1,4 +1,4 @@
-import { ReactNode, InputHTMLAttributes, ChangeEvent } from 'react';
+import { InputHTMLAttributes, ReactNode, ChangeEvent } from 'react';
 import { TOption, TStatus } from '../../type/index.js';
 
 type TRenderRadioItem = (checked: boolean, value: any) => ReactNode;

package/lib/types/components/tabs/type.d.ts

@@ -1,4 +1,4 @@
-import { ForwardRefExoticComponent, ReactNode, RefObject, CSSProperties, Ref } from 'react';
+import { ForwardRefExoticComponent, RefObject, ReactNode, Ref, CSSProperties } from 'react';
 import Item from './item.js';
 
 interface ITabItem {

package/lib/types/components/tree/type.d.ts

@@ -1,4 +1,4 @@
-import { RefObject, CSSProperties, ReactNode, MouseEvent, ForwardRefExoticComponent, RefAttributes } from 'react';
+import { ForwardRefExoticComponent, RefAttributes, ReactNode, RefObject, CSSProperties, MouseEvent } from 'react';
 import { LinkProps } from 'react-router';
 
 interface ITreeItem {

package/lib/types/js/usePreview/type.d.ts

@@ -1,4 +1,4 @@
-import { CSSProperties, ReactNode } from 'react';
+import { ReactNode, CSSProperties } from 'react';
 import { IModal } from '../../components/modal/type.js';
 
 type TPreviewItem = {

package/lib/types/js/useTheme/index.d.ts

@@ -1,9 +1,8 @@
-import * as ahooks_lib_createUseStorageState from 'D:\\codes\\ioca-react\\node_modules\\ahooks\\lib\\createUseStorageState\\index.d.ts';
 import { ITheme } from './type.js';
 
 declare const useTheme: (props?: ITheme) => {
     theme: string;
-    setTheme: (value?: ahooks_lib_createUseStorageState.SetState<string>) => void;
+    setTheme: (value: string | ((prev: string) => string)) => void;
 };
 
 export { useTheme as default };