@lowdefy/blocks-table 0.0.0-experimental-20260929110023

package/dist/features/headerMenu/measureColumnWidth.js

@@ -0,0 +1,51 @@
+/*
+  Copyright 2020-2026 Lowdefy, Inc
+
+  Licensed under the Apache License, Version 2.0 (the "License");
+  you may not use this file except in compliance with the License.
+  You may obtain a copy of the License at
+
+      http://www.apache.org/licenses/LICENSE-2.0
+
+  Unless required by applicable law or agreed to in writing, software
+  distributed under the License is distributed on an "AS IS" BASIS,
+  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+  See the License for the specific language governing permissions and
+  limitations under the License.
+*/ function horizontalPadding(element) {
+    const style = getComputedStyle(element);
+    return parseFloat(style.paddingLeft) + parseFloat(style.paddingRight);
+}
+// The width a column needs to show its rendered cells and its header without truncation. Only
+// rendered cells can be measured (the virtual window); that is what the user is looking at.
+function measureColumnWidth({ api, key }) {
+    const root = api.rootRef.current;
+    const selector = `[data-lf-cell][data-col-key="${CSS.escape(key)}"]`;
+    let width = 0;
+    root.querySelectorAll(`.lf-table-body ${selector}`).forEach((cell)=>{
+        // A cell lays its children out in a row: a tree row's indent and chevron, then the content.
+        // Portalled edit markers are absolutely positioned and take no room.
+        let content = 0;
+        Array.from(cell.children).forEach((child)=>{
+            if (getComputedStyle(child).position === 'absolute') return;
+            content += child.scrollWidth;
+        });
+        width = Math.max(width, content + horizontalPadding(cell));
+    });
+    const header = root.querySelector(`[data-lf-header]${selector}`);
+    if (header) {
+        const style = getComputedStyle(header);
+        const gap = parseFloat(style.columnGap) || 0;
+        let content = 0;
+        let parts = 0;
+        Array.from(header.children).forEach((child)=>{
+            if (getComputedStyle(child).position === 'absolute') return;
+            content += child.classList.contains('lf-table-header-title') ? child.scrollWidth : child.offsetWidth;
+            parts += 1;
+        });
+        width = Math.max(width, content + gap * Math.max(parts - 1, 0) + horizontalPadding(header));
+    }
+    // One pixel of slack: scrollWidth rounds down fractional text widths.
+    return Math.ceil(width) + 1;
+}
+export default measureColumnWidth;

package/dist/features/headerMenu/pinColumn.js

@@ -0,0 +1,27 @@
+/*
+  Copyright 2020-2026 Lowdefy, Inc
+
+  Licensed under the Apache License, Version 2.0 (the "License");
+  you may not use this file except in compliance with the License.
+  You may obtain a copy of the License at
+
+      http://www.apache.org/licenses/LICENSE-2.0
+
+  Unless required by applicable law or agreed to in writing, software
+  distributed under the License is distributed on an "AS IS" BASIS,
+  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+  See the License for the specific language governing permissions and
+  limitations under the License.
+*/ // Pins a column to `side` ('start' | 'end'), or unpins it (side null). A newly pinned column goes
+// to the inner edge of its region: the end of the start region, the start of the end region.
+function pinColumn({ pinning, key, side }) {
+    const start = pinning.start.filter((entry)=>entry !== key);
+    const end = pinning.end.filter((entry)=>entry !== key);
+    if (side === 'start') start.push(key);
+    if (side === 'end') end.unshift(key);
+    return {
+        start,
+        end
+    };
+}
+export default pinColumn;

package/dist/features/headerMenu/sectionOrder.js

@@ -0,0 +1,25 @@
+/*
+  Copyright 2020-2026 Lowdefy, Inc
+
+  Licensed under the Apache License, Version 2.0 (the "License");
+  you may not use this file except in compliance with the License.
+  You may obtain a copy of the License at
+
+      http://www.apache.org/licenses/LICENSE-2.0
+
+  Unless required by applicable law or agreed to in writing, software
+  distributed under the License is distributed on an "AS IS" BASIS,
+  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+  See the License for the specific language governing permissions and
+  limitations under the License.
+*/ // Header menu sections, top to bottom. Items name their section; a section not listed here (a
+// later feature's) goes before `manage`, in feature order.
+const sectionOrder = [
+    'sort',
+    'filter',
+    'group',
+    'pin',
+    'column',
+    'manage'
+];
+export default sectionOrder;

