@lowdefy/blocks-table 0.0.0-experimental-20260929110023

package/dist/features/editing/toEditorDraft.js

@@ -0,0 +1,56 @@
+/*
+  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 fromDateValue from './fromDateValue.js';
+// Rounds away the float noise of x100 (0.07 * 100 = 7.000000000000001).
+function scalePercent(value) {
+    return Math.round(value * 100 * 1e8) / 1e8;
+}
+// The editor's starting value for a cell value. A printable key that opened the editor seeds text
+// and number editors (a digit replaces the number); percents edit as the number shown (12 for
+// 0.12) and dates as the picker's dayjs.
+function toEditorDraft({ spec, value, seed }) {
+    switch(spec.kind){
+        case 'text':
+            if (type.isString(seed)) return seed;
+            return type.isNone(value) ? '' : String(value);
+        case 'number':
+            {
+                if (type.isString(seed) && /^\d$/.test(seed)) return Number(seed);
+                if (type.isNone(value) || value === '' || Number.isNaN(Number(value))) return null;
+                return spec.type === 'percent' ? scalePercent(Number(value)) : Number(value);
+            }
+        case 'date':
+        case 'datetime':
+            return fromDateValue({
+                value,
+                kind: spec.kind
+            });
+        case 'boolean':
+            return value === true;
+        case 'select':
+            return type.isNone(value) || value === '' ? undefined : value;
+        case 'multiSelect':
+            if (type.isArray(value)) return value;
+            return type.isNone(value) || value === '' ? [] : [
+                value
+            ];
+        case 'rating':
+            return type.isNone(value) ? 0 : Number(value);
+        default:
+            return value;
+    }
+}
+export default toEditorDraft;

package/dist/features/editing/toSelectOptions.js

@@ -0,0 +1,39 @@
+/*
+  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 StatusCell from '@lowdefy/blocks-antd/table/cells/StatusCell.js';
+import TagCell from '@lowdefy/blocks-antd/table/cells/TagCell.js';
+// The select editor's options with the look of the cell: a status dot or a tag chip in the
+// value's colour (the shared cell renderers, for one value), with the label as `text` for search
+// and as the option's `title`.
+function toSelectOptions({ components, spec, row }) {
+    const { column } = spec;
+    return (spec.options ?? []).map((option)=>({
+            label: column.type === 'status' ? /*#__PURE__*/ React.createElement(StatusCell, {
+                column: column,
+                row: row,
+                value: option.value
+            }) : /*#__PURE__*/ React.createElement(TagCell, {
+                column: column,
+                components: components,
+                row: row,
+                value: option.value
+            }),
+            text: option.label,
+            title: option.label,
+            value: option.value
+        }));
+}
+export default toSelectOptions;

package/dist/features/editing/useEditingData.js

