beautiful-grid 1.0.16 → 1.0.17

package/README.md

@@ -583,6 +583,17 @@ const columns: BGridColumn<Item>[] = [
 ];
 ```
 
+`createSelectEditorPlugin` options:
+- `options`: List of `{ value, label, disabled? }` entries.
+- `allowCustomValue?: boolean`: Set `true` to allow pasting arbitrary values not present in `options` (default: `false`, rejecting unlisted values with `parseValueFailed`). Automatically preserves numeric types when option values are numeric.
+- `copyMode?: 'label' | 'value'`: Controls clipboard copy output (`'label'` by default when label is text, or `'value'`). Matching during paste prioritizes the configured `copyMode` to prevent label/value collisions.
+- `allowEmpty?: boolean`: Set `true` to allow clearing cell values when pasting empty text (default: `false`).
+- `emptyValue?: Value | null`: Value written when empty text is pasted with `allowEmpty: true` (default: `''`).
+- `allowDisabledOptions?: boolean`: Set `true` to allow pasting options marked `disabled: true` (default: `false`, rejecting disabled options).
+- `parseClipboardText?`: Override custom clipboard parsing and validation logic.
+- `getClipboardText?`: Override custom clipboard text retrieval logic.
+- `openOnMount?: boolean`: Automatically opens native picker on editor activation (default: `true`).
+
 #### Editor Icons (Lookup & Quick Triggers)
 
 Add inline trigger icons beside cell values using `editorIcon`:
@@ -649,16 +660,15 @@ Configure active cell handling and keyboard behavior with `cellNavigationOptions
 
 ---
 
-### 5. Cell Selection & Clipboard (Excel-compatible)
+### 5. Cell Range Selection & Clipboard Integration
 
 Cell range selection and clipboard copy/paste are enabled by default.
 
 ```typescript jsx
 <BGrid
-  width={800}
-  height={400}
-  columns={columns}
   data={data}
+  columns={columns}
+  editable
   rowKey='id'
   cellSelectionOptions={{
     enabled: true,
@@ -666,20 +676,24 @@ Cell range selection and clipboard copy/paste are enabled by default.
     clearOnEscape: true,
     clearOnOutsideClick: true,
     maxClipboardCells: 100000,
-    maxClipboardTextLength: 8 * 1024 * 1024,
-    onCopyError: error => console.warn('Copy skipped:', error),
-    onPasteError: error => console.warn('Paste failed:', error),
-    createRowOnPaste: ({ rowIndex, clipboardRow, columns }) => ({
+    createRowOnPaste: ({ rowIndex, clipboardRow }) => ({
+      status: BGridDataItemStatus.new,
       values: createNewRowModel(clipboardRow),
     }),
   }}
 />
 ```
 
-- `Ctrl+C` / `Cmd+C`: Copies selected cells as Tab-separated (`\t`) values and CRLF (`\r\n`) lines, directly pasteable into Excel or Google Sheets.
-- `Ctrl+V` / `Cmd+V`: Pastes clipboard matrix starting from the focused cell across editable columns.
-- `multiSelectFocusMode: 'last'` makes the last cell selected by a drag the active cell and the paste starting point. The default is `'first'` for backward compatibility.
-- Customize copied text on a per-column basis with `getClipboardText: ({ value, values }) => string`.
+- `Ctrl+C` / `Cmd+C`: Copies selected cells as Tab-separated (`\t`) values and CRLF (`\r\n`) lines, directly pasteable into Excel or Google Sheets. Columns configured with `createSelectEditorPlugin` copy the display `label` by default.
+- `Ctrl+V` / `Cmd+V`: Pastes clipboard values across editable columns:
+  - **Single cell fill**: Pasting a 1×1 value into a multi-cell selection fills every cell in the selected range.
+  - **Pattern tiling (Repeat)**: Pasting an $n \times m$ matrix into an $N \times M$ selection whose dimensions are exact integer multiples ($N \pmod n = 0$ and $M \pmod m = 0$) tiles/repeats the pattern across the entire selection.
+  - **Non-multiple fallback**: When the selection is not an exact multiple, the matrix pastes once starting at the top-left of the selected range (or focused cell if no range).
+- `multiSelectFocusMode: 'last'` makes the last cell selected by a drag the active cell. The default is `'first'` for backward compatibility.
+- **Paste validation & editor protection**:
+  - `createSelectEditorPlugin` validates pasted text against option values and string labels, mapping labels back to values with $O(1)$ indexed lookup.
+  - By default, unlisted values and disabled options are rejected and reported as `parseValueFailed` through `onPasteError`, preventing data corruption. Set `allowCustomValue: true` on the select editor plugin to allow arbitrary inputs.
+- Customize copied text on a per-column basis with `getClipboardText: ({ value, values }) => string`, or restore/validate custom types with `parseClipboardText: (text, context) => parsedValue`.
 
 ---
 