package/dist/features/headerMenu/useHeaderMenuState.js

@@ -0,0 +1,27 @@
+/*
+  Copyright 2020-2026 Lowdefy, Inc
+
+  Licensed under the Apache License, Version 2.0 (the "License");
+  you may not use this file except in compliance with the License.
+  You may obtain a copy of the License at
+
+      http://www.apache.org/licenses/LICENSE-2.0
+
+  Unless required by applicable law or agreed to in writing, software
+  distributed under the License is distributed on an "AS IS" BASIS,
+  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+  See the License for the specific language governing permissions and
+  limitations under the License.
+*/ import { useState } from 'react';
+// Which column's header menu is open. `pressedOpen` is set by the menu button's pointerdown
+// (see handleHeaderButtonPointerDown) and read by the click that follows it.
+function useHeaderMenuState({ api }) {
+    const [openKey, setOpenKey] = useState(null);
+    api.headerMenu = {
+        openKey,
+        setOpenKey,
+        pressedOpen: api.headerMenu?.pressedOpen ?? null
+    };
+    return null;
+}
+export default useHeaderMenuState;

package/dist/features/index.js

@@ -0,0 +1,149 @@
+/*
+  Copyright 2020-2026 Lowdefy, Inc
+
+  Licensed under the Apache License, Version 2.0 (the "License");
+  you may not use this file except in compliance with the License.
+  You may obtain a copy of the License at
+
+      http://www.apache.org/licenses/LICENSE-2.0
+
+  Unless required by applicable law or agreed to in writing, software
+  distributed under the License is distributed on an "AS IS" BASIS,
+  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+  See the License for the specific language governing permissions and
+  limitations under the License.
+*/ import bulkFeature from './bulk/bulkFeature.js';
+import clipboardFeature from './clipboard/clipboardFeature.js';
+import columnManagerFeature from './columnManager/columnManagerFeature.js';
+import densityFeature from './density/densityFeature.js';
+import eventsFeature from './events/eventsFeature.js';
+import expansionFeature from './expansion/expansionFeature.js';
+import exportFeature from './export/exportFeature.js';
+import filteringFeature from './filtering/filteringFeature.js';
+import groupingFeature from './grouping/groupingFeature.js';
+import headerMenuFeature from './headerMenu/headerMenuFeature.js';
+import keyboardFeature from './keyboard/keyboardFeature.js';
+import lazyCellsFeature from './lazyCells/lazyCellsFeature.js';
+import needsEditing from './editing/needsEditing.js';
+import needsExpandable from './expandable/needsExpandable.js';
+import needsGroupRows from './grouping/needsGroupRows.js';
+import needsServerData from './serverData/needsServerData.js';
+import needsToolbar from './toolbar/needsToolbar.js';
+import needsTree from './tree/needsTree.js';
+import needsViews from './views/needsViews.js';
+import orderingFeature from './ordering/orderingFeature.js';
+import paginationFeature from './pagination/paginationFeature.js';
+import pinningFeature from './pinning/pinningFeature.js';
+import queueFeature from './queue/queueFeature.js';
+import selectionFeature from './selection/selectionFeature.js';
+import sizingFeature from './sizing/sizingFeature.js';
+import sortingFeature from './sorting/sortingFeature.js';
+import transactionsFeature from './transactions/transactionsFeature.js';
+import virtualizationFeature from './virtualization/virtualizationFeature.js';
+import visibilityFeature from './visibility/visibilityFeature.js';
+// Optional features load in their own chunk, only for tables whose config needs them
+// (core/useFeatureSet.js); `methods` are the block methods they own, registered as no-ops on
+// tables without them so a CallMethod never fails.
+function optional({ name, needs, load, methods = [] }) {
+    return {
+        load,
+        methods,
+        name,
+        needs,
+        optional: true
+    };
+}
+// The table's feature modules, in composition order. The core loops over a table's list for
+// TanStack feature slots, state slices, view/value derivation, header parts, delegated event
+// handlers, actions and block methods (see ARCHITECTURE.md). The order is the order handlers run
+// in: a handler that returns true stops the chain for that event. Filtering and the header menu
+// come first: the filtered row model feeds sorting, and their header buttons claim clicks and
+// pointer presses before sorting and column reordering see them. Views come before the toolbar,
+// which renders their tabs, and queue's single-key actions run before keyboard navigation sees
+// the key (editing's keys, earlier, win on editable cells). It is also the order of the data
+// pipeline's hooks (TableRoot): `useData` (server rows, tree flattening), `useRows`
+// (transactions, then editing's overlay over them) and `useItems` (server items, client groups,
+// tree rows, expandable detail rows, the page).
+const features = [
+    filteringFeature,
+    headerMenuFeature,
+    columnManagerFeature,
+    sortingFeature,
+    sizingFeature,
+    orderingFeature,
+    pinningFeature,
+    visibilityFeature,
+    densityFeature,
+    transactionsFeature,
+    optional({
+        name: 'editing',
+        needs: needsEditing,
+        load: ()=>import('./editing/editingFeature.js')
+    }),
+    clipboardFeature,
+    optional({
+        name: 'paste',
+        needs: ({ input })=>input === true,
+        load: ()=>import('./clipboard/pasteFeature.js')
+    }),
+    selectionFeature,
+    expansionFeature,
+    optional({
+        name: 'serverData',
+        needs: needsServerData,
+        load: ()=>import('./serverData/serverDataFeature.js'),
+        methods: [
+            'refresh'
+        ]
+    }),
+    groupingFeature,
+    optional({
+        name: 'groupRows',
+        needs: needsGroupRows,
+        load: ()=>import('./grouping/groupRowsFeature.js'),
+        methods: [
+            'collapseAllGroups',
+            'expandAllGroups',
+            'setGroup'
+        ]
+    }),
+    optional({
+        name: 'tree',
+        needs: needsTree,
+        load: ()=>import('./tree/treeFeature.js')
+    }),
+    optional({
+        name: 'expandable',
+        needs: needsExpandable,
+        load: ()=>import('./expandable/expandableFeature.js')
+    }),
+    virtualizationFeature,
+    optional({
+        name: 'positionedRows',
+        needs: ({ rowWindowStrategy })=>rowWindowStrategy === 'positioned',
+        load: ()=>import('./virtualization/positionedRowsFeature.js')
+    }),
+    optional({
+        name: 'serverRange',
+        needs: needsServerData,
+        load: ()=>import('./serverData/serverRangeFeature.js')
+    }),
+    lazyCellsFeature,
+    optional({
+        name: 'views',
+        needs: needsViews,
+        load: ()=>import('./views/viewsFeature.js')
+    }),
+    optional({
+        name: 'toolbar',
+        needs: needsToolbar,
+        load: ()=>import('./toolbar/toolbarFeature.js')
+    }),
+    bulkFeature,
+    queueFeature,
+    keyboardFeature,
+    eventsFeature,
+    exportFeature,
+    paginationFeature
+];
+export default features;

