@veltra/sheet 2.0.0

package/src/core/__test__/formula-parser.test.ts

@@ -0,0 +1,160 @@
+import { describe, expect, it } from 'vitest'
+
+import { parseRange, type CellAddress } from '../address'
+import { parseFormula } from '../formula/parser'
+import { FormulaParseError } from '../formula/tokenizer'
+import { Sheet } from '../sheet'
+import { Workbook } from '../workbook'
+
+const A1 = { row: 0, col: 0 }
+const B1 = { row: 0, col: 1 }
+const B2 = { row: 1, col: 1 }
+
+/** 写入公式并读回 CellData */
+function calc(sheet: Sheet, addr: CellAddress, formula: string) {
+  sheet.setCellFormula(addr, formula)
+  return sheet.getCellData(addr)
+}
+
+describe('公式解析：AST 形态', () => {
+  it('二元优先级：1+2*3 → 1+(2*3)', () => {
+    expect(parseFormula('1+2*3')).toEqual({
+      kind: 'binary',
+      op: '+',
+      left: { kind: 'number', value: 1 },
+      right: {
+        kind: 'binary',
+        op: '*',
+        left: { kind: 'number', value: 2 },
+        right: { kind: 'number', value: 3 }
+      }
+    })
+  })
+
+  it('括号改变优先级：(1+2)*3', () => {
+    const ast = parseFormula('(1+2)*3')
+    expect(ast).toMatchObject({ kind: 'binary', op: '*', left: { op: '+' } })
+  })
+
+  it('单元格引用 / 区域 / 跨表 / 带引号表名', () => {
+    expect(parseFormula('A1')).toEqual({ kind: 'cell', sheet: undefined, addr: A1 })
+    expect(parseFormula('A1:B9')).toEqual({
+      kind: 'range',
+      sheet: undefined,
+      range: parseRange('A1:B9')
+    })
+    expect(parseFormula('Sheet2!A1')).toEqual({ kind: 'cell', sheet: 'Sheet2', addr: A1 })
+    expect(parseFormula("'My Sheet'!A1")).toEqual({ kind: 'cell', sheet: 'My Sheet', addr: A1 })
+    expect(parseFormula("'S2'!A1:B2")).toEqual({
+      kind: 'range',
+      sheet: 'S2',
+      range: parseRange('A1:B2')
+    })
+  })
+
+  it('绝对引用 $A$1 等价 A1', () => {
+    expect(parseFormula('$A$1')).toEqual({ kind: 'cell', sheet: undefined, addr: A1 })
+  })
+
+  it('一元负号紧于幂次（Excel 行为）：-2^2 → (-2)^2', () => {
+    const ast = parseFormula('-2^2')
+    expect(ast).toMatchObject({
+      kind: 'binary',
+      op: '^',
+      left: { kind: 'unary', op: '-', operand: { kind: 'number', value: 2 } }
+    })
+  })
+
+  it('幂次右结合：2^3^2 → 2^(3^2)', () => {
+    const ast = parseFormula('2^3^2')
+    expect(ast).toMatchObject({
+      kind: 'binary',
+      op: '^',
+      left: { kind: 'number', value: 2 },
+      right: { kind: 'binary', op: '^' }
+    })
+  })
+
+  it('百分号后缀与函数调用', () => {
+    expect(parseFormula('50%')).toEqual({ kind: 'percent', operand: { kind: 'number', value: 50 } })
+    expect(parseFormula('SUM(A1:A10, 2)')).toMatchObject({
+      kind: 'call',
+      name: 'SUM',
+      args: [{ kind: 'range' }, { kind: 'number', value: 2 }]
+    })
+  })
+
+  it('布尔字面量与未知名称', () => {
+    expect(parseFormula('TRUE')).toEqual({ kind: 'boolean', value: true })
+    expect(parseFormula('false')).toEqual({ kind: 'boolean', value: false })
+    // 列限 3 字母：Sheet2 不是合法单元格引用 → 未知名称节点
+    expect(parseFormula('Sheet2')).toEqual({ kind: 'name', name: 'Sheet2' })
+  })
+
+  it('非法输入抛 FormulaParseError', () => {
+    for (const text of ['1+', 'SUM(A1', '*2', 'A1:', "'OnlyName'", '1 2', '()']) {
+      expect(() => parseFormula(text), text).toThrow(FormulaParseError)
+    }
+    // 含连续点的标识符是合法形态（未知名称），求值为 #NAME? 而非解析失败
+    const sheet = new Sheet()
+    expect(calc(sheet, A1, '=A1..B2')).toMatchObject({ v: '#NAME?', t: 'e' })
+  })
+})
+
+describe('公式解析：求值（经 Sheet）', () => {
+  it('=1+2*3 → 7；=(1+2)*3 → 9', () => {
+    const sheet = new Sheet()
+    expect(calc(sheet, A1, '=1+2*3')).toMatchObject({ f: '1+2*3', v: 7, t: 'n' })
+    expect(calc(sheet, B1, '=(1+2)*3')).toMatchObject({ v: 9 })
+  })
+
+  it('=A1+B2 引用求值；空格按 0', () => {
+    const sheet = new Sheet()
+    sheet.setCellValue(A1, 1)
+    sheet.setCellValue(B2, 2)
+    expect(calc(sheet, B1, '=A1+B2')).toMatchObject({ v: 3 })
+    // C1 为空格 → 按 0
+    expect(calc(sheet, { row: 0, col: 3 }, '=A1+C1')).toMatchObject({ v: 1 })
+  })
+
+  it('=SUM(A1:A10) 区域聚合', () => {
+    const sheet = new Sheet()
+    sheet.setCellValue(A1, 5)
+    sheet.setCellValue({ row: 9, col: 0 }, 7)
+    expect(calc(sheet, B1, '=SUM(A1:A10)')).toMatchObject({ v: 12 })
+  })
+
+  it('=Sheet2!A1*2 跨表引用', () => {
+    const workbook = new Workbook()
+    const sheet1 = workbook.activeSheet
+    const sheet2 = workbook.addSheet('Sheet2')
+    sheet2.setCellValue(A1, 21)
+    expect(calc(sheet1, A1, '=Sheet2!A1*2')).toMatchObject({ v: 42 })
+  })
+
+  it("='My Sheet'!A1 带引号表名", () => {
+    const workbook = new Workbook()
+    const sheet1 = workbook.activeSheet
+    const named = workbook.addSheet('My Sheet')
+    named.setCellValue(A1, 'hello')
+    expect(calc(sheet1, A1, "='My Sheet'!A1")).toMatchObject({ v: 'hello', t: 'str' })
+  })
+
+  it('幂/一元/百分号/拼接/比较', () => {
+    const sheet = new Sheet()
+    expect(calc(sheet, A1, '=2^3^2')).toMatchObject({ v: 512 })
+    expect(calc(sheet, B1, '=-2^2')).toMatchObject({ v: 4 })
+    expect(calc(sheet, { row: 0, col: 2 }, '=10%+1')).toMatchObject({ v: 1.1 })
+    expect(calc(sheet, { row: 0, col: 3 }, '="a"&"b"&1')).toMatchObject({ v: 'ab1' })
+    expect(calc(sheet, { row: 0, col: 4 }, '=1+1=2')).toMatchObject({ v: true, t: 'b' })
+    expect(calc(sheet, { row: 0, col: 5 }, '=2<>2')).toMatchObject({ v: false })
+    expect(calc(sheet, { row: 0, col: 6 }, '=TRUE+1')).toMatchObject({ v: 2 })
+  })
+
+  it('未知名称 → #NAME?；解析失败 → #ERROR!（f 仍保留原文）', () => {
+    const sheet = new Sheet()
+    expect(calc(sheet, A1, '=Sheet2')).toMatchObject({ f: 'Sheet2', v: '#NAME?', t: 'e' })
+    expect(calc(sheet, B1, '=1+')).toMatchObject({ f: '1+', v: '#ERROR!', t: 'e' })
+    expect(calc(sheet, B2, '=SUM(A1')).toMatchObject({ v: '#ERROR!', t: 'e' })
+  })
+})

