@veltra/sheet 2.0.1 → 2.2.0

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

@@ -1,160 +0,0 @@
-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

@@ -1,225 +0,0 @@
-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

@@ -1,106 +0,0 @@
-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

@@ -1,142 +0,0 @@
-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 })
-  })
-})