package/dist/features/keyboard/findCellElement.js

@@ -0,0 +1,21 @@
+/*
+  Copyright 2020-2026 Lowdefy, Inc
+
+  Licensed under the Apache License, Version 2.0 (the "License");
+  you may not use this file except in compliance with the License.
+  You may obtain a copy of the License at
+
+      http://www.apache.org/licenses/LICENSE-2.0
+
+  Unless required by applicable law or agreed to in writing, software
+  distributed under the License is distributed on an "AS IS" BASIS,
+  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+  See the License for the specific language governing permissions and
+  limitations under the License.
+*/ // Rows that are not data rows (an expanded detail row, a group header) may have fewer cells than
+// the grid has columns; focus lands on their first cell.
+function findCellElement({ api, row, col }) {
+    const scroller = api.scrollerRef.current;
+    return scroller?.querySelector(`[data-row-index="${row}"] [data-lf-cell][data-col-index="${col}"]`) ?? scroller?.querySelector(`[data-row-index="${row}"] [data-lf-cell]`);
+}
+export default findCellElement;

package/dist/features/keyboard/getNextCell.js

@@ -0,0 +1,74 @@
+/*
+  Copyright 2020-2026 Lowdefy, Inc
+
+  Licensed under the Apache License, Version 2.0 (the "License");
+  you may not use this file except in compliance with the License.
+  You may obtain a copy of the License at
+
+      http://www.apache.org/licenses/LICENSE-2.0
+
+  Unless required by applicable law or agreed to in writing, software
+  distributed under the License is distributed on an "AS IS" BASIS,
+  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+  See the License for the specific language governing permissions and
+  limitations under the License.
+*/ // Arrow keys, Home/End (row ends), Ctrl/Cmd+Home/End (grid corners) and PageUp/PageDown (one
+// body height). Row -1 is the header row.
+function getNextCell({ event, api, row, col }) {
+    const lastRow = api.rows.length - 1;
+    const lastCol = api.layout.cols.length - 1;
+    const modified = event.ctrlKey || event.metaKey;
+    const scroller = api.scrollerRef.current;
+    const pageRows = Math.max(1, Math.floor((scroller.clientHeight - api.headerHeight) / api.rowHeight) - 1);
+    switch(event.key){
+        case 'ArrowUp':
+            return {
+                row: Math.max(-1, row - 1),
+                col
+            };
+        case 'ArrowDown':
+            return {
+                row: Math.min(lastRow, row + 1),
+                col
+            };
+        case 'ArrowLeft':
+            return {
+                row,
+                col: Math.max(0, col - 1)
+            };
+        case 'ArrowRight':
+            return {
+                row,
+                col: Math.min(lastCol, col + 1)
+            };
+        case 'Home':
+            return modified ? {
+                row: Math.min(0, lastRow),
+                col: 0
+            } : {
+                row,
+                col: 0
+            };
+        case 'End':
+            return modified ? {
+                row: lastRow,
+                col: lastCol
+            } : {
+                row,
+                col: lastCol
+            };
+        case 'PageUp':
+            return {
+                row: row < 0 ? row : Math.max(0, row - pageRows),
+                col
+            };
+        case 'PageDown':
+            return {
+                row: Math.min(lastRow, Math.max(0, row) + pageRows),
+                col
+            };
+        default:
+            return null;
+    }
+}
+export default getNextCell;

