@lowdefy/blocks-table 0.0.0-experimental-20260929110023

package/dist/features/lazyCells/handlePointerOver.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.
+*/ import getBodyRowKey from './getBodyRowKey.js';
+function handlePointerOver(event, api) {
+    api.cellActivity.set({
+        hoveredRow: getBodyRowKey(event.target)
+    });
+    return false;
+}
+export default handlePointerOver;

package/dist/features/lazyCells/handleRowBlur.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 handleRowBlur(event, api) {
+    if (api.contains(event.relatedTarget)) return false;
+    api.cellActivity.set({
+        focusedRow: null
+    });
+    return false;
+}
+export default handleRowBlur;

package/dist/features/lazyCells/handleRowFocus.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 getBodyRowKey from './getBodyRowKey.js';
+// Keyboard focus inside a row (navigation, Tab) reveals and mounts its hover-only buttons. Focus
+// a mouse click leaves behind (on a row checkbox, a cell) does not: the buttons follow the pointer
+// to the next hovered row instead of staying on the clicked one.
+function handleRowFocus(event, api) {
+    const keyboard = event.target.matches(':focus-visible');
+    api.cellActivity.set({
+        focusedRow: keyboard ? getBodyRowKey(event.target) : null
+    });
+    return false;
+}
+export default handleRowFocus;

package/dist/features/lazyCells/lazyCellsFeature.js

@@ -0,0 +1,33 @@
+/*
+  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 handlePointerLeave from './handlePointerLeave.js';
+import handlePointerOver from './handlePointerOver.js';
+import handleRowBlur from './handleRowBlur.js';
+import handleRowFocus from './handleRowFocus.js';
+import useFastScroll from './useFastScroll.js';
+// Feeds `api.cellActivity`, which tier-1 cells (core/LazyCell.js) read to decide when to mount:
+// the hovered row and the focused row through the grid's delegated listeners, and fast scrolling
+// from the scroller. Its handlers never stop the chain.
+const lazyCellsFeature = {
+    name: 'lazyCells',
+    gridHandlers: {
+        blur: handleRowBlur,
+        focus: handleRowFocus,
+        pointerleave: handlePointerLeave,
+        pointerover: handlePointerOver
+    },
+    useGridFeature: useFastScroll
+};
+export default lazyCellsFeature;

package/dist/features/lazyCells/useFastScroll.js

@@ -0,0 +1,57 @@
+/*
+  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 { useEffect } from 'react';
+// Faster than this the rows under the viewport change every frame: tier-1 cells wait.
+const FAST_PX_PER_MS = 1.5;
+const SETTLE_MS = 150;
+// Marks the grid as fast scrolling while the scroll speed stays above FAST_PX_PER_MS, and clears
+// it once the scroll has settled for SETTLE_MS (the react-virtuoso scroll-seek pattern).
+function useFastScroll({ api, scrollerRef }) {
+    useEffect(()=>{
+        const element = scrollerRef.current;
+        const activity = api.cellActivity;
+        let lastTop = element.scrollTop;
+        let lastTime = performance.now();
+        let timer = 0;
+        function settle() {
+            timer = 0;
+            activity.set({
+                fastScrolling: false
+            });
+        }
+        function onScroll() {
+            const now = performance.now();
+            const top = element.scrollTop;
+            const speed = Math.abs(top - lastTop) / Math.max(1, now - lastTime);
+            lastTop = top;
+            lastTime = now;
+            if (speed > FAST_PX_PER_MS) activity.set({
+                fastScrolling: true
+            });
+            if (!activity.state.fastScrolling) return;
+            if (timer) clearTimeout(timer);
+            timer = setTimeout(settle, SETTLE_MS);
+        }
+        element.addEventListener('scroll', onScroll, {
+            passive: true
+        });
+        return ()=>{
+            element.removeEventListener('scroll', onScroll);
+            if (timer) clearTimeout(timer);
+        };
+    }, []);
+    return null;
+}
+export default useFastScroll;

package/dist/features/ordering/getColumnClientBounds.js

@@ -0,0 +1,32 @@
+/*
+  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.
+*/ // Client-space left/right edges of a layout column, from the layout's own geometry rather than
+// the DOM, so columns outside the rendered virtual range still work as drop targets.
+function getColumnClientBounds({ col, layout, scroller }) {
+    const rect = scroller.getBoundingClientRect();
+    let left;
+    if (col.region === 'start') {
+        left = rect.left + col.left;
+    } else if (col.region === 'end') {
+        left = rect.left + scroller.clientWidth - col.right - col.width;
+    } else {
+        left = rect.left + layout.startWidth + col.centerStart - scroller.scrollLeft;
+    }
+    return {
+        left,
+        right: left + col.width
+    };
+}
+export default getColumnClientBounds;