package/src/core/__test__/history.test.ts

@@ -0,0 +1,225 @@
+import { describe, expect, it, vi } from 'vitest'
+
+import type { CellAddress } from '../address'
+import type { CellData } from '../cell-store'
+import { HistoryManager } from '../command/history'
+import type { CellPatch, Mutation, Patch, PatchDirection } from '../command/types'
+
+/** 构造一个可区分的 cell 补丁 */
+function cellPatch(row: number, before?: CellData, after?: CellData): CellPatch {
+  const addr: CellAddress = { row, col: 0 }
+  return { kind: 'cell', addr, before, after }
+}
+
+/** 单补丁 mutation（undo/redo 共享补丁，方向决定应用哪一侧） */
+function mutationOf(...patches: Patch[]): Mutation {
+  return { redo: patches, undo: [...patches].reverse() }
+}
+
+function createHistory(capacity?: number) {
+  const applyPatch = vi.fn<(patch: Patch, direction: PatchDirection) => void>()
+  const history = new HistoryManager(applyPatch, capacity)
+  return { history, applyPatch }
+}
+
+describe('HistoryManager 基本流转', () => {
+  it('push → undo 应用 undo 补丁 → redo 应用 redo 补丁', () => {
+    const { history, applyPatch } = createHistory()
+    const patch = cellPatch(0, undefined, { v: 'x', t: 's' })
+
+    expect(history.canUndo).toBe(false)
+    expect(history.canRedo).toBe(false)
+
+    history.push([mutationOf(patch)])
+    expect(history.canUndo).toBe(true)
+
+    expect(history.undo()).toBe(true)
+    expect(applyPatch).toHaveBeenLastCalledWith(patch, 'undo')
+    expect(history.canUndo).toBe(false)
+    expect(history.canRedo).toBe(true)
+
+    expect(history.redo()).toBe(true)
+    expect(applyPatch).toHaveBeenLastCalledWith(patch, 'redo')
+    expect(history.canUndo).toBe(true)
+    expect(history.canRedo).toBe(false)
+  })
+
+  it('空栈 undo/redo 返回 false，不调用 applyPatch', () => {
+    const { history, applyPatch } = createHistory()
+    expect(history.undo()).toBe(false)
+    expect(history.redo()).toBe(false)
+    expect(applyPatch).not.toHaveBeenCalled()
+  })
+
+  it('undo 按 entry 逆序、mutation.undo 列表序应用补丁', () => {
+    const { history, applyPatch } = createHistory()
+    const a = cellPatch(0, undefined, { v: 'a' })
+    const b = cellPatch(1, undefined, { v: 'b' })
+    const c = cellPatch(2, undefined, { v: 'c' })
+    const m1: Mutation = { redo: [a], undo: [a] }
+    const m2: Mutation = { redo: [b, c], undo: [c, b] }
+
+    history.push([m1, m2])
+    history.undo()
+
+    expect(applyPatch.mock.calls).toEqual([
+      [c, 'undo'],
+      [b, 'undo'],
+      [a, 'undo']
+    ])
+
+    applyPatch.mockClear()
+    history.redo()
+    expect(applyPatch.mock.calls).toEqual([
+      [a, 'redo'],
+      [b, 'redo'],
+      [c, 'redo']
+    ])
+  })
+
+  it('新命令清空 redo 栈', () => {
+    const { history } = createHistory()
+    history.push([mutationOf(cellPatch(0, undefined, { v: 'a' }))])
+    history.undo()
+    expect(history.canRedo).toBe(true)
+
+    history.push([mutationOf(cellPatch(1, undefined, { v: 'b' }))])
+    expect(history.canRedo).toBe(false)
+    expect(history.redo()).toBe(false)
+  })
+
+  it('空 mutation 列表直接忽略', () => {
+    const { history } = createHistory()
+    history.push([])
+    expect(history.canUndo).toBe(false)
+  })
+})
+
+describe('HistoryManager 容量上限', () => {
+  it('超出容量淘汰最旧条目', () => {
+    const { history } = createHistory(3)
+    for (let i = 0; i < 5; i++) {
+      history.push([mutationOf(cellPatch(i, undefined, { v: i }))])
+    }
+    expect(history.undoSize).toBe(3)
+
+    // 只能 undo 最近 3 条；最旧 2 条已被淘汰
+    expect(history.undo()).toBe(true)
+    expect(history.undo()).toBe(true)
+    expect(history.undo()).toBe(true)
+    expect(history.undo()).toBe(false)
+
+    // redo 栈一致性：3 条全部可重做
+    expect(history.redoSize).toBe(3)
+    expect(history.redo()).toBe(true)
+    expect(history.redo()).toBe(true)
+    expect(history.redo()).toBe(true)
+    expect(history.redo()).toBe(false)
+  })
+})
+
+describe('HistoryManager 事务', () => {
+  it('事务内多次 push 合并为一个 undo 单元', () => {
+    const { history, applyPatch } = createHistory()
+    const a = cellPatch(0, undefined, { v: 'a' })
+    const b = cellPatch(1, undefined, { v: 'b' })
+
+    history.beginTransaction()
+    history.push([mutationOf(a)])
+    history.push([mutationOf(b)])
+    // 提交前不入栈
+    expect(history.canUndo).toBe(false)
+    history.commit()
+
+    expect(history.undoSize).toBe(1)
+    history.undo()
+    expect(applyPatch.mock.calls).toEqual([
+      [b, 'undo'],
+      [a, 'undo']
+    ])
+  })
+
+  it('嵌套事务拍平到最外层', () => {
+    const { history } = createHistory()
+    history.beginTransaction()
+    history.push([mutationOf(cellPatch(0, undefined, { v: 'a' }))])
+    history.beginTransaction()
+    history.push([mutationOf(cellPatch(1, undefined, { v: 'b' }))])
+    history.commit()
+    // 内层 commit 后仍未入栈
+    expect(history.canUndo).toBe(false)
+    history.commit()
+
+    expect(history.undoSize).toBe(1)
+  })
+
+  it('没有进行中事务时 commit 抛错', () => {
+    const { history } = createHistory()
+    expect(() => history.commit()).toThrow('没有进行中的事务')
+  })
+
+  it('rollback 还原缓冲中的变更，不影响 undo/redo 栈', () => {
+    const { history, applyPatch } = createHistory()
+    const before = cellPatch(0, undefined, { v: 'old' })
+    history.push([mutationOf(before)])
+
+    const a = cellPatch(1, undefined, { v: 'a' })
+    const b = cellPatch(2, undefined, { v: 'b' })
+    history.beginTransaction()
+    history.push([mutationOf(a)])
+    history.push([mutationOf(b)])
+    history.rollback()
+
+    // 缓冲被逆序回放 undo
+    expect(applyPatch.mock.calls).toEqual([
+      [b, 'undo'],
+      [a, 'undo']
+    ])
+    // 事务已结束，缓冲丢弃；栈中只剩最初一条
+    expect(history.inTransaction).toBe(false)
+    expect(history.undoSize).toBe(1)
+    expect(history.canRedo).toBe(false)
+  })
+
+  it('事务进行中 undo/redo 返回 false', () => {
+    const { history, applyPatch } = createHistory()
+    history.push([mutationOf(cellPatch(0, undefined, { v: 'a' }))])
+    history.beginTransaction()
+    expect(history.undo()).toBe(false)
+    expect(history.redo()).toBe(false)
+    history.commit()
+    expect(applyPatch).not.toHaveBeenCalled()
+  })
+})
+
+describe('HistoryManager 事件与清理', () => {
+  it('change 事件携带 canUndo/canRedo 状态', () => {
+    const { history } = createHistory()
+    const handler = vi.fn()
+    history.onChange(handler)
+
+    history.push([mutationOf(cellPatch(0, undefined, { v: 'a' }))])
+    expect(handler).toHaveBeenLastCalledWith({ canUndo: true, canRedo: false })
+
+    history.undo()
+    expect(handler).toHaveBeenLastCalledWith({ canUndo: false, canRedo: true })
+
+    history.redo()
+    expect(handler).toHaveBeenLastCalledWith({ canUndo: true, canRedo: false })
+  })
+
+  it('clear 清空全部历史与事务', () => {
+    const { history } = createHistory()
+    history.push([mutationOf(cellPatch(0, undefined, { v: 'a' }))])
+    history.undo()
+    history.beginTransaction()
+    history.push([mutationOf(cellPatch(1, undefined, { v: 'b' }))])
+
+    history.clear()
+    expect(history.canUndo).toBe(false)
+    expect(history.canRedo).toBe(false)
+    expect(history.inTransaction).toBe(false)
+    // clear 后事务状态已复位，commit 视为无事务
+    expect(() => history.commit()).toThrow()
+  })
+})