package/dist/features/keyboard/handleGridFocus.js

@@ -0,0 +1,31 @@
+/*
+  Copyright 2020-2026 Lowdefy, Inc
+
+  Licensed under the Apache License, Version 2.0 (the "License");
+  you may not use this file except in compliance with the License.
+  You may obtain a copy of the License at
+
+      http://www.apache.org/licenses/LICENSE-2.0
+
+  Unless required by applicable law or agreed to in writing, software
+  distributed under the License is distributed on an "AS IS" BASIS,
+  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+  See the License for the specific language governing permissions and
+  limitations under the License.
+*/ // Focus that lands on a cell (click, Tab, programmatic) makes it the active cell. Focus on the
+// scroller itself means the active cell is outside the rendered window: bring it back.
+function handleGridFocus(event, api) {
+    if (event.target === api.scrollerRef.current) {
+        api.keyboard.moveTo(api.keyboard.activeCell);
+        return true;
+    }
+    const cell = event.target.closest('[data-lf-cell]');
+    if (!cell || !api.contains(cell)) return false;
+    const rowElement = cell.closest('[data-row-index]');
+    api.keyboard.setActive({
+        row: Number(rowElement.dataset.rowIndex),
+        col: Number(cell.dataset.colIndex)
+    });
+    return false;
+}
+export default handleGridFocus;

package/dist/features/keyboard/handleGridKeyDown.js