@@ -0,0 +1,199 @@
+/*
+  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, useMemo, useRef, useState } from 'react';
+import applyChanges from './applyChanges.js';
+import applyMoveOverlay from './applyMoveOverlay.js';
+import applyOverlay from './applyOverlay.js';
+import createEditSpecs from './createEditSpecs.js';
+import createUndoStack from './createUndoStack.js';
+import createValueStore from './createValueStore.js';
+import findInvalidCells from './findInvalidCells.js';
+import getEditOptions from './getEditOptions.js';
+import getKeyField from './getKeyField.js';
+import pruneOverlay from './pruneOverlay.js';
+const EMPTY_MAP = new Map();
+const UNDO_LIMIT = 100;
+function createEditingState() {
+    const editing = {
+        changeCache: new WeakMap(),
+        changes: null,
+        dataIndex: null,
+        layer: null,
+        pendingStart: null,
+        reorderBlock: createValueStore(null),
+        seenChanges: null,
+        sources: new WeakMap(),
+        undo: createUndoStack({
+            limit: UNDO_LIMIT
+        }),
+        warned: new Set()
+    };
+    // The unchanged data rows by key (as a string), built on the first write after a data change.
+    editing.getDataByKey = ()=>{
+        if (editing.dataIndex?.data !== editing.data) {
+            const map = new Map(editing.data.map((row)=>[
+                    String(editing.getKey(row)),
+                    row
+                ]));
+            editing.dataIndex = {
+                data: editing.data,
+                map
+            };
+        }
+        return editing.dataIndex.map;
+    };
+    return editing;
+}
+// Rows the user changed in TableInput (updated or added); inline validation checks these only,
+// since rows as they came from `data` are the app's, and a large table stays cheap to edit.
+function getTouchedRows({ rows, changes, getKey }) {
+    const touched = new Set([
+        ...Object.keys(changes.updated),
+        ...changes.added.map((entry)=>String(entry.rowKey))
+    ]);
+    if (touched.size === 0) return [];
+    return rows.filter((row)=>touched.has(String(getKey(row))));
+}
+// The editing feature's `useRows` hook (after the rows are diffed by key, before TanStack sees
+// them). Row identity is stable here, which the overlay relies on: an entry applies until its
+// row in `data` is a different object. It compiles the edit
+// specs, and then per block:
+// - Table: lays the optimistic overlays over `data` (cell edits and a row move that are saving,
+//   or saved and not yet replaced by new data) and prunes them once `data` catches up.
+// - TableInput: shows `data` with its value (the changeset) applied, and finds the touched cells
+//   that fail inline validation.
+// `data` is never written. The per-table editing state lives on `api.editing` for handlers,
+// actions and the editing layer.
+function useEditingData({ api, config, input, properties, rows: data }) {
+    const specs = useMemo(()=>createEditSpecs({
+            columns: config.columns,
+            rawColumns: properties.columns,
+            defaultColumn: properties.defaultColumn
+        }), [
+        config
+    ]);
+    const options = getEditOptions({
+        input,
+        properties
+    });
+    const { positionField } = options;
+    const [overlay, setOverlay] = useState(EMPTY_MAP);
+    const [moveOverlay, setMoveOverlay] = useState(null);
+    const stateRef = useRef(null);
+    if (stateRef.current === null) stateRef.current = createEditingState();
+    const editing = stateRef.current;
+    const { getKey } = config;
+    const changes = input?.changes ?? null;
+    if (changes !== editing.seenChanges) {
+        editing.seenChanges = changes;
+        editing.changes = changes;
+    }
+    // Only TableInput adds rows, so only it needs the key field (and the scan of `data` for it).
+    const keyField = useMemo(()=>input ? getKeyField({
+            rowKey: properties.rowKey,
+            rows: data
+        }) : null, [
+        Boolean(input),
+        data,
+        properties.rowKey
+    ]);
+    const rows = useMemo(()=>{
+        if (changes) {
+            return applyChanges({
+                rows: data,
+                changes,
+                getKey,
+                keyField,
+                positionField,
+                cache: editing.changeCache
+            });
+        }
+        const edited = applyOverlay({
+            rows: data,
+            overlay,
+            getKey,
+            sources: editing.sources
+        });
+        return applyMoveOverlay({
+            rows: edited,
+            move: moveOverlay,
+            data,
+            getKey,
+            positionField,
+            sources: editing.sources
+        });
+    }, [
+        data,
+        changes,
+        overlay,
+        moveOverlay,
+        getKey,
+        keyField,
+        positionField
+    ]);
+    const invalid = useMemo(()=>{
+        if (!changes) return EMPTY_MAP;
+        return findInvalidCells({
+            rows: getTouchedRows({
+                rows,
+                changes,
+                getKey
+            }),
+            specs,
+            getKey
+        });
+    }, [
+        rows,
+        changes,
+        specs,
+        getKey
+    ]);
+    useEffect(()=>{
+        if (changes) return;
+        setOverlay((previous)=>pruneOverlay({
+                overlay: previous,
+                rows: data,
+                getKey
+            }));
+        setMoveOverlay((previous)=>{
+            if (!previous || previous.status === 'saving' || previous.source === data) return previous;
+            return null;
+        });
+    }, [
+        data
+    ]);
+    const anyEditable = useMemo(()=>[
+            ...specs.values()
+        ].some((spec)=>spec.editable), [
+        specs
+    ]);
+    Object.assign(editing, {
+        data,
+        enabled: Boolean(input) || anyEditable || options.rowDrag,
+        getKey,
+        input: input ?? null,
+        invalid,
+        keyField,
+        moveOverlay,
+        options,
+        overlay,
+        setMoveOverlay,
+        setOverlay,
+        specs
+    });
+    api.editing = editing;
+    return rows;
+}
+export default useEditingData;

package/dist/features/editing/useEditingFragments.js

@@ -0,0 +1,77 @@
+/*
+  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, useMemo } from 'react';
+import AddRowButton from './AddRowButton.js';
+import EditingLayer from './EditingLayer.js';
+import getReorderBlock from './getReorderBlock.js';
+import rowControlsColumn from './rowControlsColumn.js';
+const EMPTY = [];
+// Block-level editing fragment: the row controls column (`rowDrag`, or TableInput's
+// `rowActions.delete`), and under the grid the editing layer (editor and status markers,
+// portalled into cells) plus TableInput's "+ Add row". It also registers TableInput's
+// `resetChanges` method. Nothing mounts for a table without editing.
+function useEditingFragments({ api, config, data, state, table }) {
+    const { editing } = api;
+    const { addRow, addRowText, deleteButton, positionField, rowDrag } = editing.options;
+    const leadingColumns = useMemo(()=>rowDrag || deleteButton ? [
+            rowControlsColumn({
+                rowDrag,
+                deleteButton
+            })
+        ] : EMPTY, [
+        rowDrag,
+        deleteButton
+    ]);
+    const block = rowDrag ? getReorderBlock({
+        config,
+        data,
+        positionField,
+        state,
+        table
+    }) : null;
+    useEffect(()=>{
+        editing.reorderBlock.set(block);
+    }, [
+        block
+    ]);
+    useEffect(()=>{
+        // Load the editor chunk while the user reads, so the first edit opens without a wait.
+        if (editing.enabled) import('./CellEditor.js');
+    }, [
+        editing.enabled
+    ]);
+    const inputMethods = editing.input?.methods;
+    useEffect(()=>{
+        if (!inputMethods) return;
+        inputMethods.registerMethod('resetChanges', api.actions.resetChanges);
+    }, [
+        inputMethods
+    ]);
+    if (!editing.enabled) return {
+        leadingColumns
+    };
+    return {
+        leadingColumns,
+        regions: {
+            bottom: /*#__PURE__*/ React.createElement(React.Fragment, null, /*#__PURE__*/ React.createElement(EditingLayer, {
+                api: api
+            }), addRow ? /*#__PURE__*/ React.createElement(AddRowButton, {
+                api: api,
+                text: addRowText
+            }) : null)
+        }
+    };
+}
+export default useEditingFragments;