package/src/core/__test__/merge-manager.test.ts

@@ -0,0 +1,106 @@
+import { describe, expect, it } from 'vitest'
+
+import { parseRange } from '../address'
+import { MergeManager } from '../merge-manager'
+
+const B2 = { row: 1, col: 1 }
+const C3 = { row: 2, col: 2 }
+const A1 = { row: 0, col: 0 }
+
+describe('MergeManager 基本合并', () => {
+  it('merge(B2:C3) 后 getCellInfo 三种 kind 区分正确', () => {
+    const mgr = new MergeManager()
+    mgr.merge(parseRange('B2:C3')!)
+
+    expect(mgr.getCellInfo(B2)).toEqual({
+      kind: 'merged-anchor',
+      anchor: B2,
+      mergeRange: parseRange('B2:C3')!
+    })
+    expect(mgr.getCellInfo(C3)).toEqual({
+      kind: 'merged-covered',
+      anchor: B2,
+      mergeRange: parseRange('B2:C3')!
+    })
+    expect(mgr.getCellInfo(A1)).toEqual({ kind: 'normal', anchor: A1 })
+  })
+
+  it('resolveAnchor / isCovered / getMergeAt', () => {
+    const mgr = new MergeManager()
+    mgr.merge(parseRange('B2:C3')!)
+
+    expect(mgr.resolveAnchor(C3)).toEqual(B2)
+    expect(mgr.resolveAnchor(B2)).toEqual(B2)
+    expect(mgr.resolveAnchor(A1)).toEqual(A1)
+
+    expect(mgr.isCovered(C3)).toBe(true)
+    expect(mgr.isCovered(B2)).toBe(false)
+    expect(mgr.isMerged(B2)).toBe(true)
+
+    expect(mgr.getMergeAt(C3)).toEqual(parseRange('B2:C3'))
+    expect(mgr.getMergeAt(A1)).toBeUndefined()
+  })
+})
+
+describe('MergeManager 嵌套场景', () => {
+  it('已有 B2:C3，再 merge C3:D4 → 旧合并解除，新合并 = 包围盒 B2:D4，锚点 B2', () => {
+    const mgr = new MergeManager()
+    mgr.merge(parseRange('B2:C3')!)
+    const result = mgr.merge(parseRange('C3:D4')!)
+
+    expect(result.range).toEqual(parseRange('B2:D4'))
+    expect(result.removed).toEqual([parseRange('B2:C3')])
+    expect(mgr.getMerges()).toEqual([parseRange('B2:D4')])
+
+    // 旧区域内所有格都解析到新锚点
+    expect(mgr.getCellInfo(B2).kind).toBe('merged-anchor')
+    expect(mgr.getCellInfo(C3)).toMatchObject({ kind: 'merged-covered', anchor: B2 })
+    expect(mgr.getCellInfo({ row: 3, col: 3 })).toMatchObject({
+      kind: 'merged-covered',
+      anchor: B2
+    })
+  })
+})
+
+describe('MergeManager 边界', () => {
+  it('单行合并与单列合并', () => {
+    const mgr = new MergeManager()
+    mgr.merge(parseRange('B2:D2')!)
+    expect(mgr.getCellInfo({ row: 1, col: 3 })).toMatchObject({
+      kind: 'merged-covered',
+      anchor: B2
+    })
+
+    const mgr2 = new MergeManager()
+    mgr2.merge(parseRange('B2:B5')!)
+    expect(mgr2.getCellInfo({ row: 4, col: 1 })).toMatchObject({
+      kind: 'merged-covered',
+      anchor: B2
+    })
+  })
+
+  it('相邻但不重叠的合并互不影响', () => {
+    const mgr = new MergeManager()
+    mgr.merge(parseRange('B2:C3')!)
+    const result = mgr.merge(parseRange('D2:D3')!)
+
+    expect(result.range).toEqual(parseRange('D2:D3'))
+    expect(result.removed).toEqual([])
+    expect(mgr.size).toBe(2)
+    expect(mgr.getCellInfo({ row: 1, col: 3 })).toMatchObject({
+      kind: 'merged-anchor',
+      anchor: { row: 1, col: 3 }
+    })
+    expect(mgr.getCellInfo(B2).kind).toBe('merged-anchor')
+  })
+
+  it('unmerge 解除相交合并', () => {
+    const mgr = new MergeManager()
+    mgr.merge(parseRange('B2:C3')!)
+    const removed = mgr.unmerge(parseRange('C3:C3')!)
+
+    expect(removed).toEqual([parseRange('B2:C3')])
+    expect(mgr.size).toBe(0)
+    expect(mgr.getCellInfo(C3)).toEqual({ kind: 'normal', anchor: C3 })
+  })
+})

