@react-stately/table 3.2.0 → 3.2.1-nightly.3287

package/dist/main.js

@@ -1,6 +1,6 @@
 var $56JBj$reactstatelycollections = require("@react-stately/collections");
-var $56JBj$reactstatelygrid = require("@react-stately/grid");
 var $56JBj$react = require("react");
+var $56JBj$reactstatelygrid = require("@react-stately/grid");
 
 function $parcel$export(e, n, v, s) {
   Object.defineProperty(e, n, {get: v, set: s, enumerable: true, configurable: true});
@@ -26,14 +26,290 @@ function $parcel$interopDefault(a) {
 }
 
 $parcel$export(module.exports, "Section", () => $56JBj$reactstatelycollections.Section);
+var $7aa22d80cd4ca621$exports = {};
+
+$parcel$export($7aa22d80cd4ca621$exports, "useTableColumnResizeState", () => $7aa22d80cd4ca621$export$cb895dcf85db1319);
+var $3122b463430f41b1$exports = {};
+
+$parcel$export($3122b463430f41b1$exports, "getContentWidth", () => $3122b463430f41b1$export$f61abf052f87399f);
+$parcel$export($3122b463430f41b1$exports, "isStatic", () => $3122b463430f41b1$export$1994a077b98ee0d5);
+$parcel$export($3122b463430f41b1$exports, "parseStaticWidth", () => $3122b463430f41b1$export$7bbad27896f7ae9f);
+$parcel$export($3122b463430f41b1$exports, "getMaxWidth", () => $3122b463430f41b1$export$59185c62a7544aa0);
+$parcel$export($3122b463430f41b1$exports, "getMinWidth", () => $3122b463430f41b1$export$f556054ce4358701);
+$parcel$export($3122b463430f41b1$exports, "getDynamicColumnWidths", () => $3122b463430f41b1$export$a870e6692ac5ccb2);
+function $3122b463430f41b1$export$f61abf052f87399f(widths) {
+    return Array.from(widths).map((e)=>e[1]
+    ).reduce((acc, cur)=>acc + cur
+    , 0);
+}
+function $3122b463430f41b1$export$1994a077b98ee0d5(width) {
+    return width != null && (!isNaN(width) || String(width).match(/^(\d+)(?=%$)/) !== null);
+}
+function $3122b463430f41b1$var$parseFractionalUnit(width) {
+    if (!width) return 1;
+    let match = width.match(/^(\d+)(?=fr$)/);
+    // if width is the incorrect format, just deafult it to a 1fr
+    if (!match) {
+        console.warn(`width: ${width} is not a supported format, width should be a number (ex. 150), percentage (ex. '50%') or fr unit (ex. '2fr')`, 'defaulting to \'1fr\'');
+        return 1;
+    }
+    return parseInt(match[0], 10);
+}
+function $3122b463430f41b1$export$7bbad27896f7ae9f(width, tableWidth) {
+    if (typeof width === 'string') {
+        let match = width.match(/^(\d+)(?=%$)/);
+        if (!match) throw new Error('Only percentages or numbers are supported for static column widths');
+        return tableWidth * (parseInt(match[0], 10) / 100);
+    }
+    return width;
+}
+function $3122b463430f41b1$export$59185c62a7544aa0(maxWidth, tableWidth) {
+    return maxWidth != null ? $3122b463430f41b1$export$7bbad27896f7ae9f(maxWidth, tableWidth) : Infinity;
+}
+function $3122b463430f41b1$export$f556054ce4358701(minWidth, tableWidth) {
+    return minWidth != null ? $3122b463430f41b1$export$7bbad27896f7ae9f(minWidth, tableWidth) : 75;
+}
+function $3122b463430f41b1$var$mapDynamicColumns(dynamicColumns, availableSpace, tableWidth) {
+    let fractions = dynamicColumns.reduce((sum, column)=>sum + $3122b463430f41b1$var$parseFractionalUnit(column.props.defaultWidth)
+    , 0);
+    let columns = dynamicColumns.map((column, index)=>{
+        const targetWidth = $3122b463430f41b1$var$parseFractionalUnit(column.props.defaultWidth) * availableSpace / fractions;
+        const delta = Math.max($3122b463430f41b1$export$f556054ce4358701(column.props.minWidth, tableWidth) - targetWidth, targetWidth - $3122b463430f41b1$export$59185c62a7544aa0(column.props.maxWidth, tableWidth));
+        return {
+            ...column,
+            index: index,
+            delta: delta
+        };
+    });
+    return columns;
+}
+function $3122b463430f41b1$var$findDynamicColumnWidths(dynamicColumns, availableSpace, tableWidth) {
+    let fractions = dynamicColumns.reduce((sum, col)=>sum + $3122b463430f41b1$var$parseFractionalUnit(col.props.defaultWidth)
+    , 0);
+    const columns = dynamicColumns.map((column)=>{
+        const targetWidth = $3122b463430f41b1$var$parseFractionalUnit(column.props.defaultWidth) * availableSpace / fractions;
+        let width = Math.max($3122b463430f41b1$export$f556054ce4358701(column.props.minWidth, tableWidth), Math.min(Math.floor(targetWidth), $3122b463430f41b1$export$59185c62a7544aa0(column.props.maxWidth, tableWidth)));
+        column.calculatedWidth = width;
+        availableSpace -= width;
+        fractions -= $3122b463430f41b1$var$parseFractionalUnit(column.props.defaultWidth);
+        return column;
+    });
+    return columns;
+}
+function $3122b463430f41b1$export$a870e6692ac5ccb2(dynamicColumns, availableSpace, tableWidth) {
+    let columns = $3122b463430f41b1$var$mapDynamicColumns(dynamicColumns, availableSpace, tableWidth);
+    columns.sort((a, b)=>b.delta - a.delta
+    );
+    columns = $3122b463430f41b1$var$findDynamicColumnWidths(columns, availableSpace, tableWidth);
+    columns.sort((a, b)=>a.index - b.index
+    );
+    return columns;
+}
+
+
+
+function $7aa22d80cd4ca621$export$cb895dcf85db1319(props) {
+    const { columns: columns1 , getDefaultWidth: getDefaultWidth , tableWidth: defaultTableWidth = null  } = props;
+    const columnsRef = $56JBj$react.useRef([]);
+    const tableWidth = $56JBj$react.useRef(defaultTableWidth);
+    const isResizing = $56JBj$react.useRef(null);
+    const startResizeContentWidth = $56JBj$react.useRef();
+    const [columnWidths, setColumnWidths] = $56JBj$react.useState(new Map(columns1.map((col)=>[
+            col.key,
+            0
+        ]
+    )));
+    const columnWidthsRef = $56JBj$react.useRef(columnWidths);
+    const affectedColumnWidthsRef = $56JBj$react.useRef([]);
+    const [resizedColumns, setResizedColumns] = $56JBj$react.useState(new Set());
+    const resizedColumnsRef = $56JBj$react.useRef(resizedColumns);
+    function setColumnWidthsForRef(newWidths) {
+        columnWidthsRef.current = newWidths;
+        // new map so that change detection is triggered
+        setColumnWidths(newWidths);
+    }
+    /*
+    returns the resolved column width in this order: 
+    previously calculated width -> controlled width prop -> uncontrolled defaultWidth prop -> dev assigned width -> default dynamic width
+  */ let getResolvedColumnWidth = $56JBj$react.useCallback((column)=>{
+        let columnProps = column.props;
+        var _width, ref, ref1;
+        return (resizedColumns === null || resizedColumns === void 0 ? void 0 : resizedColumns.has(column.key)) ? columnWidthsRef.current.get(column.key) : (ref1 = (ref = (_width = columnProps.width) !== null && _width !== void 0 ? _width : columnProps.defaultWidth) !== null && ref !== void 0 ? ref : getDefaultWidth === null || getDefaultWidth === void 0 ? void 0 : getDefaultWidth(column.props)) !== null && ref1 !== void 0 ? ref1 : '1fr';
+    }, [
+        getDefaultWidth,
+        resizedColumns
+    ]);
+    let getStaticAndDynamicColumns = $56JBj$react.useCallback((columns)=>columns.reduce((acc, column)=>{
+            let width = getResolvedColumnWidth(column);
+            return $3122b463430f41b1$export$1994a077b98ee0d5(width) ? {
+                ...acc,
+                staticColumns: [
+                    ...acc.staticColumns,
+                    column
+                ]
+            } : {
+                ...acc,
+                dynamicColumns: [
+                    ...acc.dynamicColumns,
+                    column
+                ]
+            };
+        }, {
+            staticColumns: [],
+            dynamicColumns: []
+        })
+    , [
+        getResolvedColumnWidth
+    ]);
+    let buildColumnWidths = $56JBj$react.useCallback((affectedColumns, availableSpace)=>{
+        const widths = new Map();
+        let remainingSpace = availableSpace;
+        const { staticColumns: staticColumns , dynamicColumns: dynamicColumns  } = getStaticAndDynamicColumns(affectedColumns);
+        staticColumns.forEach((column)=>{
+            let width = getResolvedColumnWidth(column);
+            let w = $3122b463430f41b1$export$7bbad27896f7ae9f(width, tableWidth.current);
+            widths.set(column.key, w);
+            remainingSpace -= w;
+        });
+        // dynamic columns
+        if (dynamicColumns.length > 0) {
+            const newColumnWidths = $3122b463430f41b1$export$a870e6692ac5ccb2(dynamicColumns, remainingSpace, tableWidth.current);
+            for (let column of newColumnWidths)widths.set(column.key, column.calculatedWidth);
+        }
+        return widths;
+    }, [
+        getStaticAndDynamicColumns,
+        getResolvedColumnWidth
+    ]);
+    const prevColKeys = columnsRef.current.map((col)=>col.key
+    );
+    const colKeys = columns1.map((col)=>col.key
+    );
+    // if the columns change, need to rebuild widths.
+    if (!colKeys.every((col, i)=>col === prevColKeys[i]
+    )) {
+        columnsRef.current = columns1;
+        const widths = buildColumnWidths(columns1, tableWidth.current);
+        setColumnWidthsForRef(widths);
+    }
+    function setTableWidth(width) {
+        if (width && width !== tableWidth.current) {
+            tableWidth.current = width;
+            if (!isResizing.current) {
+                const widths = buildColumnWidths(columns1, width);
+                setColumnWidthsForRef(widths);
+            }
+        }
+    }
+    function onColumnResizeStart() {
+        isResizing.current = true;
+        startResizeContentWidth.current = $3122b463430f41b1$export$f61abf052f87399f(columnWidthsRef.current);
+    }
+    function onColumnResize(column, width) {
+        let widthsObj = resizeColumn(column, width);
+        affectedColumnWidthsRef.current = widthsObj;
+        props.onColumnResize && props.onColumnResize(affectedColumnWidthsRef.current);
+    }
+    function onColumnResizeEnd() {
+        isResizing.current = false;
+        props.onColumnResizeEnd && props.onColumnResizeEnd(affectedColumnWidthsRef.current);
+        affectedColumnWidthsRef.current = [];
+        let widths = new Map(columnWidthsRef.current);
+        // Need to set the resizeBufferColumn or "spooky column" back to 0 since done resizing;
+        const bufferColumnKey = columnsRef.current[columnsRef.current.length - 1].key;
+        widths.set(bufferColumnKey, 0);
+        setColumnWidthsForRef(widths);
+    }
+    function resizeColumn(column1, newWidth) {
+        let boundedWidth = Math.max($3122b463430f41b1$export$f556054ce4358701(column1.props.minWidth, tableWidth.current), Math.min(Math.floor(newWidth), $3122b463430f41b1$export$59185c62a7544aa0(column1.props.maxWidth, tableWidth.current)));
+        // copy the columnWidths map and set the new width for the column being resized
+        let widths = new Map(columnWidthsRef.current);
+        widths.set(columnsRef.current[columnsRef.current.length - 1].key, 0);
+        widths.set(column1.key, boundedWidth);
+        // keep track of all columns that have been sized
+        resizedColumnsRef.current.add(column1.key);
+        setResizedColumns(resizedColumnsRef.current);
+        // get the columns affected by resize and remaining space
+        const resizeIndex = columnsRef.current.findIndex((col)=>col.key === column1.key
+        );
+        let affectedColumns = columnsRef.current.slice(resizeIndex + 1);
+        // we only care about the columns that CAN be resized, we ignore static columns.
+        let { dynamicColumns: dynamicColumns  } = getStaticAndDynamicColumns(affectedColumns);
+        // available space for affected columns
+        let availableSpace = columnsRef.current.reduce((acc, column, index)=>{
+            if (index <= resizeIndex || $3122b463430f41b1$export$1994a077b98ee0d5(getResolvedColumnWidth(column))) return acc - widths.get(column.key);
+            return acc;
+        }, tableWidth.current);
+        // merge the unaffected column widths and the recalculated column widths
+        let recalculatedColumnWidths = buildColumnWidths(dynamicColumns, availableSpace);
+        widths = new Map([
+            ...widths,
+            ...recalculatedColumnWidths
+        ]);
+        if (startResizeContentWidth.current > tableWidth.current) widths.set(columnsRef.current[columnsRef.current.length - 1].key, Math.max(0, startResizeContentWidth.current - $3122b463430f41b1$export$f61abf052f87399f(widths)));
+        setColumnWidthsForRef(widths);
+        /*
+     when getting recalculated columns above, the column being resized is not considered "recalculated"
+     so we need to add it to the list of affected columns
+    */ let allAffectedColumns = [
+            [
+                column1.key,
+                boundedWidth
+            ],
+            ...recalculatedColumnWidths
+        ].map(([key, width])=>({
+                key: key,
+                width: width
+            })
+        );
+        return allAffectedColumns;
+    }
+    var ref2;
+    // This function is regenerated whenever columnWidthsRef.current changes in order to get the new correct ref value.
+    let getColumnWidth = $56JBj$react.useCallback((key)=>(ref2 = columnWidthsRef.current.get(key)) !== null && ref2 !== void 0 ? ref2 : 0
+    , [
+        columnWidthsRef.current
+    ]);
+    let getColumnMinWidth = $56JBj$react.useCallback((key)=>{
+        const columnIndex = columns1.findIndex((col)=>col.key === key
+        );
+        if (columnIndex === -1) return;
+        return $3122b463430f41b1$export$f556054ce4358701(columns1[columnIndex].props.minWidth, tableWidth.current);
+    }, [
+        columns1
+    ]);
+    let getColumnMaxWidth = $56JBj$react.useCallback((key)=>{
+        const columnIndex = columns1.findIndex((col)=>col.key === key
+        );
+        if (columnIndex === -1) return;
+        return $3122b463430f41b1$export$59185c62a7544aa0(columns1[columnIndex].props.maxWidth, tableWidth.current);
+    }, [
+        columns1
+    ]);
+    return {
+        columnWidths: columnWidthsRef,
+        setTableWidth: setTableWidth,
+        onColumnResize: onColumnResize,
+        onColumnResizeStart: onColumnResizeStart,
+        onColumnResizeEnd: onColumnResizeEnd,
+        getColumnWidth: getColumnWidth,
+        getColumnMinWidth: getColumnMinWidth,
+        getColumnMaxWidth: getColumnMaxWidth,
+        isResizingColumn: isResizing.current
+    };
+}
+
+
+
 var $e3f7784147dde23d$exports = {};
 
 $parcel$export($e3f7784147dde23d$exports, "useTableState", () => $e3f7784147dde23d$export$907bcc6c48325fd6);
 
 
 
+
 const $7f5a58334d8866a5$var$ROW_HEADER_COLUMN_KEY = 'row-header-column-' + Math.random().toString(36).slice(2);
-// const RESIZE_BUFFER_COLUMN_KEY = 'resize-buffer-column' + Math.random().toString(36).slice(2);
+const $7f5a58334d8866a5$var$RESIZE_BUFFER_COLUMN_KEY = 'resize-buffer-column' + Math.random().toString(36).slice(2);
 function $7f5a58334d8866a5$var$buildHeaderRows(keyMap, columnNodes) {
     let columns = [];
     let seen = new Map();
@@ -237,35 +513,38 @@ class $7f5a58334d8866a5$export$596e1b2e2cf93690 extends $56JBj$reactstatelygrid.
             for (let child of node.childNodes)visit(child);
         };
         for (let node1 of nodes)visit(node1);
-        // if (Array.from(nodes).some(node => node.props?.allowsResizing)) {
-        //   /*
-        //   If the table content width > table width, a horizontal scroll bar is present.
-        //   If a user tries to resize a column, making it smaller while they are scrolled to the
-        //   end of the content horizontally, it shrinks the total table content width, causing
-        //   things to snap around and breaks the resize behavior.
-        //   To fix this, we add a resize buffer column (aka "spooky column") to the end of the table.
-        //   The width of this column defaults to 0. If you try and shrink a column and the width of the
-        //   table contents > table width, then the "spooky column" will grow to take up the difference
-        //   so that the total table content width remains constant while you are resizing. Once you
-        //   finish resizing, the "spooky column" snaps back to 0.
-        //   */
-        //   let resizeBufferColumn: GridNode<T> = {
-        //     type: 'column',
-        //     key: RESIZE_BUFFER_COLUMN_KEY,
-        //     value: null,
-        //     textValue: '',
-        //     level: 0,
-        //     index: columns.length,
-        //     hasChildNodes: false,
-        //     rendered: null,
-        //     childNodes: [],
-        //     props: {
-        //       isResizeBuffer: true,
-        //       defaultWidth: 0
-        //     }
-        //   };
-        //   columns.push(resizeBufferColumn);
-        // }
+        if (Array.from(nodes).some((node)=>{
+            var ref;
+            return (ref = node.props) === null || ref === void 0 ? void 0 : ref.allowsResizing;
+        })) {
+            /* 
+      If the table content width > table width, a horizontal scroll bar is present.
+      If a user tries to resize a column, making it smaller while they are scrolled to the
+      end of the content horizontally, it shrinks the total table content width, causing
+      things to snap around and breaks the resize behavior.
+      
+      To fix this, we add a resize buffer column (aka "spooky column") to the end of the table.
+      The width of this column defaults to 0. If you try and shrink a column and the width of the
+      table contents > table width, then the "spooky column" will grow to take up the difference
+      so that the total table content width remains constant while you are resizing. Once you
+      finish resizing, the "spooky column" snaps back to 0.
+      */ let resizeBufferColumn = {
+                type: 'column',
+                key: $7f5a58334d8866a5$var$RESIZE_BUFFER_COLUMN_KEY,
+                value: null,
+                textValue: '',
+                level: 0,
+                index: columns.length,
+                hasChildNodes: false,
+                rendered: null,
+                childNodes: [],
+                props: {
+                    isResizeBuffer: true,
+                    defaultWidth: 0
+                }
+            };
+            columns.push(resizeBufferColumn);
+        }
         let headerRows = $7f5a58334d8866a5$var$buildHeaderRows(columnKeyMap, columns);
         headerRows.forEach((row, i)=>rows.splice(i, 0, row)
         );
@@ -310,7 +589,12 @@ function $e3f7784147dde23d$export$907bcc6c48325fd6(props) {
         ...props,
         collection: collection
     });
