@lowdefy/blocks-table 0.0.0-experimental-20260929110023

package/dist/features/grouping/handleGroupClick.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.
+*/ import scrollToCell from '../virtualization/scrollToCell.js';
+// A click on a group header row toggles the group; on its checkbox, selects the group's rows. A
+// toggle from the sticky overlay also scrolls the group's own header back to its slot, so the
+// rows that collapsed away do not leave the view somewhere below, and moves focus to that header
+// (the overlay is a hidden copy).
+function handleGroupClick(event, api) {
+    const rowElement = event.target.closest('[data-group-key]');
+    if (!rowElement || !api.contains(rowElement)) return false;
+    const key = rowElement.dataset.groupKey;
+    if (event.target.closest('[data-lf-group-select]')) {
+        api.actions.toggleGroupSelected({
+            key
+        });
+        return true;
+    }
+    api.actions.toggleGroup({
+        key
+    });
+    if (rowElement.closest('[data-lf-group-sticky]')) {
+        const row = Number(rowElement.dataset.groupIndex);
+        // An inner group's header goes to its own slot, under its outer groups' sticky headers.
+        const startInset = Number(rowElement.dataset.groupDepth) * api.rowHeight;
+        scrollToCell({
+            api,
+            row,
+            col: -1,
+            align: 'start',
+            startInset
+        });
+        api.keyboard.moveTo({
+            row,
+            col: api.keyboard.activeCell.col
+        });
+    }
+    return true;
+}
+export default handleGroupClick;

package/dist/features/grouping/handleGroupKeyDown.js

@@ -0,0 +1,60 @@
+/*
+  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.
+*/ // Keys on a focused group header cell, ahead of the keyboard feature: Enter toggles the group,
+// Right expands and Left collapses it (on an already expanded or collapsed group the arrow moves
+// between cells as usual), Space selects the group's rows. They work with `keyboard: false` too:
+// they operate the focused group header, as a click does, and move no focus.
+function handleGroupKeyDown(event, api) {
+    const cell = event.target.closest('[data-lf-cell]');
+    if (!cell || cell !== event.target || !api.contains(cell)) return false;
+    const rowElement = cell.closest('[data-group-key]');
+    if (!rowElement) return false;
+    const key = rowElement.dataset.groupKey;
+    // Read from the row, which holds it for client and server groups alike.
+    const collapsed = rowElement.getAttribute('aria-expanded') === 'false';
+    switch(event.key){
+        case 'Enter':
+            event.preventDefault();
+            api.actions.toggleGroup({
+                key
+            });
+            return true;
+        case 'ArrowRight':
+            if (!collapsed) return false;
+            event.preventDefault();
+            api.actions.toggleGroup({
+                key,
+                collapsed: false
+            });
+            return true;
+        case 'ArrowLeft':
+            if (collapsed) return false;
+            event.preventDefault();
+            api.actions.toggleGroup({
+                key,
+                collapsed: true
+            });
+            return true;
+        case ' ':
+            event.preventDefault();
+            api.actions.toggleGroupSelected({
+                key
+            });
+            return true;
+        default:
+            return false;
+    }
+}
+export default handleGroupKeyDown;

package/dist/features/grouping/initAggregates.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 { type } from '@lowdefy/helpers';
+import AGGREGATE_LABELS from '@lowdefy/blocks-antd/table/aggregateLabels.js';
+import pickViewPart from '../../core/pickViewPart.js';
+// The view's aggregate choices, `{ [columnKey]: fn | null }`. Entries for unknown columns or
+// unknown functions are dropped; column `aggregate` defaults apply under these
+// (resolveAggregates).
+function initAggregates({ value, defaultView, config }) {
+    const aggregates = pickViewPart({
+        value,
+        defaultView,
+        key: 'aggregates'
+    });
+    if (!type.isObject(aggregates)) return {};
+    const resolved = {};
+    Object.entries(aggregates).forEach(([key, fn])=>{
+        if (!config.columnsByKey.has(key)) return;
+        if (!type.isNull(fn) && !Object.hasOwn(AGGREGATE_LABELS, fn)) return;
+        resolved[key] = fn;
+    });
+    return resolved;
+}
+export default initAggregates;

package/dist/features/grouping/initCollapsedGroups.js

