deepsea-components 5.16.15 → 5.17.0

package/dist/components/DraggableGrid.js

@@ -1,5 +1,4 @@
 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";
@@ -65,68 +64,18 @@ function getOrderToKey(keyToOrder) {
             key
         ]));
 }
-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];
-    }
+function DraggableGridItem({ item, itemKey, handle, onDragMoveStart, onDragMove, onDragMoveEnd, ...rest }) {
     const element = useRef(null);
-    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;
+    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
+    });
 }
 function isLegalOrderMap({ orders, keys, orderMap }) {
     if (!isTheSameIterable(orderMap.keys(), keys)) return false;
@@ -135,7 +84,7 @@ function isLegalOrderMap({ orders, keys, orderMap }) {
     return values.length === new Set(values).size;
 }
 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_0 = useMemo(()=>{
+    const keyToItem = useMemo(()=>{
         const keyToItem = new Map();
         items.forEach((item)=>{
             const key = keyExtractor ? keyExtractor(item) : item;
@@ -146,8 +95,8 @@ function DraggableGrid({ className, classNames, style, items = [], disabled, col
         items,
         keyExtractor
     ]);
-    if (keyToItem_0.size !== items.length) throw new Error("there are duplicate keys in the items");
-    const orders_0 = useMemo(()=>{
+    if (keyToItem.size !== items.length) throw new Error("there are duplicate keys in the items");
+    const orders = 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);
@@ -160,14 +109,14 @@ function DraggableGrid({ className, classNames, style, items = [], disabled, col
     ]);
     const [keyToOrder, setKeyToOrder] = useState(()=>{
         if (orderMap && isLegalOrderMap({
-            orders: orders_0,
-            keys: keyToItem_0.keys(),
+            orders,
+            keys: keyToItem.keys(),
             orderMap
         })) return orderMap;
         const newOrderMap = getOrderMap({
             prev: orderMap,
-            orders: orders_0,
-            keys: Array.from(keyToItem_0.keys()),
+            orders,
+            keys: Array.from(keyToItem.keys()),
             orderPriority
         });
         null == onOrderMapChange || onOrderMapChange(newOrderMap);
@@ -175,29 +124,29 @@ function DraggableGrid({ className, classNames, style, items = [], disabled, col
     });
     const [dragging, setDragging] = useState(void 0);
     const { current: cache } = useRef({
-        orders: orders_0,
-        keys: Array.from(keyToItem_0.keys())
+        orders,
+        keys: Array.from(keyToItem.keys())
     });
     useEffect(()=>{
-        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({
+        if (!isTheSameArray((null == dragging ? void 0 : dragging.orders) ?? cache.orders, orders) || !isTheSameIterable((null == dragging ? void 0 : dragging.keyToOrder.keys()) ?? cache.keys, keyToItem.keys())) {
+            cache.orders = orders;
+            cache.keys = Array.from(((null == dragging ? void 0 : dragging.keyToOrder) ?? keyToItem).keys());
+            const newOrderMap = getOrderMap({
                 prev: (null == dragging ? void 0 : dragging.keyToOrder) ?? keyToOrder,
-                orders: orders_0,
+                orders,
                 keys: cache.keys,
                 orderPriority
             });
-            setKeyToOrder(newOrderMap_0);
-            null == onOrderMapChange || onOrderMapChange(newOrderMap_0);
-            const newRenderKeys = new Set(newOrderMap_0.keys());
+            setKeyToOrder(newOrderMap);
+            null == onOrderMapChange || onOrderMapChange(newOrderMap);
+            const newRenderKeys = new Set(newOrderMap.keys());
             setRenderKeys((prev)=>prev.intersection(newRenderKeys).union(newRenderKeys.difference(prev)));
         }
     }, [
         dragging,
         cache,
-        orders_0,
-        keyToItem_0,
+        orders,
+        keyToItem,
         keyToOrder,
         orderPriority,
         onOrderMapChange
@@ -205,31 +154,31 @@ function DraggableGrid({ className, classNames, style, items = [], disabled, col
     const [renderKeys, setRenderKeys] = useState(()=>new Set(keyToOrder.keys()));
     const recent = useRef(void 0);
     useEffect(()=>{
-        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()))) {
+        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()))) {
             setDragging(void 0);
-            if (isTheSameArray(dragging.orders, orders_0) && isTheSameIterable(dragging.keyToOrder.keys(), keyToItem_0.keys())) {
+            if (isTheSameArray(dragging.orders, orders) && isTheSameIterable(dragging.keyToOrder.keys(), keyToItem.keys())) {
                 setKeyToOrder(dragging.keyToOrder);
                 null == onOrderMapChange || onOrderMapChange(dragging.keyToOrder);
             }
         }
     }, [
         dragging,
-        orders_0,
+        orders,
         columns,
         rows,
         gapX,
         gapY,
         itemWidth,
         itemHeight,
-        keyToItem_0,
+        keyToItem,
         keyToOrder,
         onOrderMapChange
     ]);
     useEffect(()=>{
         if (orderMap === keyToOrder) return;
         if (!!orderMap && isLegalOrderMap({
-            orders: orders_0,
-            keys: keyToItem_0.keys(),
+            orders,
+            keys: keyToItem.keys(),
             orderMap
         })) setKeyToOrder(orderMap);
         else null == onOrderMapChange || onOrderMapChange(keyToOrder);
@@ -238,24 +187,24 @@ function DraggableGrid({ className, classNames, style, items = [], disabled, col
         keyToOrder,
         onOrderMapChange
     ]);
-    function onDragMoveStart(key_0, event) {
+    function onDragMoveStart(key, event) {
         null == _onDragMoveStart || _onDragMoveStart(event);
         const position = getPosition({
-            order: keyToOrder.get(key_0),
+            order: keyToOrder.get(key),
             columns,
             gapX,
             gapY,
             itemWidth,
             itemHeight
         });
-        recent.current = key_0;
+        recent.current = key;
         setDragging({
-            key: key_0,
+            key,
             startX: position.x,
             startY: position.y,
             deltaX: event.deltaX,
             deltaY: event.deltaY,
-            orders: orders_0,
+            orders,
             columns,
             rows,
             gapX,
@@ -265,65 +214,65 @@ function DraggableGrid({ className, classNames, style, items = [], disabled, col
             keyToOrder: keyToOrder
         });
     }
-    function onDragMove(event_0) {
-        null == _onDragMove || _onDragMove(event_0);
+    function onDragMove(event) {
+        null == _onDragMove || _onDragMove(event);
         if (!dragging) return;
-        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,
+        const { deltaX, deltaY } = event;
+        const { key, orders, keyToOrder, startX, startY, columns, gapX, gapY, itemWidth, itemHeight } = dragging;
+        setDragging((prev)=>({
+                ...prev,
                 deltaX,
                 deltaY
             }));
         const x = startX + deltaX;
         const y = startY + deltaY;
-        const currentOrder = keyToOrder_0.get(key_1);
-        const currentOrderIndex = orders_1.indexOf(currentOrder);
-        const nearestOrder = orders_1.toSorted((a, b)=>{
+        const currentOrder = keyToOrder.get(key);
+        const currentOrderIndex = orders.indexOf(currentOrder);
+        const nearestOrder = orders.toSorted((a, b)=>{
             const aPosition = getPosition({
                 order: a,
-                columns: columns_0,
-                gapX: gapX_0,
-                gapY: gapY_0,
-                itemWidth: itemWidth_0,
-                itemHeight: itemHeight_0
+                columns,
+                gapX,
+                gapY,
+                itemWidth,
+                itemHeight
             });
             const bPosition = getPosition({
                 order: b,
-                columns: columns_0,
-                gapX: gapX_0,
-                gapY: gapY_0,
-                itemWidth: itemWidth_0,
-                itemHeight: itemHeight_0
+                columns,
+                gapX,
+                gapY,
+                itemWidth,
+                itemHeight
             });
             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_1.indexOf(a);
-            const bIndex = orders_1.indexOf(b);
+            const aIndex = orders.indexOf(a);
+            const bIndex = orders.indexOf(b);
             return Math.abs(aIndex - currentOrderIndex) - Math.abs(bIndex - currentOrderIndex);
         })[0];
         if (nearestOrder === currentOrder) {
-            setKeyToOrder(keyToOrder_0);
-            null == onOrderMapChange || onOrderMapChange(keyToOrder_0);
+            setKeyToOrder(keyToOrder);
+            null == onOrderMapChange || onOrderMapChange(keyToOrder);
             return;
         }
-        const newKeyToOrder = new Map(keyToOrder_0);
-        newKeyToOrder.set(key_1, nearestOrder);
-        const orderToKey = getOrderToKey(keyToOrder_0);
+        const newKeyToOrder = new Map(keyToOrder);
+        newKeyToOrder.set(key, nearestOrder);
+        const orderToKey = getOrderToKey(keyToOrder);
         if (!orderToKey.has(nearestOrder)) {
             setKeyToOrder(newKeyToOrder);
             null == onOrderMapChange || onOrderMapChange(newKeyToOrder);
             return;
         }
-        const nearestOrderIndex = orders_1.indexOf(nearestOrder);
+        const nearestOrderIndex = orders.indexOf(nearestOrder);
         const itemDirection = currentOrderIndex > nearestOrderIndex ? "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";
+        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";
         function moveTargetOrder(targetOrder) {
             const targetKey = orderToKey.get(targetOrder);
-            const targetOrderIndex = orders_1.indexOf(targetOrder);
+            const targetOrderIndex = orders.indexOf(targetOrder);
             const nextOrderIndex = targetOrderIndex + ("decrease" === targetDirection ? -1 : 1);
-            const nextOrder = orders_1[nextOrderIndex];
+            const nextOrder = orders[nextOrderIndex];
             newKeyToOrder.set(targetKey, nextOrder);
             if (nextOrder === currentOrder || !orderToKey.has(nextOrder)) return;
             moveTargetOrder(nextOrder);
@@ -332,15 +281,15 @@ function DraggableGrid({ className, classNames, style, items = [], disabled, col
         setKeyToOrder(newKeyToOrder);
         null == onOrderMapChange || onOrderMapChange(newKeyToOrder);
     }
-    function onDragMoveEnd(event_1) {
-        null == _onDragMoveEnd || _onDragMoveEnd(event_1);
+    function onDragMoveEnd(event) {
+        null == _onDragMoveEnd || _onDragMoveEnd(event);
         if (!dragging) return;
         setDragging(void 0);
     }
-    function isItemDisabled(key_2) {
+    function isItemDisabled(key) {
         if (!_isItemDisabled) return false;
-        if (Array.isArray(_isItemDisabled)) return _isItemDisabled.includes(key_2);
-        return _isItemDisabled(keyToItem_0.get(key_2), key_2);
+        if (Array.isArray(_isItemDisabled)) return _isItemDisabled.includes(key);
+        return _isItemDisabled(keyToItem.get(key), key);
     }
     return /*#__PURE__*/ jsx("div", {
         className: clsx(DraggableGrid_module.draggableGrid, "function" == typeof className ? className({
@@ -356,20 +305,20 @@ function DraggableGrid({ className, classNames, style, items = [], disabled, col
             }) : style
         },
         ...rest,
-        children: Array.from(renderKeys).map((key_3)=>{
-            if (!keyToItem_0.has(key_3)) return;
-            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,
+        children: Array.from(renderKeys).map((key)=>{
+            if (!keyToItem.has(key)) return;
+            const item = keyToItem.get(key);
+            const order = keyToOrder.get(key);
+            const isDragging = (null == dragging ? void 0 : dragging.key) === key;
+            const position = getPosition({
+                order,
                 columns,
                 gapX,
                 gapY,
                 itemWidth,
                 itemHeight
             });
-            const style_0 = isDragging ? {
+            const style = isDragging ? {
                 "--width": `${itemWidth}px`,
                 "--height": `${itemHeight}px`,
                 "--translate-x": `${dragging.startX + dragging.deltaX}px`,
@@ -379,29 +328,29 @@ function DraggableGrid({ className, classNames, style, items = [], disabled, col
             } : {
                 "--width": `${itemWidth}px`,
                 "--height": `${itemHeight}px`,
-                "--translate-x": `${position_0.x}px`,
-                "--translate-y": `${position_0.y}px`,
+                "--translate-x": `${position.x}px`,
+                "--translate-y": `${position.y}px`,
                 "--transition-property": "transform",
-                "--z-index": recent.current === key_3 ? 999999 : keyToOrder.get(key_3)
+                "--z-index": recent.current === key ? 999999 : keyToOrder.get(key)
             };
-            const children = render ? render(item_0, {
-                order: order_2,
+            const children = render ? render(item, {
+                order,
                 isDragging: isDragging
-            }) : item_0;
+            }) : item;
             return /*#__PURE__*/ jsx(DraggableGridItem, {
-                item: item_0,
-                itemKey: key_3,
+                item: item,
+                itemKey: key,
                 handle: handle,
                 className: clsx(DraggableGrid_module.draggableGridItem, "function" == typeof (null == classNames ? void 0 : classNames.item) ? classNames.item({
-                    order: order_2,
+                    order,
                     isDragging: isDragging
                 }) : 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,
+                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,
                 children: children
-            }, key_3);
+            }, key);
         })
     });
 }

package/dist/components/Echart.cjs

@@ -30,107 +30,37 @@ __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 $ = (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 { width, height, option, chart, ...rest } = props;
     const container = (0, external_react_namespaceObject.useRef)(null);
     const chartRef = (0, external_react_namespaceObject.useRef)(null);
-    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
-            });
+    (0, external_react_namespaceObject.useLayoutEffect)(()=>{
+        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();
         };
-        $[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
+    }, []);
+    (0, external_react_namespaceObject.useImperativeHandle)(ref, ()=>container.current, []);
+    (0, external_react_namespaceObject.useImperativeHandle)(chart, ()=>chartRef.current, []);
+    (0, external_react_namespaceObject.useEffect)(()=>{
+        var _chartRef_current, _chartRef_current1;
+        null == (_chartRef_current = chartRef.current) || _chartRef_current.setOption(option);
+        null == (_chartRef_current1 = chartRef.current) || _chartRef_current1.resize({
+            width,
+            height
         });
-        $[19] = rest;
-        $[20] = t7;
-    } else t7 = $[20];
-    return t7;
+    });
+    return /*#__PURE__*/ (0, jsx_runtime_namespaceObject.jsx)("div", {
+        ref: container,
+        ...rest
+    });
 });
 const Pie = Echart;
 const Bar = Echart;