-    // const tableColumnResizeState = useTableColumnResizeState({columns: collection.columns, getDefaultWidth: props.getDefaultWidth, onColumnResize: props.onColumnResize, onColumnResizeEnd: props.onColumnResizeEnd});
+    const tableColumnResizeState = $7aa22d80cd4ca621$export$cb895dcf85db1319({
+        columns: collection.columns,
+        getDefaultWidth: props.getDefaultWidth,
+        onColumnResize: props.onColumnResize,
+        onColumnResizeEnd: props.onColumnResizeEnd
+    });
     return {
         collection: collection,
         disabledKeys: disabledKeys,
@@ -323,7 +607,8 @@ function $e3f7784147dde23d$export$907bcc6c48325fd6(props) {
                 column: columnKey,
                 direction: direction !== null && direction !== void 0 ? direction : ((ref = props.sortDescriptor) === null || ref === void 0 ? void 0 : ref.column) === columnKey ? $e3f7784147dde23d$var$OPPOSITE_SORT_DIRECTION[props.sortDescriptor.direction] : 'ascending'
             });
-        }
+        },
+        ...tableColumnResizeState
     };
 }
 
@@ -539,6 +824,8 @@ let $ad4ab0a21c733e1f$export$f6f0c3fe4ec306ea = $ad4ab0a21c733e1f$var$Cell;
 
 
 
+$parcel$exportWildcard(module.exports, $7aa22d80cd4ca621$exports);
+$parcel$exportWildcard(module.exports, $3122b463430f41b1$exports);
 $parcel$exportWildcard(module.exports, $e3f7784147dde23d$exports);
 $parcel$exportWildcard(module.exports, $f45775f5d6f744fa$exports);
 $parcel$exportWildcard(module.exports, $6ec527db6a3a5692$exports);