feat: table sheet undo redo plugin

Author: fangsmile

packages/vtable-plugins/.eslintignore

@@ -0,0 +1,5 @@
+node_modules
+coverage
+dist
+es
+cjs

packages/vtable-plugins/__tests__/auto-fill/formula-integration.test.ts

@@ -0,0 +1,50 @@
+import { createFormulaAdapter, enhanceCellDataWithFormula } from '../../src/auto-fill/formula-integration';
+
+function createTableStub(initial: Record<string, any> = {}) {
+  const store = new Map<string, any>(Object.entries(initial));
+  return {
+    getCellValue: (col: number, row: number) => store.get(`${col}:${row}`),
+    changeCellValue: (col: number, row: number, value: any) => {
+      store.set(`${col}:${row}`, value);
+    }
+  } as any;
+}
+
+test('DefaultFormulaAdapter detects and reads formula string', () => {
+  const table = createTableStub({ '0:0': '=B1' });
+  const adapter = createFormulaAdapter(table);
+  expect(adapter.isFormulaCell(0, 0)).toBe(true);
+  expect(adapter.getCellFormula(0, 0)).toBe('=B1');
+});
+
+test('DefaultFormulaAdapter setCellFormula writes to table value', () => {
+  const table = createTableStub();
+  const adapter = createFormulaAdapter(table);
+  adapter.setCellFormula(1, 2, '=A1+1');
+  expect(table.getCellValue(1, 2)).toBe('=A1+1');
+});
+
+test('CustomFormulaAdapter uses custom functions when provided', () => {
+  const table = createTableStub({ '0:0': { f: 'SUM(A1:A2)' } });
+  const adapter = createFormulaAdapter(
+    table,
+    (_c, _r, cellData) => Boolean(cellData?.f),
+    (_c, _r, cellData) => (cellData?.f ? `=${cellData.f}` : undefined),
+    (c, r, formula) => table.changeCellValue(c, r, { f: formula.replace(/^=/, '') })
+  );
+
+  expect(adapter.isFormulaCell(0, 0)).toBe(true);
+  expect(adapter.getCellFormula(0, 0)).toBe('=SUM(A1:A2)');
+
+  adapter.setCellFormula(0, 1, '=A1+1');
+  expect(table.getCellValue(0, 1)).toEqual({ f: 'A1+1' });
+});
+
+test('enhanceCellDataWithFormula attaches formula metadata for formula cells', () => {
+  const table = createTableStub({ '0:0': '=B1' });
+  const adapter = createFormulaAdapter(table);
+  const cellData = { value: '=B1', col: 0, row: 0 } as any;
+  const enhanced = enhanceCellDataWithFormula(cellData, 0, 0, adapter);
+  expect(enhanced.isFormula).toBe(true);
+  expect(enhanced.formula).toBe('=B1');
+});

packages/vtable-plugins/__tests__/history-plugin-formula-undo.test.ts

@@ -0,0 +1,116 @@
+export {};
+
+const CHANGE_CELL_VALUE = 'change_cell_value';
+const CHANGE_CELL_VALUES = 'change_cell_values';
+
+jest.mock('@visactor/vtable', () => ({
+  TABLE_EVENT_TYPE: {
+    BEFORE_KEYDOWN: 'before_keydown',
+    CHANGE_CELL_VALUE,
+    CHANGE_CELL_VALUES,
+    PASTED_DATA: 'pasted_data',
+    ADD_RECORD: 'add_record',
+    DELETE_RECORD: 'delete_record',
+    UPDATE_RECORD: 'update_record',
+    ADD_COLUMN: 'add_column',
+    DELETE_COLUMN: 'delete_column',
+    CHANGE_HEADER_POSITION: 'change_header_position',
+    RESIZE_ROW: 'resize_row',
+    RESIZE_ROW_END: 'resize_row_end',
+    RESIZE_COLUMN: 'resize_column',
+    RESIZE_COLUMN_END: 'resize_column_end'
+  }
+}));
+
+const { HistoryPlugin } = require('../src/history');
+
+function createTestEnv() {
+  const handlers: Record<string, Function[]> = {};
+  const eventManager = {
+    on: (type: string, cb: any) => {
+      handlers[type] = handlers[type] || [];
+      handlers[type].push(cb);
+    },
+    off: (type: string, cb: any) => {
+      const list = handlers[type] || [];
+      const idx = list.indexOf(cb);
+      if (idx >= 0) {
+        list.splice(idx, 1);
+      }
+    },
+    emit: (type: string, event: any) => {
+      (handlers[type] || []).forEach(cb => cb(event));
+    }
+  };
+
+  const formulaStore = new Map<string, string>();
+  const formulaManager = {
+    getCellFormula: (cell: any) => {
+      return formulaStore.get(`${cell.sheet}:${cell.row}:${cell.col}`);
+    },
+    setCellContent: (cell: any, value: any) => {
+      const key = `${cell.sheet}:${cell.row}:${cell.col}`;
+      if (typeof value === 'string' && value.startsWith('=')) {
+        formulaStore.set(key, value);
+      } else {
+        formulaStore.delete(key);
+      }
+    },
+    getCellValue: (_cell: any) => {
+      return { value: 28, error: undefined as string | undefined };
+    },
+    getCellDependents: (): any[] => []
+  };
+
+  const worksheet = {
+    eventManager,
+    tableInstance: null as any
+  };
+
+  const vtableSheet = {
+    formulaManager,
+    getWorkSheetByKey: (_sheetKey: string) => worksheet,
+    workSheetInstances: new Map([['sheet1', worksheet]])
+  };
+
+  const changeCellValueCalls: any[] = [];
+  const table: any = {
+    __vtableSheet: vtableSheet,
+    options: {},
+    records: [],
+    editorManager: { editingEditor: null },
+    changeCellValue: (...args: any[]) => {
+      changeCellValueCalls.push(args);
+    }
+  };
+  worksheet.tableInstance = table;
+
+  return { eventManager, formulaManager, table, vtableSheet, changeCellValueCalls };
+}
+
+test('HistoryPlugin undo twice restores blank after two formula edits', () => {
+  const env = createTestEnv();
+  const plugin = new HistoryPlugin();
+
+  plugin.run({ row: 4, col: 1, currentValue: '' } as any, CHANGE_CELL_VALUE as any, env.table as any);
+  env.formulaManager.setCellContent({ sheet: 'sheet1', row: 4, col: 1 }, '=sum(B4)');
+  env.eventManager.emit('formula_added', { cell: { row: 4, col: 1 }, formula: '=sum(B4)' });
+
+  plugin.run(
+    {
+      values: [{ row: 4, col: 1, currentValue: '', changedValue: 28 }]
+    } as any,
+    CHANGE_CELL_VALUES as any,
+    env.table as any
+  );
+
+  plugin.run({ row: 4, col: 1, currentValue: 28 } as any, CHANGE_CELL_VALUE as any, env.table as any);
+  env.formulaManager.setCellContent({ sheet: 'sheet1', row: 4, col: 1 }, '=sum(B3:B4)');
+  env.eventManager.emit('formula_added', { cell: { row: 4, col: 1 }, formula: '=sum(B3:B4)' });
+
+  plugin.undo();
+  expect(env.formulaManager.getCellFormula({ sheet: 'sheet1', row: 4, col: 1 })).toBe('=sum(B4)');
+
+  plugin.undo();
+  expect(env.formulaManager.getCellFormula({ sheet: 'sheet1', row: 4, col: 1 })).toBeUndefined();
+});