deepsea-components 5.16.4 → 5.16.6

package/dist/components/DraggableGrid.d.ts

@@ -25,6 +25,30 @@ export interface DraggableGridItemStatus {
 export type DraggableGridKeyToOrder<K extends Key> = Map<K, number>;
 /** 次序到元素的 key 的映射 */
 export type DraggableGridOrderToKey<K extends Key> = Map<number, K>;
+export type DraggableGridPropsCore<T, K extends Key = T extends Key ? T : never> = {
+    /** 数据源 */
+    items?: T[];
+    /** 元素的 key 到次序的映射 */
+    orderMap?: DraggableGridKeyToOrder<K>;
+    /** 次序变化时回调 */
+    onOrderMapChange?: (orderMap: DraggableGridKeyToOrder<K>) => void;
+    /** 禁用的元素 */
+    isItemDisabled?: K[] | ((item: T, key: K) => boolean);
+    /** 触发移动的元素 */
+    handle?: string | HTMLElement | ((item: T, key: K, element: HTMLDivElement) => HTMLElement | undefined | null) | undefined | null;
+} & (MustBeReactNode<T> extends true ? {
+    /** 渲染函数，当 T 为 ReactNode 时，render 为可选 */
+    render?: (item: T, status: DraggableGridItemStatus) => ReactNode;
+} : {
+    /** 渲染函数，当 T 为 ReactNode 时，render 为可选 */
+    render: (item: T, status: DraggableGridItemStatus) => ReactNode;
+}) & (MustBeReactKey<T> extends true ? {
+    /** 获取 key 的函数，当 T 为 Key 时，keyExtractor 为可选 */
+    keyExtractor?: (item: T) => K;
+} : {
+    /** 获取 key 的函数，当 T 为 Key 时，keyExtractor 为可选 */
+    keyExtractor: (item: T) => K;
+});
 export type DraggableGridProps<T, K extends Key = T extends Key ? T : never> = Omit<ComponentProps<"div">, "className" | "children"> & DragMoveEvents<HTMLDivElement> & {
     /** 类名 */
     className?: DraggableGridClassName;
@@ -32,8 +56,6 @@ export type DraggableGridProps<T, K extends Key = T extends Key ? T : never> = O
     classNames?: DraggableGridClassNames;
     /** 样式 */
     style?: DraggableGridStyle;
-    /** 数据源 */
-    items?: T[];
     /** 是否禁用拖拽 */
     disabled?: boolean;
     /** 列数 */
@@ -59,29 +81,9 @@ export type DraggableGridProps<T, K extends Key = T extends Key ? T : never> = O
     itemWidth: number;
     /** 元素高度 */
     itemHeight: number;
-    /** 元素的 key 到次序的映射 */
-    orderMap?: DraggableGridKeyToOrder<K>;
-    /** 次序变化时回调 */
-    onOrderMapChange?: (orderMap: DraggableGridKeyToOrder<K>) => void;
-    /** 禁用的元素 */
-    isItemDisabled?: K[] | ((item: T, key: K) => boolean);
     /** 禁用的次序 */
     isOrderDisabled?: number[] | ((order: number) => boolean);
     /** 次序的优先级，可以通过此函数调整元素的优先放置的方向，左上，右上，左下，右下，中心，顺时针，逆时针等等 */
     orderPriority?: (a: number, b: number) => number;
-    /** 触发移动的元素 */
-    handle?: string | HTMLElement | ((item: T, key: K, element: HTMLDivElement) => HTMLElement | undefined | null) | undefined | null;
-} & (MustBeReactNode<T> extends true ? {
-    /** 渲染函数，当 T 为 ReactNode 时，render 为可选 */
-    render?: (item: T, status: DraggableGridItemStatus) => ReactNode;
-} : {
-    /** 渲染函数，当 T 为 ReactNode 时，render 为可选 */
-    render: (item: T, status: DraggableGridItemStatus) => ReactNode;
-}) & (MustBeReactKey<T> extends true ? {
-    /** 获取 key 的函数，当 T 为 Key 时，keyExtractor 为可选 */
-    keyExtractor?: (item: T) => K;
-} : {
-    /** 获取 key 的函数，当 T 为 Key 时，keyExtractor 为可选 */
-    keyExtractor: (item: T) => K;
-});
+} & DraggableGridPropsCore<T, K>;
 export declare function DraggableGrid<T, K extends Key = T extends Key ? T : never>({ className, classNames, style, items, disabled, columns, rows, gap, gapX, gapY, itemWidth, itemHeight, orderMap, onOrderMapChange, render, keyExtractor, isItemDisabled: _isItemDisabled, isOrderDisabled, orderPriority, handle, onDragMoveStart: _onDragMoveStart, onDragMove: _onDragMove, onDragMoveEnd: _onDragMoveEnd, ...rest }: DraggableGridProps<T, K>): import("react/jsx-runtime").JSX.Element;