package/dist/features/ordering/handleReorderPointerDown.js

@@ -0,0 +1,137 @@
+/*
+  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 getColumnClientBounds from './getColumnClientBounds.js';
+import moveKeys from './moveKeys.js';
+const DRAG_THRESHOLD = 5;
+function findInsertIndex({ candidates, clientX, layout, scroller }) {
+    let index = 0;
+    candidates.forEach((col, i)=>{
+        const bounds = getColumnClientBounds({
+            col,
+            layout,
+            scroller
+        });
+        if (clientX > (bounds.left + bounds.right) / 2) index = i + 1;
+    });
+    return index;
+}
+function lineClientX({ candidates, index, layout, scroller }) {
+    if (index < candidates.length) {
+        return getColumnClientBounds({
+            col: candidates[index],
+            layout,
+            scroller
+        }).left;
+    }
+    return getColumnClientBounds({
+        col: candidates[candidates.length - 1],
+        layout,
+        scroller
+    }).right;
+}
+// Reorder by header drag (D10.6): a ghost follows the pointer and an insertion line marks the drop
+// position, both moved with transforms. Nothing renders until the drop commits the new order.
+// Columns move within their region (start-pinned, centre or end-pinned).
+function handleReorderPointerDown(event, api) {
+    if (!api.config.reorderable || event.button !== 0) return false;
+    const cell = event.target.closest('[data-lf-header]');
+    if (!cell || !api.contains(cell) || event.target.closest('[data-lf-resize]')) return false;
+    const col = api.layout.byKey.get(cell.dataset.colKey);
+    if (!col || col.special) return false;
+    const candidates = api.layout[col.region].filter((candidate)=>!candidate.special);
+    if (candidates.length < 2) return false;
+    const root = api.rootRef.current;
+    const scroller = api.scrollerRef.current;
+    const startX = event.clientX;
+    const startY = event.clientY;
+    const cellRect = cell.getBoundingClientRect();
+    const offsetX = startX - cellRect.left;
+    let dragging = false;
+    let ghost = null;
+    let line = null;
+    let insertIndex = candidates.indexOf(col);
+    function begin() {
+        dragging = true;
+        root.setAttribute('data-reordering', '');
+        ghost = document.createElement('div');
+        ghost.className = 'lf-table-reorder-ghost';
+        ghost.textContent = cell.textContent;
+        ghost.style.width = `${cellRect.width}px`;
+        ghost.style.height = `${cellRect.height}px`;
+        root.appendChild(ghost);
+        line = document.createElement('div');
+        line.className = 'lf-table-reorder-line';
+        scroller.firstChild.appendChild(line);
+    }
+    function onMove(moveEvent) {
+        if (!dragging) {
+            const distance = Math.abs(moveEvent.clientX - startX) + Math.abs(moveEvent.clientY - startY);
+            if (distance < DRAG_THRESHOLD) return;
+            begin();
+        }
+        ghost.style.transform = `translate(${moveEvent.clientX - offsetX}px, ${cellRect.top}px)`;
+        insertIndex = findInsertIndex({
+            candidates,
+            clientX: moveEvent.clientX,
+            layout: api.layout,
+            scroller
+        });
+        const scrollerRect = scroller.getBoundingClientRect();
+        const x = lineClientX({
+            candidates,
+            index: insertIndex,
+            layout: api.layout,
+            scroller
+        }) - scrollerRect.left + scroller.scrollLeft;
+        line.style.transform = `translate(${x - 1}px, ${scroller.scrollTop}px)`;
+    }
+    function cleanup() {
+        window.removeEventListener('pointermove', onMove);
+        window.removeEventListener('pointerup', onUp);
+        window.removeEventListener('pointercancel', cleanup);
+        root.removeAttribute('data-reordering');
+        ghost?.remove();
+        line?.remove();
+    }
+    function onUp() {
+        cleanup();
+        if (!dragging) return;
+        api.suppressClick();
+        const fromIndex = candidates.indexOf(col);
+        const keys = candidates.map((candidate)=>candidate.key);
+        keys.splice(fromIndex, 1);
+        const targetIndex = insertIndex > fromIndex ? insertIndex - 1 : insertIndex;
+        if (targetIndex === fromIndex) return;
+        keys.splice(targetIndex, 0, col.key);
+        api.updateSlice('columnOrder', (order)=>moveKeys({
+                order,
+                sequence: keys
+            }));
+        if (col.region !== 'center') {
+            api.updateSlice('columnPinning', (pinning)=>({
+                    ...pinning,
+                    [col.region]: moveKeys({
+                        order: pinning[col.region],
+                        sequence: keys
+                    })
+                }));
+        }
+    }
+    window.addEventListener('pointermove', onMove);
+    window.addEventListener('pointerup', onUp);
+    window.addEventListener('pointercancel', cleanup);
+    return false;
+}
+export default handleReorderPointerDown;

package/dist/features/ordering/initColumnOrder.js

@@ -0,0 +1,18 @@
+/*
+  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 initColumnOrder({ viewColumns }) {
+    return viewColumns.map((entry)=>entry.key);
+}
+export default initColumnOrder;

package/dist/features/ordering/moveKeys.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.
+*/ // Rewrites `order` so the keys of `sequence` take the positions those keys already held, in the
+// sequence's new order. Keys outside the sequence (hidden columns, other regions) stay put.
+function moveKeys({ order, sequence }) {
+    const members = new Set(sequence);
+    let next = 0;
+    return order.map((key)=>{
+        if (!members.has(key)) return key;
+        const replacement = sequence[next];
+        next += 1;
+        return replacement;
+    });
+}
+export default moveKeys;