package/src/core/__test__/sheet.test.ts

@@ -0,0 +1,142 @@
+import { describe, expect, it, vi } from 'vitest'
+
+import { parseRange } from '../address'
+import { Sheet } from '../sheet'
+import { Workbook } from '../workbook'
+
+const B2 = { row: 1, col: 1 }
+const C3 = { row: 2, col: 2 }
+
+describe('Sheet 合并值语义', () => {
+  it('B2、C3 各有值 → 合并后仅 B2 值保留；getCellData(C3) = undefined；getDisplayValue(C3) = B2 的值', () => {
+    const sheet = new Sheet()
+    sheet.setCellValue(B2, 'keep')
+    sheet.setCellValue(C3, 'drop')
+
+    sheet.mergeCells(parseRange('B2:C3')!)
+
+    expect(sheet.getDisplayValue(B2)).toBe('keep')
+    expect(sheet.getCellData(C3)).toBeUndefined()
+    expect(sheet.getDisplayValue(C3)).toBe('keep')
+  })
+
+  it('嵌套合并：已有 B2:C3，再 merge C3:D4 → 包围盒 B2:D4，数据按保留规则落 B2', () => {
+    const sheet = new Sheet()
+    sheet.setCellValue(B2, 'v-b2')
+    sheet.mergeCells(parseRange('B2:C3')!)
+    sheet.setCellValue({ row: 3, col: 3 }, 'v-d4')
+
+    const finalRange = sheet.mergeCells(parseRange('C3:D4')!)
+
+    expect(finalRange).toEqual(parseRange('B2:D4'))
+    expect(sheet.getCellInfo(B2).kind).toBe('merged-anchor')
+    expect(sheet.getDisplayValue(B2)).toBe('v-b2')
+    expect(sheet.getDisplayValue({ row: 3, col: 3 })).toBe('v-b2')
+    expect(sheet.getCellData({ row: 3, col: 3 })).toBeUndefined()
+  })
+
+  it('左上方向第一个有值格优先：锚点无值时取行主序首个有值格', () => {
+    const sheet = new Sheet()
+    sheet.setCellValue(C3, 'first-valued')
+
+    sheet.mergeCells(parseRange('B2:C3')!)
+
+    expect(sheet.getDisplayValue(B2)).toBe('first-valued')
+    expect(sheet.getCellData(C3)).toBeUndefined()
+  })
+
+  it('unmerge 后仅锚点留值', () => {
+    const sheet = new Sheet()
+    sheet.setCellValue(B2, 'keep')
+    sheet.setCellValue(C3, 'drop')
+    sheet.mergeCells(parseRange('B2:C3')!)
+
+    sheet.unmergeCells(parseRange('B2:C3')!)
+
+    expect(sheet.getCellInfo(B2)).toEqual({ kind: 'normal', anchor: B2 })
+    expect(sheet.getCellData(B2)).toMatchObject({ v: 'keep' })
+    expect(sheet.getCellData(C3)).toBeUndefined()
+  })
+
+  it('merge-change 事件', () => {
+    const sheet = new Sheet()
+    const handler = vi.fn()
+    sheet.on('merge-change', handler)
+
+    sheet.mergeCells(parseRange('B2:C3')!)
+    expect(handler).toHaveBeenCalledWith({ range: parseRange('B2:C3') })
+  })
+})
+
+describe('Sheet 数据与选区', () => {
+  it('setCellValue / getCellData / cell-change 事件', () => {
+    const sheet = new Sheet()
+    const handler = vi.fn()
+    sheet.on('cell-change', handler)
+
+    sheet.setCellValue(B2, 42)
+    expect(sheet.getCellData(B2)).toEqual({ v: 42, t: 'n' })
+    expect(handler).toHaveBeenCalledWith({ addr: B2 })
+
+    sheet.setCellValue(B2, null)
+    expect(sheet.getCellData(B2)).toBeUndefined()
+  })
+
+  it('selectCell(C3)（被覆盖）→ activeCell = B2', () => {
+    const sheet = new Sheet()
+    sheet.mergeCells(parseRange('B2:C3')!)
+
+    sheet.selectCell(C3)
+
+    expect(sheet.getSelection().activeCell).toEqual(B2)
+  })
+
+  it('selection-change 事件', () => {
+    const sheet = new Sheet()
+    const handler = vi.fn()
+    sheet.on('selection-change', handler)
+
+    sheet.selectCell(B2)
+    expect(handler).toHaveBeenCalledWith({ activeCell: B2, ranges: [{ start: B2, end: B2 }] })
+  })
+
+  it('对被覆盖格写入 → 落到锚点', () => {
+    const sheet = new Sheet()
+    sheet.mergeCells(parseRange('B2:C3')!)
+
+    sheet.setCellValue(C3, 'via-covered')
+    expect(sheet.getCellData(B2)).toMatchObject({ v: 'via-covered' })
+    expect(sheet.getCellData(C3)).toBeUndefined()
+  })
+})
+
+describe('Workbook', () => {
+  it('默认一个 sheet，可增删激活', () => {
+    const wb = new Workbook()
+    expect(wb.sheetCount).toBe(1)
+    expect(wb.activeSheet.name).toBe('Sheet1')
+
+    const s2 = wb.addSheet()
+    expect(s2.name).toBe('Sheet2')
+    expect(wb.activeSheet.name).toBe('Sheet1')
+
+    expect(wb.activateSheet('Sheet2')).toBe(true)
+    expect(wb.activeSheet).toBe(s2)
+
+    expect(wb.removeSheet('Sheet2')).toBe(true)
+    expect(wb.activeSheet.name).toBe('Sheet1')
+
+    // 至少保留一个
+    expect(wb.removeSheet('Sheet1')).toBe(false)
+  })
+
+  it('激活切换事件', () => {
+    const wb = new Workbook()
+    wb.addSheet('Data')
+    const handler = vi.fn()
+    wb.on('active-sheet-change', handler)
+
+    wb.activateSheet('Data')
+    expect(handler).toHaveBeenCalledWith({ sheet: wb.getSheet('Data'), index: 1 })
+  })
+})