@vuu-ui/vuu-table 2.1.17 → 2.1.19-beta.1

package/cjs/useTable.js

@@ -1,742 +0,0 @@
-'use strict';
-
-var vuuTableExtras = require('@vuu-ui/vuu-table-extras');
-var vuuUiControls = require('@vuu-ui/vuu-ui-controls');
-var vuuUtils = require('@vuu-ui/vuu-utils');
-var react = require('react');
-var useCellBlockSelection = require('./cell-block/useCellBlockSelection.js');
-var CellFocusState = require('./CellFocusState.js');
-var tableConfig = require('./table-config.js');
-var tableDomUtils = require('./table-dom-utils.js');
-var useCellEditing = require('./useCellEditing.js');
-var useCellFocus = require('./useCellFocus.js');
-var useDataSource = require('./table-data-source/useDataSource.js');
-var useKeyboardNavigation = require('./useKeyboardNavigation.js');
-var useRowClassNameGenerators = require('./useRowClassNameGenerators.js');
-var useSelection = require('./useSelection.js');
-var useTableContextMenu = require('./useTableContextMenu.js');
-var useTableModel = require('./useTableModel.js');
-var useTableScroll = require('./useTableScroll.js');
-var useTableViewport = require('./useTableViewport.js');
-
-const nullHeaderState = {
-  height: -1,
-  count: -1
-};
-const zeroHeaderState = {
-  height: 0,
-  count: 0
-};
-const { IS_EXPANDED, IS_LEAF } = vuuUtils.metadataKeys;
-const NULL_DRAG_DROP = {
-  draggable: void 0,
-  onMouseDown: void 0
-};
-const useNullDragDrop = () => NULL_DRAG_DROP;
-const useTable = ({
-  allowCellBlockSelection,
-  allowSelectCheckboxRow,
-  allowDragDrop = false,
-  autoSelectFirstRow,
-  autoSelectRowKey,
-  // colHeaderRowHeight,
-  config,
-  containerRef,
-  dataSource,
-  disableFocus,
-  highlightedIndex: highlightedIndexProp,
-  id,
-  navigationStyle = "cell",
-  onConfigChange,
-  // onDataEdited: onDataEditedProp,
-  onDragStart,
-  onDrop,
-  onHighlight,
-  onRowClick: onRowClickProp,
-  onSelect,
-  onSelectCellBlock,
-  onSelectionChange,
-  renderBufferSize = 0,
-  revealSelected,
-  rowHeight,
-  scrollingApiRef,
-  selectionModel,
-  showColumnHeaders,
-  showPaginationControls,
-  size
-}) => {
-  const tableConfigRef = react.useRef(config);
-  const scrollTopRef = react.useRef(0);
-  const requestScrollRef = react.useRef(void 0);
-  react.useMemo(() => {
-    tableConfigRef.current = config;
-  }, [config]);
-  const editSession = vuuUtils.useEditSession();
-  const initialState = react.useMemo(() => new CellFocusState.CellFocusState(), []);
-  const cellFocusStateRef = react.useRef(initialState);
-  const focusCellRef = react.useRef(void 0);
-  const [headerState, setHeaderState] = react.useState(
-    showColumnHeaders ? nullHeaderState : zeroHeaderState
-  );
-  const [rowCount, setRowCount] = react.useState(dataSource.size);
-  if (dataSource === void 0) {
-    throw Error("no data source provided to Vuu Table");
-  }
-  const onDataRowcountChange = react.useCallback((size2) => {
-    setRowCount(size2);
-  }, []);
-  const { selectionBookendWidth = 4 } = config;
-  const virtualContentHeight = rowHeight * rowCount;
-  const viewportBodyHeight = size.height - (headerState.height === -1 ? 0 : headerState.height);
-  const verticalScrollbarWidth = virtualContentHeight > viewportBodyHeight ? 10 : 0;
-  const availableWidth = size.width - (verticalScrollbarWidth + 2 * selectionBookendWidth);
-  const rowClassNameGenerator = useRowClassNameGenerators.useRowClassNameGenerators(config);
-  const useRowDragDrop = allowDragDrop ? vuuUiControls.useDragDrop : useNullDragDrop;
-  const {
-    columns,
-    dispatchTableModelAction,
-    headings,
-    tableAttributes,
-    tableConfig: tableConfig$1
-  } = useTableModel.useTableModel({ config, dataSource, selectionModel, availableWidth });
-  const columnsRef = vuuUtils.useStableReference(columns);
-  vuuUtils.useLayoutEffectSkipFirst(() => {
-    dispatchTableModelAction({
-      availableWidth,
-      selectionModel,
-      type: "init",
-      tableConfig: tableConfigRef.current,
-      dataSource
-    });
-  }, [
-    availableWidth,
-    config,
-    dataSource,
-    dispatchTableModelAction,
-    selectionModel
-  ]);
-  const applyTableConfigChange = react.useCallback(
-    (config2, changeType) => {
-      dispatchTableModelAction({
-        availableWidth,
-        selectionModel,
-        type: "init",
-        tableConfig: config2,
-        dataSource
-      });
-      tableConfigRef.current = config2;
-      onConfigChange?.(config2, changeType);
-    },
-    [
-      availableWidth,
-      dataSource,
-      dispatchTableModelAction,
-      onConfigChange,
-      selectionModel
-    ]
-  );
-  const handleSelectionChange = react.useCallback(
-    (selectRequest) => {
-      dataSource.select?.(selectRequest);
-      onSelectionChange?.(selectRequest);
-    },
-    [dataSource, onSelectionChange]
-  );
-  const handleSelect = react.useCallback(
-    (dataRow) => {
-      if (onSelect) {
-        onSelect(dataRow);
-      }
-    },
-    [onSelect]
-  );
-  const onSubscribed = react.useCallback(
-    ({ tableSchema }) => {
-      if (tableSchema) {
-        dispatchTableModelAction({
-          type: "setTableSchema",
-          tableSchema
-        });
-      } else {
-        console.log("subscription message with no schema");
-      }
-    },
-    [dispatchTableModelAction]
-  );
-  const {
-    getRowAtPosition,
-    getRowOffset,
-    setInSituRowOffset: viewportHookSetInSituRowOffset,
-    setScrollTop: viewportHookSetScrollTop,
-    ...viewportMeasurements
-  } = useTableViewport.useTableViewport({
-    columns,
-    headerHeight: headerState.height,
-    rowCount,
-    rowHeight,
-    selectionEndSize: selectionBookendWidth,
-    size,
-    showPaginationControls
-  });
-  const {
-    dataRows,
-    dataRowsRef,
-    getSelectedRows,
-    range,
-    // removeColumnDataFromCache,
-    setRange
-  } = useDataSource.useDataSource({
-    autoSelectFirstRow,
-    autoSelectRowKey,
-    dataSource,
-    renderBufferSize,
-    revealSelected,
-    onSelect: handleSelect,
-    onSizeChange: onDataRowcountChange,
-    onSubscribed,
-    selectionModel
-  });
-  const { requestScroll, scrollTop, ...scrollProps } = useTableScroll.useTableScroll({
-    cellFocusStateRef,
-    columns,
-    getRowAtPosition,
-    rowHeight,
-    scrollingApiRef,
-    setRange,
-    showPaginationControls,
-    onVerticalScroll: viewportHookSetScrollTop,
-    onVerticalScrollInSitu: viewportHookSetInSituRowOffset,
-    viewportMeasurements
-  });
-  scrollTopRef.current = scrollTop;
-  requestScrollRef.current = requestScroll;
-  const handleConfigChange = react.useCallback(
-    (config2, _range, confirmed, changes) => {
-      const scrollSensitiveChanges = changes?.filterChanged || changes?.groupByChanged;
-      if (scrollSensitiveChanges && scrollTopRef.current > 0) {
-        setRange(range.reset);
-        requestScrollRef.current?.({
-          type: "scroll-top",
-          scrollPos: 0,
-          instant: true
-        });
-      }
-      dispatchTableModelAction({
-        type: "tableConfig",
-        ...config2,
-        confirmed
-      });
-    },
-    [dispatchTableModelAction, range, setRange]
-  );
-  react.useEffect(() => {
-    dataSource.on("config", handleConfigChange);
-    return () => {
-      dataSource.removeListener("config", handleConfigChange);
-    };
-  }, [dataSource, dispatchTableModelAction, handleConfigChange]);
-  const removeColumn = react.useCallback(
-    (action) => {
-      const { column } = action;
-      const newTableConfig = {
-        ...tableConfig$1,
-        columns: tableConfig$1.columns.filter((col) => col.name !== column.name)
-      };
-      applyTableConfigChange(newTableConfig, {
-        type: "column-removed",
-        column
-      });
-    },
-    [applyTableConfigChange, tableConfig$1]
-  );
-  const hideColumns = react.useCallback(
-    (action) => {
-      const { columns: columns2 } = action;
-      const hiddenColumns = columns2.map((c) => c.name);
-      const newTableConfig = {
-        ...tableConfig$1,
-        columns: tableConfig$1.columns.map(
-          (col) => hiddenColumns.includes(col.name) ? { ...col, hidden: true } : col
-        )
-      };
-      applyTableConfigChange(newTableConfig, {
-        type: "columns-hidden",
-        columns: columns2
-      });
-    },
-    [tableConfig$1, applyTableConfigChange]
-  );
-  const pinColumn = react.useCallback(
-    ({ column, pin }) => {
-      applyTableConfigChange(
-        {
-          ...tableConfig$1,
-          columns: vuuUtils.updateColumn(tableConfig$1.columns, {
-            ...column,
-            pin
-          })
-        },
-        {
-          type: "column-pinned",
-          column
-        }
-      );
-    },
-    [tableConfig$1, applyTableConfigChange]
-  );
-  const handleColumnDisplayAction = react.useCallback(
-    (action) => {
-      const { type } = action;
-      switch (type) {
-        case "hideColumn":
-          return hideColumns({
-            type: "hideColumns",
-            columns: [action.column]
-          });
-        case "removeColumn":
-          return removeColumn({
-            type: "removeColumn",
-            column: action.column
-          });
-        case "pinColumn":
-          return pinColumn(action);
-        default:
-          vuuUtils.logUnhandledMessage(type, "[vuu-table] handleColumnDisplayAction");
-      }
-    },
-    [hideColumns, pinColumn, removeColumn]
-  );
-  const handleColumnAction = vuuTableExtras.useColumnActions({
-    dataSource,
-    onColumnDisplayAction: handleColumnDisplayAction
-  });
-  const handleSort = react.useCallback(
-    (column, extendSort = false, sortType) => {
-      if (dataSource) {
-        dataSource.sort = vuuUtils.toggleOrApplySort(
-          dataSource.sort,
-          column,
-          extendSort,
-          sortType
-        );
-      }
-    },
-    [dataSource]
-  );
-  const cellResizeState = react.useRef(void 0);
-  const onResizeColumn = react.useCallback(
-    (phase, columnName, width = 0) => {
-      if (phase === "resize") {
-        cellResizeState.current?.cells.forEach((cell) => {
-          cell.style.width = `${width}px`;
-        });
-        if (cellResizeState.current?.pinState) {
-          const { pinState, startWidth } = cellResizeState.current;
-          const { cell: pinnedCell, pinnedWidth } = pinState;
-          const diff = width - startWidth;
-          if (pinState.pinnedCells) {
-            pinState.pinnedCells.forEach((cell) => {
-              cell.style.left = `${parseInt(cell.style.left) + diff}px`;
-            });
-          }
-          pinnedCell.style.setProperty(
-            "--pin-width",
-            `${pinnedWidth + diff}px`
-          );
-        }
-      } else {
-        const column = columnsRef.current.find(
-          (column2) => column2.name === columnName
-        );
-        if (column) {
-          if (phase === "end") {
-            cellResizeState.current = void 0;
-            if (vuuUtils.isValidNumber(width)) {
-              dispatchTableModelAction({
-                type: "resizeColumn",
-                phase,
-                column,
-                width
-              });
-              onConfigChange?.(
-                tableConfig.updateTableConfig(tableConfig$1, {
-                  type: "col-size",
-                  column,
-                  columns,
-                  width
-                }),
-                {
-                  type: "column-resized",
-                  column,
-                  width
-                }
-              );
-            }
-          } else if (phase === "begin") {
-            cellResizeState.current = {
-              cells: vuuUtils.getAllCellsInColumn(
-                containerRef.current,
-                column.ariaColIndex
-              ),
-              startWidth: column.width
-            };
-            const [headerCell] = cellResizeState.current.cells;
-            cellResizeState.current.pinState = vuuUtils.getPinStateFromElement(headerCell);
-            dispatchTableModelAction({
-              type: "resizeColumn",
-              phase,
-              column,
-              width
-            });
-            onConfigChange?.(
-              tableConfig.updateTableConfig(tableConfig$1, {
-                type: "col-size",
-                column,
-                columns,
-                width
-              }),
-              {
-                type: "column-resized",
-                column,
-                width
-              }
-            );
-          }
-        } else {
-          throw Error(
-            `useDataTable.handleColumnResize, column ${columnName} not found`
-          );
-        }
-      }
-    },
-    [
-      columnsRef,
-      dispatchTableModelAction,
-      onConfigChange,
-      tableConfig$1,
-      columns,
-      containerRef
-    ]
-  );
-  const onToggleGroup = react.useCallback(
-    (dataRow, column) => {
-      const isJson = vuuUtils.isJsonGroup(column, dataRow);
-      const { key } = dataRow;
-      if (dataRow.isExpanded) {
-        dataSource.closeTreeNode(key, true);
-        if (isJson) {
-          const idx = columns.indexOf(column);
-          const rows = dataSource.getRowsAtDepth?.(idx + 1);
-          if (rows && !rows.some((row) => row[IS_EXPANDED] || row[IS_LEAF])) {
-            dispatchTableModelAction({
-              type: "hideColumns",
-              columns: columns.slice(idx + 2)
-            });
-          }
-        }
-      } else {
-        dataSource.openTreeNode(key);
-        if (isJson) {
-          const childRows = dataSource.getChildRows?.(key);
-          const idx = columns.indexOf(column) + 1;
-          const columnsToShow = [columns[idx]];
-          if (childRows && childRows.some((row) => row[IS_LEAF])) {
-            columnsToShow.push(columns[idx + 1]);
-          }
-          if (columnsToShow.some((col) => col.hidden)) {
-            dispatchTableModelAction({
-              type: "showColumns",
-              columns: columnsToShow
-            });
-          }
-        }
-      }
-    },
-    [columns, dataSource, dispatchTableModelAction]
-  );
-  const handleToggleGroup = react.useCallback(
-    (treeNodeOperation, rowIdx) => {
-      if (treeNodeOperation === "expand") {
-        dataSource.openTreeNode(rowIdx);
-      } else {
-        dataSource.closeTreeNode(rowIdx);
-      }
-    },
-    [dataSource]
-  );
-  const {
-    focusCell,
-    focusCellPlaceholderKeyDown,
-    focusCellPlaceholderRef,
-    setTableBodyRef: tableBodyRef
-  } = useCellFocus.useCellFocus({
-    cellFocusStateRef,
-    containerRef,
-    disableFocus,
-    requestScroll
-  });
-  focusCellRef.current = focusCell;
-  const columnCount = columns.filter((c) => c.hidden !== true).length;
-  const {
-    highlightedIndexRef,
-    navigateCell: navigate,
-    onFocus: navigationFocus,
-    onKeyDown: navigationKeyDown,
-    ...containerProps
-  } = useKeyboardNavigation.useKeyboardNavigation({
-    cellFocusStateRef,
-    columnCount,
-    containerRef,
-    disableFocus,
-    editSessionInProgress: editSession?.inEditMode,
-    focusCell,
-    headerCount: headerState.count,
-    highlightedIndex: highlightedIndexProp,
-    navigationStyle,
-    requestScroll,
-    rowCount,
-    onHighlight,
-    onToggleGroup: handleToggleGroup,
-    viewportRange: range,
-    viewportRowCount: viewportMeasurements.rowCount
-  });
-  const {
-    onBlur: editingBlur,
-    onDoubleClick: editingDoubleClick,
-    onKeyDown: editingKeyDown,
-    onFocus: editingFocus
-  } = useCellEditing.useCellEditing({
-    navigate
-  });
-  const handleFocus = react.useCallback(
-    (e) => {
-      navigationFocus();
-      if (!e.defaultPrevented) {
-        editingFocus(e);
-      }
-    },
-    [editingFocus, navigationFocus]
-  );
-  const onContextMenu = useTableContextMenu.useTableContextMenu({
-    columns,
-    dataRows,
-    dataSource,
-    getSelectedRows,
-    headerCount: headerState.count
-  });
-  const onMoveGroupColumn = react.useCallback(
-    (columns2) => {
-      dataSource.groupBy = columns2.map((col) => col.name);
-    },
-    [dataSource]
-  );
-  const onRemoveGroupColumn = react.useCallback(
-    (column) => {
-      if (vuuUtils.isGroupColumn(column)) {
-        dataSource.groupBy = [];
-      } else {
-        if (dataSource && dataSource.groupBy?.includes(column.name)) {
-          dataSource.groupBy = dataSource.groupBy.filter(
-            (columnName) => columnName !== column.name
-          );
-        }
-      }
-    },
-    [dataSource]
-  );
-  const {
-    allRowsSelected,
-    onCheckBoxColumnHeaderClick,
-    onKeyDown: selectionHookKeyDown,
-    onRowClick: selectionHookOnRowClick
-  } = useSelection.useSelection({
-    allowSelectCheckboxRow,
-    containerRef,
-    dataSource,
-    highlightedIndexRef,
-    onSelect: handleSelect,
-    onSelectionChange: handleSelectionChange,
-    selectionModel
-  });
-  const handleSelectCellBlock = react.useCallback(
-    (cellBlock2) => {
-      handleSelectionChange({
-        type: "DESELECT_ALL"
-      });
-      onSelectCellBlock?.(cellBlock2);
-    },
-    [handleSelectionChange, onSelectCellBlock]
-  );
-  const {
-    onMouseDown: cellBlockHookMouseDown,
-    cellBlock,
-    onKeyDown: cellBlockSelectionKeyDown
-  } = useCellBlockSelection.useCellBlockSelection({
-    allowCellBlockSelection,
-    columnCount,
-    containerRef,
-    onSelectCellBlock: handleSelectCellBlock,
-    rowCount
-  });
-  const handleRowClick = react.useCallback(
-    (evt, dataRow, rangeSelect, keepExistingSelection) => {
-      selectionHookOnRowClick?.(
-        evt,
-        dataRow,
-        rangeSelect,
-        keepExistingSelection
-      );
-      onRowClickProp?.(evt, dataRow);
-    },
-    [onRowClickProp, selectionHookOnRowClick]
-  );
-  const handleKeyDown = react.useCallback(
-    (e) => {
-      cellBlockSelectionKeyDown?.(e);
-      if (!e.defaultPrevented) {
-        navigationKeyDown(e);
-      }
-      if (!e.defaultPrevented) {
-        editingKeyDown(e);
-      }
-      if (!e.defaultPrevented) {
-        selectionHookKeyDown(e);
-      }
-    },
-    [
-      cellBlockSelectionKeyDown,
-      navigationKeyDown,
-      editingKeyDown,
-      selectionHookKeyDown
-    ]
-  );
-  const onMoveColumn = react.useCallback(
-    (columnName, columns2) => {
-      const newTableConfig = {
-        ...tableConfig$1,
-        columns: columns2
-      };
-      tableConfigRef.current = newTableConfig;
-      dispatchTableModelAction({
-        availableWidth,
-        type: "init",
-        tableConfig: newTableConfig,
-        dataSource
-      });
-      onConfigChange?.(newTableConfig, {
-        columnName,
-        columns: columns2,
-        type: "column-moved"
-      });
-      setTimeout(() => {
-        const headerCell = tableDomUtils.getHeaderCell(containerRef, columnName);
-        if (headerCell) {
-          const { ariaColIndex } = headerCell;
-          const { ariaRowIndex } = headerCell.parentElement;
-          const col = parseInt(ariaColIndex ?? "-1");
-          const row = parseInt(ariaRowIndex ?? "-1");
-          if (!isNaN(col) && col !== -1 && !isNaN(row) && row !== -1) {
-            focusCell([row, col]);
-          }
-        }
-      }, 300);
-    },
-    [
-      availableWidth,
-      containerRef,
-      dataSource,
-      dispatchTableModelAction,
-      focusCell,
-      onConfigChange,
-      tableConfig$1
-    ]
-  );
-  const handleDropRow = react.useCallback(
-    // TODO - this should be GlobalDropHandler
-    // eslint-disable-next-line @typescript-eslint/no-explicit-any
-    (dragDropState) => {
-      onDrop?.(dragDropState);
-    },
-    [onDrop]
-  );
-  const handleDragStartRow = react.useCallback(
-    (dragDropState) => {
-      const { initialDragElement } = dragDropState;
-      const rowIndex = vuuUtils.getAriaRowIndex(initialDragElement) - headerState.count - 1;
-      const row = dataRowsRef.current.find((row2) => row2.index === rowIndex);
-      if (row) {
-        dragDropState.setPayload(row);
-      }
-      onDragStart?.(dragDropState);
-    },
-    [dataRowsRef, headerState.count, onDragStart]
-  );
-  const onHeaderHeightMeasured = react.useCallback(
-    (height, count) => {
-      setHeaderState({ height, count });
-    },
-    []
-  );
-  const { onMouseDown: rowDragMouseDown, draggable: draggableRow } = useRowDragDrop({
-    allowDragDrop,
-    containerRef,
-    draggableClassName: `vuuTable`,
-    id,
-    onDragStart: handleDragStartRow,
-    onDrop: handleDropRow,
-    orientation: "vertical",
-    itemQuery: ".vuuTableRow"
-  });
-  const handleMouseDown = react.useCallback(
-    (evt) => {
-      rowDragMouseDown?.(evt);
-      if (!evt.isPropagationStopped()) {
-        cellBlockHookMouseDown?.(evt);
-      }
-    },
-    [rowDragMouseDown, cellBlockHookMouseDown]
-  );
-  return {
-    ...containerProps,
-    allRowsSelected,
-    "aria-rowcount": dataSource.size,
-    cellBlock,
-    columns,
-    dataRows,
-    draggableRow,
-    editSessionInProgress: editSession?.inEditMode,
-    focusCellPlaceholderKeyDown,
-    focusCellPlaceholderRef,
-    getRowOffset,
-    handleColumnAction,
-    headerState,
-    headings,
-    highlightedIndex: highlightedIndexRef.current,
-    onBlur: editingBlur,
-    onCheckBoxColumnHeaderClick,
-    onDoubleClick: editingDoubleClick,
-    onFocus: handleFocus,
-    onKeyDown: handleKeyDown,
-    onMouseDown: handleMouseDown,
-    onContextMenu,
-    // onDataEdited: handleDataEdited,
-    onHeaderHeightMeasured,
-    onMoveColumn,
-    onMoveGroupColumn,
-    onRemoveGroupColumn,
-    onRowClick: handleRowClick,
-    onSortColumn: handleSort,
-    onResizeColumn,
-    onToggleGroup,
-    rowClassNameGenerator,
-    scrollProps,
-    // TODO don't think we need these ...
-    tableAttributes,
-    tableBodyRef,
-    tableConfig: tableConfig$1,
-    viewportMeasurements
-  };
-};
-
-exports.useTable = useTable;
-//# sourceMappingURL=useTable.js.map