package/dist/features/ordering/orderingFeature.js

@@ -0,0 +1,35 @@
+/*
+  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 { columnOrderingFeature } from '@tanstack/react-table';
+import handleReorderPointerDown from './handleReorderPointerDown.js';
+import initColumnOrder from './initColumnOrder.js';
+// `columnOrder` is the order of `view.columns`; the core assembles each view column entry in this
+// order and asks the other features (sizing, pinning, visibility) to decorate it.
+const orderingFeature = {
+    name: 'ordering',
+    tableFeatures: {
+        columnOrderingFeature
+    },
+    slices: {
+        columnOrder: {
+            init: initColumnOrder,
+            cause: 'columns'
+        }
+    },
+    gridHandlers: {
+        pointerdown: handleReorderPointerDown
+    }
+};
+export default orderingFeature;

package/dist/features/pagination/TablePagination.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.
+*/ import React from 'react';
+import { Pagination } from 'antd';
+// Client-side pages below the grid (`pagination: true`), with antd's Pagination as TableLight
+// has it: the pager always shows once pagination is on.
+function TablePagination({ current, onChange, pageSize, total }) {
+    return /*#__PURE__*/ React.createElement("div", {
+        className: "lf-table-pagination"
+    }, /*#__PURE__*/ React.createElement(Pagination, {
+        current: current,
+        onChange: onChange,
+        pageSize: pageSize,
+        showSizeChanger: false,
+        size: "small",
+        total: total
+    }));
+}
+export default TablePagination;

package/dist/features/pagination/initPageSize.js

