deepsea-components 5.16.4 → 5.16.5

package/dist/components/CircleText.js

@@ -1,34 +1,130 @@
 "use client"
 import { jsx } from "react/jsx-runtime";
+import { c } from "react/compiler-runtime";
 import { Fragment } from "react";
 const CircleText = (props)=>{
-    const { width, height, radius, startAngel = 0, gapAngel = 0, align = "center", style, direction = "outer", reverse = false, separator, children, ...rest } = props;
+    const $ = c(41);
+    let children;
+    let height;
+    let radius;
+    let rest;
+    let separator;
+    let style;
+    let t0;
+    let t1;
+    let t2;
+    let t3;
+    let t4;
+    let width;
+    if ($[0] !== props) {
+        ({ width, height, radius, startAngel: t0, gapAngel: t1, align: t2, style, direction: t3, reverse: t4, separator, children, ...rest } = props);
+        $[0] = props;
+        $[1] = children;
+        $[2] = height;
+        $[3] = radius;
+        $[4] = rest;
+        $[5] = separator;
+        $[6] = style;
+        $[7] = t0;
+        $[8] = t1;
+        $[9] = t2;
+        $[10] = t3;
+        $[11] = t4;
+        $[12] = width;
+    } else {
+        children = $[1];
+        height = $[2];
+        radius = $[3];
+        rest = $[4];
+        separator = $[5];
+        style = $[6];
+        t0 = $[7];
+        t1 = $[8];
+        t2 = $[9];
+        t3 = $[10];
+        t4 = $[11];
+        width = $[12];
+    }
+    const startAngel = void 0 === t0 ? 0 : t0;
+    const gapAngel = void 0 === t1 ? 0 : t1;
+    const align = void 0 === t2 ? "center" : t2;
+    const direction = void 0 === t3 ? "outer" : t3;
+    const reverse = void 0 === t4 ? false : t4;
     const unitAngle = 2 * Math.atan(width / 2 / radius);
     const totalAngle = (unitAngle + gapAngel) * children.length - gapAngel;
     const offsetAngle = "left" === align ? 0 : "right" === align ? totalAngle : totalAngle / 2;
-    function getTransform(idx) {
-        const angle = startAngel - idx * (unitAngle + gapAngel) + offsetAngle - unitAngle / 2;
-        const x = (radius + height / 2) * Math.cos(angle) - width / 2;
-        const y = (radius + height / 2) * Math.sin(angle) * -1 - height / 2;
-        const z = Math.PI / 2 - angle + ("inner" === direction ? Math.PI : 0);
-        return `translateX(${x}px) translateY(${y}px) rotateZ(${z / Math.PI * 180}deg)`;
+    let t5;
+    if ($[13] !== direction || $[14] !== gapAngel || $[15] !== height || $[16] !== offsetAngle || $[17] !== radius || $[18] !== startAngel || $[19] !== unitAngle || $[20] !== width) {
+        t5 = function(idx) {
+            const angle = startAngel - idx * (unitAngle + gapAngel) + offsetAngle - unitAngle / 2;
+            const x = (radius + height / 2) * Math.cos(angle) - width / 2;
+            const y = (radius + height / 2) * Math.sin(angle) * -1 - height / 2;
+            const z = Math.PI / 2 - angle + ("inner" === direction ? Math.PI : 0);
+            return `translateX(${x}px) translateY(${y}px) rotateZ(${z / Math.PI * 180}deg)`;
+        };
+        $[13] = direction;
+        $[14] = gapAngel;
+        $[15] = height;
+        $[16] = offsetAngle;
+        $[17] = radius;
+        $[18] = startAngel;
+        $[19] = unitAngle;
+        $[20] = width;
+        $[21] = t5;
+    } else t5 = $[21];
+    const getTransform = t5;
+    let T0;
+    let t6;
+    if ($[22] !== children || $[23] !== getTransform || $[24] !== height || $[25] !== rest || $[26] !== reverse || $[27] !== separator || $[28] !== style || $[29] !== width) {
+        const words = "function" == typeof separator ? separator(children) : children.split(separator ?? "");
+        if (reverse) words.reverse();
+        T0 = Fragment;
+        let t7;
+        if ($[32] !== getTransform || $[33] !== height || $[34] !== rest || $[35] !== style || $[36] !== width) {
+            t7 = (w, idx_0)=>/*#__PURE__*/ jsx("span", {
+                    style: {
+                        position: "absolute",
+                        ...style,
+                        transform: getTransform(idx_0),
+                        textAlign: "center",
+                        width,
+                        lineHeight: `${height}px`,
+                        height
+                    },
+                    ...rest,
+                    children: w
+                }, idx_0);
+            $[32] = getTransform;
+            $[33] = height;
+            $[34] = rest;
+            $[35] = style;
+            $[36] = width;
+            $[37] = t7;
+        } else t7 = $[37];
+        t6 = words.map(t7);
+        $[22] = children;
+        $[23] = getTransform;
+        $[24] = height;
+        $[25] = rest;
+        $[26] = reverse;
+        $[27] = separator;
+        $[28] = style;
+        $[29] = width;
+        $[30] = T0;
+        $[31] = t6;
+    } else {
+        T0 = $[30];
+        t6 = $[31];
     }
-    const words = "function" == typeof separator ? separator(children) : children.split(separator ?? "");
-    if (reverse) words.reverse();
-    return /*#__PURE__*/ jsx(Fragment, {
-        children: words.map((w, idx)=>/*#__PURE__*/ jsx("span", {
-                style: {
-                    position: "absolute",
-                    ...style,
-                    transform: getTransform(idx),
-                    textAlign: "center",
-                    width,
-                    lineHeight: `${height}px`,
-                    height: height
-                },
-                ...rest,
-                children: w
-            }, idx))
-    });
+    let t7;
+    if ($[38] !== T0 || $[39] !== t6) {
+        t7 = /*#__PURE__*/ jsx(T0, {
+            children: t6
+        });
+        $[38] = T0;
+        $[39] = t6;
+        $[40] = t7;
+    } else t7 = $[40];
+    return t7;
 };
 export { CircleText };

package/dist/components/CopyButton.cjs

@@ -52,8 +52,14 @@ const CopyButton = /*#__PURE__*/ (0, external_react_namespaceObject.forwardRef)(
     ]);
     (0, external_react_namespaceObject.useEffect)(()=>{
         const clipboard = new (external_clipboard_default())(ele.current);
-        clipboard.on("success", (event)=>onCopySuccess.current?.(event));
-        clipboard.on("error", (event)=>onCopyError.current?.(event));
+        clipboard.on("success", (event)=>{
+            var _onCopySuccess_current;
+            return null == (_onCopySuccess_current = onCopySuccess.current) ? void 0 : _onCopySuccess_current.call(onCopySuccess, event);
+        });
+        clipboard.on("error", (event_0)=>{
+            var _onCopyError_current;
+            return null == (_onCopyError_current = onCopyError.current) ? void 0 : _onCopyError_current.call(onCopyError, event_0);
+        });
         return ()=>clipboard.destroy();
     }, []);
     return /*#__PURE__*/ (0, jsx_runtime_namespaceObject.jsx)("button", {

package/dist/components/CopyButton.js

@@ -13,8 +13,14 @@ const CopyButton = /*#__PURE__*/ forwardRef((props, ref)=>{
     ]);
     useEffect(()=>{
         const clipboard = new clipboard_0(ele.current);
-        clipboard.on("success", (event)=>onCopySuccess.current?.(event));
-        clipboard.on("error", (event)=>onCopyError.current?.(event));
+        clipboard.on("success", (event)=>{
+            var _onCopySuccess_current;
+            return null == (_onCopySuccess_current = onCopySuccess.current) ? void 0 : _onCopySuccess_current.call(onCopySuccess, event);
+        });
+        clipboard.on("error", (event_0)=>{
+            var _onCopyError_current;
+            return null == (_onCopyError_current = onCopyError.current) ? void 0 : _onCopyError_current.call(onCopyError, event_0);
+        });
         return ()=>clipboard.destroy();
     }, []);
     return /*#__PURE__*/ jsx("button", {

package/dist/components/DraggableGrid.cjs

@@ -36,6 +36,7 @@ __webpack_require__.d(__webpack_exports__, {
     DraggableGrid: ()=>DraggableGrid
 });
 const jsx_runtime_namespaceObject = require("react/jsx-runtime");
+const compiler_runtime_namespaceObject = require("react/compiler-runtime");
 const external_react_namespaceObject = require("react");
 const external_deepsea_tools_namespaceObject = require("deepsea-tools");
 const external_soda_hooks_namespaceObject = require("soda-hooks");
@@ -83,21 +84,71 @@ function getOrderToKey(keyToOrder) {
             key
         ]));
 }
-function DraggableGridItem({ item, itemKey, handle, onDragMoveStart, onDragMove, onDragMoveEnd, ...rest }) {
+function DraggableGridItem(t0) {
+    const $ = (0, compiler_runtime_namespaceObject.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 = (0, external_react_namespaceObject.useRef)(null);
-    (0, external_soda_hooks_namespaceObject.useDragMove)({
-        element: (0, external_deepsea_tools_namespaceObject.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__*/ (0, jsx_runtime_namespaceObject.jsx)("div", {
-        ref: element,
-        ...rest
-    });
+    let t1;
+    if ($[8] !== handle || $[9] !== item || $[10] !== itemKey) {
+        t1 = (0, external_deepsea_tools_namespaceObject.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];
+    (0, external_soda_hooks_namespaceObject.useDragMove)(t2);
+    let t3;
+    if ($[17] !== rest) {
+        t3 = /*#__PURE__*/ (0, jsx_runtime_namespaceObject.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 = (0, external_react_namespaceObject.useMemo)(()=>{
+    const keyToItem_0 = (0, external_react_namespaceObject.useMemo)(()=>{
         const keyToItem = new Map();
         items.forEach((item)=>{
             const key = keyExtractor ? keyExtractor(item) : item;
@@ -108,8 +159,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 = (0, external_react_namespaceObject.useMemo)(()=>{
+    if (keyToItem_0.size !== items.length) throw new Error("there are duplicate keys in the items");
+    const orders_0 = (0, external_react_namespaceObject.useMemo)(()=>{
         let orders = (0, external_deepsea_tools_namespaceObject.getArray)(columns * rows);
         if (isOrderDisabled) orders = orders.filter((order)=>Array.isArray(isOrderDisabled) ? !isOrderDisabled.includes(order) : !isOrderDisabled(order));
         if (orderPriority) orders = orders.toSorted(orderPriority);
@@ -124,89 +175,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] = (0, external_react_namespaceObject.useState)(void 0);
     const { current: cache } = (0, external_react_namespaceObject.useRef)({
-        orders,
-        keys: Array.from(keyToItem.keys())
+        orders: orders_0,
+        keys: Array.from(keyToItem_0.keys())
     });
     (0, external_react_namespaceObject.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] = (0, external_react_namespaceObject.useState)(()=>new Set(keyToOrder.keys()));
     const recent = (0, external_react_namespaceObject.useRef)(void 0);
     (0, external_react_namespaceObject.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
     ]);
     (0, external_react_namespaceObject.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,
@@ -216,89 +267,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__*/ (0, jsx_runtime_namespaceObject.jsx)("div", {
         className: (0, external_deepsea_tools_namespaceObject.clsx)(external_DraggableGrid_module_cjs_default().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`,
@@ -307,19 +358,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`,
@@ -329,29 +380,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__*/ (0, jsx_runtime_namespaceObject.jsx)(DraggableGridItem, {
-                item: item,
-                itemKey: key,
+                item: item_0,
+                itemKey: key_3,
                 handle: handle,
-                className: (0, external_deepsea_tools_namespaceObject.clsx)(external_DraggableGrid_module_cjs_default().draggableGridItem, "function" == typeof classNames?.item ? classNames.item({
-                    order,
+                className: (0, external_deepsea_tools_namespaceObject.clsx)(external_DraggableGrid_module_cjs_default().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);
         })
     });
 }