@@ -0,0 +1,72 @@
+/*
+  Copyright 2020-2026 Lowdefy, Inc
+
+  Licensed under the Apache License, Version 2.0 (the "License");
+  you may not use this file except in compliance with the License.
+  You may obtain a copy of the License at
+
+      http://www.apache.org/licenses/LICENSE-2.0
+
+  Unless required by applicable law or agreed to in writing, software
+  distributed under the License is distributed on an "AS IS" BASIS,
+  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+  See the License for the specific language governing permissions and
+  limitations under the License.
+*/ import getNextCell from './getNextCell.js';
+function activate({ event, api, cell, row, rowElement }) {
+    if (row === -1) {
+        if (cell.dataset.special === 'select') return api.actions.toggleAllRowsSelected?.();
+        return api.actions.toggleSort?.({
+            key: cell.dataset.colKey,
+            multi: event.shiftKey
+        });
+    }
+    return api.actions.activateRow?.({
+        id: rowElement.dataset.rowKey,
+        event
+    });
+}
+function handleGridKeyDown(event, api) {
+    if (!api.config.keyboard) return false;
+    const cell = event.target.closest('[data-lf-cell]');
+    if (!cell || !api.contains(cell)) return false;
+    if (event.target !== cell) {
+        // Keys typed into a control inside a cell belong to the control; Escape returns to the grid.
+        if (event.key !== 'Escape') return false;
+        cell.focus();
+        return true;
+    }
+    const rowElement = cell.closest('[data-row-index]');
+    const row = Number(rowElement.dataset.rowIndex);
+    const col = Number(cell.dataset.colIndex);
+    if (event.key === ' ') {
+        if (row < 0 || !api.config.rowSelection) return false;
+        event.preventDefault();
+        api.actions.toggleRowSelected({
+            id: rowElement.dataset.rowKey
+        });
+        return true;
+    }
+    if (event.key === 'Enter') {
+        event.preventDefault();
+        activate({
+            event,
+            api,
+            cell,
+            row,
+            rowElement
+        });
+        return true;
+    }
+    const next = getNextCell({
+        event,
+        api,
+        row,
+        col
+    });
+    if (!next) return false;
+    event.preventDefault();
+    api.keyboard.moveTo(next);
+    return true;
+}
+export default handleGridKeyDown;

package/dist/features/keyboard/isCellRendered.js

@@ -0,0 +1,22 @@
+/*
+  Copyright 2020-2026 Lowdefy, Inc
+
+  Licensed under the Apache License, Version 2.0 (the "License");
+  you may not use this file except in compliance with the License.
+  You may obtain a copy of the License at
+
+      http://www.apache.org/licenses/LICENSE-2.0
+
+  Unless required by applicable law or agreed to in writing, software
+  distributed under the License is distributed on an "AS IS" BASIS,
+  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+  See the License for the specific language governing permissions and
+  limitations under the License.
+*/ function isCellRendered({ cell, layout, range }) {
+    if (cell.row >= 0 && (cell.row < range.rowStart || cell.row >= range.rowEnd)) return false;
+    const col = layout.cols[cell.col];
+    if (!col || col.region !== 'center') return true;
+    const centerIndex = col.index - layout.start.length;
+    return centerIndex >= range.colStart && centerIndex < range.colEnd;
+}
+export default isCellRendered;

package/dist/features/keyboard/keyboardFeature.js

@@ -0,0 +1,26 @@
+/*
+  Copyright 2020-2026 Lowdefy, Inc
+
+  Licensed under the Apache License, Version 2.0 (the "License");
+  you may not use this file except in compliance with the License.
+  You may obtain a copy of the License at
+
+      http://www.apache.org/licenses/LICENSE-2.0
+
+  Unless required by applicable law or agreed to in writing, software
+  distributed under the License is distributed on an "AS IS" BASIS,
+  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+  See the License for the specific language governing permissions and
+  limitations under the License.
+*/ import handleGridFocus from './handleGridFocus.js';
+import handleGridKeyDown from './handleGridKeyDown.js';
+import useKeyboard from './useKeyboard.js';
+const keyboardFeature = {
+    name: 'keyboard',
+    useGridFeature: useKeyboard,
+    gridHandlers: {
+        focus: handleGridFocus,
+        keydown: handleGridKeyDown
+    }
+};
+export default keyboardFeature;

package/dist/features/keyboard/useKeyboard.js