@@ -0,0 +1,29 @@
+/*
+  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';
+// Collapsed group keys (JSON of the group's value path, for example `["lead"]` or
+// `["EMEA","Ada"]`). Keys of groups that no longer exist are kept: they match again when the
+// group comes back.
+function initCollapsedGroups({ value, defaultView }) {
+    const collapsed = pickViewPart({
+        value,
+        defaultView,
+        key: 'collapsedGroups'
+    });
+    if (!type.isArray(collapsed)) return [];
+    return collapsed.filter((key)=>type.isString(key));
+}
+export default initCollapsedGroups;

package/dist/features/grouping/initGrouping.js

@@ -0,0 +1,34 @@
+/*
+  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';
+import toGroupKeys from './toGroupKeys.js';
+// The group levels as column keys. Keys of unknown or non-groupable columns (a stale saved view)
+// are dropped, as are repeats.
+function initGrouping({ value, defaultView, config }) {
+    const group = pickViewPart({
+        value,
+        defaultView,
+        key: 'group'
+    });
+    if (!type.isArray(group)) return [];
+    const keys = [];
+    toGroupKeys(group).forEach((key)=>{
+        if (config.columnsByKey.get(key)?.groupable !== true || keys.includes(key)) return;
+        keys.push(key);
+    });
+    return keys;
+}
+export default initGrouping;

package/dist/features/grouping/needsGroupRows.js

@@ -0,0 +1,23 @@
+/*
+  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 someColumnConfig from '../../core/someColumnConfig.js';
+// The group rows load when a column can be grouped by: `view.group` only takes groupable columns.
+function needsGroupRows({ properties }) {
+    return someColumnConfig({
+        properties,
+        test: (column)=>column.groupable === true
+    });
+}
+export default needsGroupRows;

package/dist/features/grouping/orderGroups.js

@@ -0,0 +1,49 @@
+/*
+  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 resolveOption from '@lowdefy/blocks-antd/table/resolveOption.js';
+function optionRank({ options, value, unlisted }) {
+    const option = resolveOption({
+        options,
+        value
+    });
+    return type.isUndefined(option) ? unlisted : option.index;
+}
+// Sibling groups in display order: by the column's sort when the view sorts on it, else by
+// option order for enum columns (values without an option after them), else by first
+// appearance in the sorted rows. The empty group always comes last.
+function orderGroups({ groups, level }) {
+    const filled = groups.filter((group)=>!group.empty);
+    const empty = groups.filter((group)=>group.empty);
+    if (level.order === 'sort') {
+        const direction = level.desc ? -1 : 1;
+        filled.sort((a, b)=>direction * level.compare(a.value, b.value));
+    }
+    if (level.order === 'options') {
+        const unlisted = level.options.length;
+        // Array sort is stable, so values without an option keep their appearance order.
+        filled.sort((a, b)=>optionRank({
+                options: level.options,
+                value: a.value,
+                unlisted
+            }) - optionRank({
+                options: level.options,
+                value: b.value,
+                unlisted
+            }));
+    }
+    return filled.concat(empty);
+}
+export default orderGroups;

package/dist/features/grouping/resolveAggregates.js

@@ -0,0 +1,29 @@
+/*
+  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';
+// The aggregates in effect, in column order: the view's `aggregates` over each column's own
+// `aggregate` default. A view entry of null turns a column's default off.
+function resolveAggregates({ columns, aggregates }) {
+    const resolved = [];
+    columns.forEach((column)=>{
+        const fn = Object.hasOwn(aggregates, column.key) ? aggregates[column.key] : column.aggregate;
+        if (!type.isNone(fn)) resolved.push({
+            key: column.key,
+            fn
+        });
+    });
+    return resolved;
+}
+export default resolveAggregates;

package/dist/features/grouping/toGroupIdentity.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';
+import isEmptyValue from '@lowdefy/blocks-antd/table/isEmptyValue.js';
+// The Map key a value groups under: primitives as themselves, other values (dates, arrays,
+// objects) by their JSON, and every empty value (null, undefined, '', []) as the one null group.
+function toGroupIdentity(value) {
+    if (isEmptyValue(value)) return null;
+    if (type.isPrimitive(value)) return value;
+    return JSON.stringify(value);
+}
+export default toGroupIdentity;

package/dist/features/grouping/toGroupKeys.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';
+// Group entries as column keys: the view's `[{ key }]`, or plain keys (setGroup accepts both).
+function toGroupKeys(group) {
+    if (type.isNone(group)) return [];
+    if (!type.isArray(group)) {
+        throw new Error(`Table group must be an array of { key }. Received ${JSON.stringify(group)}.`);
+    }
+    return group.map((entry)=>type.isObject(entry) ? entry.key : entry);
+}
+export default toGroupKeys;

package/dist/features/grouping/useGrouping.js

@@ -0,0 +1,91 @@
+/*
+  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 } from 'react';
+import buildGroupTree from './buildGroupTree.js';
+import createAggregateColumns from './createAggregateColumns.js';
+import createGroupLevels from './createGroupLevels.js';
+import findGroupIndices from './findGroupIndices.js';
+import flattenGroups from './flattenGroups.js';
+// The grouping feature's display-list hook (`useItems`). Client mode groups the filtered, sorted
+// rows (the sorted row model, before pagination) into the flat list the window renders: the tree
+// rebuilds when rows, grouping, aggregates or sort change; collapsing and expanding only
+// re-flattens it. In server mode the server's groups are already in the list (serverData runs
+// first and builds the same group items), so this adds no rows and only provides what the group
+// header rows read (`api.grouping`).
+function useGrouping({ api, config, rows, state, table }) {
+    const keys = state.grouping;
+    // A tree is never grouped: its rows are already a hierarchy.
+    const active = keys.length > 0 && !config.tree;
+    const server = Boolean(config.server);
+    const sortedRows = table.getSortedRowModel().rows;
+    const levels = useMemo(()=>active ? createGroupLevels({
+            keys,
+            table,
+            sorting: state.sorting
+        }) : null, [
+        active,
+        config,
+        keys,
+        state.sorting
+    ]);
+    const aggregates = useMemo(()=>active ? createAggregateColumns({
+            config,
+            table,
+            aggregates: state.aggregates
+        }) : null, [
+        active,
+        config,
+        state.aggregates
+    ]);
+    const tree = useMemo(()=>active && !server ? buildGroupTree({
+            rows: sortedRows,
+            levels,
+            aggregates: aggregates.columns
+        }) : null, [
+        sortedRows,
+        levels,
+        aggregates,
+        server
+    ]);
+    const flat = useMemo(()=>tree ? flattenGroups({
+            groups: tree.groups,
+            leaves: tree.leaves,
+            collapsed: new Set(state.collapsedGroups)
+        }) : null, [
+        tree,
+        state.collapsedGroups
+    ]);
+    const serverGroupIndices = useMemo(()=>active && server ? findGroupIndices(rows) : null, [
+        active,
+        server,
+        rows
+    ]);
+    if (!active) {
+        api.grouping = null;
+        return null;
+    }
+    api.grouping = {
+        aggregateFns: aggregates.fnByKey,
+        groupIndices: flat ? flat.groupIndices : serverGroupIndices,
+        levels,
+        tree
+    };
+    if (!flat) return null;
+    return {
+        rows: flat.items,
+        dataRows: tree.leaves
+    };
+}
+export default useGrouping;

package/dist/features/headerMenu/HeaderMenuDropdown.js

@@ -0,0 +1,86 @@
+/*
+  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, { useEffect, useRef } from 'react';
+import { Dropdown } from 'antd';
+import collectHeaderMenuItems from './collectHeaderMenuItems.js';
+// The menu itself, mounted only while open and anchored to the bottom edge of the header cell.
+// The first item takes focus when the menu opens (the ARIA menu button pattern), so arrow keys
+// and Enter work however it was opened; choosing an item hands focus back to the header. Escape
+// is taken in the capture phase, ahead of the Dropdown's own handler, so focus goes back to the
+// column's menu button rather than to the (unfocusable) anchor.
+function HeaderMenuDropdown({ api, col }) {
+    const { items, handlers } = collectHeaderMenuItems({
+        column: col.column,
+        api,
+        features: api.features.list
+    });
+    const popupRef = useRef(null);
+    useEffect(()=>{
+        let frame = 0;
+        function focusMenu() {
+            const item = popupRef.current?.querySelector('[role="menuitem"]:not([aria-disabled="true"])');
+            if (item) {
+                item.focus({
+                    preventScroll: true
+                });
+            } else {
+                frame = requestAnimationFrame(focusMenu);
+            }
+        }
+        frame = requestAnimationFrame(focusMenu);
+        return ()=>cancelAnimationFrame(frame);
+    }, []);
+    useEffect(()=>{
+        function onKeyDown(event) {
+            if (event.key !== 'Escape') return;
+            event.stopPropagation();
+            api.actions.closeHeaderMenu({
+                restoreFocus: true
+            });
+        }
+        window.addEventListener('keydown', onKeyDown, true);
+        return ()=>window.removeEventListener('keydown', onKeyDown, true);
+    }, [
+        api
+    ]);
+    return /*#__PURE__*/ React.createElement(Dropdown, {
+        menu: {
+            items,
+            onClick: ({ key })=>{
+                api.actions.closeHeaderMenu({
+                    restoreFocus: true
+                });
+                handlers.get(key)();
+            }
+        },
+        onOpenChange: (open, info)=>{
+            if (!open && info.source === 'trigger') api.actions.closeHeaderMenu();
+        },
+        open: true,
+        placement: "bottomRight",
+        popupRender: (menu)=>/*#__PURE__*/ React.createElement("div", {
+                className: "lf-table-header-menu",
+                "data-col-key": col.key,
+                "data-lf-header-menu-popup": "",
+                ref: popupRef
+            }, menu),
+        trigger: [
+            'click'
+        ]
+    }, /*#__PURE__*/ React.createElement("span", {
+        className: "lf-table-header-anchor"
+    }));
+}
+export default HeaderMenuDropdown;

