handsontable 18.0.0 → 18.1.0-rc7

package/plugins/mergeCells/cellsCollection.js

@@ -34,13 +34,33 @@ function _interop_require_default(obj) {
     };
 }
 var /**
-   * Gets the list of the indexes that do not intersect with other merged cells within the provided range.
+   * Collects, per range line along the provided axis, the contributions of the merged cells that
+   * intersect the provided range. A line is a single row (for the `row` axis) or a single column
+   * (for the `col` axis) of the range. Each merged cell contributes, to every line it covers, its
+   * scan extent along the axis (the last covered index when scanning forward, the first when
+   * scanning backward) and the number of range cells it covers within the line. Lines without any
+   * merged cell are absent from the returned map. Only merged cells present in the lookup matrix
+   * are considered — merges purged from the matrix (fully hidden) are skipped.
    *
    * @param {CellRange} range The range to search within.
    * @param {'row' | 'col'} axis The axis to search within.
-   * @param {number} scanDirection  The direction to scan the range. `1` for forward, `-1` for backward.
-   * @returns {number[]}
-   */ _getNonIntersectingIndexes = /*#__PURE__*/ new WeakSet(), /**
+   * @param {number} scanDirection The direction to scan the range. `1` for forward, `-1` for backward.
+   * @returns {Map<number, { extents: Set<number>, coveredCells: number }>} Map keyed by the line index.
+   */ _collectLineContributions = /*#__PURE__*/ new WeakSet(), /**
+   * Finds the nearest index along the provided axis that does not intersect with any merged cell
+   * within the provided range. The range's lines are conceptually scanned in the provided
+   * direction; a line emits a candidate index when all of its cells agree on a single index — its
+   * own index when no merged cell touches it, or the shared scan extent when merged cells cover
+   * it uniformly. The first emitted candidate located at or past `visualIndex` (in the scan
+   * direction) wins. The cost scales with the number of merged cells intersecting the range, not
+   * with the area of the range.
+   *
+   * @param {CellRange} range The range to search within.
+   * @param {'row' | 'col'} axis The axis to search within.
+   * @param {number} scanDirection The direction to scan the range. `1` for forward, `-1` for backward.
+   * @param {number} visualIndex The visual row/column index the search relates to.
+   * @returns {number} The found visual index, or `visualIndex` when every line intersects a merged cell.
+   */ _findNonIntersectingIndex = /*#__PURE__*/ new WeakSet(), /**
    * Adds a merged cell to the matrix.
    *
    * @param {MergedCellCoords} mergedCell The merged cell to add.
@@ -103,6 +123,38 @@ var /**
         return result;
     }
     /**
+   * Get the merged cells that cover any cell of the provided visual row. The cost scales with the
+   * number of merged cells covering the row, not with the number of table columns. Merges purged
+   * from the lookup matrix (fully hidden) are not returned.
+   *
+   * @param {number} row Visual row index.
+   * @returns {MergedCellCoords[]} Array of merged cells covering the row.
+   */ getByVisualRow(row) {
+        const rowEntries = this.mergedCellsMatrix.get(row);
+        if (!rowEntries) {
+            return [];
+        }
+        return Array.from(new Set(rowEntries.values()));
+    }
+    /**
+   * Get the merged cells that cover any cell of the provided visual column. The cost scales with
+   * the total number of merged cells, not with the number of table rows. Merges purged from the
+   * lookup matrix (fully hidden) are not returned.
+   *
+   * @param {number} column Visual column index.
+   * @returns {MergedCellCoords[]} Array of merged cells covering the column.
+   */ getByVisualColumn(column) {
+        const result = [];
+        for(let i = 0; i < this.mergedCells.length; i++){
+            const mergedCell = this.mergedCells[i];
+            if (mergedCell.col <= column && column <= mergedCell.col + mergedCell.colspan - 1 && // The lookup matrix is the authority on visibility (see `getWithinRange`).
+            this.get(mergedCell.row, mergedCell.col) === mergedCell) {
+                result.push(mergedCell);
+            }
+        }
+        return result;
+    }
+    /**
    * Filters merge cells objects provided by users from overlapping cells.
    *
    * @param {{ row: number, col: number, rowspan: number, colspan: number }} mergedCellsInfo The merged cell information object.
@@ -144,11 +196,13 @@ var /**
         return filteredMergeCells;
     }
     /**
-   * Get a merged cell contained in the provided range.
+   * Get the merged cells contained in the provided range. Each merged cell is returned once, even
+   * when it spans multiple cells of the range. The cost scales with the number of merged cells in
+   * the collection, not with the area of the range.
    *
    * @param {CellRange} range The range to search merged cells in.
    * @param {boolean} [countPartials=false] If set to `true`, all the merged cells overlapping the range will be taken into calculation.
-   * @returns {MergedCellCoords[]} Array of found merged cells.
+   * @returns {MergedCellCoords[]} Array of found merged cells, ordered by their first covered cell in row-major order.
    */ getWithinRange(range, countPartials = false) {
         const { row: rowStart, col: columnStart } = range.getTopStartCorner();
         const { row: rowEnd, col: columnEnd } = range.getBottomEndCorner();
@@ -156,14 +210,22 @@ var /**
             return [];
         }
         const result = [];
-        for(let row = rowStart; row <= rowEnd; row++){
-            for(let column = columnStart; column <= columnEnd; column++){
-                const mergedCell = this.get(row, column);
-                if (mergedCell && (countPartials || !countPartials && mergedCell.row === row && mergedCell.col === column)) {
-                    result.push(mergedCell);
-                }
+        for(let i = 0; i < this.mergedCells.length; i++){
+            const mergedCell = this.mergedCells[i];
+            const { row, col, rowspan, colspan } = mergedCell;
+            const isWithin = countPartials ? row <= rowEnd && row + rowspan - 1 >= rowStart && col <= columnEnd && col + colspan - 1 >= columnStart : row >= rowStart && row <= rowEnd && col >= columnStart && col <= columnEnd;
+            // The lookup matrix is the authority on visibility: merges whose whole visible span is
+            // hidden are purged from the matrix while staying in the `mergedCells` list, and their
+            // visual coordinates may be stale.
+            if (isWithin && this.get(row, col) === mergedCell) {
+                result.push(mergedCell);
             }
         }
+        if (result.length > 1) {
+            result.sort((cellA, cellB)=>{
+                return Math.max(cellA.row, rowStart) - Math.max(cellB.row, rowStart) || Math.max(cellA.col, columnStart) - Math.max(cellB.col, columnStart);
+            });
+        }
         return result;
     }
     /**
@@ -297,15 +359,7 @@ var /**
    * @param {number} visualColumnIndex The visual column index to start the search from.
    * @returns {number}
    */ getStartMostColumnIndex(range, visualColumnIndex) {
-        const indexes = _class_private_method_get(this, _getNonIntersectingIndexes, getNonIntersectingIndexes).call(this, range, 'col', -1);
-        let startMostIndex = visualColumnIndex;
-        for(let i = 0; i < indexes.length; i++){
-            if (indexes[i] <= visualColumnIndex) {
-                startMostIndex = indexes[i];
-                break;
-            }
-        }
-        return startMostIndex;
+        return _class_private_method_get(this, _findNonIntersectingIndex, findNonIntersectingIndex).call(this, range, 'col', -1, visualColumnIndex);
     }
     /**
    * Gets the end-most visual column index that do not intersect with other merged cells within the provided range.
@@ -314,15 +368,7 @@ var /**
    * @param {number} visualColumnIndex The visual column index to start the search from.
    * @returns {number}
    */ getEndMostColumnIndex(range, visualColumnIndex) {
-        const indexes = _class_private_method_get(this, _getNonIntersectingIndexes, getNonIntersectingIndexes).call(this, range, 'col', 1);
-        let endMostIndex = visualColumnIndex;
-        for(let i = 0; i < indexes.length; i++){
-            if (indexes[i] >= visualColumnIndex) {
-                endMostIndex = indexes[i];
-                break;
-            }
-        }
-        return endMostIndex;
+        return _class_private_method_get(this, _findNonIntersectingIndex, findNonIntersectingIndex).call(this, range, 'col', 1, visualColumnIndex);
     }
     /**
    * Gets the top-most visual row index that do not intersect with other merged cells within the provided range.
@@ -331,15 +377,7 @@ var /**
    * @param {number} visualRowIndex The visual row index to start the search from.
    * @returns {number}
    */ getTopMostRowIndex(range, visualRowIndex) {
-        const indexes = _class_private_method_get(this, _getNonIntersectingIndexes, getNonIntersectingIndexes).call(this, range, 'row', -1);
-        let topMostIndex = visualRowIndex;
-        for(let i = 0; i < indexes.length; i++){
-            if (indexes[i] <= visualRowIndex) {
-                topMostIndex = indexes[i];
-                break;
-            }
-        }
-        return topMostIndex;
+        return _class_private_method_get(this, _findNonIntersectingIndex, findNonIntersectingIndex).call(this, range, 'row', -1, visualRowIndex);
     }
     /**
    * Gets the bottom-most visual row index that do not intersect with other merged cells within the provided range.
@@ -348,15 +386,7 @@ var /**
    * @param {number} visualRowIndex The visual row index to start the search from.
    * @returns {number}
    */ getBottomMostRowIndex(range, visualRowIndex) {
-        const indexes = _class_private_method_get(this, _getNonIntersectingIndexes, getNonIntersectingIndexes).call(this, range, 'row', 1);
-        let bottomMostIndex = visualRowIndex;
-        for(let i = 0; i < indexes.length; i++){
-            if (indexes[i] >= visualRowIndex) {
-                bottomMostIndex = indexes[i];
-                break;
-            }
-        }
-        return bottomMostIndex;
+        return _class_private_method_get(this, _findNonIntersectingIndex, findNonIntersectingIndex).call(this, range, 'row', 1, visualRowIndex);
     }
     /**
    * Shift the merged cell in the direction and by an offset defined in the arguments.
@@ -508,9 +538,36 @@ var /**
         });
     }
     /**
+   * Relocates a batch of merges in the coords->merge lookup matrix, applying each merge's new visual
+   * top-left. Used after re-anchoring to the visible rows on a trimming/sort change. Incremental
+   * alternative to a full rebuild — only the cells of the affected merges are touched. Runs in two
+   * phases (remove all, then re-add all) so merges that swap visual positions don't clobber each
+   * other's freshly written entries.
+   *
+   * @param {Array<{ mergedCell: MergedCellCoords, row: number, col: number }>} relocations The merges
+   * to move together with their new top-left visual `row`/`col`.
+   */ relocateInMatrix(relocations) {
+        relocations.forEach(({ mergedCell })=>_class_private_method_get(this, _removeMergedCellFromMatrix, removeMergedCellFromMatrix).call(this, mergedCell));
+        relocations.forEach(({ mergedCell, row, col })=>{
+            mergedCell.relocate(row, col);
+            _class_private_method_get(this, _addMergedCellToMatrix, addMergedCellToMatrix).call(this, mergedCell);
+        });
+    }
+    /**
+   * Removes a batch of merges from the coords->merge lookup matrix without touching the
+   * `mergedCells` list. Used to purge merges whose whole visible span has been trimmed away, so their
+   * stale entries cannot resolve to a phantom merge once a different row surfaces at the same visual
+   * slot. The merges themselves are kept (their physical anchor lets them be re-added when visible).
+   *
+   * @param {Array<MergedCellCoords>} merges The merges to remove from the matrix.
+   */ removeFromMatrix(merges) {
+        merges.forEach((mergedCell)=>_class_private_method_get(this, _removeMergedCellFromMatrix, removeMergedCellFromMatrix).call(this, mergedCell));
+    }
+    /**
    * Initializes the cells collection with references to the MergeCells plugin and the Handsontable instance.
    */ constructor(mergeCellsPlugin){
-        _class_private_method_init(this, _getNonIntersectingIndexes);
+        _class_private_method_init(this, _collectLineContributions);
+        _class_private_method_init(this, _findNonIntersectingIndex);
         _class_private_method_init(this, _addMergedCellToMatrix);
         _class_private_method_init(this, _removeMergedCellFromMatrix);
         /**
@@ -527,29 +584,93 @@ var /**
         this.hot = mergeCellsPlugin.hot;
     }
 }
-function getNonIntersectingIndexes(range, axis, scanDirection = 1) {
-    const indexes = new Map();
-    const from = scanDirection === 1 ? range.getTopStartCorner() : range.getBottomEndCorner();
-    const to = scanDirection === 1 ? range.getBottomEndCorner() : range.getTopStartCorner();
-    const fromRow = from.row ?? 0;
-    const fromCol = from.col ?? 0;
-    const toRow = to.row ?? 0;
-    const toCol = to.col ?? 0;
-    for(let row = fromRow; scanDirection === 1 ? row <= toRow : row >= toRow; row += scanDirection){
-        for(let column = fromCol; scanDirection === 1 ? column <= toCol : column >= toCol; column += scanDirection){
-            const index = axis === 'row' ? row : column;
-            const mergedCell = this.get(row, column);
-            let lastIndex = index;
-            if (mergedCell) {
-                lastIndex = scanDirection === 1 ? mergedCell[axis] + mergedCell[`${axis}span`] - 1 : mergedCell[axis];
+function collectLineContributions(range, axis, scanDirection) {
+    const { row: rangeStartRow, col: rangeStartColumn } = range.getTopStartCorner();
+    const { row: rangeEndRow, col: rangeEndColumn } = range.getBottomEndCorner();
+    const startRow = rangeStartRow ?? 0;
+    const startColumn = rangeStartColumn ?? 0;
+    const endRow = rangeEndRow ?? 0;
+    const endColumn = rangeEndColumn ?? 0;
+    const isRowAxis = axis === 'row';
+    const lineStart = isRowAxis ? startRow : startColumn;
+    const lineEnd = isRowAxis ? endRow : endColumn;
+    const crossStart = isRowAxis ? startColumn : startRow;
+    const crossEnd = isRowAxis ? endColumn : endRow;
+    const lines = new Map();
+    for(let i = 0; i < this.mergedCells.length; i++){
+        const mergedCell = this.mergedCells[i];
+        const mergeLineStart = isRowAxis ? mergedCell.row : mergedCell.col;
+        const mergeLineEnd = mergeLineStart + (isRowAxis ? mergedCell.rowspan : mergedCell.colspan) - 1;
+        const mergeCrossStart = isRowAxis ? mergedCell.col : mergedCell.row;
+        const mergeCrossEnd = mergeCrossStart + (isRowAxis ? mergedCell.colspan : mergedCell.rowspan) - 1;
+        if (mergeLineEnd < lineStart || mergeLineStart > lineEnd || mergeCrossEnd < crossStart || mergeCrossStart > crossEnd || // The lookup matrix is the authority on visibility: merges purged from the matrix
+        // (fully hidden) keep stale visual coordinates in the `mergedCells` list.
+        this.get(mergedCell.row, mergedCell.col) !== mergedCell) {
+            continue;
+        }
+        const extent = scanDirection === 1 ? mergeLineEnd : mergeLineStart;
+        const coveredCells = Math.min(mergeCrossEnd, crossEnd) - Math.max(mergeCrossStart, crossStart) + 1;
+        const firstLine = Math.max(mergeLineStart, lineStart);
+        const lastLine = Math.min(mergeLineEnd, lineEnd);
+        for(let line = firstLine; line <= lastLine; line++){
+            let entry = lines.get(line);
+            if (!entry) {
+                entry = {
+                    extents: new Set(),
+                    coveredCells: 0
+                };
+                lines.set(line, entry);
             }
-            if (!indexes.has(index)) {
-                indexes.set(index, new Set());
+            entry.extents.add(extent);
+            entry.coveredCells += coveredCells;
+        }
+    }
+    return lines;
+}
+function findNonIntersectingIndex(range, axis, scanDirection, visualIndex) {
+    const { row: rangeStartRow, col: rangeStartColumn } = range.getTopStartCorner();
+    const { row: rangeEndRow, col: rangeEndColumn } = range.getBottomEndCorner();
+    const isRowAxis = axis === 'row';
+    const lineStart = (isRowAxis ? rangeStartRow : rangeStartColumn) ?? 0;
+    const lineEnd = (isRowAxis ? rangeEndRow : rangeEndColumn) ?? 0;
+    const crossLength = isRowAxis ? (rangeEndColumn ?? 0) - (rangeStartColumn ?? 0) + 1 : (rangeEndRow ?? 0) - (rangeStartRow ?? 0) + 1;
+    const matches = (index)=>scanDirection === 1 ? index >= visualIndex : index <= visualIndex;
+    const lines = _class_private_method_get(this, _collectLineContributions, collectLineContributions).call(this, range, axis, scanDirection);
+    const touchedLines = Array.from(lines.keys()).sort((lineA, lineB)=>(lineA - lineB) * scanDirection);
+    // The first merge-touched line (in scan order) whose cells all agree on a single index
+    // that lies at or past `visualIndex`.
+    let touchedMatchLine = null;
+    let touchedMatchIndex = 0;
+    for(let i = 0; i < touchedLines.length; i++){
+        const line = touchedLines[i];
+        const { extents, coveredCells } = lines.get(line);
+        // Cells not covered by any merged cell contribute the line's own index.
+        if (coveredCells < crossLength) {
+            extents.add(line);
+        }
+        if (extents.size === 1) {
+            const candidate = extents.values().next().value;
+            if (matches(candidate)) {
+                touchedMatchLine = line;
+                touchedMatchIndex = candidate;
+                break;
             }
-            indexes.get(index).add(lastIndex);
         }
     }
-    return Array.from(new Set(Array.from(indexes.entries()).filter(([, set])=>set.size === 1).flatMap(([, set])=>Array.from(set))));
+    // The first merge-free line in scan order that lies at or past `visualIndex`; such a line
+    // always emits its own index.
+    let freeMatchLine = scanDirection === 1 ? Math.max(lineStart, visualIndex) : Math.min(lineEnd, visualIndex);
+    while(freeMatchLine >= lineStart && freeMatchLine <= lineEnd && lines.has(freeMatchLine)){
+        freeMatchLine += scanDirection;
+    }
+    const hasFreeMatch = freeMatchLine >= lineStart && freeMatchLine <= lineEnd;
+    if (touchedMatchLine === null) {
+        return hasFreeMatch ? freeMatchLine : visualIndex;
+    }
+    if (!hasFreeMatch || (touchedMatchLine - freeMatchLine) * scanDirection <= 0) {
+        return touchedMatchIndex;
+    }
+    return freeMatchLine;
 }
 function addMergedCellToMatrix(mergedCell) {
     for(let row = mergedCell.row; row < mergedCell.row + mergedCell.rowspan; row++){