package/dist/features/editing/useEditingGrid.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.
+*/ import { useLayoutEffect } from 'react';
+const NONE = {};
+// After every grid render (scroll, resize, a new row window), cells may have mounted or
+// unmounted: the editing layer finds the cells for its editor and markers again.
+function useEditingGrid({ api }) {
+    useLayoutEffect(()=>{
+        api.editing?.layer?.sync();
+    });
+    return NONE;
+}
+export default useEditingGrid;

package/dist/features/editing/validateCellValue.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.
+*/ import isEmptyValue from '@lowdefy/blocks-antd/table/isEmptyValue.js';
+// The first failing message for a cell value, or null when it passes. `row` is the row with the
+// new value already in it, so a `pass` condition with a `key` reads the edited row.
+function validateCellValue({ spec, row, value }) {
+    if (spec.required && isEmptyValue(value)) return 'Required.';
+    for (const rule of spec.validate){
+        if (rule.test(row, value) !== true) return rule.message;
+    }
+    return null;
+}
+export default validateCellValue;

package/dist/features/editing/valuesEqual.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 { type } from '@lowdefy/helpers';
+// Whether an edit changed nothing, so no event fires and no write happens. Empty values (null,
+// undefined, '') are one value: opening and closing an editor on an empty cell is not an edit.
+function valuesEqual(a, b) {
+    const aEmpty = type.isNone(a) || a === '';
+    const bEmpty = type.isNone(b) || b === '';
+    if (aEmpty || bEmpty) return aEmpty && bEmpty;
+    if (type.isDate(a) || type.isDate(b)) {
+        return type.isDate(a) && type.isDate(b) && a.getTime() === b.getTime();
+    }
+    if (type.isArray(a) || type.isArray(b)) {
+        return type.isArray(a) && type.isArray(b) && a.length === b.length && a.every((item, i)=>valuesEqual(item, b[i]));
+    }
+    if (type.isObject(a) || type.isObject(b)) return JSON.stringify(a) === JSON.stringify(b);
+    return a === b;
+}
+export default valuesEqual;

package/dist/features/editing/warnMissingEvent.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.
+*/ // Development warning, once per table and event: an edit or move shows in the table but nothing
+// saves it.
+function warnMissingEvent({ api, name, what }) {
+    if (process.env.NODE_ENV === 'production' || api.editing.warned.has(name)) return;
+    api.editing.warned.add(name);
+    // eslint-disable-next-line no-console
+    console.warn(`Table "${api.blockId}" allows ${what} but has no ${name} event, so they only show in the table and are never saved. Add an ${name} event that saves them.`);
+}
+export default warnMissingEvent;

