feat: add reorderrange to ref-range

packages/sheets/src/commands/commands/reorder-range.command.ts

@@ -20,14 +20,17 @@ import type { IAccessor } from '@wendellhu/redi';
 import type { ISheetCommandSharedParams } from '../utils/interface';
 import type { IReorderRangeMutationParams } from '../mutations/reorder-range.mutation';
 import { ReorderRangeMutation, ReorderRangeUndoMutationFactory } from '../mutations/reorder-range.mutation';
+import { SheetInterceptorService } from '../../services/sheet-interceptor/sheet-interceptor.service';
 
 export interface IReorderRangeCommandParams extends ISheetCommandSharedParams {
     range: IRange;
     order: { [key: number]: number };
 }
 
+export const ReorderRangeCommandId = 'sheet.command.reorder-range' as const;
+
 export const ReorderRangeCommand: ICommand<IReorderRangeCommandParams> = {
-    id: 'sheet.command.reorder-range',
+    id: ReorderRangeCommandId,
     type: CommandType.COMMAND,
     handler: (accessor: IAccessor, params: IReorderRangeCommandParams) => {
         const { subUnitId, unitId, range, order } = params;
@@ -47,14 +50,27 @@ export const ReorderRangeCommand: ICommand<IReorderRangeCommandParams> = {
             id: ReorderRangeMutation.id,
             params: ReorderRangeUndoMutationFactory(reorderMutation.params),
         };
+        const sheetInterceptorService = accessor.get(SheetInterceptorService);
+        const interceptorCommands = sheetInterceptorService.onCommandExecute({ id: ReorderRangeCommand.id, params });
+
+        const redos = [
+            ...(interceptorCommands.preRedos ?? []),
+            reorderMutation,
+            ...interceptorCommands.redos,
+        ];
 
-        const result = sequenceExecute([reorderMutation], commandService);
+        const undos = [
+            ...(interceptorCommands.preUndos ?? []),
+            undoReorderMutation,
+            ...interceptorCommands.undos,
+        ];
+        const result = sequenceExecute(redos, commandService);
         if (result.result) {
             const undoRedoService = accessor.get(IUndoRedoService);
             undoRedoService.pushUndoRedo({
                 unitID: unitId,
-                undoMutations: [undoReorderMutation],
-                redoMutations: [reorderMutation],
+                undoMutations: undos,
+                redoMutations: redos,
             });
             return true;
         }

packages/sheets/src/services/ref-range/ref-range.service.ts

@@ -264,6 +264,22 @@ export class RefRangeService extends Disposable {
                             };
                             return this._checkRange([effectRange], unitId, subUnitId);
                         }
+                        case EffectRefRangId.ReorderRangeCommandId: {
+                            const params = command;
+                            const { range, order } = params.params!;
+                            const effectRanges = [];
+                            for (let row = range.startRow; row <= range.endRow; row++) {
+                                if (row in order) {
+                                    effectRanges.push({
+                                        startRow: row,
+                                        endRow: row,
+                                        startColumn: range.startColumn,
+                                        endColumn: range.endColumn,
+                                    });
+                                }
+                            }
+                            return this._checkRange(effectRanges, unitId, subUnitId);
+                        }
                     }
                 };
                 const cbList = getEffectsCbList() || [];

packages/sheets/src/services/ref-range/type.ts

@@ -32,6 +32,8 @@ import type { IMoveColsCommandParams, IMoveRowsCommandParams } from '../../comma
 import { MoveColsCommandId, MoveRowsCommandId } from '../../commands/commands/move-rows-cols.command';
 import type { IRemoveRowColCommandParams } from '../../commands/commands/remove-row-col.command';
 import { RemoveColCommandId, RemoveRowCommandId } from '../../commands/commands/remove-row-col.command';
+import type { IReorderRangeCommandParams } from '../../commands/commands/reorder-range.command';
+import { ReorderRangeCommandId } from '../../commands/commands/reorder-range.command';
 
 export type IMoveRowsCommand = ICommandInfo<IMoveRowsCommandParams> & { id: typeof MoveRowsCommandId };
 export type IMoveColsCommand = ICommandInfo<IMoveColsCommandParams> & { id: typeof MoveColsCommandId };
@@ -55,6 +57,8 @@ export type IInsertRangeMoveRightCommand = ICommandInfo<InsertRangeMoveRightComm
     id: typeof InsertRangeMoveRightCommandId;
 };
 
+export type IReorderRangeCommand = ICommandInfo<IReorderRangeCommandParams> & { id: typeof ReorderRangeCommandId };
+
 export type EffectRefRangeParams =
     | IMoveRangeCommand
     | IInsertRowCommand
@@ -65,7 +69,8 @@ export type EffectRefRangeParams =
     | IInsertRangeMoveDownCommand
     | IInsertRangeMoveRightCommand
     | IMoveColsCommand
-    | IMoveRowsCommand;
+    | IMoveRowsCommand
+    | IReorderRangeCommand;
 
 export const EffectRefRangId = {
     MoveRangeCommandId,
@@ -79,6 +84,7 @@ export const EffectRefRangId = {
     InsertRangeMoveRightCommandId,
     MoveColsCommandId,
     MoveRowsCommandId,
+    ReorderRangeCommandId,
 } as const;
 
 export enum OperatorType {

packages/sheets/src/services/ref-range/util.ts

@@ -38,6 +38,7 @@ import type {
     IMoveRowsCommand,
     IOperator,
     IRemoveRowColCommand,
+    IReorderRangeCommand,
 } from './type';
 import { EffectRefRangId, OperatorType } from './type';
 
@@ -499,6 +500,28 @@ export const handleIRemoveRow = (param: IRemoveRowColCommand, targetRange: IRang
     }
     return operators;
 };
+
+export const handleReorderRange = (param: IReorderRangeCommand, targetRange: IRange) => {
+    const { range, order } = param.params || {};
+    if (!range || !order) {
+        return [];
+    }
+    const operators: IOperator[] = [];
+    const targetRow = targetRange.startRow;
+    for (const k in order) {
+        if (order[k] === targetRow) {
+            const toRow = Number(k);
+            operators.push({
+                type: OperatorType.VerticalMove,
+                step: toRow - targetRow,
+                length: 0,
+            });
+            return operators;
+        }
+    }
+    return [];
+};
+
 // see docs/tldr/ref-range/insert-rows-cols.tldr
 export const handleBaseInsertRange = (_insertRange: IRange, _targetRange: IRange) => {
     const insertRange = handleRangeTypeInput(_insertRange);
@@ -904,6 +927,10 @@ export const handleDefaultRangeChangeWithEffectRefCommands = (range: IRange, com
             operator = handleIRemoveRow(commandInfo as IRemoveRowColCommand, range);
             break;
         }
+        case EffectRefRangId.ReorderRangeCommandId: {
+            operator = handleReorderRange(commandInfo as IReorderRangeCommand, range);
+            break;
+        }
     }
 
     const resultRange = runRefRangeMutations(operator, range);
@@ -1136,6 +1163,22 @@ export function getEffectedRangesOnCommand(command: EffectRefRangeParams, deps:
             }
             return [range];
         }
+        case EffectRefRangId.ReorderRangeCommandId: {
+            const params = command;
+            const { range, order } = params.params!;
+            const effectRanges = [];
+            for (let row = range.startRow; row <= range.endRow; row++) {
+                if (row in order) {
+                    effectRanges.push({
+                        startRow: row,
+                        endRow: row,
+                        startColumn: range.startColumn,
+                        endColumn: range.endColumn,
+                    });
+                }
+            }
+            return effectRanges;
+        }
     }
 }