package/dist/components/DraggableGrid.js

@@ -1,4 +1,5 @@
 import { jsx } from "react/jsx-runtime";
+import { c } from "react/compiler-runtime";
 import { useEffect, useMemo, useRef, useState } from "react";
 import { clsx, getArray, isNullable } from "deepsea-tools";
 import { useDragMove } from "soda-hooks";
@@ -45,21 +46,71 @@ function getOrderToKey(keyToOrder) {
             key
         ]));
 }
-function DraggableGridItem({ item, itemKey, handle, onDragMoveStart, onDragMove, onDragMoveEnd, ...rest }) {
+function DraggableGridItem(t0) {
+    const $ = c(19);
+    let handle;
+    let item;
+    let itemKey;
+    let onDragMove;
+    let onDragMoveEnd;
+    let onDragMoveStart;
+    let rest;
+    if ($[0] !== t0) {
+        ({ item, itemKey, handle, onDragMoveStart, onDragMove, onDragMoveEnd, ...rest } = t0);
+        $[0] = t0;
+        $[1] = handle;
+        $[2] = item;
+        $[3] = itemKey;
+        $[4] = onDragMove;
+        $[5] = onDragMoveEnd;
+        $[6] = onDragMoveStart;
+        $[7] = rest;
+    } else {
+        handle = $[1];
+        item = $[2];
+        itemKey = $[3];
+        onDragMove = $[4];
+        onDragMoveEnd = $[5];
+        onDragMoveStart = $[6];
+        rest = $[7];
+    }
     const element = useRef(null);
-    useDragMove({
-        element: isNullable(handle) ? element : ()=>element.current && ("string" == typeof handle ? element.current.querySelector(handle) : "function" == typeof handle ? handle(item, itemKey, element.current) : handle),
-        onDragMoveStart,
-        onDragMove,
-        onDragMoveEnd
-    });
-    return /*#__PURE__*/ jsx("div", {
-        ref: element,
-        ...rest
-    });
+    let t1;
+    if ($[8] !== handle || $[9] !== item || $[10] !== itemKey) {
+        t1 = isNullable(handle) ? element : ()=>element.current && ("string" == typeof handle ? element.current.querySelector(handle) : "function" == typeof handle ? handle(item, itemKey, element.current) : handle);
+        $[8] = handle;
+        $[9] = item;
+        $[10] = itemKey;
+        $[11] = t1;
+    } else t1 = $[11];
+    let t2;
+    if ($[12] !== onDragMove || $[13] !== onDragMoveEnd || $[14] !== onDragMoveStart || $[15] !== t1) {
+        t2 = {
+            element: t1,
+            onDragMoveStart,
+            onDragMove,
+            onDragMoveEnd
+        };
+        $[12] = onDragMove;
+        $[13] = onDragMoveEnd;
+        $[14] = onDragMoveStart;
+        $[15] = t1;
+        $[16] = t2;
+    } else t2 = $[16];
+    useDragMove(t2);
+    let t3;
+    if ($[17] !== rest) {
+        t3 = /*#__PURE__*/ jsx("div", {
+            ref: element,
+            ...rest
+        });
+        $[17] = rest;
+        $[18] = t3;
+    } else t3 = $[18];
+    return t3;
 }
 function DraggableGrid({ className, classNames, style, items = [], disabled, columns, rows, gap = 0, gapX = gap, gapY = gap, itemWidth, itemHeight, orderMap, onOrderMapChange, render, keyExtractor, isItemDisabled: _isItemDisabled, isOrderDisabled, orderPriority, handle, onDragMoveStart: _onDragMoveStart, onDragMove: _onDragMove, onDragMoveEnd: _onDragMoveEnd, ...rest }) {
-    const keyToItem = useMemo(()=>{
+    const keyToItem_0 = useMemo(()=>{
         const keyToItem = new Map();
         items.forEach((item)=>{
             const key = keyExtractor ? keyExtractor(item) : item;
@@ -70,8 +121,8 @@ function DraggableGrid({ className, classNames, style, items = [], disabled, col
         items,
         keyExtractor
     ]);
-    if (keyToItem.size !== items.length) throw new Error("there are duplicate keys in the items");
-    const orders = useMemo(()=>{
+    if (keyToItem_0.size !== items.length) throw new Error("there are duplicate keys in the items");
+    const orders_0 = useMemo(()=>{
         let orders = getArray(columns * rows);
         if (isOrderDisabled) orders = orders.filter((order)=>Array.isArray(isOrderDisabled) ? !isOrderDisabled.includes(order) : !isOrderDisabled(order));
         if (orderPriority) orders = orders.toSorted(orderPriority);
@@ -86,89 +137,89 @@ function DraggableGrid({ className, classNames, style, items = [], disabled, col
         if (orderMap) return orderMap;
         const newOrderMap = getOrderMap({
             prev: void 0,
-            orders,
-            keys: Array.from(keyToItem.keys())
+            orders: orders_0,
+            keys: Array.from(keyToItem_0.keys())
         });
-        onOrderMapChange?.(newOrderMap);
+        null == onOrderMapChange || onOrderMapChange(newOrderMap);
         return newOrderMap;
     });
     const [dragging, setDragging] = useState(void 0);
     const { current: cache } = useRef({
-        orders,
-        keys: Array.from(keyToItem.keys())
+        orders: orders_0,
+        keys: Array.from(keyToItem_0.keys())
     });
     useEffect(()=>{
-        if (!isTheSameArray(dragging?.orders ?? cache.orders, orders) || !isTheSameIterable(dragging?.keyToOrder.keys() ?? cache.keys, keyToItem.keys())) {
-            cache.orders = orders;
-            cache.keys = Array.from((dragging?.keyToOrder ?? keyToItem).keys());
-            const newOrderMap = getOrderMap({
-                prev: dragging?.keyToOrder ?? keyToOrder,
-                orders,
+        if (!isTheSameArray((null == dragging ? void 0 : dragging.orders) ?? cache.orders, orders_0) || !isTheSameIterable((null == dragging ? void 0 : dragging.keyToOrder.keys()) ?? cache.keys, keyToItem_0.keys())) {
+            cache.orders = orders_0;
+            cache.keys = Array.from(((null == dragging ? void 0 : dragging.keyToOrder) ?? keyToItem_0).keys());
+            const newOrderMap_0 = getOrderMap({
+                prev: (null == dragging ? void 0 : dragging.keyToOrder) ?? keyToOrder,
+                orders: orders_0,
                 keys: cache.keys
             });
-            setKeyToOrder(newOrderMap);
-            onOrderMapChange?.(newOrderMap);
-            const newRenderKeys = new Set(newOrderMap.keys());
+            setKeyToOrder(newOrderMap_0);
+            null == onOrderMapChange || onOrderMapChange(newOrderMap_0);
+            const newRenderKeys = new Set(newOrderMap_0.keys());
             setRenderKeys((prev)=>prev.intersection(newRenderKeys).union(newRenderKeys.difference(prev)));
         }
     }, [
         dragging,
         cache,
-        orders,
-        keyToItem,
+        orders_0,
+        keyToItem_0,
         keyToOrder,
         onOrderMapChange
     ]);
     const [renderKeys, setRenderKeys] = useState(()=>new Set(keyToOrder.keys()));
     const recent = useRef(void 0);
     useEffect(()=>{
-        if (!!dragging && (!isTheSameArray(dragging.orders, orders) || dragging.columns !== columns || dragging.rows !== rows || dragging.gapX !== gapX || dragging.gapY !== gapY || dragging.itemWidth !== itemWidth || dragging.itemHeight !== itemHeight || !isTheSameIterable(dragging.keyToOrder.keys(), keyToItem.keys()))) {
+        if (!!dragging && (!isTheSameArray(dragging.orders, orders_0) || dragging.columns !== columns || dragging.rows !== rows || dragging.gapX !== gapX || dragging.gapY !== gapY || dragging.itemWidth !== itemWidth || dragging.itemHeight !== itemHeight || !isTheSameIterable(dragging.keyToOrder.keys(), keyToItem_0.keys()))) {
             setDragging(void 0);
-            if (isTheSameArray(dragging.orders, orders) && isTheSameIterable(dragging.keyToOrder.keys(), keyToItem.keys())) {
+            if (isTheSameArray(dragging.orders, orders_0) && isTheSameIterable(dragging.keyToOrder.keys(), keyToItem_0.keys())) {
                 setKeyToOrder(dragging.keyToOrder);
-                onOrderMapChange?.(dragging.keyToOrder);
+                null == onOrderMapChange || onOrderMapChange(dragging.keyToOrder);
             }
         }
     }, [
         dragging,
-        orders,
+        orders_0,
         columns,
         rows,
         gapX,
         gapY,
         itemWidth,
         itemHeight,
-        keyToItem,
+        keyToItem_0,
         keyToOrder,
         onOrderMapChange
     ]);
     useEffect(()=>{
         if (orderMap === keyToOrder) return;
         if (orderMap) setKeyToOrder(orderMap);
-        else onOrderMapChange?.(keyToOrder);
+        else null == onOrderMapChange || onOrderMapChange(keyToOrder);
     }, [
         orderMap,
         keyToOrder,
         onOrderMapChange
     ]);
-    function onDragMoveStart(key, event) {
-        _onDragMoveStart?.(event);
+    function onDragMoveStart(key_0, event) {
+        null == _onDragMoveStart || _onDragMoveStart(event);
         const position = getPosition({
-            order: keyToOrder.get(key),
+            order: keyToOrder.get(key_0),
             columns,
             gapX,
             gapY,
             itemWidth,
             itemHeight
         });
-        recent.current = key;
+        recent.current = key_0;
         setDragging({
-            key,
+            key: key_0,
             startX: position.x,
             startY: position.y,
             deltaX: event.deltaX,
             deltaY: event.deltaY,
-            orders,
+            orders: orders_0,
             columns,
             rows,
             gapX,
@@ -178,89 +229,89 @@ function DraggableGrid({ className, classNames, style, items = [], disabled, col
             keyToOrder: keyToOrder
         });
     }
-    function onDragMove(event) {
-        _onDragMove?.(event);
+    function onDragMove(event_0) {
+        null == _onDragMove || _onDragMove(event_0);
         if (!dragging) return;
-        const { deltaX, deltaY } = event;
-        const { key, orders, keyToOrder, startX, startY, columns, gapX, gapY, itemWidth, itemHeight } = dragging;
-        setDragging((prev)=>({
-                ...prev,
+        const { deltaX, deltaY } = event_0;
+        const { key: key_1, orders: orders_1, keyToOrder: keyToOrder_0, startX, startY, columns: columns_0, gapX: gapX_0, gapY: gapY_0, itemWidth: itemWidth_0, itemHeight: itemHeight_0 } = dragging;
+        setDragging((prev_0)=>({
+                ...prev_0,
                 deltaX,
                 deltaY
             }));
         const x = startX + deltaX;
         const y = startY + deltaY;
-        const currentOrder = keyToOrder.get(key);
-        const currentOrderIndex = orders.indexOf(currentOrder);
-        const nearestOrder = orders.toSorted((a, b)=>{
+        const currentOrder = keyToOrder_0.get(key_1);
+        const currentOrderIndex = orders_1.indexOf(currentOrder);
+        const nearestOrder = orders_1.toSorted((a, b)=>{
             const aPosition = getPosition({
                 order: a,
-                columns,
-                gapX,
-                gapY,
-                itemWidth,
-                itemHeight
+                columns: columns_0,
+                gapX: gapX_0,
+                gapY: gapY_0,
+                itemWidth: itemWidth_0,
+                itemHeight: itemHeight_0
             });
             const bPosition = getPosition({
                 order: b,
-                columns,
-                gapX,
-                gapY,
-                itemWidth,
-                itemHeight
+                columns: columns_0,
+                gapX: gapX_0,
+                gapY: gapY_0,
+                itemWidth: itemWidth_0,
+                itemHeight: itemHeight_0
             });
             const aDistance = (x - aPosition.x) ** 2 + (y - aPosition.y) ** 2;
             const bDistance = (x - bPosition.x) ** 2 + (y - bPosition.y) ** 2;
             if (aDistance - bDistance !== 0) return aDistance - bDistance;
-            const aIndex = orders.indexOf(a);
-            const bIndex = orders.indexOf(b);
+            const aIndex = orders_1.indexOf(a);
+            const bIndex = orders_1.indexOf(b);
             return Math.abs(aIndex - currentOrderIndex) - Math.abs(bIndex - currentOrderIndex);
         })[0];
         if (nearestOrder === currentOrder) {
-            setKeyToOrder(keyToOrder);
-            onOrderMapChange?.(keyToOrder);
+            setKeyToOrder(keyToOrder_0);
+            null == onOrderMapChange || onOrderMapChange(keyToOrder_0);
             return;
         }
-        const newKeyToOrder = new Map(keyToOrder);
-        newKeyToOrder.set(key, nearestOrder);
-        const orderToKey = getOrderToKey(keyToOrder);
+        const newKeyToOrder = new Map(keyToOrder_0);
+        newKeyToOrder.set(key_1, nearestOrder);
+        const orderToKey = getOrderToKey(keyToOrder_0);
         if (!orderToKey.has(nearestOrder)) {
             setKeyToOrder(newKeyToOrder);
-            onOrderMapChange?.(newKeyToOrder);
+            null == onOrderMapChange || onOrderMapChange(newKeyToOrder);
             return;
         }
-        const nearestOrderIndex = orders.indexOf(nearestOrder);
+        const nearestOrderIndex = orders_1.indexOf(nearestOrder);
         const itemDirection = currentOrderIndex > nearestOrderIndex ? "decrease" : "increase";
-        const targetDirection = "decrease" === itemDirection && orders.slice(0, nearestOrderIndex).some((order)=>!orderToKey.has(order)) || "increase" === itemDirection && orders.slice(nearestOrderIndex + 1).every((order)=>orderToKey.has(order)) ? "decrease" : "increase";
+        const targetDirection = "decrease" === itemDirection && orders_1.slice(0, nearestOrderIndex).some((order_1)=>!orderToKey.has(order_1)) || "increase" === itemDirection && orders_1.slice(nearestOrderIndex + 1).every((order_0)=>orderToKey.has(order_0)) ? "decrease" : "increase";
         function moveTargetOrder(targetOrder) {
             const targetKey = orderToKey.get(targetOrder);
-            const targetOrderIndex = orders.indexOf(targetOrder);
+            const targetOrderIndex = orders_1.indexOf(targetOrder);
             const nextOrderIndex = targetOrderIndex + ("decrease" === targetDirection ? -1 : 1);
-            const nextOrder = orders[nextOrderIndex];
+            const nextOrder = orders_1[nextOrderIndex];
             newKeyToOrder.set(targetKey, nextOrder);
             if (nextOrder === currentOrder || !orderToKey.has(nextOrder)) return;
             moveTargetOrder(nextOrder);
         }
         moveTargetOrder(nearestOrder);
         setKeyToOrder(newKeyToOrder);
-        onOrderMapChange?.(newKeyToOrder);
+        null == onOrderMapChange || onOrderMapChange(newKeyToOrder);
     }
-    function onDragMoveEnd(event) {
-        _onDragMoveEnd?.(event);
+    function onDragMoveEnd(event_1) {
+        null == _onDragMoveEnd || _onDragMoveEnd(event_1);
         if (!dragging) return;
         setDragging(void 0);
     }
-    function isItemDisabled(key) {
+    function isItemDisabled(key_2) {
         if (!_isItemDisabled) return false;
-        if (Array.isArray(_isItemDisabled)) return _isItemDisabled.includes(key);
-        return _isItemDisabled(keyToItem.get(key), key);
+        if (Array.isArray(_isItemDisabled)) return _isItemDisabled.includes(key_2);
+        return _isItemDisabled(keyToItem_0.get(key_2), key_2);
     }
     return /*#__PURE__*/ jsx("div", {
         className: clsx(DraggableGrid_module.draggableGrid, "function" == typeof className ? className({
             isDragging: !!dragging
-        }) : className, "function" == typeof classNames?.container ? classNames.container({
+        }) : className, "function" == typeof (null == classNames ? void 0 : classNames.container) ? classNames.container({
             isDragging: !!dragging
-        }) : classNames?.container),
+        }) : null == classNames ? void 0 : classNames.container),
         style: {
             "--width": `${columns * (itemWidth + gapX) - gapX}px`,
             "--height": `${rows * (itemHeight + gapY) - gapY}px`,
@@ -269,19 +320,19 @@ function DraggableGrid({ className, classNames, style, items = [], disabled, col
             }) : style
         },
         ...rest,
-        children: Array.from(renderKeys).map((key)=>{
-            const item = keyToItem.get(key);
-            const order = keyToOrder.get(key);
-            const isDragging = dragging?.key === key;
-            const position = getPosition({
-                order,
+        children: Array.from(renderKeys).map((key_3)=>{
+            const item_0 = keyToItem_0.get(key_3);
+            const order_2 = keyToOrder.get(key_3);
+            const isDragging = (null == dragging ? void 0 : dragging.key) === key_3;
+            const position_0 = getPosition({
+                order: order_2,
                 columns,
                 gapX,
                 gapY,
                 itemWidth,
                 itemHeight
             });
-            const style = isDragging ? {
+            const style_0 = isDragging ? {
                 "--width": `${itemWidth}px`,
                 "--height": `${itemHeight}px`,
                 "--translate-x": `${dragging.startX + dragging.deltaX}px`,
@@ -291,29 +342,29 @@ function DraggableGrid({ className, classNames, style, items = [], disabled, col
             } : {
                 "--width": `${itemWidth}px`,
                 "--height": `${itemHeight}px`,
-                "--translate-x": `${position.x}px`,
-                "--translate-y": `${position.y}px`,
+                "--translate-x": `${position_0.x}px`,
+                "--translate-y": `${position_0.y}px`,
                 "--transition-property": "transform",
-                "--z-index": recent.current === key ? 999999 : keyToOrder.get(key)
+                "--z-index": recent.current === key_3 ? 999999 : keyToOrder.get(key_3)
             };
-            const children = render ? render(item, {
-                order,
+            const children = render ? render(item_0, {
+                order: order_2,
                 isDragging: isDragging
-            }) : item;
+            }) : item_0;
             return /*#__PURE__*/ jsx(DraggableGridItem, {
-                item: item,
-                itemKey: key,
+                item: item_0,
+                itemKey: key_3,
                 handle: handle,
-                className: clsx(DraggableGrid_module.draggableGridItem, "function" == typeof classNames?.item ? classNames.item({
-                    order,
+                className: clsx(DraggableGrid_module.draggableGridItem, "function" == typeof (null == classNames ? void 0 : classNames.item) ? classNames.item({
+                    order: order_2,
                     isDragging: isDragging
-                }) : classNames?.item),
-                style: style,
-                onDragMoveStart: disabled || isItemDisabled(key) ? void 0 : (event)=>onDragMoveStart(key, event),
-                onDragMove: disabled || isItemDisabled(key) ? void 0 : onDragMove,
-                onDragMoveEnd: disabled || isItemDisabled(key) ? void 0 : onDragMoveEnd,
+                }) : null == classNames ? void 0 : classNames.item),
+                style: style_0,
+                onDragMoveStart: disabled || isItemDisabled(key_3) ? void 0 : (event_2)=>onDragMoveStart(key_3, event_2),
+                onDragMove: disabled || isItemDisabled(key_3) ? void 0 : onDragMove,
+                onDragMoveEnd: disabled || isItemDisabled(key_3) ? void 0 : onDragMoveEnd,
                 children: children
-            }, key);
+            }, key_3);
         })
     });
 }

package/dist/components/Echart.cjs

@@ -30,33 +30,107 @@ __webpack_require__.d(__webpack_exports__, {
     Bar: ()=>Bar
 });
 const jsx_runtime_namespaceObject = require("react/jsx-runtime");
+const compiler_runtime_namespaceObject = require("react/compiler-runtime");
 const external_echarts_namespaceObject = require("echarts");
 const external_react_namespaceObject = require("react");
 const Echart = /*#__PURE__*/ (0, external_react_namespaceObject.forwardRef)((props, ref)=>{
-    const { width, height, option, chart, ...rest } = props;
+    const $ = (0, compiler_runtime_namespaceObject.c)(21);
+    let chart;
+    let height;
+    let option;
+    let rest;
+    let width;
+    if ($[0] !== props) {
+        ({ width, height, option, chart, ...rest } = props);
+        $[0] = props;
+        $[1] = chart;
+        $[2] = height;
+        $[3] = option;
+        $[4] = rest;
+        $[5] = width;
+    } else {
+        chart = $[1];
+        height = $[2];
+        option = $[3];
+        rest = $[4];
+        width = $[5];
+    }
     const container = (0, external_react_namespaceObject.useRef)(null);
     const chartRef = (0, external_react_namespaceObject.useRef)(null);
-    (0, external_react_namespaceObject.useLayoutEffect)(()=>{
-        const ele = container.current;
-        chartRef.current = (0, external_echarts_namespaceObject.init)(ele, option, {
-            width,
-            height
+    let t0;
+    if ($[6] !== height || $[7] !== option || $[8] !== width) {
+        t0 = ()=>{
+            const ele = container.current;
+            chartRef.current = (0, external_echarts_namespaceObject.init)(ele, option, {
+                width,
+                height
+            });
+            return ()=>{
+                var _chartRef_current;
+                return null == (_chartRef_current = chartRef.current) ? void 0 : _chartRef_current.dispose();
+            };
+        };
+        $[6] = height;
+        $[7] = option;
+        $[8] = width;
+        $[9] = t0;
+    } else t0 = $[9];
+    let t1;
+    if ($[10] === Symbol.for("react.memo_cache_sentinel")) {
+        t1 = [];
+        $[10] = t1;
+    } else t1 = $[10];
+    (0, external_react_namespaceObject.useLayoutEffect)(t0, t1);
+    let t2;
+    let t3;
+    if ($[11] === Symbol.for("react.memo_cache_sentinel")) {
+        t2 = ()=>container.current;
+        t3 = [];
+        $[11] = t2;
+        $[12] = t3;
+    } else {
+        t2 = $[11];
+        t3 = $[12];
+    }
+    (0, external_react_namespaceObject.useImperativeHandle)(ref, t2, t3);
+    let t4;
+    let t5;
+    if ($[13] === Symbol.for("react.memo_cache_sentinel")) {
+        t4 = ()=>chartRef.current;
+        t5 = [];
+        $[13] = t4;
+        $[14] = t5;
+    } else {
+        t4 = $[13];
+        t5 = $[14];
+    }
+    (0, external_react_namespaceObject.useImperativeHandle)(chart, t4, t5);
+    let t6;
+    if ($[15] !== height || $[16] !== option || $[17] !== width) {
+        t6 = ()=>{
+            var _chartRef_current, _chartRef_current1;
+            null == (_chartRef_current = chartRef.current) || _chartRef_current.setOption(option);
+            null == (_chartRef_current1 = chartRef.current) || _chartRef_current1.resize({
+                width,
+                height
+            });
+        };
+        $[15] = height;
+        $[16] = option;
+        $[17] = width;
+        $[18] = t6;
+    } else t6 = $[18];
+    (0, external_react_namespaceObject.useEffect)(t6);
+    let t7;
+    if ($[19] !== rest) {
+        t7 = /*#__PURE__*/ (0, jsx_runtime_namespaceObject.jsx)("div", {
+            ref: container,
+            ...rest
         });
-        return ()=>chartRef.current?.dispose();
-    }, []);
-    (0, external_react_namespaceObject.useImperativeHandle)(ref, ()=>container.current, []);
-    (0, external_react_namespaceObject.useImperativeHandle)(chart, ()=>chartRef.current, []);
-    (0, external_react_namespaceObject.useEffect)(()=>{
-        chartRef.current?.setOption(option);
-        chartRef.current?.resize({
-            width,
-            height
-        });
-    });
-    return /*#__PURE__*/ (0, jsx_runtime_namespaceObject.jsx)("div", {
-        ref: container,
-        ...rest
-    });
+        $[19] = rest;
+        $[20] = t7;
+    } else t7 = $[20];
+    return t7;
 });
 const Pie = Echart;
 const Bar = Echart;