package/dist/features/events/createActivateRow.js

@@ -0,0 +1,54 @@
+/*
+  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 getRowIndex from './getRowIndex.js';
+import openRowLink from './openRowLink.js';
+// A row "activation" (click, or Enter on a focused cell), with TableLight's semantics: onRowClick
+// fires, and rowLink is followed unless onRowClick is defined too, in which case a plain click is
+// the app's (a peek, say) and only a modified click (Cmd/Ctrl/Shift) follows the link, in a new
+// tab.
+function createActivateRow(api) {
+    return function activateRow({ id, event, newTab }) {
+        const row = api.table.getRow(id, true);
+        if (!row) return false;
+        const hasRowClick = Boolean(api.events.onRowClick);
+        if (hasRowClick) {
+            const rowKey = api.config.getKey(row.original);
+            api.methods.triggerEvent({
+                name: 'onRowClick',
+                event: {
+                    row: row.original,
+                    rowKey,
+                    index: getRowIndex({
+                        api,
+                        rowKey
+                    })
+                }
+            });
+        }
+        const { rowLink } = api.config;
+        if (!rowLink) return true;
+        const modified = event?.metaKey || event?.ctrlKey || event?.shiftKey;
+        const openInNewTab = newTab === true || modified === true;
+        if (openInNewTab || !hasRowClick) {
+            openRowLink({
+                rowLink,
+                row: row.original,
+                newTab: openInNewTab
+            });
+        }
+        return true;
+    };
+}
+export default createActivateRow;

package/dist/features/events/eventsFeature.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 createActivateRow from './createActivateRow.js';
+import handleAuxClick from './handleAuxClick.js';
+import handlePointerDown from './handlePointerDown.js';
+import handleRowClick from './handleRowClick.js';
+import handleRowDoubleClick from './handleRowDoubleClick.js';
+// Row and cell events through the grid's one delegated listener (D5): onRowClick,
+// onRowDoubleClick, onCellClick and rowLink. Cell renderers fire their own events (buttons, menus,
+// onCellLink) with full payloads through `api.onCellEvent`.
+const eventsFeature = {
+    name: 'events',
+    actions: {
+        activateRow: createActivateRow
+    },
+    gridHandlers: {
+        auxclick: handleAuxClick,
+        click: handleRowClick,
+        dblclick: handleRowDoubleClick,
+        pointerdown: handlePointerDown
+    }
+};
+export default eventsFeature;

package/dist/features/events/getBodyTarget.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.
+*/ // The body row and cell an event targets, or null for header and non-row targets.
+function getBodyTarget({ event, api }) {
+    const rowElement = event.target.closest('[data-row-key]');
+    if (!rowElement || !api.contains(rowElement)) return null;
+    const row = api.table.getRow(rowElement.dataset.rowKey, true);
+    if (!row) return null;
+    return {
+        cell: event.target.closest('[data-lf-cell]'),
+        row,
+        rowElement
+    };
+}
+export default getBodyTarget;

package/dist/features/events/getRowIndex.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.
+*/ // The `index` of row events (onRowClick, onRowDoubleClick). Client data: the row's index in
+// `data` (with `childrenField`, in the depth-first list of every node). Server mode: the row's
+// index on the server in its list (the root list, or its group's), its block's startRow plus its
+// place in the block. Rows that are not in `data`, added by applyTransaction or in a TableInput,
+// have no index: null.
+function getRowIndex({ api, rowKey }) {
+    if (api.serverStore) return api.serverStore.getRowIndex(rowKey);
+    return api.getSourceIndex(rowKey);
+}
+export default getRowIndex;

package/dist/features/events/handleAuxClick.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 isControlTarget from '@lowdefy/blocks-antd/table/isControlTarget.js';
+import getBodyTarget from './getBodyTarget.js';
+import openRowLink from './openRowLink.js';
+// Middle click opens the row link in a new tab, like a middle-clicked link.
+function handleAuxClick(event, api) {
+    if (event.button !== 1 || !api.config.rowLink) return false;
+    const target = getBodyTarget({
+        event,
+        api
+    });
+    if (!target) return false;
+    if (isControlTarget({
+        target: event.target,
+        container: target.rowElement
+    })) return false;
+    event.preventDefault();
+    openRowLink({
+        rowLink: api.config.rowLink,
+        row: target.row.original,
+        newTab: true
+    });
+    return true;
+}
+export default handleAuxClick;