package/cjs/components/Table.js

@@ -1226,7 +1226,7 @@ function Table(props) {
                         var rowHasNewLogicalCell = false;
                         var columnIndexes = Array.from((_f = selectedCells.get(ri)) !== null && _f !== void 0 ? _f : []).sort(function (a, b) { return a - b; });
                         columnIndexes.forEach(function (ci) {
-                            var _a;
+                            var _a, _b, _c;
                             var column = columns[ci];
                             if (!column)
                                 return;
@@ -1240,8 +1240,10 @@ function Table(props) {
                             rowHasNewLogicalCell = true;
                             var logicalItem = (_a = data[logicalCell.cell.rowIndex]) !== null && _a !== void 0 ? _a : item;
                             var value = (0, utils_1.getCellValueByRowKey)(column.key, logicalItem.values);
-                            var clipboardValue = column.getClipboardText
-                                ? column.getClipboardText({
+                            var pluginClipboardTextGetter = ((_b = column.editor) === null || _b === void 0 ? void 0 : _b.type) === 'plugin' ? column.editor.getClipboardText : undefined;
+                            var clipboardTextGetter = (_c = column.getClipboardText) !== null && _c !== void 0 ? _c : pluginClipboardTextGetter;
+                            var clipboardValue = clipboardTextGetter
+                                ? clipboardTextGetter({
                                     column: column,
                                     index: logicalCell.cell.rowIndex,
                                     columnIndex: ci,
@@ -1328,7 +1330,7 @@ function Table(props) {
         cellSelectionOptions === null || cellSelectionOptions === void 0 ? void 0 : cellSelectionOptions.onCopyError,
     ]);
     var pasteClipboardText = (0, react_1.useCallback)(function (text, clipboardTypes) {
-        var _a, _b;
+        var _a, _b, _c, _d, _e, _f, _g;
         if (clipboardTypes === void 0) { clipboardTypes = []; }
         if (!cellSelectionEnabled || !editable || !activeCell || data.length === 0 || columns.length === 0) {
             return false;
@@ -1367,17 +1369,41 @@ function Table(props) {
             });
             return true;
         }
-        var startRowIndex = activeCell.rowIndex;
-        var startColumnIndex = activeCell.columnIndex;
+        var primaryRange = cellSelectionRanges.length === 1 ? (0, cellSelectionGeometry_1.normalizeCellSelectionRange)(cellSelectionRanges[0]) : null;
+        var selectionRowCount = primaryRange ? primaryRange.endRowIndex - primaryRange.startRowIndex + 1 : 1;
+        var selectionColCount = primaryRange ? primaryRange.endColumnIndex - primaryRange.startColumnIndex + 1 : 1;
+        // Determine fill rows and cols:
+        // 1. Single cell (1x1) copied into multi-cell selection: fill the entire selection.
+        // 2. nxm copied into exact multiple NxM selection: repeat pattern across selection.
+        // 3. Otherwise: paste 1:1 matching matrix dimensions, anchored at selection top-left (or activeCell if no range).
+        var isSingleClipboardCell = matrix.length === 1 && ((_c = matrix[0]) === null || _c === void 0 ? void 0 : _c.length) === 1;
+        var matrixColCount = matrix.reduce(function (max, row) { return Math.max(max, row.length); }, 0);
+        var isExactRowMultiple = primaryRange && matrix.length > 0 && selectionRowCount % matrix.length === 0;
+        var isExactColMultiple = primaryRange &&
+            matrixColCount > 0 &&
+            selectionColCount % matrixColCount === 0;
+        var canTileMatrix = primaryRange &&
+            isExactRowMultiple &&
+            isExactColMultiple &&
+            (selectionRowCount > matrix.length || selectionColCount > matrixColCount);
+        var fillRowCount = matrix.length;
+        var fillColCount = matrixColCount;
+        var startRowIndex = primaryRange ? primaryRange.startRowIndex : activeCell.rowIndex;
+        var startColumnIndex = primaryRange ? primaryRange.startColumnIndex : activeCell.columnIndex;
+        if (primaryRange && (isSingleClipboardCell || canTileMatrix)) {
+            fillRowCount = selectionRowCount;
+            fillColCount = selectionColCount;
+        }
         var nextData = __spreadArray([], __read(data), false);
         var appendedRows = [];
         var changes = [];
         var createRowOnPaste = cellSelectionOptions === null || cellSelectionOptions === void 0 ? void 0 : cellSelectionOptions.createRowOnPaste;
         if (createRowOnPaste) {
-            var requiredRowCount = startRowIndex + matrix.length;
+            var requiredRowCount = startRowIndex + fillRowCount;
             while (nextData.length < requiredRowCount) {
                 var rowIndex = nextData.length;
-                var clipboardRow = matrix[rowIndex - startRowIndex];
+                var matrixRowOffset = isSingleClipboardCell ? 0 : (rowIndex - startRowIndex) % matrix.length;
+                var clipboardRow = matrix[matrixRowOffset];
                 if (!clipboardRow)
                     break;
                 var createdItem = void 0;
@@ -1397,18 +1423,36 @@ function Table(props) {
         }
         var logicalResolutionData = __spreadArray([], __read(nextData), false);
         var pasteTargets = new Map();
-        matrix.forEach(function (clipboardRow, rowOffset) {
+        for (var rowOffset = 0; rowOffset < fillRowCount; rowOffset++) {
             var rowIndex = startRowIndex + rowOffset;
             var item = logicalResolutionData[rowIndex];
             if (!item || item.status === types_1.BGridDataItemStatus.remove)
-                return;
-            clipboardRow.forEach(function (clipboardValue, columnOffset) {
-                var columnIndex = startColumnIndex + columnOffset;
+                continue;
+            var matrixRow = isSingleClipboardCell ? matrix[0] : matrix[rowOffset % matrix.length];
+            if (!matrixRow || matrixRow.length === 0)
+                continue;
+            for (var colOffset = 0; colOffset < fillColCount; colOffset++) {
+                var columnIndex = startColumnIndex + colOffset;
                 var column = columns[columnIndex];
                 // Pasting mutates row data without opening an editor, so only columns
                 // explicitly opted into editing may receive clipboard values.
                 if (!column || column.editable !== true)
-                    return;
+                    continue;
+                var clipboardValue = void 0;
+                if (isSingleClipboardCell) {
+                    clipboardValue = (_e = (_d = matrix[0]) === null || _d === void 0 ? void 0 : _d[0]) !== null && _e !== void 0 ? _e : '';
+                }
+                else if (canTileMatrix) {
+                    var cellColOffset = matrixColCount > 0 ? colOffset % matrixColCount : 0;
+                    if (cellColOffset >= matrixRow.length)
+                        continue;
+                    clipboardValue = (_f = matrixRow[cellColOffset]) !== null && _f !== void 0 ? _f : '';
+                }
+                else {
+                    if (colOffset >= matrixRow.length)
+                        continue;
+                    clipboardValue = (_g = matrixRow[colOffset]) !== null && _g !== void 0 ? _g : '';
+                }
                 var logicalCell = (0, utils_1.resolveLogicalCell)(logicalResolutionData, props.cellMergeOptions, {
                     rowIndex: rowIndex,
                     columnIndex: columnIndex,
@@ -1417,7 +1461,7 @@ function Table(props) {
                     return !logicalResolutionData[targetRowIndex] ||
                         logicalResolutionData[targetRowIndex].status === types_1.BGridDataItemStatus.remove;
                 })) {
-                    return;
+                    continue;
                 }
                 var targetKey = "".concat(logicalCell.cell.rowIndex, ":").concat(columnIndex);
                 var existingTarget = pasteTargets.get(targetKey);
@@ -1430,7 +1474,7 @@ function Table(props) {
                             columnIndex: columnIndex,
                         });
                     }
-                    return;
+                    continue;
                 }
                 pasteTargets.set(targetKey, {
                     canonicalRowIndex: logicalCell.cell.rowIndex,
@@ -1439,14 +1483,14 @@ function Table(props) {
                     clipboardValue: clipboardValue,
                     conflicted: false,
                 });
-            });
-        });
+            }
+        }
         var selectionStartRowIndex = Number.POSITIVE_INFINITY;
         var selectionEndRowIndex = Number.NEGATIVE_INFINITY;
         var selectionStartColumnIndex = Number.POSITIVE_INFINITY;
         var selectionEndColumnIndex = Number.NEGATIVE_INFINITY;
         pasteTargets.forEach(function (target) {
-            var _a;
+            var _a, _b, _c, _d;
             if (target.conflicted)
                 return;
             var column = columns[target.columnIndex];
@@ -1455,8 +1499,10 @@ function Table(props) {
                 return;
             var currentValue = (0, utils_1.getCellValueByRowKey)(column.key, item.values);
             var nextValue = target.clipboardValue;
-            var textEditorParser = ((_a = column.editor) === null || _a === void 0 ? void 0 : _a.type) === 'text' ? column.editor.parseValue : undefined;
-            if (column.parseClipboardText || textEditorParser) {
+            var pluginClipboardParser = ((_a = column.editor) === null || _a === void 0 ? void 0 : _a.type) === 'plugin' ? column.editor.parseClipboardText : undefined;
+            var textEditorParser = ((_b = column.editor) === null || _b === void 0 ? void 0 : _b.type) === 'text' ? column.editor.parseValue : undefined;
+            var clipboardParser = (_d = (_c = column.parseClipboardText) !== null && _c !== void 0 ? _c : pluginClipboardParser) !== null && _d !== void 0 ? _d : textEditorParser;
+            if (clipboardParser) {
                 try {
                     var context = {
                         index: target.canonicalRowIndex,
@@ -1467,9 +1513,7 @@ function Table(props) {
                         value: currentValue,
                         text: target.clipboardValue,
                     };
-                    nextValue = column.parseClipboardText
-                        ? column.parseClipboardText(target.clipboardValue, context)
-                        : textEditorParser(target.clipboardValue, context);
+                    nextValue = clipboardParser(target.clipboardValue, context);
                 }
                 catch (error) {
                     notifyPasteError({
@@ -1533,6 +1577,7 @@ function Table(props) {
     }, [
         activeCell,
         cellSelectionEnabled,
+        cellSelectionRanges,
         columns,
         data,
         editable,

package/cjs/editors/createSelectEditorPlugin.js

@@ -32,12 +32,25 @@ var __importStar = (this && this.__importStar) || (function () {
         return result;
     };
 })();
+var __values = (this && this.__values) || function(o) {
+    var s = typeof Symbol === "function" && Symbol.iterator, m = s && o[s], i = 0;
+    if (m) return m.call(o);
+    if (o && typeof o.length === "number") return {
+        next: function () {
+            if (o && i >= o.length) o = void 0;
+            return { value: o && o[i++], done: !o };
+        }
+    };
+    throw new TypeError(s ? "Object is not iterable." : "Symbol.iterator is not defined.");
+};
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.createSelectEditorPlugin = createSelectEditorPlugin;
 var React = __importStar(require("react"));
 var defineEditorPlugin_1 = require("./defineEditorPlugin");
 var getColumnId_1 = require("../utils/getColumnId");
 function createSelectEditorPlugin(options) {
+    var e_1, _a;
+    var _b, _c;
     function SelectEditor(_a) {
         var _b, _c;
         var value = _a.value, column = _a.column, commit = _a.commit, cancel = _a.cancel;
@@ -91,8 +104,93 @@ function createSelectEditorPlugin(options) {
                     React.createElement("path", { d: 'm4 6 4 4 4-4', stroke: 'currentColor', strokeWidth: '1.5', strokeLinecap: 'round', strokeLinejoin: 'round' })))));
     }
     SelectEditor.displayName = "BGridSelectEditor(".concat(options.id, ")");
+    // Precompute lookup maps for O(1) clipboard parsing and copying
+    var valueMap = new Map();
+    var labelMap = new Map();
+    var valueToLabelMap = new Map();
+    var isNumericValue = options.options.some(function (opt) { return typeof opt.value === 'number'; });
+    try {
+        for (var _d = __values(options.options), _e = _d.next(); !_e.done; _e = _d.next()) {
+            var opt = _e.value;
+            var valKey = String(opt.value);
+            if (!valueMap.has(valKey)) {
+                valueMap.set(valKey, opt);
+            }
+            if (typeof opt.label === 'string' || typeof opt.label === 'number') {
+                var labelText = String(opt.label);
+                var trimmedLabel = labelText.trim();
+                if (!labelMap.has(trimmedLabel)) {
+                    labelMap.set(trimmedLabel, opt);
+                }
+                if (!valueToLabelMap.has(opt.value)) {
+                    valueToLabelMap.set(opt.value, labelText);
+                }
+            }
+        }
+    }
+    catch (e_1_1) { e_1 = { error: e_1_1 }; }
+    finally {
+        try {
+            if (_e && !_e.done && (_a = _d.return)) _a.call(_d);
+        }
+        finally { if (e_1) throw e_1.error; }
+    }
+    var defaultParseClipboardText = function (text) {
+        var _a, _b, _c, _d;
+        var trimmed = text.trim();
+        // Check empty input
+        if (trimmed === '') {
+            var emptyOption = options.copyMode === 'value'
+                ? ((_a = valueMap.get('')) !== null && _a !== void 0 ? _a : labelMap.get(''))
+                : ((_b = labelMap.get('')) !== null && _b !== void 0 ? _b : valueMap.get(''));
+            if (emptyOption) {
+                if (emptyOption.disabled && !options.allowDisabledOptions) {
+                    throw new Error("Disabled select option for editor \"".concat(options.id, "\""));
+                }
+                return emptyOption.value;
+            }
+            if (options.allowEmpty) {
+                return options.emptyValue !== undefined ? options.emptyValue : '';
+            }
+        }
+        // Match order depends on copyMode:
+        // If copyMode is 'label' (default), match by label first, then by value.
+        // If copyMode is 'value', match by value first, then by label.
+        var matched = options.copyMode === 'value'
+            ? ((_c = valueMap.get(trimmed)) !== null && _c !== void 0 ? _c : labelMap.get(trimmed))
+            : ((_d = labelMap.get(trimmed)) !== null && _d !== void 0 ? _d : valueMap.get(trimmed));
+        if (matched) {
+            if (matched.disabled && !options.allowDisabledOptions) {
+                throw new Error("Disabled select option \"".concat(text, "\" for editor \"").concat(options.id, "\""));
+            }
+            return matched.value;
+        }
+        if (options.allowCustomValue) {
+            if (isNumericValue) {
+                var num = Number(trimmed);
+                if (!Number.isNaN(num)) {
+                    return num;
+                }
+            }
+            return trimmed;
+        }
+        throw new Error("Invalid select value \"".concat(text, "\" for editor \"").concat(options.id, "\""));
+    };
+    var defaultGetClipboardText = function (params) {
+        var value = params.value;
+        if (options.copyMode === 'value') {
+            return value;
+        }
+        var label = valueToLabelMap.get(value);
+        if (label !== undefined) {
+            return label;
+        }
+        return value;
+    };
     return (0, defineEditorPlugin_1.defineEditorPlugin)({
         id: options.id,
         component: SelectEditor,
+        parseClipboardText: (_b = options.parseClipboardText) !== null && _b !== void 0 ? _b : (function (text, _params) { return defaultParseClipboardText(text); }),
+        getClipboardText: (_c = options.getClipboardText) !== null && _c !== void 0 ? _c : defaultGetClipboardText,
     });
 }

package/esm/components/Table.js

@@ -1071,8 +1071,10 @@ function Table(props) {
                 rowHasNewLogicalCell = true;
                 const logicalItem = data[logicalCell.cell.rowIndex] ?? item;
                 const value = getCellValueByRowKey(column.key, logicalItem.values);
-                const clipboardValue = column.getClipboardText
-                    ? column.getClipboardText({
+                const pluginClipboardTextGetter = column.editor?.type === 'plugin' ? column.editor.getClipboardText : undefined;
+                const clipboardTextGetter = column.getClipboardText ?? pluginClipboardTextGetter;
+                const clipboardValue = clipboardTextGetter
+                    ? clipboardTextGetter({
                         column,
                         index: logicalCell.cell.rowIndex,
                         columnIndex: ci,
@@ -1180,17 +1182,41 @@ function Table(props) {
             });
             return true;
         }
-        const startRowIndex = activeCell.rowIndex;
-        const startColumnIndex = activeCell.columnIndex;
+        const primaryRange = cellSelectionRanges.length === 1 ? normalizeCellSelectionRange(cellSelectionRanges[0]) : null;
+        const selectionRowCount = primaryRange ? primaryRange.endRowIndex - primaryRange.startRowIndex + 1 : 1;
+        const selectionColCount = primaryRange ? primaryRange.endColumnIndex - primaryRange.startColumnIndex + 1 : 1;
+        // Determine fill rows and cols:
+        // 1. Single cell (1x1) copied into multi-cell selection: fill the entire selection.
+        // 2. nxm copied into exact multiple NxM selection: repeat pattern across selection.
+        // 3. Otherwise: paste 1:1 matching matrix dimensions, anchored at selection top-left (or activeCell if no range).
+        const isSingleClipboardCell = matrix.length === 1 && matrix[0]?.length === 1;
+        const matrixColCount = matrix.reduce((max, row) => Math.max(max, row.length), 0);
+        const isExactRowMultiple = primaryRange && matrix.length > 0 && selectionRowCount % matrix.length === 0;
+        const isExactColMultiple = primaryRange &&
+            matrixColCount > 0 &&
+            selectionColCount % matrixColCount === 0;
+        const canTileMatrix = primaryRange &&
+            isExactRowMultiple &&
+            isExactColMultiple &&
+            (selectionRowCount > matrix.length || selectionColCount > matrixColCount);
+        let fillRowCount = matrix.length;
+        let fillColCount = matrixColCount;
+        let startRowIndex = primaryRange ? primaryRange.startRowIndex : activeCell.rowIndex;
+        let startColumnIndex = primaryRange ? primaryRange.startColumnIndex : activeCell.columnIndex;
+        if (primaryRange && (isSingleClipboardCell || canTileMatrix)) {
+            fillRowCount = selectionRowCount;
+            fillColCount = selectionColCount;
+        }
         const nextData = [...data];
         const appendedRows = [];
         const changes = [];
         const createRowOnPaste = cellSelectionOptions?.createRowOnPaste;
         if (createRowOnPaste) {
-            const requiredRowCount = startRowIndex + matrix.length;
+            const requiredRowCount = startRowIndex + fillRowCount;
             while (nextData.length < requiredRowCount) {
                 const rowIndex = nextData.length;
-                const clipboardRow = matrix[rowIndex - startRowIndex];
+                const matrixRowOffset = isSingleClipboardCell ? 0 : (rowIndex - startRowIndex) % matrix.length;
+                const clipboardRow = matrix[matrixRowOffset];
                 if (!clipboardRow)
                     break;
                 let createdItem;
@@ -1210,25 +1236,43 @@ function Table(props) {
         }
         const logicalResolutionData = [...nextData];
         const pasteTargets = new Map();
-        matrix.forEach((clipboardRow, rowOffset) => {
+        for (let rowOffset = 0; rowOffset < fillRowCount; rowOffset++) {
             const rowIndex = startRowIndex + rowOffset;
             const item = logicalResolutionData[rowIndex];
             if (!item || item.status === BGridDataItemStatus.remove)
-                return;
-            clipboardRow.forEach((clipboardValue, columnOffset) => {
-                const columnIndex = startColumnIndex + columnOffset;
+                continue;
+            const matrixRow = isSingleClipboardCell ? matrix[0] : matrix[rowOffset % matrix.length];
+            if (!matrixRow || matrixRow.length === 0)
+                continue;
+            for (let colOffset = 0; colOffset < fillColCount; colOffset++) {
+                const columnIndex = startColumnIndex + colOffset;
                 const column = columns[columnIndex];
                 // Pasting mutates row data without opening an editor, so only columns
                 // explicitly opted into editing may receive clipboard values.
                 if (!column || column.editable !== true)
-                    return;
+                    continue;
+                let clipboardValue;
+                if (isSingleClipboardCell) {
+                    clipboardValue = matrix[0]?.[0] ?? '';
+                }
+                else if (canTileMatrix) {
+                    const cellColOffset = matrixColCount > 0 ? colOffset % matrixColCount : 0;
+                    if (cellColOffset >= matrixRow.length)
+                        continue;
+                    clipboardValue = matrixRow[cellColOffset] ?? '';
+                }
+                else {
+                    if (colOffset >= matrixRow.length)
+                        continue;
+                    clipboardValue = matrixRow[colOffset] ?? '';
+                }
                 const logicalCell = resolveLogicalCell(logicalResolutionData, props.cellMergeOptions, {
                     rowIndex,
                     columnIndex,
                 });
                 if (logicalCell.rowIndexes.some(targetRowIndex => !logicalResolutionData[targetRowIndex] ||
                     logicalResolutionData[targetRowIndex].status === BGridDataItemStatus.remove)) {
-                    return;
+                    continue;
                 }
                 const targetKey = `${logicalCell.cell.rowIndex}:${columnIndex}`;
                 const existingTarget = pasteTargets.get(targetKey);
@@ -1241,7 +1285,7 @@ function Table(props) {
                             columnIndex,
                         });
                     }
-                    return;
+                    continue;
                 }
                 pasteTargets.set(targetKey, {
                     canonicalRowIndex: logicalCell.cell.rowIndex,
@@ -1250,8 +1294,8 @@ function Table(props) {
                     clipboardValue,
                     conflicted: false,
                 });
-            });
-        });
+            }
+        }
         let selectionStartRowIndex = Number.POSITIVE_INFINITY;
         let selectionEndRowIndex = Number.NEGATIVE_INFINITY;
         let selectionStartColumnIndex = Number.POSITIVE_INFINITY;
@@ -1265,8 +1309,10 @@ function Table(props) {
                 return;
             const currentValue = getCellValueByRowKey(column.key, item.values);
             let nextValue = target.clipboardValue;
+            const pluginClipboardParser = column.editor?.type === 'plugin' ? column.editor.parseClipboardText : undefined;
             const textEditorParser = column.editor?.type === 'text' ? column.editor.parseValue : undefined;
-            if (column.parseClipboardText || textEditorParser) {
+            const clipboardParser = column.parseClipboardText ?? pluginClipboardParser ?? textEditorParser;
+            if (clipboardParser) {
                 try {
                     const context = {
                         index: target.canonicalRowIndex,
@@ -1277,9 +1323,7 @@ function Table(props) {
                         value: currentValue,
                         text: target.clipboardValue,
                     };
-                    nextValue = column.parseClipboardText
-                        ? column.parseClipboardText(target.clipboardValue, context)
-                        : textEditorParser(target.clipboardValue, context);
+                    nextValue = clipboardParser(target.clipboardValue, context);
                 }
                 catch (error) {
                     notifyPasteError({
@@ -1340,6 +1384,7 @@ function Table(props) {
     }, [
         activeCell,
         cellSelectionEnabled,
+        cellSelectionRanges,
         columns,
         data,
         editable,

package/esm/editors/createSelectEditorPlugin.js

@@ -53,8 +53,82 @@ export function createSelectEditorPlugin(options) {
                     React.createElement("path", { d: 'm4 6 4 4 4-4', stroke: 'currentColor', strokeWidth: '1.5', strokeLinecap: 'round', strokeLinejoin: 'round' })))));
     }
     SelectEditor.displayName = `BGridSelectEditor(${options.id})`;
+    // Precompute lookup maps for O(1) clipboard parsing and copying
+    const valueMap = new Map();
+    const labelMap = new Map();
+    const valueToLabelMap = new Map();
+    const isNumericValue = options.options.some(opt => typeof opt.value === 'number');
+    for (const opt of options.options) {
+        const valKey = String(opt.value);
+        if (!valueMap.has(valKey)) {
+            valueMap.set(valKey, opt);
+        }
+        if (typeof opt.label === 'string' || typeof opt.label === 'number') {
+            const labelText = String(opt.label);
+            const trimmedLabel = labelText.trim();
+            if (!labelMap.has(trimmedLabel)) {
+                labelMap.set(trimmedLabel, opt);
+            }
+            if (!valueToLabelMap.has(opt.value)) {
+                valueToLabelMap.set(opt.value, labelText);
+            }
+        }
+    }
+    const defaultParseClipboardText = (text) => {
+        const trimmed = text.trim();
+        // Check empty input
+        if (trimmed === '') {
+            const emptyOption = options.copyMode === 'value'
+                ? (valueMap.get('') ?? labelMap.get(''))
+                : (labelMap.get('') ?? valueMap.get(''));
+            if (emptyOption) {
+                if (emptyOption.disabled && !options.allowDisabledOptions) {
+                    throw new Error(`Disabled select option for editor "${options.id}"`);
+                }
+                return emptyOption.value;
+            }
+            if (options.allowEmpty) {
+                return options.emptyValue !== undefined ? options.emptyValue : '';
+            }
+        }
+        // Match order depends on copyMode:
+        // If copyMode is 'label' (default), match by label first, then by value.
+        // If copyMode is 'value', match by value first, then by label.
+        const matched = options.copyMode === 'value'
+            ? (valueMap.get(trimmed) ?? labelMap.get(trimmed))
+            : (labelMap.get(trimmed) ?? valueMap.get(trimmed));
+        if (matched) {
+            if (matched.disabled && !options.allowDisabledOptions) {
+                throw new Error(`Disabled select option "${text}" for editor "${options.id}"`);
+            }
+            return matched.value;
+        }
+        if (options.allowCustomValue) {
+            if (isNumericValue) {
+                const num = Number(trimmed);
+                if (!Number.isNaN(num)) {
+                    return num;
+                }
+            }
+            return trimmed;
+        }
+        throw new Error(`Invalid select value "${text}" for editor "${options.id}"`);
+    };
+    const defaultGetClipboardText = (params) => {
+        const { value } = params;
+        if (options.copyMode === 'value') {
+            return value;
+        }
+        const label = valueToLabelMap.get(value);
+        if (label !== undefined) {
+            return label;
+        }
+        return value;
+    };
     return defineEditorPlugin({
         id: options.id,
         component: SelectEditor,
+        parseClipboardText: options.parseClipboardText ?? ((text, _params) => defaultParseClipboardText(text)),
+        getClipboardText: options.getClipboardText ?? defaultGetClipboardText,
     });
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "beautiful-grid",
-  "version": "1.0.16",
+  "version": "1.0.17",
   "description": "A beautiful, powerful, open-source React Data Grid.",
   "homepage": "https://bgrid.axisj.com",
   "bugs": {

package/types/editors/createSelectEditorPlugin.d.ts

@@ -1,5 +1,5 @@
 import * as React from 'react';
-import { BGridPluginEditorConfig } from '../types';
+import { BGridCellClipboardParseParams, BGridCellClipboardTextParams, BGridPluginEditorConfig } from '../types';
 export interface BGridSelectEditorOption<Value extends string | number> {
     value: Value;
     label: React.ReactNode;
@@ -11,5 +11,41 @@ export interface BGridSelectEditorPluginOptions<Value extends string | number> {
     ariaLabel?: string;
     placeholder?: string;
     openOnMount?: boolean;
+    /**
+     * Whether to allow pasting values that do not match any option value or label.
+     * Defaults to false (unmatched values throw an error and report parseValueFailed).
+     */
+    allowCustomValue?: boolean;
+    /**
+     * Clipboard text mode when copying cells using this editor.
+     * 'label' (default): copies the option's label if it is a string or number.
+     * 'value': copies the option's raw value.
+     */
+    copyMode?: 'label' | 'value';
+    /**
+     * Whether to allow clearing cell values by pasting empty or whitespace-only text.
+     * Defaults to false (unmatched empty text throws parseValueFailed).
+     * When true, pastes `emptyValue` into the cell.
+     */
+    allowEmpty?: boolean;
+    /**
+     * Value written when an empty text is pasted and `allowEmpty` is true.
+     * Defaults to undefined.
+     */
+    emptyValue?: Value | null;
+    /**
+     * Whether to allow pasting options that have `disabled: true`.
+     * Defaults to false (pasting a disabled option throws an error).
+     */
+    allowDisabledOptions?: boolean;
+    /**
+     * Custom clipboard parser for this editor.
+     * Throw an error to reject the paste for this cell.
+     */
+    parseClipboardText?: <T>(text: string, params: BGridCellClipboardParseParams<T>) => Value | unknown;
+    /**
+     * Custom clipboard text getter for this editor.
+     */
+    getClipboardText?: <T>(params: BGridCellClipboardTextParams<T>) => any;
 }
 export declare function createSelectEditorPlugin<T, Value extends string | number = string>(options: BGridSelectEditorPluginOptions<Value>): BGridPluginEditorConfig<T>;

package/types/types.d.ts

@@ -122,6 +122,13 @@ export interface BGridPluginEditorConfig<T> {
     type: 'plugin';
     id: string;
     component: React.ComponentType<BGridEditorPluginProps<T>>;
+    getClipboardText?: (params: BGridCellClipboardTextParams<T>) => any;
+    /**
+     * Restores text/plain clipboard input to the editor's stored value type.
+     * Takes precedence over built-in fallback parser during multi-cell paste.
+     * Throw to keep the current cell value and report parseValueFailed through onPasteError.
+     */
+    parseClipboardText?: (text: string, params: BGridCellClipboardParseParams<T>) => unknown;
 }
 export type BGridCellEditorConfig<T> = BGridTextEditorConfig<T> | BGridCheckboxEditorConfig<T> | BGridPluginEditorConfig<T>;
 export interface BGridCellClipboardTextParams<T> {