@apple-pie/slice 0.1.59 → 0.2.0

package/dist/cjs/chunks/viewState-CMugA-g4.js

@@ -0,0 +1,627 @@
+'use client';
+"use strict";
+
+var jsxRuntime = require("react/jsx-runtime"), React = require("react");
+
+require("../theme/colors.js");
+
+var theme_corners = require("../theme/corners.js");
+
+require("../theme/type.js"), require("./resolveColor-DkYThq2J.js"), require("./breakpoints-BDw1OJh9.js"), 
+require("./tslib.es6-B8JY5ZGw.js");
+
+var misc = require("./misc-PmT7cZzC.js");
+
+require("./broadcastChannel-DdPZ3LUB.js"), require("./files-RYD9L_pI.js"), require("./webRTCStore-OGkXAovD.js"), 
+require("./microphoneStore-D7DuvQeX.js"), require("./volumeStore-BoEoo9wA.js");
+
+var hooks_useObserveResize = require("../hooks/useObserveResize.js"), resolveColorProps = require("./resolveColorProps-DE1k1P-Z.js"), Icon = require("./Icon-COY7IZkK.js"), rafThrottle = require("./rafThrottle-BRdLzPo7.js"), styles = {
+    tableWrapper: "DataTable-module_tableWrapper__BzoJE",
+    resizeBar: "DataTable-module_resizeBar__LmzEF",
+    table: "DataTable-module_table__oL4Dz",
+    baseCell: "DataTable-module_baseCell__DQl-z",
+    baseCellWrapper: "DataTable-module_baseCellWrapper__WMgNm",
+    headerCellWrapper: "DataTable-module_headerCellWrapper__ytVYY",
+    colResizeHandle: "DataTable-module_colResizeHandle__dF5Es",
+    header: "DataTable-module_header__QgdCY",
+    headerTitle: "DataTable-module_headerTitle__K0pmX",
+    m: "DataTable-module_m__G9QOp type-module_body-m-regular__LuQBA",
+    scroll: "DataTable-module_scroll__grEU0 scrollBars-module_scrollbars__c-ZPl",
+    fixedCell: "DataTable-module_fixedCell__dgbUW",
+    cellViewport: "DataTable-module_cellViewport__WZBIX"
+};
+
+const resolveAlignValue = value => {
+    switch (value) {
+      case "start":
+        return "flex-start";
+
+      case "center":
+      default:
+        return "center";
+
+      case "end":
+        return "flex-end";
+    }
+}, resolveDragHandleXPos = elements => {
+    const {cell: cell, handle: handle, parent: parent, position: position = "right"} = null != elements ? elements : {};
+    if (!cell || !parent || !handle) return;
+    const {left: left, width: width} = cell.getBoundingClientRect(), x = left - parent.getBoundingClientRect().left - parent.clientLeft + parent.scrollLeft;
+    handle.style.left = "right" === position ? `${x + width}px` : `${x}px`;
+};
+
+const DEFAULT_OVERSCAN = 6;
+
+function DefaultHeaderRenderer(props) {
+    var _a, _b, _c;
+    const {col: col, sortKey: sortKey} = props, sortable = void 0 !== col.sort, sorted = void 0 !== (null == sortKey ? void 0 : sortKey.key) && sortKey.key === col.sort, sortIcon = "asc" === (null == sortKey ? void 0 : sortKey.dir) ? "arrows.arrow-top" : "arrows.arrow-bottom", justify = null !== (_b = null !== (_a = col.justifyHeader) && void 0 !== _a ? _a : col.justify) && void 0 !== _b ? _b : "start", indicator = sortable && (null === (_c = col.showSortIcon) || void 0 === _c || _c) ? jsxRuntime.jsx(Icon.Icon, {
+        name: sorted ? sortIcon : "system.blank",
+        pointerEvents: "none",
+        size: 16
+    }) : null;
+    return jsxRuntime.jsxs("div", {
+        className: styles.header,
+        style: {
+            justifyContent: resolveAlignValue(justify)
+        },
+        children: [ "end" === justify && indicator, jsxRuntime.jsx("div", {
+            className: styles.headerTitle,
+            style: {
+                flex: "0 1 auto"
+            },
+            children: col.title
+        }), "end" !== justify && indicator ]
+    });
+}
+
+function DefaultCellRenderer(props) {
+    var _a;
+    const {value: value} = props;
+    return null !== (_a = null == value ? void 0 : value.toString()) && void 0 !== _a ? _a : "";
+}
+
+function isInteractiveTarget(target, row) {
+    return target instanceof Element && Boolean(target.closest('button, a, input, select, textarea, summary, [contenteditable]:not([contenteditable="false"]), [role="button"], [role="checkbox"], [role="switch"], [role="link"], [role="slider"], [role="combobox"], [role="textbox"], [role="radio"]')) && target !== row;
+}
+
+exports.DataTable = function(rawProps) {
+    const props = resolveColorProps.resolveColorProps(rawProps), {backgroundColor: backgroundColor = "var(--core-surface-primary)", headerBackgroundColor: headerBackgroundColor = "var(--core-surface-secondary)", headerBackgroundColorHover: headerBackgroundColorHover = "var(--core-surface-primary-tint)", candyStripeBackgroundColor: candyStripeBackgroundColor = "var(--core-surface-primary-tint)", backgroundColorHoverRow: backgroundColorHoverRow = "var(--core-surface-primary-tint)", handleHoverColor: handleHoverColor = "var(--core-button-primary)", freezeColumn: freezeColumn = !1, headerSticky: headerSticky = !0, height: height = "auto", width: width = "100%", maxWidth: maxWidth, colResize: colResize = !0, colReorder: colReorder = !0, columnOrder: controlledColumnOrder, columnWidths: controlledColumnWidths, defaultSort: defaultSort, onRowClick: onRowClick, freezeColumnBackgroundColor: freezeColumnBackgroundColor, borderColor: borderColor = "var(--core-outline-primary)", borderStyle: borderStyle = "box", columnDefinitions: columnDefinitions = [], tableData: tableData = [], getRowId: getRowId, filter: filter, caption: caption = "Data Table", onDoubleClick: onDoubleClick, onClick: onClick, onMouseOut: onMouseOut, onMouseOver: onMouseOver, sort: sort, onSortChange: onSortChange, onColumnResize: onColumnResize, onColumnReorder: onColumnReorder, borderRadius: borderRadius = theme_corners.corners["corner-m"], virtualizeRows: virtualizeRows, virtualizeRowThreshold: virtualizeRowThreshold = 500, rowHeight: rowHeight = 44, overscanRows: overscanRows, margin: margin} = props, [hScroll, setHScroll] = React.useState(!1), [vScroll, setVScroll] = React.useState(!1), [internalSort, setInternalSort] = React.useState(defaultSort), sortControlled = Object.hasOwn(rawProps, "sort"), sortKey = sortControlled ? sort : internalSort, [internalColumnWidths, setInternalColumnWidths] = React.useState({}), [internalColumnOrder, setInternalColumnOrder] = React.useState(null), columnOrder = null != controlledColumnOrder ? controlledColumnOrder : internalColumnOrder, columnWidths = null != controlledColumnWidths ? controlledColumnWidths : internalColumnWidths, setColumnWidths = React.useCallback(next => {
+        void 0 === controlledColumnWidths && setInternalColumnWidths(next);
+    }, [ controlledColumnWidths ]), setColumnOrder = React.useCallback(next => {
+        void 0 === controlledColumnOrder && setInternalColumnOrder(next);
+    }, [ controlledColumnOrder ]), [draggedColId, setDraggedColId] = React.useState(null), wrapperRef = React.useRef(null), headerRef = React.useRef(null), headerSize = hooks_useObserveResize.useObserveResize(headerRef, {
+        ignore: "width"
+    }), resizeBarRef = React.useRef(null), colRefs = React.useRef({}), elements = React.useMemo(() => ({
+        handle: resizeBarRef,
+        parent: wrapperRef
+    }), []), cornerBoxShadow = React.useMemo(() => {
+        const shadows = [];
+        return hScroll && freezeColumn && shadows.push("1px 0 0 var(--core-outline-primary)", "5px 0 0 rgba(0,0,0,0.1)"), 
+        vScroll && headerSticky && shadows.push("0 1px 0 var(--core-outline-primary)"), 
+        vScroll && headerSticky && !hScroll && shadows.push("0 5px 0 rgba(0,0,0,0.1)"), 
+        shadows.length > 0 ? shadows.join(",") : "none";
+    }, [ hScroll, vScroll, freezeColumn, headerSticky ]), columnBoxShadow = React.useMemo(() => {
+        const shadows = [];
+        return hScroll && freezeColumn && shadows.push("1px 0 0 var(--core-outline-primary)", "5px 0 0 rgba(0,0,0,0.1)"), 
+        shadows.length > 0 ? shadows.join(",") : "none";
+    }, [ hScroll, freezeColumn ]), headerBoxShadow = React.useMemo(() => {
+        const shadows = [];
+        return vScroll && headerSticky && shadows.push("0 1px 0 var(--core-outline-primary)", "0 5px 0 rgba(0,0,0,0.1)"), 
+        shadows.length > 0 ? shadows.join(",") : "none";
+    }, [ vScroll, headerSticky ]), cssVars = React.useMemo(() => ({
+        "--table-width": misc.setStyle(width),
+        "--table-max-width": misc.setStyle(maxWidth),
+        "--table-height": misc.setStyle(height),
+        "--table-margin": misc.setStyle(margin, 0),
+        "--table-background-color": backgroundColor,
+        "--table-hover-background": backgroundColorHoverRow,
+        "--table-row-height": `${rowHeight}px`,
+        "--table-column-box-shadow": columnBoxShadow,
+        "--table-header-box-shadow": headerBoxShadow,
+        "--table-corner-box-shadow": cornerBoxShadow,
+        "--table-header-background-color": headerBackgroundColor,
+        "--table-header-background-color-hover": headerBackgroundColorHover,
+        "--table-candy-stripe-background-color": candyStripeBackgroundColor,
+        "--table-freeze-column-position": freezeColumn ? "sticky" : "relative",
+        "--table-header-sticky-position": headerSticky ? "sticky" : "relative",
+        "--table-border-color": borderColor,
+        "--table-corner-position": freezeColumn || headerSticky ? "sticky" : "relative",
+        "--table-corner-left": freezeColumn ? "0px" : "unset",
+        "--table-corner-top": headerSticky ? "0px" : "auto",
+        "--table-border-width": "none" === borderStyle ? "0" : "1px",
+        "--table-border-sides": "box" === borderStyle ? "1px" : "0",
+        "--table-handle-hover-color": handleHoverColor,
+        "--table-border-radius": "box" === borderStyle ? misc.setStyle(borderRadius) : theme_corners.corners["corner-none"]
+    }), [ backgroundColor, backgroundColorHoverRow, rowHeight, headerBackgroundColor, headerBackgroundColorHover, candyStripeBackgroundColor, cornerBoxShadow, columnBoxShadow, headerBoxShadow, freezeColumn, headerSticky, width, height, borderColor, borderStyle, handleHoverColor, borderRadius, maxWidth, margin ]), handleCreateRefs = React.useCallback((el, id) => {
+        colRefs.current[id] = el;
+    }, []), orderedColumns = React.useMemo(() => {
+        if (!columnOrder) return columnDefinitions;
+        const byId = new Map(columnDefinitions.map(column => [ column.id, column ])), ordered = columnOrder.map(id => byId.get(id)).filter(column => !!column), seen = new Set(columnOrder);
+        return [ ...ordered, ...columnDefinitions.filter(column => !seen.has(column.id)) ];
+    }, [ columnDefinitions, columnOrder ]), finishResize = React.useCallback((id, width) => {
+        var _a;
+        const element = colRefs.current[id];
+        if (void 0 !== controlledColumnWidths && element) {
+            const column = orderedColumns.find(column => column.id === id);
+            element.style.width = misc.setStyle(null !== (_a = controlledColumnWidths[id]) && void 0 !== _a ? _a : null == column ? void 0 : column.width);
+        }
+        null == onColumnResize || onColumnResize(id, width);
+    }, [ controlledColumnWidths, orderedColumns, onColumnResize ]), {dragResize: dragResize, hoverResize: hoverResize} = function(elements, colResize, setColumnWidths, onColumnResize) {
+        const resizeCallback = React.useRef(onColumnResize);
+        resizeCallback.current = onColumnResize;
+        const [resizeCol, setResizeCol] = React.useState(null), [client, setClient] = React.useState(null), [resizing, setResizing] = React.useState(!1), didSetListenersRef = React.useRef(!1), previousStyles = React.useRef({
+            userSelect: "",
+            webkitUserSelect: "",
+            cursor: ""
+        }), originalWidth = React.useRef(""), colStartX = React.useRef(0), lastWidthRef = React.useRef(0), hasMovedRef = React.useRef(!1), resolveStartingXPos = React.useCallback(() => (null == resizeCol ? void 0 : resizeCol.cell) ? resizeCol.cell.getBoundingClientRect().left : 0, [ resizeCol ]), applyHandlePos = React.useCallback(show => {
+            var _a, _b;
+            const {cell: cell} = null != resizeCol ? resizeCol : {}, handle = null === (_a = elements.handle) || void 0 === _a ? void 0 : _a.current, parent = null === (_b = elements.parent) || void 0 === _b ? void 0 : _b.current;
+            !show && handle ? handle.style.left = "-500px" : resolveDragHandleXPos({
+                cell: cell,
+                handle: handle,
+                parent: parent
+            });
+        }, [ resizeCol, elements ]), applyWidth = React.useCallback(clientX => {
+            if (!(null == resizeCol ? void 0 : resizeCol.col)) return;
+            const newWidth = Math.max(40, clientX - colStartX.current);
+            resizeCol.col.style.width = `${newWidth}px`, lastWidthRef.current = newWidth, hasMovedRef.current = !0;
+        }, [ resizeCol ]), handleMouseMove = React.useCallback(e => {
+            e.stopPropagation(), e.preventDefault(), setResizing(!0);
+            const nextClientPos = (e => {
+                var _a, _b, _c, _d;
+                if (e.type.startsWith("touch")) {
+                    const touchEvent = e;
+                    return {
+                        x: null !== (_b = null === (_a = touchEvent.touches[0]) || void 0 === _a ? void 0 : _a.clientX) && void 0 !== _b ? _b : 0,
+                        y: null !== (_d = null === (_c = touchEvent.touches[0]) || void 0 === _c ? void 0 : _c.clientY) && void 0 !== _d ? _d : 0
+                    };
+                }
+                const mouseEvent = e;
+                return {
+                    x: mouseEvent.clientX,
+                    y: mouseEvent.clientY
+                };
+            })(e);
+            setClient(nextClientPos), applyWidth(nextClientPos.x), applyHandlePos(!0);
+        }, [ applyWidth, applyHandlePos ]), handleMouseUp = React.useCallback(e => {
+            var _a;
+            if (e.stopPropagation(), e.preventDefault(), resizeCol && hasMovedRef.current) {
+                const colId = resizeCol.id, width = lastWidthRef.current;
+                setColumnWidths(prev => Object.assign(Object.assign({}, prev), {
+                    [colId]: width
+                })), null === (_a = resizeCallback.current) || void 0 === _a || _a.call(resizeCallback, colId, width);
+            }
+            setResizing(!1), setClient(null), applyHandlePos(!1), setResizeCol(null);
+        }, [ resizeCol, applyHandlePos, setColumnWidths ]), cancelResize = React.useCallback(() => {
+            resizeCol && (resizeCol.col.style.width = originalWidth.current), setResizing(!1), 
+            setClient(null), applyHandlePos(!1), setResizeCol(null);
+        }, [ resizeCol, applyHandlePos ]), initListeners = React.useCallback(() => {
+            didSetListenersRef.current || (document.documentElement.addEventListener("mousemove", handleMouseMove, !1), 
+            document.documentElement.addEventListener("mouseup", handleMouseUp, !1), document.documentElement.addEventListener("touchmove", handleMouseMove, {
+                passive: !1
+            }), document.documentElement.addEventListener("touchend", handleMouseUp, !1), document.documentElement.addEventListener("touchcancel", cancelResize, !1), 
+            window.addEventListener("blur", cancelResize), previousStyles.current = {
+                userSelect: document.documentElement.style.userSelect,
+                webkitUserSelect: document.documentElement.style.webkitUserSelect,
+                cursor: document.documentElement.style.cursor
+            }, document.documentElement.style.userSelect = "none", document.documentElement.style.webkitUserSelect = "none", 
+            document.documentElement.style.cursor = "col-resize", colStartX.current = resolveStartingXPos(), 
+            didSetListenersRef.current = !0);
+        }, [ handleMouseMove, handleMouseUp, resolveStartingXPos, cancelResize ]), clearListeners = React.useCallback(() => {
+            didSetListenersRef.current && (document.documentElement.removeEventListener("mousemove", handleMouseMove), 
+            document.documentElement.removeEventListener("mouseup", handleMouseUp), document.documentElement.removeEventListener("touchmove", handleMouseMove, !1), 
+            document.documentElement.removeEventListener("touchend", handleMouseUp, !1), document.documentElement.removeEventListener("touchcancel", cancelResize, !1), 
+            window.removeEventListener("blur", cancelResize), document.documentElement.style.userSelect = previousStyles.current.userSelect, 
+            document.documentElement.style.webkitUserSelect = previousStyles.current.webkitUserSelect, 
+            document.documentElement.style.cursor = previousStyles.current.cursor, colStartX.current = 0, 
+            lastWidthRef.current = 0, hasMovedRef.current = !1, didSetListenersRef.current = !1);
+        }, [ handleMouseMove, handleMouseUp, cancelResize ]), dragResize = React.useCallback((id, e, colRefs) => {
+            if (e.stopPropagation(), e.preventDefault(), !colResize) return;
+            const cell = e.currentTarget.parentElement, col = colRefs.current[id];
+            cell && col && (originalWidth.current = col.style.width, setResizeCol({
+                id: id,
+                cell: cell,
+                col: col
+            }));
+        }, [ colResize ]), hoverResize = React.useCallback((show, e) => {
+            var _a, _b;
+            if (!colResize || resizeCol) return;
+            const cell = e.currentTarget.parentElement, handle = null === (_a = elements.handle) || void 0 === _a ? void 0 : _a.current, parent = null === (_b = elements.parent) || void 0 === _b ? void 0 : _b.current;
+            !show && handle ? handle.style.left = "-500px" : resolveDragHandleXPos({
+                cell: cell,
+                handle: handle,
+                parent: parent
+            });
+        }, [ resizeCol, colResize, elements ]);
+        return React.useEffect(() => {
+            if (!resizeCol || colResize) return resizeCol ? initListeners() : clearListeners(), 
+            () => clearListeners();
+            cancelResize();
+        }, [ resizeCol, initListeners, clearListeners, colResize, cancelResize ]), {
+            clientX: null == client ? void 0 : client.x,
+            clientY: null == client ? void 0 : client.y,
+            resizing: resizing,
+            dragResize: dragResize,
+            hoverResize: hoverResize
+        };
+    }(elements, colResize, setColumnWidths, finishResize), {dragStart: dragStart, dragOver: dragOver, dragDrop: dragDrop} = function(columnDefinitions, setColumnOrder, setDraggedColId, onColumnReorder, freezeColumn) {
+        const [isDragging, setIsDragging] = React.useState(!1), draggedColId = React.useRef(null), draggedColIndex = React.useRef(null), draggedOverColId = React.useRef(null), currentOrderRef = React.useRef(columnDefinitions.map(column => column.id)), initialColumnOrder = React.useRef(null), moveColumn = React.useCallback((draggedId, targetId) => {
+            if (draggedId !== targetId) {
+                const currentOrder = currentOrderRef.current, draggedIndex = currentOrder.indexOf(draggedId), targetIndex = currentOrder.indexOf(targetId);
+                if (-1 === draggedIndex || -1 === targetIndex) return;
+                if (freezeColumn && (0 === draggedIndex || 0 === targetIndex)) return;
+                let next, insertAt;
+                initialColumnOrder.current || (initialColumnOrder.current = currentOrder), targetIndex < draggedIndex ? (next = currentOrder.filter(id => id !== draggedId), 
+                insertAt = next.indexOf(targetId)) : (next = currentOrder.filter(id => id !== draggedId), 
+                insertAt = next.indexOf(targetId) + 1), next.splice(insertAt, 0, draggedId), currentOrderRef.current = next, 
+                setColumnOrder(next), null == onColumnReorder || onColumnReorder(next);
+            }
+        }, [ freezeColumn, onColumnReorder, setColumnOrder ]), dragStart = React.useCallback((col, e) => {
+            currentOrderRef.current = columnDefinitions.map(column => column.id), e.dataTransfer.setData("text/plain", col.id), 
+            draggedColId.current = col.id, setDraggedColId(col.id), setIsDragging(!0), initialColumnOrder.current = null;
+        }, [ setDraggedColId, columnDefinitions ]), dragOver = React.useCallback((col, colIndex, e) => {
+            draggedColId.current && (e.preventDefault(), e.stopPropagation(), draggedColIndex.current = colIndex, 
+            freezeColumn && 0 === colIndex || draggedOverColId.current !== col.id && draggedColId.current !== col.id && (draggedOverColId.current = col.id, 
+            draggedColId.current && moveColumn(draggedColId.current, col.id)));
+        }, [ freezeColumn, moveColumn ]), dragDrop = React.useCallback((e, global = !1) => {
+            e.preventDefault(), e.stopPropagation(), initialColumnOrder.current && (global || freezeColumn && 0 === draggedColIndex.current) && (setColumnOrder(initialColumnOrder.current), 
+            null == onColumnReorder || onColumnReorder(initialColumnOrder.current)), setDraggedColId(null), 
+            setIsDragging(!1), draggedOverColId.current = null, draggedColId.current = null, 
+            draggedColIndex.current = null, initialColumnOrder.current = null;
+        }, [ setColumnOrder, setDraggedColId, freezeColumn, onColumnReorder ]), handleGlobalOver = React.useCallback(e => {
+            e.preventDefault(), draggedOverColId.current = null, draggedColIndex.current = null;
+        }, []), handleGlobalDrop = React.useCallback(e => dragDrop(e, !0), [ dragDrop ]);
+        return React.useEffect(() => {
+            if (isDragging) return document.addEventListener("drop", handleGlobalDrop), document.addEventListener("dragover", handleGlobalOver), 
+            () => {
+                document.removeEventListener("drop", handleGlobalDrop), document.removeEventListener("dragover", handleGlobalOver);
+            };
+        }, [ isDragging, handleGlobalDrop, handleGlobalOver ]), {
+            dragStart: dragStart,
+            dragOver: dragOver,
+            dragDrop: dragDrop
+        };
+    }(orderedColumns, setColumnOrder, setDraggedColId, onColumnReorder, freezeColumn), rows = React.useMemo(() => {
+        const filtered = filter ? tableData.filter((row, index, array) => filter(row, index, array)) : tableData;
+        return void 0 === (null == sortKey ? void 0 : sortKey.key) ? filtered : [ ...filtered ].sort((a, b) => {
+            var _a;
+            if (void 0 === (null == sortKey ? void 0 : sortKey.key)) return 0;
+            const compare = null === (_a = orderedColumns.find(column => column.sort === sortKey.key)) || void 0 === _a ? void 0 : _a.compare;
+            if (compare) return compare(a, b) * ("desc" === sortKey.dir ? -1 : 1);
+            const {key: key, dir: dir} = sortKey;
+            /** Deterministic comparison for default field sorting; missing values stay last in either direction. */
+            return function(a, b, direction) {
+                if (Object.is(a, b)) return 0;
+                const missingA = null == a || "number" == typeof a && Number.isNaN(a), missingB = null == b || "number" == typeof b && Number.isNaN(b);
+                if (missingA && missingB) return 0;
+                if (missingA) return 1;
+                if (missingB) return -1;
+                const multiplier = "desc" === direction ? -1 : 1;
+                return "number" == typeof a && "number" == typeof b ? (a - b) * multiplier : a instanceof Date && b instanceof Date ? (a.getTime() - b.getTime()) * multiplier : String(a).localeCompare(String(b), void 0, {
+                    numeric: !0
+                }) * multiplier;
+            }(a[key], b[key], dir);
+        });
+    }, [ tableData, filter, sortKey, orderedColumns ]), requestedVirtualization = (explicit = virtualizeRows, 
+    rowCount = rows.length, threshold = virtualizeRowThreshold, null != explicit ? explicit : rowCount > threshold);
+    var explicit, rowCount, threshold;
+    const shouldVirtualize = requestedVirtualization && "auto" !== height, rowWindow = function(wrapperRef, rowCount, options) {
+        const {enabled: enabled, rowHeight: rowHeight, overscan: rawOverscan = DEFAULT_OVERSCAN, headerHeight: headerHeight = 0} = options, overscan = Number.isFinite(rawOverscan) ? Math.max(0, Math.floor(rawOverscan)) : DEFAULT_OVERSCAN, viewport = hooks_useObserveResize.useObserveResize(enabled ? wrapperRef : void 0, {
+            ignore: "width"
+        }), [scrollTop, setScrollTop] = React.useState(0), throttledSetScrollTop = React.useMemo(() => rafThrottle.rafThrottle(value => setScrollTop(value)), []);
+        React.useEffect(() => () => throttledSetScrollTop.cancel(), [ throttledSetScrollTop ]);
+        const handleScroll = React.useCallback(nextScrollTop => {
+            enabled && throttledSetScrollTop(nextScrollTop);
+        }, [ enabled, throttledSetScrollTop ]);
+        return React.useEffect(() => {
+            if (!enabled) return;
+            const maxScrollTop = Math.max(0, headerHeight + rowCount * rowHeight - (viewport.height || 0));
+            setScrollTop(prev => prev <= maxScrollTop ? prev : (wrapperRef.current && (wrapperRef.current.scrollTop = 0), 
+            0));
+        }, [ enabled, rowCount, rowHeight, viewport.height, wrapperRef, headerHeight ]), 
+        React.useMemo(() => {
+            if (!enabled || !Number.isFinite(rowHeight) || rowHeight <= 0) return {
+                enabled: !1,
+                startIndex: 0,
+                endIndex: rowCount,
+                topSpacerHeight: 0,
+                bottomSpacerHeight: 0,
+                handleScroll: handleScroll
+            };
+            const viewportHeight = viewport.height || 0, visibleCount = Math.ceil(viewportHeight / rowHeight), firstVisible = Math.floor(Math.max(0, scrollTop - headerHeight) / rowHeight), startIndex = Math.max(0, firstVisible - overscan), endIndex = Math.min(rowCount, firstVisible + visibleCount + overscan);
+            return {
+                enabled: !0,
+                startIndex: startIndex,
+                endIndex: endIndex,
+                topSpacerHeight: startIndex * rowHeight,
+                bottomSpacerHeight: Math.max(0, rowCount - endIndex) * rowHeight,
+                handleScroll: handleScroll
+            };
+        }, [ enabled, rowHeight, overscan, rowCount, viewport.height, scrollTop, handleScroll, headerHeight ]);
+    }(wrapperRef, rows.length, {
+        enabled: shouldVirtualize,
+        rowHeight: rowHeight,
+        headerHeight: headerSize.height,
+        overscan: overscanRows
+    });
+    React.useEffect(() => {
+        "production" !== process.env.NODE_ENV && (requestedVirtualization && "auto" === height && console.warn('[DataTable] `virtualizeRows` needs a bounded `height` (e.g. a fixed px or vh value) to create a scrollable viewport smaller than the full row count - with height="auto" the wrapper grows to fit every row and there\'s nothing to trim.'), 
+        shouldVirtualize && !getRowId && console.warn("[DataTable] `virtualizeRows` is on without `getRowId`. Rows fall back to index-based keys, which can misattach hover/focus state to the wrong row as the window scrolls - pass `getRowId` for stable identity."));
+    }, [ shouldVirtualize, requestedVirtualization, height, getRowId ]);
+    const handleScroll = React.useCallback(() => {
+        var _a, _b, _c, _d;
+        const hScrollAmount = null !== (_b = null === (_a = wrapperRef.current) || void 0 === _a ? void 0 : _a.scrollLeft) && void 0 !== _b ? _b : 0, vScrollAmount = null !== (_d = null === (_c = wrapperRef.current) || void 0 === _c ? void 0 : _c.scrollTop) && void 0 !== _d ? _d : 0;
+        setHScroll(hScrollAmount > 0), setVScroll(vScrollAmount > 0), rowWindow.handleScroll(vScrollAmount);
+    }, [ rowWindow.handleScroll ]), handleClick = React.useCallback((col, colId, row, rowId, dbl) => {
+        dbl && onDoubleClick ? onDoubleClick(col, colId, row, rowId) : !dbl && onClick && onClick(col, colId, row, rowId);
+    }, [ onDoubleClick, onClick ]), handleSort = React.useCallback(key => {
+        if (void 0 === key) return;
+        const next = (null == sortKey ? void 0 : sortKey.key) === key ? {
+            key: key,
+            dir: "asc" === (null == sortKey ? void 0 : sortKey.dir) ? "desc" : "asc"
+        } : {
+            key: key,
+            dir: "asc"
+        };
+        let didChange = !0;
+        (null == sortKey ? void 0 : sortKey.key) === (null == next ? void 0 : next.key) && (null == sortKey ? void 0 : sortKey.dir) === (null == next ? void 0 : next.dir) && (didChange = !1), 
+        didChange && (sortControlled || setInternalSort(next), null == onSortChange || onSortChange(next));
+    }, [ sortKey, onSortChange, sortControlled ]), resolveAriaSort = React.useCallback(column => {
+        const sortable = void 0 !== column.sort, isSortedColumn = sortable && (null == sortKey ? void 0 : sortKey.key) === column.sort;
+        if (sortable) return isSortedColumn ? "asc" === (null == sortKey ? void 0 : sortKey.dir) ? "ascending" : "descending" : void 0;
+    }, [ sortKey ]), renderCellResizeHandle = React.useCallback((last, col) => {
+        var _a, _b;
+        return last || !colResize ? null : jsxRuntime.jsx("div", {
+            className: styles.colResizeHandle,
+            role: "separator",
+            "aria-label": `Resize ${col.title}`,
+            "aria-orientation": "vertical",
+            "aria-valuenow": "number" == typeof (null !== (_a = columnWidths[col.id]) && void 0 !== _a ? _a : col.width) ? Number(null !== (_b = columnWidths[col.id]) && void 0 !== _b ? _b : col.width) : 40,
+            "aria-valuemin": 40,
+            tabIndex: 0,
+            onClick: event => event.stopPropagation(),
+            onKeyDown: event => {
+                if ("ArrowLeft" !== event.key && "ArrowRight" !== event.key) return;
+                event.preventDefault(), event.stopPropagation();
+                const element = colRefs.current[col.id];
+                if (!element) return;
+                const current = element.getBoundingClientRect().width, width = Math.max(40, current + ("ArrowRight" === event.key ? 10 : -10));
+                setColumnWidths(previous => Object.assign(Object.assign({}, previous), {
+                    [col.id]: width
+                })), null == onColumnResize || onColumnResize(col.id, width);
+            },
+            onTouchStart: e => dragResize(col.id, e, colRefs),
+            onMouseDown: e => dragResize(col.id, e, colRefs),
+            onMouseOver: e => hoverResize(!0, e),
+            onFocus: e => hoverResize(!0, e),
+            onMouseOut: e => hoverResize(!1, e),
+            onBlur: e => hoverResize(!1, e)
+        });
+    }, [ colResize, dragResize, hoverResize, columnWidths, setColumnWidths, onColumnResize ]), renderHeader = React.useCallback((col, sortKey) => {
+        if (col.renderHeader) {
+            return (0, col.renderHeader)({
+                column: col,
+                sortKey: sortKey
+            });
+        }
+        return jsxRuntime.jsx(DefaultHeaderRenderer, {
+            col: col,
+            sortKey: sortKey
+        });
+    }, []), renderBodyCell = React.useCallback((col, row, rowIndex) => {
+        const value = function(col, row) {
+            return col.accessor ? col.accessor(row) : void 0 !== col.key ? row[col.key] : void 0;
+        }(col, row);
+        if (col.renderCell) {
+            return (0, col.renderCell)({
+                row: row,
+                value: value,
+                rowIndex: rowIndex
+            });
+        }
+        return jsxRuntime.jsx(DefaultCellRenderer, {
+            value: value
+        });
+    }, []);
+    return jsxRuntime.jsxs("div", {
+        ref: wrapperRef,
+        className: `${styles.tableWrapper} ${styles.scroll}`,
+        style: cssVars,
+        onScroll: handleScroll,
+        children: [ jsxRuntime.jsxs("table", {
+            className: styles.table,
+            "aria-rowcount": rowWindow.enabled ? rows.length + 1 : void 0,
+            children: [ jsxRuntime.jsx("caption", {
+                children: caption
+            }), jsxRuntime.jsx("colgroup", {
+                children: orderedColumns.map(column => {
+                    var _a;
+                    return jsxRuntime.jsx("col", {
+                        ref: el => handleCreateRefs(el, column.id),
+                        style: {
+                            width: misc.setStyle(null !== (_a = columnWidths[column.id]) && void 0 !== _a ? _a : column.width)
+                        }
+                    }, column.id);
+                })
+            }), jsxRuntime.jsx("thead", {
+                ref: headerRef,
+                children: jsxRuntime.jsx("tr", {
+                    children: orderedColumns.map((col, colIndex) => {
+                        var _a, _b;
+                        const padding = misc.setStyle(col.padding, "var(--spacing-m)"), sortable = void 0 !== col.sort, cursor = sortable ? "pointer" : "default", last = colIndex === orderedColumns.length - 1, background = draggedColId === col.id ? backgroundColor : headerBackgroundColor;
+                        return jsxRuntime.jsxs("th", {
+                            "data-column-id": col.id,
+                            "aria-label": col.title,
+                            className: `${styles.baseCell} ${styles.headerCell} ${styles.m}`,
+                            onClick: event => {
+                                isInteractiveTarget(event.target, event.currentTarget) || handleSort(col.sort);
+                            },
+                            onKeyDown: event => {
+                                if (event.target === event.currentTarget) {
+                                    if (colReorder && event.altKey && ("ArrowLeft" === event.key || "ArrowRight" === event.key)) {
+                                        event.preventDefault();
+                                        const next = orderedColumns.map(column => column.id), target = colIndex + ("ArrowRight" === event.key ? 1 : -1);
+                                        if (target < 0 || target >= next.length || freezeColumn && (0 === colIndex || 0 === target)) return;
+                                        return [next[colIndex], next[target]] = [ next[target], next[colIndex] ], setColumnOrder(next), 
+                                        void (null == onColumnReorder || onColumnReorder(next));
+                                    }
+                                    misc.accessibleKeyDown(event, () => handleSort(col.sort));
+                                }
+                            },
+                            style: {
+                                cursor: cursor,
+                                "--table-header-cell-background": background
+                            },
+                            tabIndex: sortable || colReorder ? 0 : void 0,
+                            role: sortable ? "columnheader" : void 0,
+                            "aria-sort": resolveAriaSort(col),
+                            draggable: colReorder && !(freezeColumn && 0 === colIndex),
+                            onDragStart: e => {
+                                colReorder && dragStart(col, e);
+                            },
+                            onDragOver: e => {
+                                colReorder && dragOver(col, colIndex, e);
+                            },
+                            onDrop: e => dragDrop(e),
+                            onDragEnd: e => dragDrop(e, !0),
+                            children: [ renderCellResizeHandle(last, col), jsxRuntime.jsx("div", {
+                                className: styles.headerCellWrapper,
+                                style: {
+                                    padding: padding,
+                                    justifyContent: resolveAlignValue(null !== (_b = null !== (_a = col.justifyHeader) && void 0 !== _a ? _a : col.justify) && void 0 !== _b ? _b : "start")
+                                },
+                                children: renderHeader(col, sortKey)
+                            }) ]
+                        }, col.id);
+                    })
+                })
+            }), jsxRuntime.jsxs("tbody", {
+                children: [ rowWindow.enabled && rowWindow.topSpacerHeight > 0 && jsxRuntime.jsx("tr", {
+                    "aria-hidden": "true",
+                    "data-spacer": "true",
+                    children: jsxRuntime.jsx("td", {
+                        role: "presentation",
+                        colSpan: Math.max(1, orderedColumns.length),
+                        style: {
+                            height: rowWindow.topSpacerHeight,
+                            padding: 0,
+                            border: 0,
+                            background: backgroundColor
+                        }
+                    })
+                }), (rowWindow.enabled ? rows.slice(rowWindow.startIndex, rowWindow.endIndex) : rows).map((row, localIndex) => {
+                    const rowIndex = rowWindow.enabled ? rowWindow.startIndex + localIndex : localIndex, isLastRow = rowIndex === rows.length - 1;
+                    return jsxRuntime.jsx("tr", {
+                        "aria-rowindex": rowWindow.enabled ? rowIndex + 2 : void 0,
+                        tabIndex: onRowClick ? 0 : void 0,
+                        onClick: event => {
+                            isInteractiveTarget(event.target, event.currentTarget) || null == onRowClick || onRowClick(row, rowIndex);
+                        },
+                        onKeyDown: event => {
+                            event.target === event.currentTarget && onRowClick && misc.accessibleKeyDown(event, () => onRowClick(row, rowIndex));
+                        },
+                        children: orderedColumns.map((col, colIndex) => {
+                            var _a;
+                            const justifyContent = resolveAlignValue(null !== (_a = col.justify) && void 0 !== _a ? _a : "start"), alignItems = resolveAlignValue(col.align), padding = misc.setStyle(col.padding, "var(--spacing-m)"), whiteSpace = col.nowrap ? "nowrap" : "", background = candyStripeBackgroundColor && rowIndex % 2 != 0 ? candyStripeBackgroundColor : backgroundColor, opacity = draggedColId === col.id ? .2 : 1, borderBottom = rowWindow.enabled && isLastRow && rowWindow.bottomSpacerHeight > 0 ? 0 : void 0;
+                            return jsxRuntime.jsx("td", {
+                                "data-column-id": `${colIndex}.${rowIndex}`,
+                                className: `${styles.baseCell} ${styles.m}${rowWindow.enabled ? ` ${styles.fixedCell}` : ""}`,
+                                onClick: event => {
+                                    isInteractiveTarget(event.target, event.currentTarget) || handleClick(col, colIndex, row, rowIndex, !1);
+                                },
+                                onDoubleClick: event => {
+                                    isInteractiveTarget(event.target, event.currentTarget) || handleClick(col, colIndex, row, rowIndex, !0);
+                                },
+                                tabIndex: onClick && !onRowClick ? 0 : void 0,
+                                onKeyDown: e => {
+                                    e.target === e.currentTarget && onClick && (e.stopPropagation(), misc.accessibleKeyDown(e, () => handleClick(col, colIndex, row, rowIndex, !1)));
+                                },
+                                onMouseEnter: () => null == onMouseOver ? void 0 : onMouseOver(col, colIndex, row, rowIndex),
+                                onFocus: () => null == onMouseOver ? void 0 : onMouseOver(col, colIndex, row, rowIndex),
+                                onMouseLeave: () => null == onMouseOut ? void 0 : onMouseOut(col, colIndex, row, rowIndex),
+                                onBlur: () => null == onMouseOut ? void 0 : onMouseOut(col, colIndex, row, rowIndex),
+                                style: {
+                                    "--table-cell-background": freezeColumn && 0 === colIndex && null != freezeColumnBackgroundColor ? freezeColumnBackgroundColor : background,
+                                    opacity: opacity,
+                                    borderBottom: borderBottom
+                                },
+                                children: jsxRuntime.jsx("div", {
+                                    className: styles.cellViewport,
+                                    children: jsxRuntime.jsx("div", {
+                                        className: styles.baseCellWrapper,
+                                        style: {
+                                            justifyContent: justifyContent,
+                                            alignItems: alignItems,
+                                            padding: padding,
+                                            whiteSpace: whiteSpace
+                                        },
+                                        children: renderBodyCell(col, row, rowIndex)
+                                    })
+                                })
+                            }, col.id);
+                        })
+                    }, getRowId ? getRowId(row, rowIndex) : rowIndex);
+                }), rowWindow.enabled && rowWindow.bottomSpacerHeight > 0 && jsxRuntime.jsx("tr", {
+                    "aria-hidden": "true",
+                    "data-spacer": "true",
+                    children: jsxRuntime.jsx("td", {
+                        role: "presentation",
+                        colSpan: Math.max(1, orderedColumns.length),
+                        style: {
+                            height: rowWindow.bottomSpacerHeight,
+                            padding: 0,
+                            border: 0,
+                            background: backgroundColor
+                        }
+                    })
+                }) ]
+            }) ]
+        }), jsxRuntime.jsx("div", {
+            className: styles.resizeBar,
+            ref: resizeBarRef
+        }) ]
+    });
+}, exports.applyDataTableViewState = function(columns, state) {
+    var _a;
+    if (!state) return columns;
+    const byId = new Map(columns.map(column => [ column.id, column ])), hidden = new Set(null !== (_a = state.hiddenColumns) && void 0 !== _a ? _a : []), seen = new Set, ordered = [];
+    for (const id of state.columnOrder) {
+        if (seen.has(id) || hidden.has(id)) continue;
+        const column = byId.get(id);
+        column && (seen.add(id), ordered.push(column));
+    }
+    for (const column of columns) seen.has(column.id) || hidden.has(column.id) || (seen.add(column.id), 
+    ordered.push(column));
+    if (!state.columnWidths) return ordered;
+    const widths = state.columnWidths;
+    return ordered.map(column => column.id in widths ? Object.assign(Object.assign({}, column), {
+        width: widths[column.id]
+    }) : column);
+}, exports.captureSortToViewState = function(columns, sort) {
+    if (void 0 === (null == sort ? void 0 : sort.key)) return;
+    const column = columns.find(c => c.sort === sort.key);
+    return column ? {
+        columnId: column.id,
+        dir: sort.dir
+    } : void 0;
+}, exports.createColumnHelper = function() {
+    return {
+        accessor: (accessor, def) => Object.assign({
+            accessor: accessor
+        }, def)
+    };
+}, exports.createDefaultViewState = function(columns) {
+    return {
+        columnOrder: columns.map(column => column.id)
+    };
+}, exports.resolveSortFromViewState = function(columns, state) {
+    if (!(null == state ? void 0 : state.sort)) return;
+    const column = columns.find(c => {
+        var _a;
+        return c.id === (null === (_a = state.sort) || void 0 === _a ? void 0 : _a.columnId);
+    });
+    return void 0 !== (null == column ? void 0 : column.sort) ? {
+        key: column.sort,
+        dir: state.sort.dir
+    } : void 0;
+};

package/dist/cjs/chunks/{volumeStore-DzgmrI6q.js → volumeStore-BoEoo9wA.js}

@@ -1,6 +1,6 @@
 "use strict";
 
-var tslib_es6 = require("./tslib.es6-B2uEaXWi.js");
+var tslib_es6 = require("./tslib.es6-B8JY5ZGw.js");
 
 const useVolumeStore = require("zustand").create((set, get) => ({
     volume: 1,