@@ -0,0 +1,28 @@
+/*
+  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 { type } from '@lowdefy/helpers';
+import pickViewPart from '../../core/pickViewPart.js';
+// `view.pageSize`, else the `pageSize` property (normalised with `pagination`). Without
+// pagination a view's pageSize is kept as it is, for when pagination is turned on.
+function initPageSize({ value, defaultView, config }) {
+    const pageSize = pickViewPart({
+        value,
+        defaultView,
+        key: 'pageSize'
+    });
+    if (type.isInt(pageSize) && pageSize > 0) return pageSize;
+    return config.pagination?.pageSize;
+}
+export default initPageSize;

package/dist/features/pagination/paginationFeature.js

@@ -0,0 +1,36 @@
+/*
+  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 initPageSize from './initPageSize.js';
+import paginationToValue from './paginationToValue.js';
+import usePager from './usePager.js';
+import usePagination from './usePagination.js';
+// `pagination: true` (off by default: the Table scrolls any number of rows virtually). Last in
+// the registry: a page is a slice of the finished display list. `view.pageSize` is the page size.
+const paginationFeature = {
+    name: 'pagination',
+    viewKeys: [
+        'pageSize'
+    ],
+    slices: {
+        pageSize: {
+            init: initPageSize,
+            cause: 'pageSize'
+        }
+    },
+    toValue: paginationToValue,
+    useItems: usePagination,
+    useFeature: usePager
+};
+export default paginationFeature;

package/dist/features/pagination/paginationToValue.js

@@ -0,0 +1,24 @@
+/*
+  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 { type } from '@lowdefy/helpers';
+function paginationToValue({ state }) {
+    if (type.isUndefined(state.pageSize)) return null;
+    return {
+        view: {
+            pageSize: state.pageSize
+        }
+    };
+}
+export default paginationToValue;

package/dist/features/pagination/usePager.js

@@ -0,0 +1,32 @@
+/*
+  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 React from 'react';
+import TablePagination from './TablePagination.js';
+// The pager below the grid for the page usePagination picked in this render.
+function usePager({ api }) {
+    if (!api.page) return null;
+    const { current, onChange, pageSize, total } = api.page;
+    return {
+        regions: {
+            bottom: /*#__PURE__*/ React.createElement(TablePagination, {
+                current: current,
+                onChange: onChange,
+                pageSize: pageSize,
+                total: total
+            })
+        }
+    };
+}
+export default usePager;

package/dist/features/pagination/usePagination.js

@@ -0,0 +1,58 @@
+/*
+  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 { useMemo, useState } from 'react';
+import isDataItem from '../../core/isDataItem.js';
+// The pagination feature's display-list hook, last in the registry: one page of the display list
+// (rows, or group headers and rows when grouped). The page is local UI state (not part of the
+// value); it is clamped when the list shrinks under it, and changing page scrolls the grid back
+// to the top. `api.page` is what the pager (usePager) renders. `dataRows` keeps every page for
+// export and the summary.
+function usePagination({ api, config, rows, state }) {
+    const [page, setPage] = useState(1);
+    const pageSize = state.pageSize;
+    const total = rows.length;
+    const pageCount = config.pagination ? Math.max(1, Math.ceil(total / pageSize)) : 1;
+    const current = Math.min(page, pageCount);
+    const start = (current - 1) * pageSize;
+    const end = Math.min(total, current * pageSize);
+    const pageRows = useMemo(()=>config.pagination ? rows.slice(start, end) : null, [
+        config.pagination,
+        rows,
+        start,
+        end
+    ]);
+    const dataRows = useMemo(()=>config.pagination ? rows.filter(isDataItem) : null, [
+        config.pagination,
+        rows
+    ]);
+    if (!config.pagination) {
+        api.page = null;
+        return null;
+    }
+    api.page = {
+        current,
+        pageSize,
+        total,
+        onChange (next) {
+            setPage(next);
+            if (api.scrollerRef.current) api.scrollerRef.current.scrollTop = 0;
+        }
+    };
+    return {
+        rows: pageRows,
+        dataRows
+    };
+}
+export default usePagination;

package/dist/features/pinning/initColumnPinning.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 initColumnPinning({ viewColumns }) {
+    return {
+        start: viewColumns.filter((entry)=>entry.pinned === 'start').map((entry)=>entry.key),
+        end: viewColumns.filter((entry)=>entry.pinned === 'end').map((entry)=>entry.key)
+    };
+}
+export default initColumnPinning;