package/dist/features/headerMenu/HeaderMenuTrigger.js

@@ -0,0 +1,44 @@
+/*
+  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, { Suspense } from 'react';
+import LazyHeaderMenuDropdown from './LazyHeaderMenuDropdown.js';
+import MenuIcon from './MenuIcon.js';
+// Header part: the menu button, shown on hover or focus of the header cell, over the end of the
+// cell (it takes no room from the title). It is tabbable while its header cell is the grid's
+// active cell, so Tab from a focused header reaches it and Enter opens the menu. The antd
+// Dropdown (its own chunk, preloaded on hover or focus of the button) mounts only while the menu
+// is open.
+function HeaderMenuTrigger({ api, col, focused }) {
+    if (!api.config.headerMenu) return null;
+    const open = api.headerMenu.openKey === col.key;
+    return /*#__PURE__*/ React.createElement(React.Fragment, null, /*#__PURE__*/ React.createElement("button", {
+        "aria-expanded": open,
+        "aria-haspopup": "menu",
+        "aria-label": "Column menu",
+        className: "lf-table-header-button lf-table-header-menu-trigger",
+        "data-lf-header-menu": "",
+        "data-open": open ? '' : undefined,
+        onFocus: LazyHeaderMenuDropdown.preload,
+        onPointerEnter: LazyHeaderMenuDropdown.preload,
+        tabIndex: focused ? 0 : -1,
+        type: "button"
+    }, /*#__PURE__*/ React.createElement(MenuIcon, null)), open ? /*#__PURE__*/ React.createElement(Suspense, {
+        fallback: null
+    }, /*#__PURE__*/ React.createElement(LazyHeaderMenuDropdown, {
+        api: api,
+        col: col
+    })) : null);
+}
+export default HeaderMenuTrigger;

package/dist/features/headerMenu/LazyHeaderMenuDropdown.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.
+*/ import lazyComponent from '../../core/lazyComponent.js';
+// The header menu, loaded when a header menu first opens (the menu button preloads it on hover
+// and focus).
+const LazyHeaderMenuDropdown = lazyComponent(()=>import('./HeaderMenuDropdown.js'));
+export default LazyHeaderMenuDropdown;

package/dist/features/headerMenu/MenuIcon.js

@@ -0,0 +1,38 @@
+/*
+  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';
+function MenuIcon() {
+    return /*#__PURE__*/ React.createElement("svg", {
+        "aria-hidden": "true",
+        className: "lf-table-icon",
+        viewBox: "0 0 16 16"
+    }, /*#__PURE__*/ React.createElement("circle", {
+        cx: "8",
+        cy: "3.5",
+        fill: "currentColor",
+        r: "1.25"
+    }), /*#__PURE__*/ React.createElement("circle", {
+        cx: "8",
+        cy: "8",
+        fill: "currentColor",
+        r: "1.25"
+    }), /*#__PURE__*/ React.createElement("circle", {
+        cx: "8",
+        cy: "12.5",
+        fill: "currentColor",
+        r: "1.25"
+    }));
+}
+export default MenuIcon;