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.

91.7 KB
Raw Blame
/**
 * Copyright 2023-present DreamNum Co., Ltd.
 *
 * 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 { ICommandInfo, IMutationInfo, IRange } from '@univerjs/core';
import { Direction, RANGE_TYPE } from '@univerjs/core';
import { beforeEach, describe, expect, it } from 'vitest';
import type { IRemoveSheetMutationParams } from '../../../basics';
import type { IInsertColCommandParams, IInsertRowCommandParams } from '../../../commands/commands/insert-row-col.command';
import type { IRemoveRowColCommandInterceptParams } from '../../../commands/commands/remove-row-col.command';
import type { IMoveRowsMutationParams } from '../../../commands/mutations/move-rows-cols.mutation';
import type { IRemoveRowColCommand } from '../type';
import { InsertColMutation, InsertRowMutation } from '../../../commands/mutations/insert-row-col.mutation';
import { MoveColsMutation, MoveRowsMutation } from '../../../commands/mutations/move-rows-cols.mutation';
import { RemoveColMutation, RemoveRowMutation } from '../../../commands/mutations/remove-row-col.mutation';
import { RemoveSheetMutation } from '../../../commands/mutations/remove-sheet.mutation';
import { EffectRefRangId } from '../type';
import {
    adjustRangeOnMutation,
    getEffectedRangesOnCommand,
    getEffectedRangesOnMutation,
    handleDefaultRangeChangeWithEffectRefCommands,
    handleDefaultRangeChangeWithEffectRefCommandsSkipNoInterests,
    handleDeleteRangeMoveLeft,
    handleDeleteRangeMoveLeftCommon,
    handleDeleteRangeMoveUp,
    handleDeleteRangeMoveUpCommon,
    handleInsertCol,
    handleInsertColCommon,
    handleInsertRangeMoveDown,
    handleInsertRangeMoveDownCommon,
    handleInsertRangeMoveRight,
    handleInsertRangeMoveRightCommon,
    handleInsertRow,
    handleInsertRowCommon,
    handleIRemoveCol,
    handleIRemoveRow,
    handleMoveCols,
    handleMoveColsCommon,
    handleMoveRange,
    handleMoveRangeCommon,
    handleMoveRows,
    handleMoveRowsCommon,
    handleRangeTypeInput,
    handleRangeTypeOutput,
    handleRemoveRowCommon,
    handleReorderRange,
    handleReorderRangeCommon,
    rotateRange,
    runRefRangeMutations,
} from '../util';

const countRange = ([a, b, c, d]: readonly [number, number, number, number]) => (a * 1000 + b * 100 + c * 10 + d);

const formatRanges = (ranges: IRange[]) => ranges.map((range) => [range.startRow, range.endRow, range.startColumn, range.endColumn] as const).sort((prev, aft) => countRange(prev) - countRange(aft));

const formatCoveredCells = (ranges: IRange[]) => {
    const cells = new Set<string>();
    ranges.forEach((range) => {
        for (let row = range.startRow; row <= range.endRow; row++) {
            for (let column = range.startColumn; column <= range.endColumn; column++) {
                cells.add(`${row}:${column}`);
            }
        }
    });
    return Array.from(cells).sort();
};

describe('test ref-range move', () => {
    describe('range type and effect-range helpers', () => {
        it('normalizes row, column, all, and NaN range coordinates', () => {
            expect(handleRangeTypeInput({ startRow: Number.NaN, endRow: Number.NaN, startColumn: 2, endColumn: 4 })).toMatchObject({
                startRow: 0,
                startColumn: 2,
                endColumn: 4,
            });
            expect(handleRangeTypeInput({ startRow: 3, endRow: 5, startColumn: Number.NaN, endColumn: Number.NaN })).toMatchObject({
                startRow: 3,
                endRow: 5,
                startColumn: 0,
            });
            expect(handleRangeTypeInput({ startRow: 1, endRow: 1, startColumn: 1, endColumn: 1, rangeType: RANGE_TYPE.ALL })).toMatchObject({
                startRow: 0,
                startColumn: 0,
            });
            expect(handleRangeTypeOutput({ startRow: -3, endRow: 20, startColumn: -4, endColumn: 30 }, 10, 12)).toEqual({
                startRow: 0,
                endRow: 10,
                startColumn: 0,
                endColumn: 12,
            });
            expect(handleRangeTypeOutput({ startRow: 2, endRow: 4, startColumn: 1, endColumn: 3, rangeType: RANGE_TYPE.ROW }, 10, 12)).toMatchObject({
                startColumn: 0,
                endColumn: 12,
            });
            expect(rotateRange({ startRow: 1, endRow: 3, startColumn: 5, endColumn: 7, rangeType: RANGE_TYPE.ROW })).toEqual({
                startRow: 5,
                endRow: 7,
                startColumn: 1,
                endColumn: 3,
                rangeType: RANGE_TYPE.COLUMN,
            });
        });

        it('handles column movement and row reorder common transformations', () => {
            const fromRange = { startRow: 0, endRow: 99, startColumn: 2, endColumn: 3 };
            const toRange = { startRow: 0, endRow: 99, startColumn: 7, endColumn: 8 };
            const targetRange = { startRow: 1, endRow: 2, startColumn: 4, endColumn: 5 };

            const operators = handleMoveCols({ id: EffectRefRangId.MoveColsCommandId, params: { fromRange, toRange } }, targetRange);
            expect(runRefRangeMutations(operators, targetRange)).toEqual({ startRow: 1, endRow: 2, startColumn: 2, endColumn: 3 });
            expect(formatRanges(handleMoveColsCommon({ id: EffectRefRangId.MoveColsCommandId, params: { fromRange, toRange } }, targetRange))).toEqual([[1, 2, 2, 3]]);
            expect(handleMoveCols({ id: EffectRefRangId.MoveColsCommandId, params: undefined }, targetRange)).toEqual([]);
            expect(handleMoveColsCommon({ id: EffectRefRangId.MoveColsCommandId, params: undefined }, targetRange)).toEqual([targetRange]);

            const reorderRange = { startRow: 1, endRow: 3, startColumn: 0, endColumn: 1 };
            const order = { 1: 3, 2: 1, 3: 2 };
            const reorderOperators = handleReorderRange({ id: EffectRefRangId.ReorderRangeCommandId, params: { unitId: 'unit', subUnitId: 'sheet', range: reorderRange, order } }, { startRow: 2, endRow: 2, startColumn: 0, endColumn: 1 });
            expect(runRefRangeMutations(reorderOperators, { startRow: 2, endRow: 2, startColumn: 0, endColumn: 1 })).toEqual({ startRow: 3, endRow: 3, startColumn: 0, endColumn: 1 });
            expect(formatRanges(handleReorderRangeCommon({ id: EffectRefRangId.ReorderRangeCommandId, params: { unitId: 'unit', subUnitId: 'sheet', range: reorderRange, order } }, reorderRange))).toEqual([[1, 3, 0, 1]]);
            expect(handleReorderRangeCommon({ id: EffectRefRangId.ReorderRangeCommandId, params: undefined }, reorderRange)).toEqual([reorderRange]);
        });

        it('finds command and mutation effect ranges and skips unrelated commands', () => {
            const selectionManagerService = {
                getCurrentSelections: () => [{ range: { startRow: 5, endRow: 6, startColumn: 5, endColumn: 6 } }],
            } as never;
            const targetRange = { startRow: 10, endRow: 11, startColumn: 10, endColumn: 11 };

            expect(getEffectedRangesOnCommand({ id: EffectRefRangId.InsertRangeMoveDownCommandId }, { selectionManagerService })).toEqual([
                { startRow: 5, endRow: 6, startColumn: 5, endColumn: 6 },
            ]);
            expect(getEffectedRangesOnCommand({ id: EffectRefRangId.InsertRangeMoveRightCommandId, params: { range: targetRange } }, { selectionManagerService })).toEqual([targetRange]);
            expect(getEffectedRangesOnCommand({ id: EffectRefRangId.ReorderRangeCommandId, params: { unitId: 'unit', subUnitId: 'sheet', range: { startRow: 1, endRow: 3, startColumn: 0, endColumn: 1 }, order: { 2: 1 } } }, { selectionManagerService })).toEqual([
                { startRow: 2, endRow: 2, startColumn: 0, endColumn: 1 },
            ]);
            expect(handleDefaultRangeChangeWithEffectRefCommandsSkipNoInterests(targetRange, { id: EffectRefRangId.InsertRowCommandId, params: { range: { startRow: 0, endRow: 1, startColumn: 0, endColumn: 9 }, direction: Direction.DOWN, unitId: 'u', subUnitId: 's' } } as never, { selectionManagerService })).toEqual(targetRange);
            expect(handleDefaultRangeChangeWithEffectRefCommands(targetRange, { id: EffectRefRangId.InsertRowCommandId, params: { range: { startRow: 9, endRow: 9, startColumn: 0, endColumn: 9 }, direction: Direction.DOWN, unitId: 'u', subUnitId: 's' } } as never)).toEqual({
                startRow: 10,
                endRow: 11,
                startColumn: 10,
                endColumn: 11,
            });

            expect(getEffectedRangesOnMutation({ id: MoveColsMutation.id, params: { sourceRange: { startRow: 0, endRow: 9, startColumn: 1, endColumn: 1 }, targetRange: { startRow: 0, endRow: 9, startColumn: 4, endColumn: 4 } } as never })).toHaveLength(2);
            expect(getEffectedRangesOnMutation({ id: MoveRowsMutation.id, params: { sourceRange: { startRow: 1, endRow: 1, startColumn: 0, endColumn: 9 }, targetRange: { startRow: 4, endRow: 4, startColumn: 0, endColumn: 9 } } as never })).toHaveLength(2);
            expect(getEffectedRangesOnMutation({ id: InsertColMutation.id, params: { range: { startRow: 0, endRow: 9, startColumn: 2, endColumn: 3 } } as never })).toEqual([{ startRow: 0, endRow: 9, startColumn: 1.5, endColumn: 1.5 }]);
            expect(getEffectedRangesOnMutation({ id: InsertRowMutation.id, params: { range: { startRow: 2, endRow: 3, startColumn: 0, endColumn: 9 } } as never })).toEqual([{ startRow: 1.5, endRow: 1.5, startColumn: 0, endColumn: 9 }]);
            expect(getEffectedRangesOnMutation({ id: RemoveColMutation.id, params: { range: { startRow: 0, endRow: 9, startColumn: 2, endColumn: 3 } } as never })).toEqual([{ startRow: 0, endRow: 9, startColumn: 2, endColumn: 3 }]);
            expect(getEffectedRangesOnMutation({ id: RemoveRowMutation.id, params: { range: { startRow: 2, endRow: 3, startColumn: 0, endColumn: 9 } } as never })).toEqual([{ startRow: 2, endRow: 3, startColumn: 0, endColumn: 9 }]);
            expect(getEffectedRangesOnMutation({ id: 'unknown', params: {} as never })).toBeUndefined();
        });
    });

    describe('handleMoveRows', () => {
        // see docs/tldr/handMoveRowsCols.tldr
        const startCol = 0;
        const endCol = 999;
        let fromRange: IRange;
        let toRange: IRange;
        describe('fromRange is top of toRange', () => {
            beforeEach(() => {
                fromRange = { startRow: 5, endRow: 10, startColumn: startCol, endColumn: endCol };
                toRange = { startRow: 15, endRow: 20, startColumn: startCol, endColumn: endCol };
            });
            it('1-1 unchanged', () => {
                const targetRange = { startRow: 3, endRow: 4, startColumn: startCol, endColumn: endCol };
                const operators = handleMoveRows(
                    { id: EffectRefRangId.MoveRowsCommandId, params: { toRange, fromRange } },
                    targetRange
                );
                expect(runRefRangeMutations(operators!, targetRange)).toEqual({
                    startRow: 3,
                    endRow: 4,
                    startColumn: startCol,
                    endColumn: endCol,
                });
            });
            it('1-3 unchanged', () => {
                const targetRange = { startRow: 25, endRow: 26, startColumn: startCol, endColumn: endCol };
                const operators = handleMoveRows(
                    { id: EffectRefRangId.MoveRowsCommandId, params: { toRange, fromRange } },
                    targetRange
                );
                expect(runRefRangeMutations(operators!, targetRange)).toEqual({
                    startRow: 25,
                    endRow: 26,
                    startColumn: startCol,
                    endColumn: endCol,
                });
            });
            it('1-11 unchanged', () => {
                const targetRange = { startRow: 3, endRow: 26, startColumn: startCol, endColumn: endCol };
                const operators = handleMoveRows(
                    { id: EffectRefRangId.MoveRowsCommandId, params: { toRange, fromRange } },
                    targetRange
                );
                expect(runRefRangeMutations(operators!, targetRange)).toEqual({
                    startRow: 3,
                    endRow: 26,
                    startColumn: startCol,
                    endColumn: endCol,
                });
            });

            it('1-2 move left', () => {
                const targetRange = { startRow: 12, endRow: 13, startColumn: startCol, endColumn: endCol };
                const operators = handleMoveRows(
                    { id: EffectRefRangId.MoveRowsCommandId, params: { toRange, fromRange } },
                    targetRange
                );
                expect(runRefRangeMutations(operators!, targetRange)).toEqual({
                    startRow: 6,
                    endRow: 7,
                    startColumn: startCol,
                    endColumn: endCol,
                });
            });
            it('1-12 move right', () => {
                const targetRange = { startRow: 6, endRow: 7, startColumn: startCol, endColumn: endCol };
                const operators = handleMoveRows(
                    { id: EffectRefRangId.MoveRowsCommandId, params: { toRange, fromRange } },
                    targetRange
                );
                expect(runRefRangeMutations(operators!, targetRange)).toEqual({
                    startRow: 10,
                    endRow: 11,
                    startColumn: startCol,
                    endColumn: endCol,
                });
            });
            it('1-4 reduce', () => {
                const targetRange = { startRow: 3, endRow: 7, startColumn: startCol, endColumn: endCol };
                const operators = handleMoveRows(
                    { id: EffectRefRangId.MoveRowsCommandId, params: { toRange, fromRange } },
                    targetRange
                );
                expect(runRefRangeMutations(operators!, targetRange)).toEqual({
                    startRow: 3,
                    endRow: 4,
                    startColumn: startCol,
                    endColumn: endCol,
                });
            });
            it('1-5 reduce', () => {
                const targetRange = { startRow: 8, endRow: 12, startColumn: startCol, endColumn: endCol };
                const operators = handleMoveRows(
                    { id: EffectRefRangId.MoveRowsCommandId, params: { toRange, fromRange } },
                    targetRange
                );
                expect(runRefRangeMutations(operators!, targetRange)).toEqual({
                    startRow: 2,
                    endRow: 3,
                    startColumn: startCol,
                    endColumn: endCol,
                });
            });
            it('1-8 reduce', () => {
                const targetRange = { startRow: 8, endRow: 16, startColumn: startCol, endColumn: endCol };
                const operators = handleMoveRows(
                    { id: EffectRefRangId.MoveRowsCommandId, params: { toRange, fromRange } },
                    targetRange
                );
                expect(runRefRangeMutations(operators!, targetRange)).toEqual({
                    startRow: 2,
                    endRow: 7,
                    startColumn: startCol,
                    endColumn: endCol,
                });
            });
            it('1-9 reduce', () => {
                const targetRange = { startRow: 3, endRow: 12, startColumn: startCol, endColumn: endCol };
                const operators = handleMoveRows(
                    { id: EffectRefRangId.MoveRowsCommandId, params: { toRange, fromRange } },
                    targetRange
                );
                expect(runRefRangeMutations(operators!, targetRange)).toEqual({
                    startRow: 3,
                    endRow: 6,
                    startColumn: startCol,
                    endColumn: endCol,
                });
            });
            it('1-14 unchanged', () => {
                const targetRange = { startRow: 3, endRow: 19, startColumn: startCol, endColumn: endCol };
                const operators = handleMoveRows(
                    { id: EffectRefRangId.MoveRowsCommandId, params: { toRange, fromRange } },
                    targetRange
                );
                expect(runRefRangeMutations(operators!, targetRange)).toEqual({
                    startRow: 3,
                    endRow: 19,
                    startColumn: startCol,
                    endColumn: endCol,
                });
            });
            it('1-15 move left and expend', () => {
                const targetRange = { startRow: 9, endRow: 19, startColumn: startCol, endColumn: endCol };
                const operators = handleMoveRows(
                    { id: EffectRefRangId.MoveRowsCommandId, params: { toRange, fromRange } },
                    targetRange
                );
                expect(runRefRangeMutations(operators!, targetRange)).toEqual({
                    startRow: 3,
                    endRow: 17,
                    startColumn: startCol,
                    endColumn: endCol,
                });
            });
            it('1-6 expend', () => {
                const targetRange = { startRow: 13, endRow: 18, startColumn: startCol, endColumn: endCol };
                const operators = handleMoveRows(
                    { id: EffectRefRangId.MoveRowsCommandId, params: { toRange, fromRange } },
                    targetRange
                );
                expect(runRefRangeMutations(operators!, targetRange)).toEqual({
                    startRow: 7,
                    endRow: 18,
                    startColumn: startCol,
                    endColumn: endCol,
                });
            });
        });
        describe('fromRange is bottom of toRange', () => {
            beforeEach(() => {
                fromRange = { startRow: 15, endRow: 20, startColumn: startCol, endColumn: endCol };
                toRange = { startRow: 5, endRow: 10, startColumn: startCol, endColumn: endCol };
            });
            it('2-3 unchanged', () => {
                const targetRange = { startRow: 25, endRow: 26, startColumn: startCol, endColumn: endCol };
                const operators = handleMoveRows(
                    { id: EffectRefRangId.MoveRowsCommandId, params: { toRange, fromRange } },
                    targetRange
                );
                expect(runRefRangeMutations(operators!, targetRange)).toEqual({
                    startRow: 25,
                    endRow: 26,
                    startColumn: startCol,
                    endColumn: endCol,
                });
            });
            it('2-1 unchanged', () => {
                const targetRange = { startRow: 2, endRow: 3, startColumn: startCol, endColumn: endCol };
                const operators = handleMoveRows(
                    { id: EffectRefRangId.MoveRowsCommandId, params: { toRange, fromRange } },
                    targetRange
                );
                expect(runRefRangeMutations(operators!, targetRange)).toEqual({
                    startRow: 2,
                    endRow: 3,
                    startColumn: startCol,
                    endColumn: endCol,
                });
            });
            it('2-2 move right', () => {
                const targetRange = { startRow: 12, endRow: 13, startColumn: startCol, endColumn: endCol };
                const operators = handleMoveRows(
                    { id: EffectRefRangId.MoveRowsCommandId, params: { toRange, fromRange } },
                    targetRange
                );
                expect(runRefRangeMutations(operators!, targetRange)).toEqual({
                    startRow: 18,
                    endRow: 19,
                    startColumn: startCol,
                    endColumn: endCol,
                });
            });
            it('2-4 expend', () => {
                const targetRange = { startRow: 3, endRow: 6, startColumn: startCol, endColumn: endCol };
                const operators = handleMoveRows(
                    { id: EffectRefRangId.MoveRowsCommandId, params: { toRange, fromRange } },
                    targetRange
                );
                expect(runRefRangeMutations(operators!, targetRange)).toEqual({
                    startRow: 3,
                    endRow: 12,
                    startColumn: startCol,
                    endColumn: endCol,
                });
            });
            it('2-5 move right', () => {
                const targetRange = { startRow: 7, endRow: 10, startColumn: startCol, endColumn: endCol };
                const operators = handleMoveRows(
                    { id: EffectRefRangId.MoveRowsCommandId, params: { toRange, fromRange } },
                    targetRange
                );
                expect(runRefRangeMutations(operators!, targetRange)).toEqual({
                    startRow: 13,
                    endRow: 16,
                    startColumn: startCol,
                    endColumn: endCol,
                });
            });
            it('2-9 expend', () => {
                const targetRange = { startRow: 3, endRow: 11, startColumn: startCol, endColumn: endCol };
                const operators = handleMoveRows(
                    { id: EffectRefRangId.MoveRowsCommandId, params: { toRange, fromRange } },
                    targetRange
                );
                expect(runRefRangeMutations(operators!, targetRange)).toEqual({
                    startRow: 3,
                    endRow: 17,
                    startColumn: startCol,
                    endColumn: endCol,
                });
            });
            it('2-8 reduce and move right', () => {
                const targetRange = { startRow: 8, endRow: 18, startColumn: startCol, endColumn: endCol };
                const operators = handleMoveRows(
                    { id: EffectRefRangId.MoveRowsCommandId, params: { toRange, fromRange } },
                    targetRange
                );
                expect(runRefRangeMutations(operators!, targetRange)).toEqual({
                    startRow: 14,
                    endRow: 20,
                    startColumn: startCol,
                    endColumn: endCol,
                });
            });
            it('2-11 unchanged', () => {
                const targetRange = { startRow: 3, endRow: 25, startColumn: startCol, endColumn: endCol };
                const operators = handleMoveRows(
                    { id: EffectRefRangId.MoveRowsCommandId, params: { toRange, fromRange } },
                    targetRange
                );
                expect(runRefRangeMutations(operators!, targetRange)).toEqual({
                    startRow: 3,
                    endRow: 25,
                    startColumn: startCol,
                    endColumn: endCol,
                });
            });
            it('2-12 move right', () => {
                const targetRange = { startRow: 6, endRow: 7, startColumn: startCol, endColumn: endCol };
                const operators = handleMoveRows(
                    { id: EffectRefRangId.MoveRowsCommandId, params: { toRange, fromRange } },
                    targetRange
                );
                expect(runRefRangeMutations(operators!, targetRange)).toEqual({
                    startRow: 12,
                    endRow: 13,
                    startColumn: startCol,
                    endColumn: endCol,
                });
            });
            it('2-14 expend', () => {
                const targetRange = { startRow: 3, endRow: 18, startColumn: startCol, endColumn: endCol };
                const operators = handleMoveRows(
                    { id: EffectRefRangId.MoveRowsCommandId, params: { toRange, fromRange } },
                    targetRange
                );
                expect(runRefRangeMutations(operators!, targetRange)).toEqual({
                    startRow: 3,
                    endRow: 20,
                    startColumn: startCol,
                    endColumn: endCol,
                });
            });
            it('2-13 move left', () => {
                const targetRange = { startRow: 16, endRow: 17, startColumn: startCol, endColumn: endCol };
                const operators = handleMoveRows(
                    { id: EffectRefRangId.MoveRowsCommandId, params: { toRange, fromRange } },
                    targetRange
                );
                expect(runRefRangeMutations(operators!, targetRange)).toEqual({
                    startRow: 6,
                    endRow: 7,
                    startColumn: startCol,
                    endColumn: endCol,
                });
            });
        });
    });
    describe('handleMoveRowsCommon', () => {
        // see docs/tldr/handMoveRowsCols.tldr
        const startCol = 0;
        const endCol = 999;
        let fromRange: IRange;
        let toRange: IRange;

        describe('formRange is top of toRange', () => {
            beforeEach(() => {
                fromRange = { startRow: 5, endRow: 10, startColumn: startCol, endColumn: endCol };
                toRange = { startRow: 15, endRow: 20, startColumn: startCol, endColumn: endCol };
            });

            it('contain', () => {
                const targetRange2_1: IRange = {
                    startRow: 6,
                    endRow: 9,
                    startColumn: 0,
                    endColumn: 2,
                };
                const targetRange2_2: IRange = {
                    startRow: 16,
                    endRow: 19,
                    startColumn: 0,
                    endColumn: 2,
                };

                const resRange2_1 = handleMoveRowsCommon(
                    { id: EffectRefRangId.MoveRowsCommandId, params: { toRange, fromRange } },
                    targetRange2_1
                );
                const resRange2_2 = handleMoveRowsCommon(
                    { id: EffectRefRangId.MoveRowsCommandId, params: { toRange, fromRange } },
                    targetRange2_2
                );
                expect(resRange2_1[0].startRow).toEqual(10);
                expect(resRange2_1[0].endRow).toEqual(13);

                expect(formatRanges(resRange2_2)).toEqual(formatRanges([targetRange2_2]));
            });

            it('intersect', () => {
                const targetRange1_1: IRange = {
                    startRow: 2,
                    endRow: 12,
                    startColumn: 0,
                    endColumn: 10,
                };
                const targetRange1_2: IRange = {
                    startRow: 12,
                    endRow: 22,
                    startColumn: 0,
                    endColumn: 10,
                };

                const resRange1_1 = handleMoveRowsCommon(
                    { id: EffectRefRangId.MoveRowsCommandId, params: { toRange, fromRange } },
                    targetRange1_1
                );
                const resRange1_2 = handleMoveRowsCommon(
                    { id: EffectRefRangId.MoveRowsCommandId, params: { toRange, fromRange } },
                    targetRange1_2
                );

                expect(formatRanges(resRange1_1)).toEqual(formatRanges(
                    [
                        {
                            endColumn: 10,
                            endRow: 14,
                            startColumn: 0,
                            startRow: 9,
                        },
                        {
                            endColumn: 10,
                            endRow: 6,
                            startColumn: 0,
                            startRow: 2,
                        },
                    ]
                ));
                expect(formatRanges(resRange1_2)).toEqual(formatRanges([
                    {
                        endColumn: 10,
                        endRow: 22,
                        startColumn: 0,
                        startRow: 15,
                    },
                    {
                        endColumn: 10,
                        endRow: 8,
                        startColumn: 0,
                        startRow: 6,
                    },
                ]));
            });
        });
    });
    describe('handleInsertRangeMoveDown', () => {
        let range: IRange;
        beforeEach(() => {
            range = { startRow: 5, endRow: 10, startColumn: 4, endColumn: 7 };
        });
        it('the targetRange is in the range bottom without overlap', () => {
            const targetRange = { startRow: 12, endRow: 13, startColumn: 5, endColumn: 5 };
            const operators = handleInsertRangeMoveDown(
                {
                    params: { range },
                    id: EffectRefRangId.InsertRangeMoveDownCommandId,
                },
                targetRange
            );
            const result = runRefRangeMutations(operators!, targetRange);
            expect(result).toEqual({ startRow: 18, endRow: 19, startColumn: 5, endColumn: 5 });
        });
        it('the targetRange is in the range bottom with overlap', () => {
            const targetRange = { startRow: 10, endRow: 11, startColumn: 5, endColumn: 5 };
            const operators = handleInsertRangeMoveDown(
                {
                    params: { range },
                    id: EffectRefRangId.InsertRangeMoveDownCommandId,
                },
                targetRange
            );
            const result = runRefRangeMutations(operators!, targetRange);
            expect(result).toEqual({ startRow: 16, endRow: 17, startColumn: 5, endColumn: 5 });
        });
        it('the targetRange is overlap with range ', () => {
            const targetRange = { startRow: 12, endRow: 13, startColumn: 4, endColumn: 6 };
            const operators = handleInsertRangeMoveDown(
                {
                    params: { range },
                    id: EffectRefRangId.InsertRangeMoveDownCommandId,
                },
                targetRange
            );
            const result = runRefRangeMutations(operators!, targetRange);
            expect(result).toEqual({ ...targetRange, startRow: 18, endRow: 19 });
        });
    });

    describe('handleInsertRangeMoveDownCommon', () => {
        let range: IRange;
        beforeEach(() => {
            range = { startRow: 2, endRow: 2, startColumn: 0, endColumn: 5 };
        });

        it('intersects', () => {
            const target = {
                startRow: 0,
                endRow: 5,
                startColumn: 0,
                endColumn: 5,
            };

            const res = handleInsertRangeMoveDownCommon(
                {
                    params: { range },
                    id: EffectRefRangId.InsertRangeMoveDownCommandId,
                },
                target
            );

            expect(formatRanges(res)).toEqual(
                formatRanges([
                    {
                        startRow: 3,
                        endRow: 6,
                        startColumn: 0,
                        endColumn: 5,
                    },
                    {
                        startRow: 0,
                        endRow: 1,
                        startColumn: 0,
                        endColumn: 5,
                    },
                ])
            );
        });

        it('no-intersects', () => {
            const target = {
                startRow: 0,
                endRow: 5,
                startColumn: 6,
                endColumn: 10,
            };

            const res = handleInsertRangeMoveDownCommon(
                {
                    params: { range },
                    id: EffectRefRangId.InsertRangeMoveDownCommandId,
                },
                target
            );

            expect(formatRanges(res)).toEqual(
                formatRanges([
                    {
                        startRow: 0,
                        endRow: 5,
                        startColumn: 6,
                        endColumn: 10,
                    },
                ])
            );
        });
    });

    describe('handleInsertRangeMoveRight', () => {
        let range: IRange;
        beforeEach(() => {
            range = { startRow: 5, endRow: 10, startColumn: 4, endColumn: 7 };
        });
        it('the targetRange is in the range right without overlap', () => {
            const targetRange = { startRow: 6, endRow: 8, startColumn: 9, endColumn: 10 };
            const operators = handleInsertRangeMoveRight(
                {
                    params: { range },
                    id: EffectRefRangId.InsertRangeMoveRightCommandId,
                },
                targetRange
            );
            const result = runRefRangeMutations(operators!, targetRange);
            expect(result).toEqual({ startRow: 6, endRow: 8, startColumn: 13, endColumn: 14 });
        });
        it('the targetRange is in the range right with overlap', () => {
            const targetRange = { startRow: 6, endRow: 8, startColumn: 7, endColumn: 8 };
            const operators = handleInsertRangeMoveRight(
                {
                    params: { range },
                    id: EffectRefRangId.InsertRangeMoveRightCommandId,
                },
                targetRange
            );
            const result = runRefRangeMutations(operators!, targetRange);
            expect(result).toEqual({ startRow: 6, endRow: 8, startColumn: 11, endColumn: 12 });
        });
        it('the targetRange is overlap with range ', () => {
            const targetRange = { startRow: 10, endRow: 13, startColumn: 11, endColumn: 11 };
            const operators = handleInsertRangeMoveRight(
                {
                    params: { range },
                    id: EffectRefRangId.InsertRangeMoveRightCommandId,
                },
                targetRange
            );
            const result = runRefRangeMutations(operators!, targetRange);
            expect(result).toEqual(targetRange);
        });
    });

    describe('handleInsertRangeMoveRightCommon', () => {
        let range: IRange;
        beforeEach(() => {
            range = { startColumn: 2, endColumn: 2, startRow: 0, endRow: 5 };
        });

        it('intersects', () => {
            const target = {
                startColumn: 0,
                endColumn: 5,
                startRow: 0,
                endRow: 5,
            };

            const res = handleInsertRangeMoveRightCommon(
                {
                    params: { range },
                    id: EffectRefRangId.InsertRangeMoveRightCommandId,
                },
                target
            );

            expect(formatRanges(res)).toEqual(
                formatRanges([
                    {
                        startColumn: 3,
                        endColumn: 6,
                        startRow: 0,
                        endRow: 5,
                    },
                    {
                        startColumn: 0,
                        endColumn: 1,
                        startRow: 0,
                        endRow: 5,
                    },
                ])
            );
        });

        it('no-intersects', () => {
            const target = {
                startColumn: 0,
                endColumn: 5,
                startRow: 6,
                endRow: 10,
            };

            const res = handleInsertRangeMoveRightCommon(
                {
                    params: { range },
                    id: EffectRefRangId.InsertRangeMoveRightCommandId,
                },
                target
            );

            expect(formatRanges(res)).toEqual(
                formatRanges([
                    {
                        startColumn: 0,
                        endColumn: 5,
                        startRow: 6,
                        endRow: 10,
                    },
                ])
            );
        });
    });

    describe('handleDeleteRangeMoveLeft', () => {
        let range: IRange;
        beforeEach(() => {
            range = { startRow: 5, endRow: 10, startColumn: 4, endColumn: 7 };
        });
        it('the targetRange is in the range right without overlap', () => {
            const targetRange = { startRow: 6, endRow: 8, startColumn: 9, endColumn: 10 };
            const operators = handleDeleteRangeMoveLeft(
                {
                    params: { range },
                    id: EffectRefRangId.DeleteRangeMoveLeftCommandId,
                },
                targetRange
            );
            const result = runRefRangeMutations(operators!, targetRange);
            expect(result).toEqual({ startRow: 6, endRow: 8, startColumn: 5, endColumn: 6 });
        });
        it('the targetRange is in the range right with overlap', () => {
            const targetRange = { startRow: 6, endRow: 8, startColumn: 7, endColumn: 8 };
            const operators = handleDeleteRangeMoveLeft(
                {
                    params: { range },
                    id: EffectRefRangId.DeleteRangeMoveLeftCommandId,
                },
                targetRange
            );
            const result = runRefRangeMutations(operators!, targetRange);
            expect(result).toEqual({ startRow: 6, endRow: 8, startColumn: 4, endColumn: 4 });
        });
        it('the targetRange is in the range right with overlap, but startColumn is the same', () => {
            const targetRange = { startRow: 6, endRow: 8, startColumn: 7, endColumn: 8 };
            const operators = handleDeleteRangeMoveLeft(
                {
                    params: { range },
                    id: EffectRefRangId.DeleteRangeMoveLeftCommandId,
                },
                targetRange
            );
            const result = runRefRangeMutations(operators!, targetRange);
            expect(result).toEqual({ startRow: 6, endRow: 8, startColumn: 4, endColumn: 4 });
        });
        it('the targetRange is overlap with range ', () => {
            const targetRange = { startRow: 10, endRow: 13, startColumn: 11, endColumn: 11 };
            const operators = handleDeleteRangeMoveLeft(
                {
                    params: { range },
                    id: EffectRefRangId.DeleteRangeMoveLeftCommandId,
                },
                targetRange
            );
            const result = runRefRangeMutations(operators!, targetRange);
            expect(result).toEqual(targetRange);
        });
    });

    describe('handleDeleteRangeMoveLeftCommon', () => {
        let range: IRange;
        beforeEach(() => {
            range = { startColumn: 2, endColumn: 2, startRow: 0, endRow: 5 };
        });

        it('intersects', () => {
            const target = {
                startRow: 0,
                endRow: 5,
                startColumn: 0,
                endColumn: 5,
            };

            const res = handleDeleteRangeMoveLeftCommon(
                {
                    params: { range },
                    id: EffectRefRangId.DeleteRangeMoveLeftCommandId,
                },
                target
            );

            expect(formatRanges(res)).toEqual(
                formatRanges([
                    {
                        startRow: 0,
                        endRow: 5,
                        startColumn: 0,
                        endColumn: 4,
                    },
                ])
            );
        });

        it('no-intersects', () => {
            const target = {
                startRow: 6,
                endRow: 10,
                startColumn: 0,
                endColumn: 5,
            };

            const res = handleDeleteRangeMoveLeftCommon(
                {
                    params: { range },
                    id: EffectRefRangId.DeleteRangeMoveLeftCommandId,
                },
                target
            );

            expect(formatRanges(res)).toEqual(
                formatRanges([
                    {
                        startRow: 6,
                        endRow: 10,
                        startColumn: 0,
                        endColumn: 5,
                    },
                ])
            );
        });
    });

    describe('handleDeleteRangeMoveUpCommon', () => {
        let range: IRange;
        beforeEach(() => {
            range = { startRow: 2, endRow: 2, startColumn: 0, endColumn: 5 };
        });

        it('intersects', () => {
            const target = {
                startRow: 0,
                endRow: 5,
                startColumn: 0,
                endColumn: 5,
            };

            const res = handleDeleteRangeMoveUpCommon(
                {
                    params: { range },
                    id: EffectRefRangId.DeleteRangeMoveUpCommandId,
                },
                target
            );

            expect(formatRanges(res)).toEqual(
                formatRanges([
                    {
                        startRow: 0,
                        endRow: 4,
                        startColumn: 0,
                        endColumn: 5,
                    },
                ])
            );
        });

        it('no-intersects', () => {
            const target = {
                startRow: 0,
                endRow: 5,
                startColumn: 6,
                endColumn: 10,
            };

            const res = handleDeleteRangeMoveUpCommon(
                {
                    params: { range },
                    id: EffectRefRangId.DeleteRangeMoveUpCommandId,
                },
                target
            );

            expect(formatRanges(res)).toEqual(
                formatRanges([
                    {
                        startRow: 0,
                        endRow: 5,
                        startColumn: 6,
                        endColumn: 10,
                    },
                ])
            );
        });
    });
    describe('handleDeleteRangeMoveUp', () => {
        let range: IRange;
        beforeEach(() => {
            range = { startRow: 5, endRow: 10, startColumn: 4, endColumn: 7 };
        });
        it('the targetRange is in the range bottom without overlap', () => {
            const targetRange = { startRow: 12, endRow: 13, startColumn: 5, endColumn: 5 };
            const operators = handleDeleteRangeMoveUp(
                {
                    params: { range },
                    id: EffectRefRangId.DeleteRangeMoveUpCommandId,
                },
                targetRange
            );
            const result = runRefRangeMutations(operators!, targetRange);
            expect(result).toEqual({ startRow: 6, endRow: 7, startColumn: 5, endColumn: 5 });
        });
        it('the targetRange is in the range bottom with overlap', () => {
            const targetRange = { startRow: 10, endRow: 11, startColumn: 5, endColumn: 5 };
            const operators = handleDeleteRangeMoveUp(
                {
                    params: { range },
                    id: EffectRefRangId.DeleteRangeMoveUpCommandId,
                },
                targetRange
            );
            const result = runRefRangeMutations(operators!, targetRange);
            expect(result).toEqual({ startRow: 5, endRow: 5, startColumn: 5, endColumn: 5 });
        });

        it('the targetRange is not overlap with range ', () => {
            const targetRange = { startRow: 0, endRow: 1, startColumn: 5, endColumn: 5 };
            const operators = handleDeleteRangeMoveUp(
                {
                    params: { range },
                    id: EffectRefRangId.DeleteRangeMoveUpCommandId,
                },
                targetRange
            );
            const result = runRefRangeMutations(operators!, targetRange);
            expect(result).toEqual({ startRow: 0, endRow: 1, startColumn: 5, endColumn: 5 });
        });
        it('the targetRange is  overlap with range 2', () => {
            const targetRange = { startRow: 5, endRow: 5, startColumn: 4, endColumn: 7 };
            const operators = handleDeleteRangeMoveUp(
                {
                    params: { range },
                    id: EffectRefRangId.DeleteRangeMoveUpCommandId,
                },
                targetRange
            );
            const result = runRefRangeMutations(operators!, targetRange);
            expect(result).toEqual(null);
        });
    });

    describe('handleInsertCol', () => {
        let range: IRange;
        beforeEach(() => {
            range = { startRow: 0, endRow: 99, startColumn: 5, endColumn: 10 };
        });
        it('the targetRange is on the range left', () => {
            const targetRange = { startRow: 0, endRow: 99, startColumn: 2, endColumn: 3 };
            const operators = handleInsertCol(
                {
                    id: EffectRefRangId.InsertColCommandId,
                    params: { range, unitId: '', subUnitId: '', direction: Direction.LEFT },
                },
                targetRange
            );
            const result = runRefRangeMutations(operators!, targetRange);
            expect(result).toEqual({ startRow: 0, endRow: 99, startColumn: 2, endColumn: 3 });
        });
        it('the targetRange is in the range', () => {
            const targetRange = { startRow: 0, endRow: 99, startColumn: 5, endColumn: 6 };
            const operators = handleInsertCol(
                {
                    id: EffectRefRangId.InsertColCommandId,
                    params: { range, unitId: '', subUnitId: '', direction: Direction.LEFT },
                },
                targetRange
            );
            const result = runRefRangeMutations(operators!, targetRange);
            expect(result).toEqual({ startRow: 0, endRow: 99, startColumn: 11, endColumn: 12 });
        });
        it('the targetRange is contain the range', () => {
            const targetRange = { startRow: 0, endRow: 99, startColumn: 4, endColumn: 11 };
            const operators = handleInsertCol(
                {
                    id: EffectRefRangId.InsertColCommandId,
                    params: { range, unitId: '', subUnitId: '', direction: Direction.LEFT },
                },
                targetRange
            );
            const result = runRefRangeMutations(operators!, targetRange);
            expect(result).toEqual({ startRow: 0, endRow: 99, startColumn: 4, endColumn: 17 });
        });
        it('the targetRange is overlap with  range', () => {
            const targetRange = { startRow: 0, endRow: 99, startColumn: 4, endColumn: 6 };
            const operators = handleInsertCol(
                {
                    id: EffectRefRangId.InsertColCommandId,
                    params: { range, unitId: '', subUnitId: '', direction: Direction.LEFT },
                },
                targetRange
            );
            const result = runRefRangeMutations(operators!, targetRange);
            expect(result).toEqual({ ...targetRange, endColumn: 12 });
        });
        it('the targetRange is on the range bottom', () => {
            const targetRange = { startRow: 0, endRow: 99, startColumn: 12, endColumn: 13 };

            const operators = handleInsertCol(
                {
                    id: EffectRefRangId.InsertColCommandId,
                    params: { range, unitId: '', subUnitId: '', direction: Direction.LEFT },
                },
                targetRange
            );
            const result = runRefRangeMutations(operators!, targetRange);
            expect(result).toEqual({ startRow: 0, endRow: 99, startColumn: 18, endColumn: 19 });
        });

        it('the targetRange is on the range start', () => {
            const targetRange = { startRow: 0, endRow: 99, startColumn: 5, endColumn: 6 };

            const operators = handleInsertCol(
                {
                    id: EffectRefRangId.InsertColCommandId,
                    params: { range, unitId: '', subUnitId: '', direction: Direction.LEFT },
                },
                targetRange
            );
            const result = runRefRangeMutations(operators!, targetRange);
            expect(result).toEqual({ startRow: 0, endRow: 99, startColumn: 11, endColumn: 12 });
        });
    });

    describe('handleInsertRow', () => {
        let range: IRange;
        beforeEach(() => {
            range = { startRow: 5, endRow: 10, startColumn: 0, endColumn: 99 };
        });
        it('the targetRange is on the range top', () => {
            const targetRange = { startRow: 3, endColumn: 99, startColumn: 0, endRow: 4 };
            const operators = handleInsertRow(
                {
                    id: EffectRefRangId.InsertRowCommandId,
                    params: { range, unitId: '', subUnitId: '', direction: Direction.UP },
                },
                targetRange
            );
            const result = runRefRangeMutations(operators!, targetRange);
            expect(result).toEqual({ startRow: 3, endColumn: 99, startColumn: 0, endRow: 4 });
        });
        it('the targetRange is in the range', () => {
            const targetRange = { startRow: 5, endRow: 6, endColumn: 99, startColumn: 0 };
            const operators = handleInsertRow(
                {
                    id: EffectRefRangId.InsertRowCommandId,
                    params: { range, unitId: '', subUnitId: '', direction: Direction.UP },
                },
                targetRange
            );
            const result = runRefRangeMutations(operators!, targetRange);
            expect(result).toEqual({ startRow: 11, endColumn: 99, startColumn: 0, endRow: 12 });
        });
        it('the targetRange is contain the range', () => {
            const targetRange = { startRow: 4, endRow: 11, endColumn: 99, startColumn: 0 };
            const operators = handleInsertRow(
                {
                    id: EffectRefRangId.InsertRowCommandId,
                    params: { range, unitId: '', subUnitId: '', direction: Direction.UP },
                },
                targetRange
            );
            const result = runRefRangeMutations(operators!, targetRange);
            expect(result).toEqual({ startRow: 4, endRow: 17, endColumn: 99, startColumn: 0 });
        });
        it('the targetRange is overlap with range', () => {
            const targetRange = { startRow: 4, endRow: 6, endColumn: 99, startColumn: 0 };
            const operators = handleInsertRow(
                {
                    id: EffectRefRangId.InsertRowCommandId,
                    params: { range, unitId: '', subUnitId: '', direction: Direction.UP },
                },
                targetRange
            );
            const result = runRefRangeMutations(operators!, targetRange);
            expect(result).toEqual({ ...targetRange, endRow: 12 });
        });
        it('the targetRange is on the range bottom', () => {
            const targetRange = { startRow: 12, endColumn: 99, startColumn: 0, endRow: 13 };
            const operators = handleInsertRow(
                {
                    id: EffectRefRangId.InsertRowCommandId,
                    params: { range, unitId: '', subUnitId: '', direction: Direction.UP },
                },
                targetRange
            );
            const result = runRefRangeMutations(operators!, targetRange);
            expect(result).toEqual({ startRow: 18, endColumn: 99, startColumn: 0, endRow: 19 });
        });

        it('the targetRange is on the range start', () => {
            const targetRange = { startRow: 5, endRow: 6, endColumn: 99, startColumn: 0 };
            const operators = handleInsertRow(
                {
                    id: EffectRefRangId.InsertRowCommandId,
                    params: { range, unitId: '', subUnitId: '', direction: Direction.UP },
                },
                targetRange
            );
            const result = runRefRangeMutations(operators!, targetRange);
            expect(result).toEqual({ startRow: 11, endColumn: 99, startColumn: 0, endRow: 12 });
        });

        it('the targetRange is overlap range 2', () => {
            const targetRange = { startRow: 4, endRow: 6, endColumn: 99, startColumn: 0 };
            const operators = handleInsertRow(
                {
                    id: EffectRefRangId.InsertRowCommandId,
                    params: { range, unitId: '', subUnitId: '', direction: Direction.UP },
                },
                targetRange
            );
            const result = runRefRangeMutations(operators!, targetRange);
            expect(result).toEqual({ startRow: 4, endRow: 12, endColumn: 99, startColumn: 0 });
        });
    });
    describe('handleInsertRowCommon', () => {
        it('should shift range down when range is below insertion point', () => {
            const info: ICommandInfo<IInsertRowCommandParams> = {
                params: {
                    range: { startRow: 5, endRow: 7, startColumn: 0, endColumn: 5 },
                    unitId: '',
                    subUnitId: '',
                    direction: 0,
                },
                id: '',
            };
            const targetRange = { startRow: 10, endRow: 15, startColumn: 2, endColumn: 8 };

            const result = handleInsertRowCommon(info, targetRange);

            expect(result).toEqual([{
                startRow: 13, // 10 + (7 - 5 + 1)
                endRow: 18, // 15 + (7 - 5 + 1)
                startColumn: 2,
                endColumn: 8,
            }]);
        });

        it('should not change range when range is above insertion point', () => {
            const info: ICommandInfo<IInsertRowCommandParams> = {
                params: {
                    range: { startRow: 10, endRow: 12, startColumn: 0, endColumn: 5 },
                    unitId: '',
                    subUnitId: '',
                    direction: 0,
                },
                id: '',
            };
            const targetRange = { startRow: 3, endRow: 8, startColumn: 2, endColumn: 8 };

            const result = handleInsertRowCommon(info, targetRange);

            expect(result).toEqual([targetRange]);
        });

        it('should expand range when insertion point is within the range', () => {
            const info: ICommandInfo<IInsertRowCommandParams> = {
                params: {
                    range: { startRow: 7, endRow: 9, startColumn: 0, endColumn: 5 },
                    unitId: '',
                    subUnitId: '',
                    direction: 0,
                },
                id: '',
            };
            const targetRange = { startRow: 5, endRow: 12, startColumn: 2, endColumn: 8 };

            const result = handleInsertRowCommon(info, targetRange);

            expect(result).toEqual([{
                startRow: 5,
                endRow: 15, // 12 + (9 - 7 + 1)
                startColumn: 2,
                endColumn: 8,
            }]);
        });

        it('should shift the range down when insertion is at the first row of the range', () => {
            const info: ICommandInfo<IInsertRowCommandParams> = {
                params: {
                    range: { startRow: 5, endRow: 7, startColumn: 0, endColumn: 5 },
                    unitId: '',
                    subUnitId: '',
                    direction: 0,
                },
                id: '',
            };
            const targetRange = { startRow: 5, endRow: 10, startColumn: 2, endColumn: 8 };

            const result = handleInsertRowCommon(info, targetRange);

            expect(result).toEqual([{
                startRow: 8, // 5 + (7 - 5 + 1): inserting above the range shifts it
                endRow: 13, // 10 + (7 - 5 + 1)
                startColumn: 2,
                endColumn: 8,
            }]);
        });

        it('should handle insertion at the end of the range', () => {
            const info = {
                params: {
                    range: { startRow: 10, endRow: 12, startColumn: 0, endColumn: 5 },
                    unitId: '',
                    subUnitId: '',
                    direction: 0,
                },
                id: '',
            };
            const targetRange = { startRow: 5, endRow: 10, startColumn: 2, endColumn: 8 };

            const result = handleInsertRowCommon(info, targetRange);

            expect(result).toEqual([{
                startRow: 5,
                endRow: 13, // 10 + (12 - 10 + 1)
                startColumn: 2,
                endColumn: 8,
            }]);
        });

        it('should handle insertion of multiple rows', () => {
            const info = {
                params: {
                    range: { startRow: 5, endRow: 10, startColumn: 0, endColumn: 5 },
                    unitId: '',
                    subUnitId: '',
                    direction: 0,
                },
                id: '',
            };
            const targetRange = { startRow: 15, endRow: 20, startColumn: 2, endColumn: 8 };

            const result = handleInsertRowCommon(info, targetRange);

            expect(result).toEqual([{
                startRow: 21, // 15 + (10 - 5 + 1)
                endRow: 26, // 20 + (10 - 5 + 1)
                startColumn: 2,
                endColumn: 8,
            }]);
        });
    });
    describe('handleInsertColCommon', () => {
        it('should shift range right when range is to the right of insertion point', () => {
            const info: ICommandInfo<IInsertColCommandParams> = {
                params: {
                    range: { startRow: 0, endRow: 5, startColumn: 5, endColumn: 7 },
                    unitId: '',
                    subUnitId: '',
                    direction: Direction.LEFT,
                },
                id: '',
            };
            const targetRange = { startRow: 2, endRow: 8, startColumn: 10, endColumn: 15 };

            const result = handleInsertColCommon(info, targetRange);

            expect(result).toEqual([{
                startRow: 2,
                endRow: 8,
                startColumn: 13, // 10 + (7 - 5 + 1)
                endColumn: 18, // 15 + (7 - 5 + 1)
            }]);
        });

        it('should not change range when range is to the left of insertion point', () => {
            const info: ICommandInfo<IInsertColCommandParams> = {
                params: {
                    range: { startRow: 0, endRow: 5, startColumn: 10, endColumn: 12 },
                    unitId: '',
                    subUnitId: '',
                    direction: Direction.LEFT,
                },
                id: '',
            };
            const targetRange = { startRow: 2, endRow: 8, startColumn: 3, endColumn: 8 };

            const result = handleInsertColCommon(info, targetRange);

            expect(result).toEqual([targetRange]);
        });

        it('should expand range when insertion point is within the range', () => {
            const info: ICommandInfo<IInsertColCommandParams> = {
                params: {
                    range: { startRow: 0, endRow: 5, startColumn: 7, endColumn: 9 },
                    unitId: '',
                    subUnitId: '',
                    direction: Direction.LEFT,
                },
                id: '',
            };
            const targetRange = { startRow: 2, endRow: 8, startColumn: 5, endColumn: 12 };

            const result = handleInsertColCommon(info, targetRange);

            expect(result).toEqual([{
                startRow: 2,
                endRow: 8,
                startColumn: 5,
                endColumn: 15, // 12 + (9 - 7 + 1)
            }]);
        });

        it('should shift the range right when insertion is at the first column of the range', () => {
            const info: ICommandInfo<IInsertColCommandParams> = {
                params: {
                    range: { startRow: 0, endRow: 5, startColumn: 5, endColumn: 7 },
                    unitId: '',
                    subUnitId: '',
                    direction: Direction.LEFT,
                },
                id: '',
            };
            const targetRange = { startRow: 2, endRow: 8, startColumn: 5, endColumn: 10 };

            const result = handleInsertColCommon(info, targetRange);

            expect(result).toEqual([{
                startRow: 2,
                endRow: 8,
                startColumn: 8, // 5 + (7 - 5 + 1): inserting to the left of the range shifts it
                endColumn: 13, // 10 + (7 - 5 + 1)
            }]);
        });

        it('should handle insertion at the end of the range', () => {
            const info: ICommandInfo<IInsertColCommandParams> = {
                params: {
                    range: { startRow: 0, endRow: 5, startColumn: 10, endColumn: 12 },
                    unitId: '',
                    subUnitId: '',
                    direction: Direction.LEFT,
                },
                id: '',
            };
            const targetRange = { startRow: 2, endRow: 8, startColumn: 5, endColumn: 10 };

            const result = handleInsertColCommon(info, targetRange);

            expect(result).toEqual([{
                startRow: 2,
                endRow: 8,
                startColumn: 5,
                endColumn: 13, // 10 + (12 - 10 + 1)
            }]);
        });

        it('should handle insertion of multiple columns', () => {
            const info: ICommandInfo<IInsertColCommandParams> = {
                params: {
                    range: { startRow: 0, endRow: 5, startColumn: 5, endColumn: 10 },
                    unitId: '',
                    subUnitId: '',
                    direction: Direction.LEFT,
                },
                id: '',
            };
            const targetRange = { startRow: 2, endRow: 8, startColumn: 15, endColumn: 20 };

            const result = handleInsertColCommon(info, targetRange);

            expect(result).toEqual([{
                startRow: 2,
                endRow: 8,
                startColumn: 21, // 15 + (10 - 5 + 1)
                endColumn: 26, // 20 + (10 - 5 + 1)
            }]);
        });
    });
    describe('handleMoveRange', () => {
        describe('fromRange and toRange is no overlap', () => {
            let toRange: IRange;
            let fromRange: IRange;
            beforeEach(() => {
                toRange = { startRow: 4, endColumn: 7, startColumn: 4, endRow: 7 };
                fromRange = { startRow: 0, endColumn: 3, startColumn: 0, endRow: 3 };
            });
            it('fromRange contain targetRange  ', () => {
                const targetRange: IRange = { startRow: 0, endRow: 1, startColumn: 0, endColumn: 1 };
                const operators = handleMoveRange(
                    { id: EffectRefRangId.MoveRangeCommandId, params: { toRange, fromRange } },
                    targetRange
                );
                const result = runRefRangeMutations(operators!, targetRange);
                expect(result).toEqual({ endColumn: 5, endRow: 5, startColumn: 4, startRow: 4 });
            });
            it('fromRange intersect targetRange  ', () => {
                const targetRange: IRange = { startRow: 3, endRow: 4, startColumn: 0, endColumn: 1 };
                const operators = handleMoveRange(
                    { id: EffectRefRangId.MoveRangeCommandId, params: { toRange, fromRange } },
                    targetRange
                );
                const result = runRefRangeMutations(operators!, targetRange);
                expect(result).toEqual(targetRange);
            });

            it('toRange intersect targetRange  ', () => {
                const targetRange: IRange = { startRow: 4, endRow: 9, startColumn: 4, endColumn: 5 };
                const operators = handleMoveRange(
                    { id: EffectRefRangId.MoveRangeCommandId, params: { toRange, fromRange } },
                    targetRange
                );
                const result = runRefRangeMutations(operators!, targetRange);
                expect(result).toEqual(targetRange);
            });
            it('toRange contain targetRange  ', () => {
                const targetRange: IRange = { startRow: 4, endRow: 5, startColumn: 4, endColumn: 5 };
                const operators = handleMoveRange(
                    { id: EffectRefRangId.MoveRangeCommandId, params: { toRange, fromRange } },
                    targetRange
                );
                const result = runRefRangeMutations(operators!, targetRange);
                expect(result).toEqual(null);
            });

            it('toRange and  fromRange not overlap with targetRange', () => {
                const targetRange: IRange = { startRow: 20, endRow: 30, startColumn: 20, endColumn: 30 };
                const operators = handleMoveRange(
                    { id: EffectRefRangId.MoveRangeCommandId, params: { toRange, fromRange } },
                    targetRange
                );
                const result = runRefRangeMutations(operators!, targetRange);
                expect(result).toEqual({ startRow: 20, endRow: 30, startColumn: 20, endColumn: 30 });
            });
        });
        describe('fromRange and toRang is overlap ', () => {
            let toRange: IRange;
            let fromRange: IRange;
            beforeEach(() => {
                fromRange = { startRow: 0, endColumn: 3, startColumn: 0, endRow: 3 };
                toRange = { startRow: 2, endRow: 5, startColumn: 2, endColumn: 5 };
            });
            it('fromRange contain targetRange and is not intersect toRange', () => {
                const targetRange: IRange = { startRow: 0, endRow: 1, startColumn: 0, endColumn: 1 };
                const operators = handleMoveRange(
                    { id: EffectRefRangId.MoveRangeCommandId, params: { toRange, fromRange } },
                    targetRange
                );
                const result = runRefRangeMutations(operators!, targetRange);
                expect(result).toEqual({ endColumn: 3, endRow: 3, startColumn: 2, startRow: 2 });
            });
            it('fromRange contain targetRange and is intersect toRange', () => {
                const targetRange: IRange = { startRow: 2, endRow: 3, startColumn: 1, endColumn: 2 };
                const operators = handleMoveRange(
                    { id: EffectRefRangId.MoveRangeCommandId, params: { toRange, fromRange } },
                    targetRange
                );
                const result = runRefRangeMutations(operators!, targetRange);
                expect(result).toEqual({ endColumn: 4, endRow: 5, startColumn: 3, startRow: 4 });
            });
            it('targetRange is equal with the intersect with fromRange and toRange  ', () => {
                const targetRange: IRange = { startRow: 2, endRow: 3, startColumn: 2, endColumn: 3 };
                const operators = handleMoveRange(
                    { id: EffectRefRangId.MoveRangeCommandId, params: { toRange, fromRange } },
                    targetRange
                );
                const result = runRefRangeMutations(operators!, targetRange);
                expect(result).toEqual({ endColumn: 5, endRow: 5, startColumn: 4, startRow: 4 });
            });
            it('toRange and  fromRange not overlap with targetRange', () => {
                const targetRange: IRange = { startRow: 20, endRow: 30, startColumn: 20, endColumn: 30 };
                const operators = handleMoveRange(
                    { id: EffectRefRangId.MoveRangeCommandId, params: { toRange, fromRange } },
                    targetRange
                );
                const result = runRefRangeMutations(operators!, targetRange);
                expect(result).toEqual({ startRow: 20, endRow: 30, startColumn: 20, endColumn: 30 });
            });
            it('targetRange is intersect with toRange ', () => {
                const targetRange: IRange = { startRow: 2, endRow: 3, startColumn: 4, endColumn: 5 };
                const operators = handleMoveRange(
                    { id: EffectRefRangId.MoveRangeCommandId, params: { toRange, fromRange } },
                    targetRange
                );
                const result = runRefRangeMutations(operators!, targetRange);
                expect(result).toEqual(null);
            });
        });
    });

    describe('handleMoveRangeCommon', () => {
        describe('intersects', () => {
            let toRange: IRange;
            let fromRange: IRange;
            beforeEach(() => {
                toRange = { startRow: 4, endColumn: 7, startColumn: 4, endRow: 7 };
                fromRange = { startRow: 0, endColumn: 3, startColumn: 0, endRow: 3 };
            });

            it('should work', () => {
                const range1 = {
                    startRow: 0,
                    endColumn: 5,
                    startColumn: 0,
                    endRow: 5,
                };
                const range2 = {
                    startRow: 6,
                    endColumn: 10,
                    startColumn: 6,
                    endRow: 10,
                };
                const res1 = handleMoveRangeCommon(
                    { id: EffectRefRangId.MoveRangeCommandId, params: { toRange, fromRange } },
                    range1
                );

                const res2 = handleMoveRangeCommon(
                    { id: EffectRefRangId.MoveRangeCommandId, params: { toRange, fromRange } },
                    range2
                );

                expect(formatRanges(res1)).toEqual(
                    formatRanges(
                        [{
                            endColumn: 7,
                            endRow: 5,
                            startColumn: 0,
                            startRow: 4,
                        }, {
                            endColumn: 5,
                            endRow: 3,
                            startColumn: 4,
                            startRow: 0,
                        }, {
                            endColumn: 7,
                            endRow: 7,
                            startColumn: 4,
                            startRow: 6,
                        }]
                    )
                );
                expect(formatCoveredCells(res2)).toEqual(
                    formatCoveredCells(
                        [{
                            endColumn: 10,
                            endRow: 10,
                            startColumn: 8,
                            startRow: 6,
                        }, {
                            endColumn: 7,
                            endRow: 10,
                            startColumn: 6,
                            startRow: 8,
                        }]
                    )
                );
            });
        });
    });
    describe('handleIRemoveCol', () => {
        let range: IRange;
        describe('the range contain targetRange', () => {
            beforeEach(() => {
                range = { startRow: 0, endColumn: 10, startColumn: 5, endRow: 99 };
            });
            it('the targetRange is single col', () => {
                const targetRange = { startRow: 0, endColumn: 5, startColumn: 5, endRow: 99 };
                const operators = handleIRemoveCol(
                    { params: { range }, id: EffectRefRangId.RemoveColCommandId },
                    targetRange
                );
                const result = runRefRangeMutations(operators!, targetRange);
                expect(result).toBe(null);
            });
            it('the targetRange is multiple col ', () => {
                const targetRange = { startRow: 0, endColumn: 5, startColumn: 6, endRow: 99 };
                const operators = handleIRemoveCol(
                    { params: { range }, id: EffectRefRangId.RemoveColCommandId },
                    targetRange
                );
                const result = runRefRangeMutations(operators!, targetRange);
                expect(result).toBe(null);
            });
            it('the targetRange is equal range', () => {
                const targetRange = { startRow: 0, endColumn: 5, startColumn: 10, endRow: 99 };
                const operators = handleIRemoveCol(
                    { params: { range }, id: EffectRefRangId.RemoveColCommandId },
                    targetRange
                );
                const result = runRefRangeMutations(operators!, targetRange);
                expect(result).toBe(null);
            });
        });
        describe('the targetRange in the range right', () => {
            beforeEach(() => {
                range = { startRow: 0, endColumn: 10, startColumn: 5, endRow: 99 };
            });
            it('targetRange is overlap with range ', () => {
                const targetRange = { startRow: 0, endColumn: 11, startColumn: 10, endRow: 99 };
                const operators = handleIRemoveCol(
                    { params: { range }, id: EffectRefRangId.RemoveColCommandId },
                    targetRange
                );
                const result = runRefRangeMutations(operators!, targetRange);
                expect(result).toEqual({ startRow: 0, endColumn: 5, startColumn: 5, endRow: 99 });
            });
            it('targetRange is no overlap with range ', () => {
                const targetRange = { startRow: 0, endColumn: 12, startColumn: 11, endRow: 99 };
                const operators = handleIRemoveCol(
                    { params: { range }, id: EffectRefRangId.RemoveColCommandId },
                    targetRange
                );
                const result = runRefRangeMutations(operators!, targetRange);
                expect(result).toEqual({ startRow: 0, endColumn: 6, startColumn: 5, endRow: 99 });
            });
        });
        describe('the targetRange in the range left', () => {
            beforeEach(() => {
                range = { startRow: 0, endColumn: 10, startColumn: 5, endRow: 99 };
            });
            it('targetRange is overlap with range ', () => {
                const targetRange = { startRow: 0, endColumn: 5, startColumn: 4, endRow: 99 };
                const operators = handleIRemoveCol(
                    { params: { range }, id: EffectRefRangId.RemoveColCommandId },
                    targetRange
                );
                const result = runRefRangeMutations(operators!, targetRange);
                expect(result).toEqual({ startRow: 0, endColumn: 4, startColumn: 4, endRow: 99 });
            });
            it('targetRange is no overlap with range ', () => {
                const targetRange = { startRow: 0, endColumn: 3, startColumn: 2, endRow: 99 };
                const operators = handleIRemoveCol(
                    { params: { range }, id: EffectRefRangId.RemoveColCommandId },
                    targetRange
                );
                const result = runRefRangeMutations(operators!, targetRange);
                expect(result).toEqual({ startRow: 0, endColumn: 3, startColumn: 2, endRow: 99 });
            });
        });
    });
    // eslint-disable-next-line test/no-identical-title
    describe('handleIRemoveCol', () => {
        it('should delete the target range when it is completely contained within the removed range', () => {
            const param: IRemoveRowColCommand = {
                id: EffectRefRangId.RemoveColCommandId,
                params: {
                    range: { startRow: 0, endRow: 10, startColumn: 3, endColumn: 8 },

                },
            };
            const targetRange = { startRow: 2, endRow: 5, startColumn: 4, endColumn: 7 };

            const operators = handleIRemoveCol(param, targetRange);
            const result = runRefRangeMutations(operators, targetRange);

            expect(result).toBeNull();
        });

        it('should shift the target range left when it is to the right of the removed range', () => {
            const param: IRemoveRowColCommand = {
                id: EffectRefRangId.RemoveColCommandId,
                params: {
                    range: { startRow: 0, endRow: 10, startColumn: 3, endColumn: 5 },

                },
            };
            const targetRange = { startRow: 2, endRow: 5, startColumn: 8, endColumn: 12 };

            const operators = handleIRemoveCol(param, targetRange);
            const result = runRefRangeMutations(operators, targetRange);

            expect(result).toEqual({
                startRow: 2,
                endRow: 5,
                startColumn: 5, // 8 - (5 - 3 + 1)
                endColumn: 9, // 12 - (5 - 3 + 1)
            });
        });

        it('should not affect the target range when it is to the left of the removed range', () => {
            const param: IRemoveRowColCommand = {
                id: EffectRefRangId.RemoveColCommandId,
                params: {
                    range: { startRow: 0, endRow: 10, startColumn: 8, endColumn: 10 },

                },
            };
            const targetRange = { startRow: 2, endRow: 5, startColumn: 3, endColumn: 6 };

            const operators = handleIRemoveCol(param, targetRange);
            const result = runRefRangeMutations(operators, targetRange);

            expect(result).toEqual(targetRange);
        });

        it('should reduce the width of the target range when it overlaps with the right side of the removed range', () => {
            const param: IRemoveRowColCommand = {
                id: EffectRefRangId.RemoveColCommandId,
                params: {
                    range: { startRow: 0, endRow: 10, startColumn: 5, endColumn: 8 },

                },
            };
            const targetRange = { startRow: 2, endRow: 5, startColumn: 3, endColumn: 10 };

            const operators = handleIRemoveCol(param, targetRange);
            const result = runRefRangeMutations(operators, targetRange);

            expect(result).toEqual({
                startRow: 2,
                endRow: 5,
                startColumn: 3,
                endColumn: 6, // 10 - (8 - 5 + 1)
            });
        });

        it('should reduce the width of the target range when it overlaps with the left side of the removed range', () => {
            const param: IRemoveRowColCommand = {
                id: EffectRefRangId.RemoveColCommandId,
                params: {
                    range: { startRow: 0, endRow: 10, startColumn: 3, endColumn: 6 },

                },
            };
            const targetRange = { startRow: 2, endRow: 5, startColumn: 1, endColumn: 5 };

            const operators = handleIRemoveCol(param, targetRange);
            const result = runRefRangeMutations(operators, targetRange);

            expect(result).toEqual({
                startRow: 2,
                endRow: 5,
                startColumn: 1,
                endColumn: 2, // 5 - (6 - 3 + 1)
            });
        });

        it('should handle the case when the removed range starts at the same column as the target range', () => {
            const param: IRemoveRowColCommand = {
                id: EffectRefRangId.RemoveColCommandId,
                params: {
                    range: { startRow: 0, endRow: 10, startColumn: 3, endColumn: 5 },

                },
            };
            const targetRange = { startRow: 2, endRow: 5, startColumn: 3, endColumn: 8 };

            const operators = handleIRemoveCol(param, targetRange);
            const result = runRefRangeMutations(operators, targetRange);

            expect(result).toEqual({
                startRow: 2,
                endRow: 5,
                startColumn: 3,
                endColumn: 5, // 8 - (5 - 3 + 1)
            });
        });

        it('should handle the case when the removed range ends at the same column as the target range', () => {
            const param: IRemoveRowColCommand = {
                id: EffectRefRangId.RemoveColCommandId,
                params: {
                    range: { startRow: 0, endRow: 10, startColumn: 3, endColumn: 8 },

                },
            };
            const targetRange = { startRow: 2, endRow: 5, startColumn: 6, endColumn: 8 };

            const operators = handleIRemoveCol(param, targetRange);
            const result = runRefRangeMutations(operators, targetRange);

            expect(result).toBeNull();
        });

        it('should return empty operators when range is not provided', () => {
            const param: IRemoveRowColCommand = {
                id: EffectRefRangId.RemoveColCommandId,
                params: undefined,
            };
            const targetRange = { startRow: 2, endRow: 5, startColumn: 3, endColumn: 8 };

            const operators = handleIRemoveCol(param, targetRange);

            expect(operators).toEqual([]);
        });
    });
    describe('handleIRemoveRow', () => {
        let range: IRange;
        describe('the range contain targetRange', () => {
            beforeEach(() => {
                range = { startRow: 5, endRow: 10, startColumn: 0, endColumn: 99 };
            });
            it('the targetRange is single row', () => {
                const targetRange = { startRow: 5, endRow: 5, startColumn: 0, endColumn: 99 };
                const operators = handleIRemoveRow(
                    { params: { range }, id: EffectRefRangId.RemoveRowCommandId },
                    targetRange
                );
                const result = runRefRangeMutations(operators!, targetRange);
                expect(result).toBe(null);
            });
            it('the targetRange is multiple row ', () => {
                const targetRange = { startRow: 0, endRow: 5, startColumn: 0, endColumn: 99 };
                const operators = handleIRemoveRow(
                    { params: { range }, id: EffectRefRangId.RemoveRowCommandId },
                    targetRange
                );
                const result = runRefRangeMutations(operators!, targetRange);
                expect(result).toEqual({
                    endColumn: 99,
                    endRow: 4,
                    startColumn: 0,
                    startRow: 0,
                });
            });
        });
        describe('the targetRange in the range top', () => {
            beforeEach(() => {
                range = { startRow: 5, endColumn: 99, startColumn: 0, endRow: 10 };
            });
            it('targetRange is overlap with range ', () => {
                const targetRange = { startRow: 4, endRow: 5, endColumn: 99, startColumn: 0 };
                const operators = handleIRemoveRow(
                    { params: { range }, id: EffectRefRangId.RemoveRowCommandId },
                    targetRange
                );
                const result = runRefRangeMutations(operators!, targetRange);
                expect(result).toEqual({ startRow: 4, endColumn: 99, startColumn: 0, endRow: 4 });
            });
            it('targetRange is no overlap with range ', () => {
                const targetRange = { startRow: 0, endColumn: 99, startColumn: 0, endRow: 3 };
                const operators = handleIRemoveRow(
                    { params: { range }, id: EffectRefRangId.RemoveRowCommandId },
                    targetRange
                );
                const result = runRefRangeMutations(operators!, targetRange);
                expect(result).toEqual({ startRow: 0, endColumn: 99, startColumn: 0, endRow: 3 });
            });
        });
        describe('the targetRange in the range bottom', () => {
            beforeEach(() => {
                range = { startRow: 5, endRow: 10, startColumn: 0, endColumn: 99 };
            });
            it('targetRange is overlap with range ', () => {
                const targetRange = { startRow: 10, endRow: 11, startColumn: 0, endColumn: 99 };
                const operators = handleIRemoveRow(
                    { params: { range }, id: EffectRefRangId.RemoveRowCommandId },
                    targetRange
                );
                const result = runRefRangeMutations(operators!, targetRange);
                expect(result).toEqual({ startRow: 5, endRow: 5, startColumn: 0, endColumn: 99 });
            });
            it('targetRange is no overlap with range ', () => {
                const targetRange = { startRow: 11, endRow: 13, endColumn: 99, startColumn: 0 };
                const operators = handleIRemoveRow(
                    { params: { range }, id: EffectRefRangId.RemoveRowCommandId },
                    targetRange
                );
                const result = runRefRangeMutations(operators!, targetRange);
                expect(result).toEqual({ startRow: 5, endRow: 7, endColumn: 99, startColumn: 0 });
            });
        });
    });

    describe('handleRemoveRowCommon', () => {
        it('should remove rows from the target range when removing a single range', () => {
            const param = {
                range: { startRow: 5, endRow: 7, startColumn: 0, endColumn: 10 },
                unitId: '',
                subUnitId: '',
            };
            const targetRange = { startRow: 3, endRow: 10, startColumn: 2, endColumn: 8 };

            const result = handleRemoveRowCommon(param, targetRange);

            // The result should have the rows 5-7 removed from the original range
            expect(result).toEqual([
                { startRow: 3, endRow: 7, startColumn: 2, endColumn: 8 },
            ]);
        });

        it('should remove rows from the target range when removing multiple ranges', () => {
            const param = {
                ranges: [
                    { startRow: 3, endRow: 4, startColumn: 0, endColumn: 10 },
                    { startRow: 8, endRow: 9, startColumn: 0, endColumn: 10 },
                ],
            } as IRemoveRowColCommandInterceptParams;
            const targetRange = { startRow: 2, endRow: 12, startColumn: 2, endColumn: 8 };

            const result = handleRemoveRowCommon(param, targetRange);

            // The result should have rows 3-4 and 8-9 removed
            expect(result).toEqual([
                { startRow: 2, endRow: 8, startColumn: 2, endColumn: 8 },
            ]);
        });

        it('should return empty array when all rows in the target range are removed', () => {
            const param = {
                range: { startRow: 5, endRow: 8, startColumn: 0, endColumn: 10 },
                unitId: '',
                subUnitId: '',
            };
            const targetRange = { startRow: 5, endRow: 8, startColumn: 2, endColumn: 8 };

            const result = handleRemoveRowCommon(param, targetRange);

            expect(result).toEqual([]);
        });

        it('should handle removing rows at the beginning of the target range', () => {
            const param = {
                range: { startRow: 3, endRow: 5, startColumn: 0, endColumn: 10 },
                unitId: '',
                subUnitId: '',
            };
            const targetRange = { startRow: 3, endRow: 10, startColumn: 2, endColumn: 8 };

            const result = handleRemoveRowCommon(param, targetRange);

            expect(result).toEqual([
                { startRow: 3, endRow: 7, startColumn: 2, endColumn: 8 },
            ]);
        });

        it('should handle removing rows at the end of the target range', () => {
            const param = {
                range: { startRow: 8, endRow: 10, startColumn: 0, endColumn: 10 },
                unitId: '',
                subUnitId: '',
            };
            const targetRange = { startRow: 3, endRow: 10, startColumn: 2, endColumn: 8 };

            const result = handleRemoveRowCommon(param, targetRange);

            expect(result).toEqual([
                { startRow: 3, endRow: 7, startColumn: 2, endColumn: 8 },
            ]);
        });

        it('should handle removing rows outside the target range', () => {
            const param = {
                range: { startRow: 15, endRow: 20, startColumn: 0, endColumn: 10 },
                unitId: '',
                subUnitId: '',
            };
            const targetRange = { startRow: 3, endRow: 10, startColumn: 2, endColumn: 8 };

            const result = handleRemoveRowCommon(param, targetRange);

            // The target range should remain unchanged
            expect(result).toEqual([targetRange]);
        });

        it('should handle removing rows that partially overlap with the target range', () => {
            const param = {
                range: { startRow: 8, endRow: 15, startColumn: 0, endColumn: 10 },
                unitId: '',
                subUnitId: '',
            };
            const targetRange = { startRow: 5, endRow: 12, startColumn: 2, endColumn: 8 };

            const result = handleRemoveRowCommon(param, targetRange);

            expect(result).toEqual([
                { startRow: 5, endRow: 7, startColumn: 2, endColumn: 8 },
            ]);
        });
    });

    describe('test different situations of adjustRangeOnMutation', () => {
        it('should "RemoveSheetMutation" drop all range in the same worksheet', () => {
            const range: IRange = { startRow: 0, endRow: 10, startColumn: 0, endColumn: 10 };
            const mutation = { id: RemoveSheetMutation.id, params: {} as IRemoveSheetMutationParams };
            const result = adjustRangeOnMutation(range, mutation);
            expect(result).toBe(null);
        });

        describe('test move row situations', () => {
            it('should move when the range is contained', () => {
                const range: IRange = { startRow: 1, endRow: 1, startColumn: 1, endColumn: 1 };
                const mutation: IMutationInfo<IMoveRowsMutationParams> = {
                    id: MoveRowsMutation.id,
                    params: {
                        unitId: '',
                        subUnitId: '',
                        sourceRange: { startRow: 0, endRow: 2, startColumn: 0, endColumn: 2 },
                        targetRange: { startRow: 7, endRow: 9, startColumn: 0, endColumn: 2 },
                    },
                };
                const result = adjustRangeOnMutation(range, mutation);
                expect(result).toEqual({ startRow: 5, endRow: 5, startColumn: 1, endColumn: 1 });
            });

            it('should expand when move inside', () => {
                const range: IRange = { startRow: 5, endRow: 7, startColumn: 1, endColumn: 1 };
                const mutation: IMutationInfo<IMoveRowsMutationParams> = {
                    id: MoveRowsMutation.id,
                    params: {
                        unitId: '',
                        subUnitId: '',
                        sourceRange: { startRow: 0, endRow: 2, startColumn: 0, endColumn: 2 },
                        targetRange: { startRow: 6, endRow: 8, startColumn: 0, endColumn: 2 },
                    },
                };
                const result = adjustRangeOnMutation(range, mutation);
                expect(result).toEqual({ startRow: 2, endRow: 7, startColumn: 1, endColumn: 1 });
            });

            it('should expand when move inside 222', () => {
                const range: IRange = { startRow: 7, endRow: 9, startColumn: 1, endColumn: 1 };
                const mutation: IMutationInfo<IMoveRowsMutationParams> = {
                    id: MoveRowsMutation.id,
                    params: {
                        unitId: '',
                        subUnitId: '',
                        sourceRange: { startRow: 0, endRow: 2, startColumn: 0, endColumn: 2 },
                        targetRange: { startRow: 6, endRow: 8, startColumn: 0, endColumn: 2 },
                    },
                };
                const result = adjustRangeOnMutation(range, mutation);
                expect(result).toEqual({ startRow: 7, endRow: 9, startColumn: 1, endColumn: 1 });
            });

            it('should be delete', () => {
                const targetRange: IRange = { startRow: 5, endRow: 7, startColumn: 1, endColumn: 1 };
                const resultRange = handleRemoveRowCommon({ range: { ...targetRange }, unitId: '', subUnitId: '' }, targetRange);
                expect(resultRange.length).toBe(0);

                const resultRange2 = handleRemoveRowCommon({ range: { ...targetRange }, unitId: '', subUnitId: '' }, { ...targetRange, startRow: 4 });
                expect(resultRange2).toEqual([{ startRow: 4, endRow: 4, startColumn: 1, endColumn: 1 }]);
            });

            it('should not be delete ', () => {
                const targetRange: IRange = { startRow: 5, endRow: 7, startColumn: 1, endColumn: 1 };
                const resultRange = handleRemoveRowCommon({ range: { ...targetRange }, unitId: '', subUnitId: '', ranges: [{ startRow: 5, endRow: 5, startColumn: 1, endColumn: 1 }, { startRow: 6, endRow: 6, startColumn: 1, endColumn: 1 }] }, targetRange);
                expect(resultRange).toEqual([{ startRow: 5, endRow: 5, startColumn: 1, endColumn: 1 }]);
            });
        });
    });
});