@@ -0,0 +1,84 @@
+/*
+  Copyright 2020-2026 Lowdefy, Inc
+
+  Licensed under the Apache License, Version 2.0 (the "License");
+  you may not use this file except in compliance with the License.
+  You may obtain a copy of the License at
+
+      http://www.apache.org/licenses/LICENSE-2.0
+
+  Unless required by applicable law or agreed to in writing, software
+  distributed under the License is distributed on an "AS IS" BASIS,
+  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+  See the License for the specific language governing permissions and
+  limitations under the License.
+*/ import { useLayoutEffect, useRef, useState } from 'react';
+import findCellElement from './findCellElement.js';
+import isCellRendered from './isCellRendered.js';
+import scrollToCell from '../virtualization/scrollToCell.js';
+function clampCell({ cell, rowCount, colCount }) {
+    return {
+        row: Math.min(Math.max(cell.row, -1), rowCount - 1),
+        col: Math.min(Math.max(cell.col, 0), Math.max(colCount - 1, 0))
+    };
+}
+// Roving tabindex over the grid (D11): exactly one cell (header row -1 included) is tabbable. The
+// active cell may be scrolled out of the rendered window; then the scroller itself takes the tab
+// stop and hands focus back to the cell (scrolled into view) when it receives it.
+function useKeyboard(ctx) {
+    const { api, layout, range, rows } = ctx;
+    const [active, setActive] = useState(null);
+    const pendingFocus = useRef(false);
+    const fallback = {
+        row: rows.length ? 0 : -1,
+        col: 0
+    };
+    const activeCell = clampCell({
+        cell: active ?? fallback,
+        rowCount: rows.length,
+        colCount: layout.cols.length
+    });
+    api.keyboard = {
+        activeCell,
+        moveTo (cell) {
+            const next = clampCell({
+                cell,
+                rowCount: api.rows.length,
+                colCount: api.layout.cols.length
+            });
+            pendingFocus.current = true;
+            setActive(next);
+            scrollToCell({
+                api,
+                row: next.row,
+                col: next.col
+            });
+        },
+        setActive (cell) {
+            setActive((previous)=>previous?.row === cell.row && previous?.col === cell.col ? previous : cell);
+        }
+    };
+    useLayoutEffect(()=>{
+        if (!pendingFocus.current) return;
+        const element = findCellElement({
+            api,
+            row: activeCell.row,
+            col: activeCell.col
+        });
+        if (!element) return;
+        pendingFocus.current = false;
+        element.focus({
+            preventScroll: true
+        });
+    });
+    const rendered = isCellRendered({
+        cell: activeCell,
+        layout,
+        range
+    });
+    return {
+        activeCell,
+        scrollerTabIndex: rendered ? -1 : 0
+    };
+}
+export default useKeyboard;

package/dist/features/lazyCells/getBodyRowKey.js

@@ -0,0 +1,19 @@
+/*
+  Copyright 2020-2026 Lowdefy, Inc
+
+  Licensed under the Apache License, Version 2.0 (the "License");
+  you may not use this file except in compliance with the License.
+  You may obtain a copy of the License at
+
+      http://www.apache.org/licenses/LICENSE-2.0
+
+  Unless required by applicable law or agreed to in writing, software
+  distributed under the License is distributed on an "AS IS" BASIS,
+  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+  See the License for the specific language governing permissions and
+  limitations under the License.
+*/ function getBodyRowKey(target) {
+    if (!(target instanceof Element)) return null;
+    return target.closest('.lf-table-body [data-row-key]')?.dataset.rowKey ?? null;
+}
+export default getBodyRowKey;

package/dist/features/lazyCells/handlePointerLeave.js

@@ -0,0 +1,21 @@
+/*
+  Copyright 2020-2026 Lowdefy, Inc
+
+  Licensed under the Apache License, Version 2.0 (the "License");
+  you may not use this file except in compliance with the License.
+  You may obtain a copy of the License at
+
+      http://www.apache.org/licenses/LICENSE-2.0
+
+  Unless required by applicable law or agreed to in writing, software
+  distributed under the License is distributed on an "AS IS" BASIS,
+  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+  See the License for the specific language governing permissions and
+  limitations under the License.
+*/ function handlePointerLeave(event, api) {
+    api.cellActivity.set({
+        hoveredRow: null
+    });
+    return false;
+}
+export default handlePointerLeave;