Skip to content

armgit / macro

Public Imported from GitHub
0

Macro is a unified workspace for teams: email, chat, docs, tasks, agents, calls, and CRM — @-linked together with shared AI memory.

25.7 KB
Raw Blame
import { LoroDoc } from 'loro-crdt';
import { createRoot, createSignal } from 'solid-js';
import { describe, expect, it, vi } from 'vitest';
import type { SpreadsheetDocumentSource } from '../context/spreadsheet-source';
import {
  DEFAULT_SHEET_ID,
  readSpreadsheetCells,
  readSpreadsheetLayout,
  resizeSpreadsheetColumn,
  type SpreadsheetSelection,
  writeSpreadsheetCells,
} from '../core/spreadsheet-document';
import {
  addSpreadsheetSheet,
  deleteSpreadsheetSheet,
  moveSpreadsheetSheet,
  readSpreadsheetSheets,
} from '../core/workbook-document';
import { createSpreadsheetStore } from './create-spreadsheet-store';

describe('spreadsheet store', () => {
  it('applies structural patches as one undo step and rejects stale collaborator snapshots', async () => {
    const doc = new LoroDoc();
    writeSpreadsheetCells(doc, {
      A1: { value: '10', bold: true },
      A2: { value: '20' },
    });
    let dispose = () => {};
    const store = createRoot((cleanup) => {
      dispose = cleanup;
      return createSpreadsheetStore({
        canEdit: () => true,
        source: {
          doc: () => doc,
          ready: () => true,
          error: () => undefined,
          status: () => 'local',
          peers: () => [],
          setSelection: () => {},
        },
      });
    });
    await Promise.resolve();
    // Live cells change in place; structural edits compare by revision.
    const before = structuredClone(store.workbook());
    const next = before.map((sheet) => ({
      ...sheet,
      cells: { A2: sheet.cells.A1, A3: sheet.cells.A2 },
      metadata: { hiddenRows: [1] },
    }));
    store.applyStructure(before, next, store.revision());
    expect(store.cells().A1).toBeUndefined();
    expect(store.cells().A2).toEqual({ value: '10', bold: true });
    store.undo();
    expect(store.cells()).toEqual(before[0].cells);
    expect(store.activeSheet().metadata?.hiddenRows).toBeUndefined();
    const revision = store.revision();
    const peer = new LoroDoc();
    peer.import(doc.export({ mode: 'snapshot' }));
    writeSpreadsheetCells(peer, { B1: { value: 'New collaborator edit' } });
    doc.import(peer.export({ mode: 'update' }));
    expect(() => store.applyStructure(before, next, revision)).toThrow(
      'workbook changed'
    );
    expect(readSpreadsheetCells(doc).B1.value).toBe('New collaborator edit');
    dispose();
    peer.free();
    doc.free();
  });

  it("rejects a shift prepared before a collaborator's width or layout change", async () => {
    const doc = new LoroDoc();
    writeSpreadsheetCells(doc, { A1: { value: 'Name' } });
    resizeSpreadsheetColumn(doc, 1, 150);
    let dispose = () => {};
    const store = createRoot((cleanup) => {
      dispose = cleanup;
      return createSpreadsheetStore({
        canEdit: () => true,
        source: {
          doc: () => doc,
          ready: () => true,
          error: () => undefined,
          status: () => 'connected',
          peers: () => [],
          setSelection: () => {},
        },
      });
    });
    await Promise.resolve();
    store.setMetadata({ hiddenColumns: [1] });
    const peer = new LoroDoc();
    peer.import(doc.export({ mode: 'snapshot' }));
    // Insert a column at A, as the calculation worker would return it.
    const shift = () => {
      const before = structuredClone(store.workbook());
      const next = before.map((sheet) => ({
        ...sheet,
        cells: { B1: sheet.cells.A1 },
        metadata: { ...sheet.metadata, hiddenColumns: [2] },
        layout: {
          ...sheet.layout,
          columnCount: sheet.layout.columnCount + 1,
          columnWidths: Object.fromEntries(
            Object.entries(sheet.layout.columnWidths).map(([key, width]) => [
              Number(key) + 1,
              width,
            ])
          ),
        },
      }));
      return { before, next, revision: store.revision() };
    };
    const sync = () => {
      doc.import(peer.export({ mode: 'update', from: doc.oplogVersion() }));
      peer.import(doc.export({ mode: 'update', from: peer.oplogVersion() }));
    };

    let pending = shift();
    resizeSpreadsheetColumn(peer, 2, 240);
    sync();
    expect(() =>
      store.applyStructure(pending.before, pending.next, pending.revision)
    ).toThrow('workbook changed');
    expect(readSpreadsheetLayout(doc).columnWidths[2]).toBe(240);
    expect(store.cells().A1.value).toBe('Name');

    pending = shift();
    peer
      .getMap('spreadsheetSheetMetadata')
      .set(
        DEFAULT_SHEET_ID,
        JSON.stringify({ hiddenColumns: [1], hiddenRows: [4] })
      );
    peer.commit();
    sync();
    expect(() =>
      store.applyStructure(pending.before, pending.next, pending.revision)
    ).toThrow('workbook changed');
    expect(store.activeSheet().metadata).toEqual({
      hiddenColumns: [1],
      hiddenRows: [4],
    });

    // A shift prepared after both changes moves them with the cells.
    pending = shift();
    store.applyStructure(pending.before, pending.next, pending.revision);
    expect(store.cells().B1.value).toBe('Name');
    expect(readSpreadsheetLayout(doc).columnWidths[3]).toBe(240);
    expect(store.activeSheet().metadata?.hiddenRows).toEqual([4]);
    dispose();
    peer.free();
    doc.free();
  });

  it('shifts coordinates in a connected workbook and keeps inserted columns', async () => {
    const doc = new LoroDoc();
    writeSpreadsheetCells(doc, { A1: { value: 'Name' }, B1: { value: '=A1' } });
    let dispose = () => {};
    const store = createRoot((cleanup) => {
      dispose = cleanup;
      return createSpreadsheetStore({
        canEdit: () => true,
        source: {
          doc: () => doc,
          ready: () => true,
          error: () => undefined,
          status: () => 'connected',
          peers: () => [],
          setSelection: () => {},
        },
      });
    });
    await Promise.resolve();
    expect(store.canChangeStructure()).toBe(true);
    const before = structuredClone(store.workbook());
    const columns = before[0].layout.columnCount;
    const next = before.map((sheet) => ({
      ...sheet,
      cells: { B1: sheet.cells.A1, C1: { ...sheet.cells.B1, value: '=B1' } },
      layout: { ...sheet.layout, columnCount: columns + 1 },
    }));
    store.applyStructure(before, next, store.revision());
    expect(store.cells().A1).toBeUndefined();
    expect(store.cells().B1.value).toBe('Name');
    expect(store.cells().C1.value).toBe('=B1');
    expect(readSpreadsheetLayout(doc).columnCount).toBe(columns + 1);
    store.undo();
    expect(store.cells().A1.value).toBe('Name');
    expect(readSpreadsheetLayout(doc).columnCount).toBe(columns);
    dispose();
    doc.free();
  });

  it.each(['connecting', 'offline'] as const)(
    'rejects coordinate shifts for a %s collaborative source',
    async (status) => {
      const doc = new LoroDoc();
      writeSpreadsheetCells(doc, { A1: { value: 'Keep me' } });
      let dispose = () => {};
      const store = createRoot((cleanup) => {
        dispose = cleanup;
        return createSpreadsheetStore({
          canEdit: () => true,
          source: {
            doc: () => doc,
            ready: () => true,
            error: () => undefined,
            status: () => status,
            peers: () => [],
            setSelection: () => {},
          },
        });
      });
      await Promise.resolve();
      const before = store.workbook(),
        version = doc.version().toJSON();
      expect(store.canChangeStructure()).toBe(false);
      expect(() =>
        store.applyStructure(before, before, store.revision())
      ).toThrow('Reconnect');
      expect(doc.version().toJSON()).toEqual(version);
      dispose();
      doc.free();
    }
  );
  it('reports blocked structural history through its error accessor and preserves the undo step', async () => {
    const doc = new LoroDoc();
    const peer = new LoroDoc();
    const id = addSpreadsheetSheet(doc, 'Before');
    let dispose = () => {};
    const store = createRoot((cleanup) => {
      dispose = cleanup;
      return createSpreadsheetStore({
        canEdit: () => true,
        source: {
          doc: () => doc,
          ready: () => true,
          error: () => undefined,
          status: () => 'local',
          peers: () => [],
          setSelection: () => {},
        },
      });
    });
    await Promise.resolve();
    store.renameSheet(id, 'After');
    peer.import(doc.export({ mode: 'update' }));
    writeSpreadsheetCells(peer, { A1: { value: '=After!A1' } });
    doc.import(peer.export({ mode: 'update' }));
    const version = doc.version().toJSON();
    store.undo();
    expect(store.error()).toContain('a formula references');
    expect(doc.version().toJSON()).toEqual(version);
    expect(store.canUndo()).toBe(true);
    expect(store.canRedo()).toBe(false);
    writeSpreadsheetCells(peer, { A1: { value: '' } });
    doc.import(peer.export({ mode: 'update' }));
    store.undo();
    expect(store.error()).toBeUndefined();
    expect(store.sheets()).toContainEqual({ id, name: 'Before' });
    dispose();
    peer.free();
    doc.free();
  });

  it('moves sheets as undoable steps that merge with a collaborator moving another sheet', async () => {
    const doc = new LoroDoc();
    const peer = new LoroDoc();
    const b = addSpreadsheetSheet(doc, 'B');
    const c = addSpreadsheetSheet(doc, 'C');
    const d = addSpreadsheetSheet(doc, 'D');
    let dispose = () => {};
    const store = createRoot((cleanup) => {
      dispose = cleanup;
      return createSpreadsheetStore({
        canEdit: () => true,
        source: {
          doc: () => doc,
          ready: () => true,
          error: () => undefined,
          status: () => 'connected',
          peers: () => [],
          setSelection: () => {},
        },
      });
    });
    await Promise.resolve();
    const names = () => store.sheets().map((sheet) => sheet.name);
    store.moveSheet(d, 0);
    expect(names()).toEqual(['D', 'Sheet1', 'B', 'C']);
    store.moveSheet(DEFAULT_SHEET_ID, 3);
    expect(names()).toEqual(['D', 'B', 'C', 'Sheet1']);
    store.undo();
    expect(names()).toEqual(['D', 'Sheet1', 'B', 'C']);
    store.redo();
    expect(names()).toEqual(['D', 'B', 'C', 'Sheet1']);
    store.moveSheet(b, 1);
    expect(names()).toEqual(['D', 'B', 'C', 'Sheet1']);

    peer.import(doc.export({ mode: 'snapshot' }));
    moveSpreadsheetSheet(peer, c, 0);
    store.moveSheet(DEFAULT_SHEET_ID, 1);
    doc.import(peer.export({ mode: 'update' }));
    peer.import(doc.export({ mode: 'update' }));
    expect(names()).toEqual(['C', 'D', 'Sheet1', 'B']);
    expect(readSpreadsheetSheets(peer).map((sheet) => sheet.name)).toEqual(
      names()
    );
    dispose();
    peer.free();
    doc.free();
  });

  it('renumbers sheets whose orders tie when moving between them', () => {
    const doc = new LoroDoc();
    const b = addSpreadsheetSheet(doc, 'B');
    const c = addSpreadsheetSheet(doc, 'C');
    const order = doc.getMap('spreadsheetSheetOrder');
    order.set(b, 5);
    order.set(c, 5);
    doc.commit();
    // Equal orders sort by sheet id.
    const [, first, second] = readSpreadsheetSheets(doc).map(
      (sheet) => sheet.name
    );
    moveSpreadsheetSheet(doc, DEFAULT_SHEET_ID, 1);
    expect(readSpreadsheetSheets(doc).map((sheet) => sheet.name)).toEqual([
      first,
      'Sheet1',
      second,
    ]);
    expect(Object.values(order.toJSON()).sort()).toEqual([0, 1, 2]);
    expect(() => moveSpreadsheetSheet(doc, 'missing', 0)).toThrow(
      'no longer exists'
    );
    doc.free();
  });

  it.each(['readonly', 'hydrating'] as const)(
    'does not revive a retained fallback while %s',
    async (state) => {
      const doc = new LoroDoc();
      doc.getMap('spreadsheetDeletedSheets').set(DEFAULT_SHEET_ID, true);
      doc.commit();
      const version = doc.version().toJSON();
      let dispose = () => {};
      const store = createRoot((cleanup) => {
        dispose = cleanup;
        return createSpreadsheetStore({
          canEdit: () => state !== 'readonly',
          source: {
            doc: () => doc,
            ready: () => state !== 'hydrating',
            error: () => undefined,
            status: () => 'local',
            peers: () => [],
            setSelection: () => {},
          },
        });
      });
      await Promise.resolve();
      expect(store.activeSheetId()).toBe(DEFAULT_SHEET_ID);
      store.setCells({ A1: { value: 'blocked' } });
      store.resizeColumn(0, 200);
      store.appendRows(100);
      store.renameSheet(DEFAULT_SHEET_ID, 'Blocked');
      store.addSheet('Blocked');
      store.duplicateSheet(DEFAULT_SHEET_ID);
      store.moveSheet(DEFAULT_SHEET_ID, 1);
      store.undo();
      expect(doc.version().toJSON()).toEqual(version);
      expect(doc.getMap('spreadsheetDeletedSheets').get(DEFAULT_SHEET_ID)).toBe(
        true
      );
      expect(doc.getMap('spreadsheetSheetRevivals').toJSON()).toEqual({});
      dispose();
      doc.free();
    }
  );

  it('keeps active sheets local and routes cells, layout and presence to the selected sheet', async () => {
    const doc = new LoroDoc();
    const selections: (SpreadsheetSelection | undefined)[] = [];
    const source: SpreadsheetDocumentSource = {
      doc: () => doc,
      ready: () => true,
      error: () => undefined,
      status: () => 'local',
      peers: () => [],
      setSelection: (selection) => {
        selections.push(selection);
      },
    };
    let dispose = () => {};
    const { alice, bob } = createRoot((cleanup) => {
      dispose = cleanup;
      return {
        alice: createSpreadsheetStore({ source, canEdit: () => true }),
        bob: createSpreadsheetStore({ source, canEdit: () => true }),
      };
    });
    await Promise.resolve();
    const id = alice.addSheet('Budget')!;
    expect(alice.activeSheetId()).toBe(id);
    expect(bob.activeSheetId()).toBe(DEFAULT_SHEET_ID);
    alice.setCells({ A1: { value: 'budget' } });
    alice.resizeColumn(0, 300);
    alice.appendRows(50);
    expect(alice.rowCount()).toBe(250);
    alice.setSelection({ anchor: 'A1', focus: 'B2' });
    expect(alice.selection()).toEqual({
      anchor: 'A1',
      focus: 'B2',
      sheetId: id,
    });
    expect(bob.selection()).toBeUndefined();
    expect(selections.at(-1)).toEqual({
      anchor: 'A1',
      focus: 'B2',
      sheetId: id,
    });
    alice.setActiveSheet(DEFAULT_SHEET_ID);
    expect(alice.cells()).toEqual({});
    expect(alice.rowCount()).toBe(200);
    expect(alice.layout().columnWidths).toEqual({});
    expect(selections.at(-1)).toBeUndefined();
    alice.setActiveSheet(id);
    expect(alice.selection()).toEqual({
      anchor: 'A1',
      focus: 'B2',
      sheetId: id,
    });
    expect(selections.at(-1)).toEqual(alice.selection());
    expect(alice.cells().A1.value).toBe('budget');
    expect(alice.layout().columnWidths[0]).toBe(300);
    const version = doc.version().toJSON();
    alice.setActiveSheet(DEFAULT_SHEET_ID);
    expect(doc.version().toJSON()).toEqual(version);
    dispose();
    doc.free();
  });

  it.each(['switch', 'delete'] as const)(
    'publishes the restored cursor on sheet %s and cancels pending old-sheet presence',
    async (action) => {
      vi.useFakeTimers();
      const doc = new LoroDoc();
      const publish = vi.fn();
      let dispose = () => {};
      try {
        const store = createRoot((cleanup) => {
          dispose = cleanup;
          return createSpreadsheetStore({
            canEdit: () => true,
            source: {
              doc: () => doc,
              ready: () => true,
              error: () => undefined,
              status: () => 'local',
              peers: () => [],
              setSelection: publish,
            },
          });
        });
        await Promise.resolve();
        store.setSelection({ anchor: 'C3', focus: 'E5' });
        const restored = store.selection();
        const other = store.addSheet('Other')!;
        store.setSelection({ anchor: 'A1', focus: 'A1' });
        store.setSelection({ anchor: 'A1', focus: 'B2' });
        if (action === 'switch') store.setActiveSheet(DEFAULT_SHEET_ID);
        else {
          deleteSpreadsheetSheet(doc, other);
          await Promise.resolve();
        }
        expect(store.activeSheetId()).toBe(DEFAULT_SHEET_ID);
        expect(store.selection()).toEqual(restored);
        expect(publish).toHaveBeenLastCalledWith(restored);
        const calls = publish.mock.calls.length;
        await vi.advanceTimersByTimeAsync(200);
        expect(publish).toHaveBeenCalledTimes(calls);
        expect(publish).toHaveBeenLastCalledWith(restored);
      } finally {
        dispose();
        doc.free();
        vi.useRealTimers();
      }
    }
  );

  it('filters remote cursors by sheet and treats legacy presence as Sheet1', async () => {
    const doc = new LoroDoc();
    const source: SpreadsheetDocumentSource = {
      doc: () => doc,
      ready: () => true,
      error: () => undefined,
      status: () => 'local',
      setSelection: () => {},
      peers: () => [
        {
          peerId: 'legacy',
          color: '#123456',
          selection: { anchor: 'A1', focus: 'A1' },
        },
      ],
    };
    let dispose = () => {};
    const store = createRoot((cleanup) => {
      dispose = cleanup;
      return createSpreadsheetStore({ source, canEdit: () => true });
    });
    await Promise.resolve();
    expect(store.peers()).toHaveLength(1);
    const id = store.addSheet('Other')!;
    expect(store.peers()).toHaveLength(0);
    source.peers = () => [
      {
        peerId: 'new',
        color: '#123456',
        selection: { anchor: 'A1', focus: 'A1', sheetId: id },
      },
    ];
    expect(store.peers()).toHaveLength(1);
    store.setActiveSheet(DEFAULT_SHEET_ID);
    expect(store.peers()).toHaveLength(0);
    dispose();
    doc.free();
  });

  it('falls back after a remote deletion and restores an imported workbook in one undo', async () => {
    const doc = new LoroDoc();
    const source: SpreadsheetDocumentSource = {
      doc: () => doc,
      ready: () => true,
      error: () => undefined,
      status: () => 'local',
      peers: () => [],
      setSelection: () => {},
    };
    let dispose = () => {};
    const store = createRoot((cleanup) => {
      dispose = cleanup;
      return createSpreadsheetStore({ source, canEdit: () => true });
    });
    await Promise.resolve();
    const id = store.addSheet('Other')!;
    deleteSpreadsheetSheet(doc, id);
    await vi.waitFor(() =>
      expect(store.activeSheetId()).toBe(DEFAULT_SHEET_ID)
    );
    store.setCells({ A1: { value: 'original' } });
    const ids = await store.replaceWorkbook([
      {
        name: 'Imported',
        cells: { A1: { value: 'imported' } },
        rowCount: 300,
        columnWidths: {},
      },
      {
        name: 'Summary',
        cells: { A1: { value: '=Imported!A1' } },
        rowCount: 200,
        columnWidths: {},
      },
    ]);
    expect(store.activeSheetId()).toBe(ids[0]);
    expect(store.workbook()).toHaveLength(2);
    store.undo();
    expect(store.activeSheetId()).toBe(DEFAULT_SHEET_ID);
    expect(store.cells().A1.value).toBe('original');
    store.redo();
    expect(store.workbook().map((sheet) => sheet.name)).toEqual([
      'Imported',
      'Summary',
    ]);
    dispose();
    doc.free();
  });

  it('writes a large import in steps that undo as one', async () => {
    const doc = new LoroDoc();
    const source: SpreadsheetDocumentSource = {
      doc: () => doc,
      ready: () => true,
      error: () => undefined,
      status: () => 'local',
      peers: () => [],
      setSelection: () => {},
    };
    let dispose = () => {};
    const store = createRoot((cleanup) => {
      dispose = cleanup;
      return createSpreadsheetStore({ source, canEdit: () => true });
    });
    await Promise.resolve();
    store.setCells({ A1: { value: 'original' } });
    const cells: Record<string, { value: string; numberFormat?: string }> = {};
    for (let row = 1; row <= 6_000; row++) {
      cells[`A${row}`] = {
        value: String(45_000 + row),
        numberFormat: 'm/d/yyyy',
      };
      cells[`B${row}`] = { value: `=A${row}+1` };
    }
    const progress: number[] = [];
    const commits: string[] = [];
    const unsubscribe = doc.subscribeLocalUpdates(() => commits.push('update'));
    const [id] = await store.replaceWorkbook(
      [{ name: 'Large', cells, rowCount: 6_000, columnWidths: {} }],
      { onProgress: (fraction) => progress.push(fraction) }
    );
    unsubscribe();
    // 12,000 cells take several commits, each reported, and a registration.
    expect(progress.length).toBeGreaterThan(1);
    expect(progress).toEqual([...progress].sort((a, b) => a - b));
    expect(progress.at(-1)).toBe(1);
    expect(commits.length).toBe(progress.length + 1);
    expect(store.activeSheetId()).toBe(id);
    expect(Object.keys(store.cells())).toHaveLength(12_000);
    expect(store.cells().A6000).toEqual({
      value: '51000',
      numberFormat: 'm/d/yyyy',
    });
    store.undo();
    expect(store.workbook().map((sheet) => sheet.name)).toEqual(['Sheet1']);
    expect(store.cells().A1.value).toBe('original');
    store.redo();
    expect(store.workbook().map((sheet) => sheet.name)).toEqual(['Large']);
    expect(Object.keys(store.cells())).toHaveLength(12_000);
    dispose();
    doc.free();
  });

  it('blocks workbook mutations while read-only without blocking tab selection', async () => {
    const doc = new LoroDoc();
    const [canEdit, setCanEdit] = createSignal(true);
    const source: SpreadsheetDocumentSource = {
      doc: () => doc,
      ready: () => true,
      error: () => undefined,
      status: () => 'local',
      peers: () => [],
      setSelection: () => {},
    };
    let dispose = () => {};
    const store = createRoot((cleanup) => {
      dispose = cleanup;
      return createSpreadsheetStore({ source, canEdit });
    });
    await Promise.resolve();
    const id = store.addSheet('Budget')!;
    setCanEdit(false);
    const version = doc.version().toJSON();
    expect(store.addSheet('blocked')).toBeUndefined();
    expect(store.duplicateSheet(id)).toBeUndefined();
    store.renameSheet(id, 'blocked');
    store.deleteSheet(id);
    expect(
      await store.appendSheets([
        { name: 'blocked', cells: {}, rowCount: 200, columnWidths: {} },
      ])
    ).toEqual([]);
    expect(
      await store.replaceWorkbook([
        { name: 'blocked', cells: {}, rowCount: 200, columnWidths: {} },
      ])
    ).toEqual([]);
    expect(doc.version().toJSON()).toEqual(version);
    store.setActiveSheet(DEFAULT_SHEET_ID);
    expect(store.activeSheetId()).toBe(DEFAULT_SHEET_ID);
    expect(store.sheets()).toHaveLength(2);
    dispose();
    doc.free();
  });

  it('blocks writes before hydration and while read-only', async () => {
    const doc = new LoroDoc();
    const [ready, setReady] = createSignal(false);
    const [canEdit, setCanEdit] = createSignal(true);
    const source: SpreadsheetDocumentSource = {
      doc: () => doc,
      ready,
      error: () => undefined,
      status: () => 'local',
      peers: () => [],
      setSelection: () => {},
    };
    let dispose = () => {};
    const store = createRoot((cleanup) => {
      dispose = cleanup;
      return createSpreadsheetStore({ source, canEdit });
    });
    await Promise.resolve();
    store.setCells({ A1: { value: 'too early' } });
    store.appendRows(100);
    store.resizeColumn(0, 240);
    expect(readSpreadsheetLayout(doc)).toEqual({
      rowCount: 200,
      columnCount: 26,
      columnWidths: {},
    });
    expect(readSpreadsheetCells(doc)).toEqual({});
    setReady(true);
    store.setCells({ A1: { value: 'allowed' } });
    expect(store.cells().A1.value).toBe('allowed');
    expect(store.canUndo()).toBe(true);
    setCanEdit(false);
    store.setCells({ A1: { value: 'denied' } });
    store.appendRows(100);
    store.resizeColumn(0, 240);
    expect(readSpreadsheetLayout(doc)).toEqual({
      rowCount: 200,
      columnCount: 26,
      columnWidths: {},
    });
    store.undo();
    expect(store.cells().A1.value).toBe('allowed');
    expect(store.canUndo()).toBe(false);
    setCanEdit(true);
    store.undo();
    expect(store.cells()).toEqual({});
    store.appendRows(100);
    store.resizeColumn(0, 240);
    expect(store.rowCount()).toBe(300);
    expect(store.layout().columnWidths[0]).toBe(240);
    store.undo();
    expect(store.layout().columnWidths[0]).toBeUndefined();
    store.undo();
    expect(store.rowCount()).toBe(200);
    dispose();
    doc.free();
  });

  it('grows a table with a value typed beside it in one undo step', async () => {
    const doc = new LoroDoc();
    writeSpreadsheetCells(doc, {
      A1: { value: 'Item' },
      B1: { value: 'Qty' },
      A2: { value: 'Pens' },
      B2: { value: '2' },
    });
    let dispose = () => {};
    const store = createRoot((cleanup) => {
      dispose = cleanup;
      return createSpreadsheetStore({
        canEdit: () => true,
        source: {
          doc: () => doc,
          ready: () => true,
          error: () => undefined,
          status: () => 'local',
          peers: () => [],
          setSelection: () => {},
        },
      });
    });
    await Promise.resolve();
    store.editSheets([
      {
        sheetId: DEFAULT_SHEET_ID,
        edits: {},
        metadata: {
          tables: [
            {
              name: 'Sales',
              range: 'A1:B2',
              totalsRow: false,
              bandedRows: true,
            },
          ],
        },
      },
    ]);
    store.setCells({ C2: { value: 'blue' } });
    expect(store.cells().C1.value).toBe('Column3');
    expect(store.activeSheet().metadata?.tables?.[0].range).toBe('A1:C2');
    store.setCells({ A3: { value: 'Ink' } });
    expect(store.activeSheet().metadata?.tables?.[0].range).toBe('A1:C3');
    store.undo();
    expect(store.cells().A3).toBeUndefined();
    expect(store.activeSheet().metadata?.tables?.[0].range).toBe('A1:C2');
    store.undo();
    expect(store.cells().C1).toBeUndefined();
    expect(store.activeSheet().metadata?.tables?.[0].range).toBe('A1:B2');
    dispose();
    doc.free();
  });
});