Skip to content

Build your own AI office with Univer Office SDK. Bring editing, calculation, collaboration, and file processing into your product for people and AI agents. Built on an extensible open-source core.

fix: searcharray (#3883)

lumix602f44abf1cb
diff --git a/packages/core/src/shared/__tests__/array-search.spec.ts b/packages/core/src/shared/__tests__/array-search.spec.ts
new file mode 100644
index 0000000000..be7fe440ac
--- /dev/null
+++ b/packages/core/src/shared/__tests__/array-search.spec.ts
@@ -0,0 +1,50 @@
+/**
+ * Copyright 2023-present DreamNum 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 { describe, expect, it } from 'vitest';
+import { binSearchFirstGreaterThanTarget, searchArray, searchInOrderedArray } from '../array-search';
+
+describe('test searchArray function', () => {
+ const array = [0, 1, 2, 3, 4, 4, 4, 5, 5, 5];
+
+ it('searchArray test', () => {
+ expect(searchArray(array, -1)).toBe(array.indexOf(0));
+ expect(searchArray(array, 0)).toBe(array.indexOf(1));
+ expect(searchArray(array, 4)).toBe(array.indexOf(5));
+ expect(searchArray(array, 5)).toBe(array.length - 1);
+ expect(searchArray(array, 8)).toBe(array.length - 1);
+
+ expect(searchArray(array, 4, true)).toBe(array.indexOf(5));
+ expect(searchArray(array, 5, true)).toBe(array.indexOf(5));
+ expect(searchArray(array, 8, true)).toBe(array.indexOf(5));
+ });
+
+ it('searchInOrderedArray test', () => {
+ expect(searchInOrderedArray(array, -1)).toBe(array.indexOf(0));
+ expect(searchInOrderedArray(array, 0)).toBe(array.indexOf(1));
+ expect(searchInOrderedArray(array, 4)).toBe(array.indexOf(5));
+ expect(searchInOrderedArray(array, 5)).toBe(array.length - 1);
+ expect(searchInOrderedArray(array, 8)).toBe(array.length - 1);
+ });
+
+ it('binSearchFirstGreaterThanTarget test', () => {
+ expect(searchArray(array, -1)).toBe(array.indexOf(0));
+ expect(binSearchFirstGreaterThanTarget(array, 0)).toBe(array.indexOf(1));
+ expect(binSearchFirstGreaterThanTarget(array, 4)).toBe(array.indexOf(5));
+ expect(binSearchFirstGreaterThanTarget(array, 5)).toBe(array.length - 1);
+ expect(binSearchFirstGreaterThanTarget(array, 8)).toBe(array.length - 1);
+ });
+});
diff --git a/packages/core/src/shared/array-search.ts b/packages/core/src/shared/array-search.ts
index f691180e07..1be028555a 100644
--- a/packages/core/src/shared/array-search.ts
+++ b/packages/core/src/shared/array-search.ts
@@ -14,6 +14,61 @@
* limitations under the License.
*/
+/**
+ * Return the index of the first value in an ascending array that is greater than the target value. If there is no value greater than the target, return -1.
+ *
+ * Alternatively, you can consider inserting a number to ensure the array remains sorted, and return the position for insertion. If the target is the same as the maximum value, return arr.length -1
+ * @param arr
+ * @param target
+ */
+export function searchInOrderedArray(arr: number[], target: number) {
+ let left = 0;
+ let right = arr.length - 1;
+
+ if (target < arr[0]) return 0;
+ if (target >= arr[arr.length - 1]) return arr.length - 1;
+
+ while (left <= right) {
+ // When an equal value is found, it is necessary to find the position immediately following the last occurrence of that equal value.
+ if (arr[left] === target) {
+ while (left < arr.length && arr[left] === target) {
+ left++;
+ }
+ return left;
+ }
+
+ if (target > arr[left] && target < arr[left + 1]) {
+ return left + 1;
+ }
+
+ if (arr[right] === target) {
+ while (right < arr.length && arr[right] === target) {
+ right++;
+ }
+ return right;
+ }
+
+ if (target > arr[right - 1] && target < arr[right]) {
+ return right;
+ }
+
+ left++;
+ right--;
+ }
+
+ return -1;
+}
+
+/**
+ * Return the index of the first value in an ascending array that is greater than the target value. If there is no value greater than the target, return last index.
+ *
+ *
+ * binarySearchArray([0,1,2,3,4, 4, 4,5, 5, 5], 1) return 2
+ * binarySearchArray([0,1,2,3,4, 4, 4, 5, 5, 5], 5) return last index, because max value 5 is not greater than target 5
+ * binarySearchArray([0,1,2,3,4, 4, 4, 5, 5, 5], 8) return last index, because max value 5 is not greater than target 8.
+ * @param arr
+ * @param pos
+ */
export function binarySearchArray(arr: number[], pos: number) {
let low: number = 0;
let high = arr.length - 1;
@@ -36,70 +91,70 @@ export function binarySearchArray(arr: number[], pos: number) {
return -1;
}
-export function orderSearchArray(arr: number[], pos: number) {
- let i = 0;
- let cur = 0;
- let cur_pre = 0;
- let cur_index = -1;
- let i_ed = arr.length - 1;
-
- while (i < arr.length && i_ed >= 0 && i_ed >= i) {
- cur = arr[i_ed];
-
- if (i_ed === 0) {
- cur_pre = 0;
- } else {
- cur_pre = arr[i_ed - 1];
- }
-
- if (pos >= cur_pre && pos <= cur) {
- cur_index = i_ed;
- break;
- }
+/**
+ * Return the index of the last index in an ascending array which value is just greater than the target. If there is no value greater than the target, return arr.length - 1.
+ *
+ * Alternatively, you can consider inserting a number to ensure the array remains sorted, and return the position for insertion.
+ *
+ * binarySearchArray([0,1,2,3,4, 4, 4,5, 5, 5], 1) return 2
+ * binarySearchArray([0,1,2,3,4, 4, 4, 5, 5, 5], 5) return last index, because max value 5 is not greater than target 5
+ * binarySearchArray([0,1,2,3,4, 4, 4, 5, 5, 5], 8) return last index, because max value 5 is not greater than target 8.
+ * @param arr
+ * @param target
+ */
+export function binSearchFirstGreaterThanTarget(arr: number[], target: number) {
+ let left = 0;
+ let right = arr.length;
- cur = arr[i];
+ while (left < right) {
+ const mid = Math.floor((left + right) / 2);
- if (i === 0) {
- cur_pre = 0;
+ // If the middle value is less than or equal to the target value, continue searching in the right half.
+ if (arr[mid] <= target) {
+ left = mid + 1;
} else {
- cur_pre = arr[i - 1];
+ right = mid;
}
-
- if (pos >= cur_pre && pos < cur) {
- cur_index = i;
- break;
- }
-
- i++;
- i_ed--;
}
- return cur_index;
+ // Returns the index of the first element greater than the target value;
+ // returns last index if no value in array is greater than target.
+ return left < arr.length ? left : arr.length - 1;
}
/**
- * return the first index which arr[index] > num
- * ex: searchArray([1, 3, 5, 7, 9], 7) = 4
- * @param arr
- * @param num
+ * Find value in the data that is just greater than the target; if there are equal values greater than the target, select the last one.
+ * Translation: If firstMatch is true, then return the index of the first number greater than the target.
+ *
+ * @param arr ascending array
+ * @param target value wants to find
+ * @param firstMatch if true, return the first match when value > target in the array, otherwise return the last value > target. if not match,
* @returns {number} index
*/
-export function searchArray(arr: number[], num: number) {
+
+// searchArray([0, 1, 2, 3, 4, 4, 4, 5, 5, 5], 1) return 2
+// searchArray([0, 1, 2, 3, 4, 4, 4, 5, 5, 5], 1) return 7 (first 5 index)
+// searchArray([0, 1, 2, 3, 4, 4, 4, 5, 5, 5], 5) return 9
+// searchArray([0, 1, 2, 3, 4, 4, 4, 5, 5, 5], 8) return 9
+// searchArray([0, 1, 2, 3, 4, 4, 4, 5, 5, 5], 5) return 9
+// searchArray([0, 1, 2, 3, 4, 4, 4, 5, 5, 5], 5, true) return 7 (first 5 index)
+
+export function searchArray(arr: number[], target: number, firstMatch = false) {
let index: number = arr.length - 1;
- if (num < 0) {
- return -1;
- }
- if (num < arr[0]) {
+ if (target < 0 || target < arr[0]) {
return 0;
}
- if (num > arr[arr.length - 1]) {
- return Number.POSITIVE_INFINITY;
- }
- if (arr.length < 40 || num <= arr[20] || num >= arr[index - 20]) {
- index = orderSearchArray(arr, num);
+ // Excluding the special conditions mentioned above, the next return values can only be between 1 and length - 1.
+ if (arr.length < 40 || target <= arr[20] || target >= arr[index - 20]) {
+ index = searchInOrderedArray(arr, target);
} else {
- index = binarySearchArray(arr, num);
+ index = binSearchFirstGreaterThanTarget(arr, target);
+ }
+
+ if (firstMatch) {
+ const val = arr[index];
+ return arr.indexOf(val);
}
return index;
diff --git a/packages/engine-render/src/components/sheets/sheet-skeleton.ts b/packages/engine-render/src/components/sheets/sheet-skeleton.ts
index 82f9b12400..68fdc2d8cc 100644
--- a/packages/engine-render/src/components/sheets/sheet-skeleton.ts
+++ b/packages/engine-render/src/components/sheets/sheet-skeleton.ts
@@ -221,6 +221,11 @@ export interface ICacheItem {
border: boolean;
}
+export interface IGetRowColByPosOptions {
+ closeFirst?: boolean;
+ visibleOnly?: boolean;
+}
+
export class SpreadsheetSkeleton extends Skeleton {
private _rowHeightAccumulation: number[] = [];
private _columnWidthAccumulation: number[] = [];
@@ -455,7 +460,7 @@ export class SpreadsheetSkeleton extends Skeleton {
}
if (bounds != null) {
- const range = this.getRowColumnSegment(bounds);
+ const range = this.getRangeByBounding(bounds);
this._visibleRange = range;
this._visibleRangeMap.set(bounds.viewportKey as SHEET_VIEWPORT_KEY, range);
}
@@ -890,9 +895,8 @@ export class SpreadsheetSkeleton extends Skeleton {
return Math.max(rowHeader.width, widthByComputation);
}
- getRowColumnSegment(bounds?: IViewportInfo): IRange {
- return this._getBounding(this._rowHeightAccumulation, this._columnWidthAccumulation, bounds?.cacheBound);
- // return this._getBounding(this._rowHeightAccumulation, this._columnWidthAccumulation, bounds?.viewBound);
+ getRangeByBounding(bounds?: IViewportInfo): IRange {
+ return this._getRangeByViewBounding(this._rowHeightAccumulation, this._columnWidthAccumulation, bounds?.cacheBound);
}
/**
@@ -903,8 +907,8 @@ export class SpreadsheetSkeleton extends Skeleton {
return this._worksheetData;
}
- getRowColumnSegmentByViewBound(bound?: IBoundRectNoAngle): IRange {
- return this._getBounding(this._rowHeightAccumulation, this._columnWidthAccumulation, bound);
+ getRangeByViewBound(bound?: IBoundRectNoAngle): IRange {
+ return this._getRangeByViewBounding(this._rowHeightAccumulation, this._columnWidthAccumulation, bound);
}
getMergeBounding(startRow: number, startColumn: number, endRow: number, endColumn: number): IRange {
@@ -1076,29 +1080,6 @@ export class SpreadsheetSkeleton extends Skeleton {
};
}
- /**
- * Get cell by pos(offsetX, offsetY).
- * @param offsetX HTML coordinate system, mouse position x.
- * @param offsetY HTML coordinate system, mouse position y.
- * @param scaleX render scene scale x-axis, scene.getAncestorScale
- * @param scaleY render scene scale y-axis, scene.getAncestorScale
- * @param scrollXY render viewport scroll {x, y}, scene.getScrollXYByRelativeCoords, scene.getScrollXY
- * @param scrollXY.x
- * @param scrollXY.y
- * @returns Selection data with coordinates
- */
- calculateCellIndexByPosition(
- offsetX: number,
- offsetY: number,
- scaleX: number,
- scaleY: number,
- scrollXY: { x: number; y: number }
- ): Nullable<ISelectionCellWithMergeInfo> {
- const { row, column } = this.getCellPositionByOffset(offsetX, offsetY, scaleX, scaleY, scrollXY);
-
- return this.getCellByIndex(row, column);
- }
-
/**
*
* @param offsetX HTML coordinate system, mouse position x.
@@ -1116,10 +1097,10 @@ export class SpreadsheetSkeleton extends Skeleton {
scaleX: number,
scaleY: number,
scrollXY: { x: number; y: number },
- closeFirst?: boolean
+ options?: IGetRowColByPosOptions
): { row: number; column: number } {
- const row = this.getRowPositionByOffsetY(offsetY, scaleY, scrollXY, closeFirst);
- const column = this.getColumnPositionByOffsetX(offsetX, scaleX, scrollXY, closeFirst);
+ const row = this.getRowPositionByOffsetY(offsetY, scaleY, scrollXY, options);
+ const column = this.getColumnPositionByOffsetX(offsetX, scaleX, scrollXY, options);
return {
row,
@@ -1128,27 +1109,17 @@ export class SpreadsheetSkeleton extends Skeleton {
}
/**
- *
- * @param offsetX scaled offset x
+ * Get column index by offsetX
+ * @param offsetX no scaled offset x
* @param scaleX scale x
* @param scrollXY
- * @returns
*/
-
- getColumnPositionByOffsetX(offsetX: number, scaleX: number, scrollXY: { x: number; y: number }, closeFirst?: boolean): number {
+ getColumnPositionByOffsetX(offsetX: number, scaleX: number, scrollXY: { x: number; y: number }, options?: IGetRowColByPosOptions): number {
offsetX = this.getTransformOffsetX(offsetX, scaleX, scrollXY);
-
const { columnWidthAccumulation } = this;
-
let column = searchArray(columnWidthAccumulation, offsetX);
- if (column === Number.POSITIVE_INFINITY) {
- column = columnWidthAccumulation.length - 1;
- } else if (column === -1) {
- column = 0;
- }
-
- if (closeFirst) {
+ if (options?.closeFirst) {
// check if upper column was closer than current
if (Math.abs(columnWidthAccumulation[column] - offsetX) < Math.abs(offsetX - (columnWidthAccumulation[column - 1] ?? 0))) {
column = column + 1;
@@ -1159,28 +1130,21 @@ export class SpreadsheetSkeleton extends Skeleton {
}
/**
- *
+ * Get row index by offsetY
* @param offsetY scaled offset y
* @param scaleY scale y
* @param scrollXY
* @param scrollXY.x
* @param scrollXY.y
*/
- getRowPositionByOffsetY(offsetY: number, scaleY: number, scrollXY: { x: number; y: number }, closeFirst?: boolean): number {
+ getRowPositionByOffsetY(offsetY: number, scaleY: number, scrollXY: { x: number; y: number }, options?: IGetRowColByPosOptions): number {
const { rowHeightAccumulation } = this;
-
offsetY = this.getTransformOffsetY(offsetY, scaleY, scrollXY);
- let row = searchArray(rowHeightAccumulation, offsetY);
-
- if (row === Number.POSITIVE_INFINITY) {
- row = rowHeightAccumulation.length - 1;
- } else if (row === -1) {
- row = 0;
- }
+ let row = searchArray(rowHeightAccumulation, offsetY, options?.visibleOnly);
- if (closeFirst) {
- // check if upper row was closer than current
+ if (options?.closeFirst) {
+ // check if next row was closer than current
if (Math.abs(rowHeightAccumulation[row] - offsetY) < Math.abs(offsetY - (rowHeightAccumulation[row - 1] ?? 0))) {
row = row + 1;
}
@@ -1489,19 +1453,17 @@ export class SpreadsheetSkeleton extends Skeleton {
}
getDecomposedOffset(offsetX: number, offsetY: number): { row: number; column: number; columnOffset: number; rowOffset: number } {
- let column = searchArray(this._columnWidthAccumulation, offsetX);
+ const column = searchArray(this._columnWidthAccumulation, offsetX);
let columnOffset = 0;
- if (column === -1 || column === 0) {
- column = 0;
+ if (column === 0) {
columnOffset = offsetX;
} else {
columnOffset = offsetX - this._columnWidthAccumulation[column - 1];
}
- let row = searchArray(this._rowHeightAccumulation, offsetY);
+ const row = searchArray(this._rowHeightAccumulation, offsetY);
let rowOffset = 0;
- if (row === -1 || row === 0) {
- row = 0;
+ if (row === 0) {
rowOffset = offsetY;
} else {
rowOffset = offsetY - this._rowHeightAccumulation[row - 1];
@@ -1635,75 +1597,40 @@ export class SpreadsheetSkeleton extends Skeleton {
}
/**
- *
+ * Get the range of the bounding area of the canvas.
* @param rowHeightAccumulation Row layout information
* @param columnWidthAccumulation Column layout information
* @param viewBound The range of the visible area of the canvas
* @returns The range cell index of the canvas visible area
*/
- protected _getBounding(
+ protected _getRangeByViewBounding(
rowHeightAccumulation: number[],
columnWidthAccumulation: number[],
viewBound?: IBoundRectNoAngle
): IRange {
- const rhaLength = rowHeightAccumulation.length;
- const cwaLength = columnWidthAccumulation.length;
+ const lenOfRowData = rowHeightAccumulation.length;
+ const lenOfColData = columnWidthAccumulation.length;
if (!viewBound) {
return {
startRow: 0,
- endRow: rhaLength - 1,
+ endRow: lenOfRowData - 1,
startColumn: 0,
- endColumn: cwaLength - 1,
+ endColumn: lenOfColData - 1,
};
}
- let dataset_row_st = -1;
- let dataset_row_ed = -1;
- let dataset_col_st = -1;
- let dataset_col_ed = -1;
-
- const row_st = searchArray(rowHeightAccumulation, Math.round(viewBound.top) - this.columnHeaderHeightAndMarginTop);
- const row_ed = searchArray(rowHeightAccumulation, Math.round(viewBound.bottom) - this.columnHeaderHeightAndMarginTop);
-
- if (row_st === -1 && row_ed === 0) {
- dataset_row_st = 0;
- dataset_row_ed = 0;
- } else {
- dataset_row_st = Math.max(0, row_st);
-
- if (row_ed === Number.POSITIVE_INFINITY) {
- dataset_row_ed = rhaLength - 1;
- } else if (row_ed >= rhaLength) {
- dataset_row_ed = rhaLength - 1;
- } else {
- dataset_row_ed = Math.max(0, row_ed);
- }
- }
-
- const col_st = searchArray(columnWidthAccumulation, Math.round(viewBound.left) - this.rowHeaderWidthAndMarginLeft);
- const col_ed = searchArray(columnWidthAccumulation, Math.round(viewBound.right) - this.rowHeaderWidthAndMarginLeft);
-
- if (col_st === -1 && col_ed === 0) {
- dataset_col_st = 0;
- dataset_col_ed = 0;
- } else {
- dataset_col_st = Math.max(0, col_st);
-
- if (col_ed === Number.POSITIVE_INFINITY) {
- dataset_col_ed = cwaLength - 1;
- } else if (col_ed >= cwaLength) {
- dataset_col_ed = cwaLength - 1;
- } else {
- dataset_col_ed = Math.max(0, col_ed);
- }
- }
+ // viewBound contains header, so need to subtract the header height and margin
+ const startRow = searchArray(rowHeightAccumulation, Math.round(viewBound.top) - this.columnHeaderHeightAndMarginTop);
+ const endRow = searchArray(rowHeightAccumulation, Math.round(viewBound.bottom) - this.columnHeaderHeightAndMarginTop);
+ const startColumn = searchArray(columnWidthAccumulation, Math.round(viewBound.left) - this.rowHeaderWidthAndMarginLeft);
+ const endColumn = searchArray(columnWidthAccumulation, Math.round(viewBound.right) - this.rowHeaderWidthAndMarginLeft);
return {
- startRow: dataset_row_st,
- endRow: dataset_row_ed,
- startColumn: dataset_col_st,
- endColumn: dataset_col_ed,
+ startRow,
+ endRow,
+ startColumn,
+ endColumn,
} as IRange;
}
diff --git a/packages/engine-render/src/components/sheets/spreadsheet.ts b/packages/engine-render/src/components/sheets/spreadsheet.ts
index ee724dca7a..0613ff900c 100644
--- a/packages/engine-render/src/components/sheets/spreadsheet.ts
+++ b/packages/engine-render/src/components/sheets/spreadsheet.ts
@@ -117,10 +117,10 @@ export class Spreadsheet extends SheetComponent {
const parentScale = this.getParentScale();
const diffRanges = this._refreshIncrementalState && viewportInfo.diffBounds
- ? viewportInfo.diffBounds?.map((bound) => spreadsheetSkeleton.getRowColumnSegmentByViewBound(bound))
+ ? viewportInfo.diffBounds?.map((bound) => spreadsheetSkeleton.getRangeByViewBound(bound))
: [];
- const viewRanges = [spreadsheetSkeleton.getRowColumnSegmentByViewBound(viewportInfo.cacheBound)];
+ const viewRanges = [spreadsheetSkeleton.getRangeByViewBound(viewportInfo.cacheBound)];
const extensions = this.getExtensionsByOrder();
// At this moment, ctx.transform is at topLeft of sheet content, cell(0, 0)
diff --git a/packages/sheets-ui/src/controllers/render-controllers/mobile/mobile-scroll.render-controller.ts b/packages/sheets-ui/src/controllers/render-controllers/mobile/mobile-scroll.render-controller.ts
index 62157b932a..a809a9020d 100644
--- a/packages/sheets-ui/src/controllers/render-controllers/mobile/mobile-scroll.render-controller.ts
+++ b/packages/sheets-ui/src/controllers/render-controllers/mobile/mobile-scroll.render-controller.ts
@@ -498,7 +498,7 @@ export class MobileSheetsScrollRenderController extends Disposable implements IR
}
const bounds = viewport.getBounding();
- return skeleton.getRowColumnSegment(bounds);
+ return skeleton.getRangeByBounding(bounds);
}
// eslint-disable-next-line max-lines-per-function, complexity
diff --git a/packages/sheets-ui/src/controllers/render-controllers/scroll.render-controller.ts b/packages/sheets-ui/src/controllers/render-controllers/scroll.render-controller.ts
index 40e94c56a4..5737550df2 100644
--- a/packages/sheets-ui/src/controllers/render-controllers/scroll.render-controller.ts
+++ b/packages/sheets-ui/src/controllers/render-controllers/scroll.render-controller.ts
@@ -475,7 +475,7 @@ export class SheetsScrollRenderController extends Disposable implements IRenderM
}
const bounds = viewport.getBounding();
- return skeleton.getRowColumnSegmentByViewBound(bounds.viewBound);
+ return skeleton.getRangeByViewBound(bounds.viewBound);
}
// eslint-disable-next-line max-lines-per-function, complexity
diff --git a/packages/sheets-ui/src/controllers/render-controllers/sheet.render-controller.ts b/packages/sheets-ui/src/controllers/render-controllers/sheet.render-controller.ts
index 65014a7af6..fb73e146f4 100644
--- a/packages/sheets-ui/src/controllers/render-controllers/sheet.render-controller.ts
+++ b/packages/sheets-ui/src/controllers/render-controllers/sheet.render-controller.ts
@@ -238,7 +238,6 @@ export class SheetRenderController extends RxDisposable implements IRenderModule
private _initViewports(scene: Scene, rowHeader: { width: number }, columnHeader: { height: number }) {
const bufferEdgeX = 100;
const bufferEdgeY = 100;
-
const viewMain = new Viewport(SHEET_VIEWPORT_KEY.VIEW_MAIN, scene, {
left: rowHeader.width,
top: columnHeader.height,
diff --git a/packages/sheets-ui/src/controllers/utils/component-tools.ts b/packages/sheets-ui/src/controllers/utils/component-tools.ts
index f463c2a8fe..a064278f0f 100644
--- a/packages/sheets-ui/src/controllers/utils/component-tools.ts
+++ b/packages/sheets-ui/src/controllers/utils/component-tools.ts
@@ -122,7 +122,7 @@ export function getCoordByOffset(
scaleX,
scaleY,
scrollXY,
- closeFirst
+ { closeFirst }
);
const { row, column } = moveActualSelection;
diff --git a/packages/sheets-ui/src/services/selection/base-selection-render.service.ts b/packages/sheets-ui/src/services/selection/base-selection-render.service.ts
index 1fd8cff4ab..dac618973f 100644
--- a/packages/sheets-ui/src/services/selection/base-selection-render.service.ts
+++ b/packages/sheets-ui/src/services/selection/base-selection-render.service.ts
@@ -606,6 +606,7 @@ export class BaseSelectionRenderService extends Disposable implements ISheetSele
scene.getActiveViewportByCoord(Vector2.FromArray([moveOffsetX, moveOffsetY])) ??
this._getViewportByCell(selection?.endRow, selection?.endColumn);
+ // find viewports that can be crossed by selection.
const isCrossableViewports = () => {
if (!startViewport || !endViewport || !viewportMain) {
return false;
@@ -752,13 +753,9 @@ export class BaseSelectionRenderService extends Disposable implements ISheetSele
const scrollXY = scene.getViewportScrollXY(scene.getViewport(SHEET_VIEWPORT_KEY.VIEW_MAIN)!);
const { scaleX, scaleY } = scene.getAncestorScale();
- return skeleton.calculateCellIndexByPosition(
- x,
- y,
- scaleX,
- scaleY,
- scrollXY
- ) as Nullable<ISelectionCellWithMergeInfo>;
+ const { row, column } = skeleton.getCellPositionByOffset(x, y, scaleX, scaleY, scrollXY);
+ const cell = skeleton.getCellByIndex(row, column) as Nullable<ISelectionCellWithMergeInfo>;
+ return cell;
}
/**
@@ -909,13 +906,8 @@ export class BaseSelectionRenderService extends Disposable implements ISheetSele
scrollXY: { x: number; y: number }
): Nullable<ISelectionWithCoord> {
if (this._shouldDetectMergedCells) {
- const primaryWithCoord = this._skeleton?.calculateCellIndexByPosition(
- offsetX,
- offsetY,
- scaleX,
- scaleY,
- scrollXY
- );
+ const { row, column } = this._skeleton.getCellPositionByOffset(offsetX, offsetY, scaleX, scaleY, scrollXY, { visibleOnly: true });
+ const primaryWithCoord = this._skeleton.getCellByIndex(row, column) as Nullable<ISelectionCellWithMergeInfo>;
if (!primaryWithCoord) return;