@veltra/sheet 2.0.0 → 2.0.1

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

@@ -0,0 +1,140 @@
+import { describe, expect, it } from 'vitest'
+
+import { parseRange } from '../address'
+import { computeFillTargetRange, generateFill, shiftFormulaRefs } from '../fill'
+import { Sheet } from '../sheet'
+
+describe('shiftFormulaRefs', () => {
+  it('相对引用随行列位移', () => {
+    expect(shiftFormulaRefs('A1+B2', 1, 0)).toBe('A2+B3')
+    expect(shiftFormulaRefs('A1+B2', 0, 1)).toBe('B1+C2')
+    expect(shiftFormulaRefs('SUM(A1:B2)', 2, 1)).toBe('SUM(B3:C4)')
+  })
+
+  it('尊重 $ 绝对行列', () => {
+    expect(shiftFormulaRefs('$A$1+A1', 1, 1)).toBe('$A$1+B2')
+    expect(shiftFormulaRefs('$A1+A$1', 2, 3)).toBe('$A3+D$1')
+    expect(shiftFormulaRefs('Sheet2!$B2+C$3', 1, 1)).toBe('Sheet2!$B3+D$3')
+  })
+
+  it('出界变为 #REF!；不改写字符串字面量', () => {
+    expect(shiftFormulaRefs('A1', 0, -1)).toBe('#REF!')
+    expect(shiftFormulaRefs('A1', -1, 0)).toBe('#REF!')
+    expect(shiftFormulaRefs('"A1"&B1', 1, 0)).toBe('"A1"&B2')
+    expect(shiftFormulaRefs('LOG10(A1)', 1, 0)).toBe('LOG10(A2)')
+  })
+})
+
+describe('computeFillTargetRange', () => {
+  it('按方向裁剪扩展选区中的新增区域', () => {
+    const source = parseRange('A1:B2')!
+    expect(computeFillTargetRange(source, 'bottom', parseRange('A1:B5')!)).toEqual(
+      parseRange('A3:B5')
+    )
+    expect(computeFillTargetRange(source, 'right', parseRange('A1:D2')!)).toEqual(
+      parseRange('C1:D2')
+    )
+    expect(computeFillTargetRange(source, 'top', parseRange('A1:B2')!)).toBeNull()
+  })
+})
+
+describe('generateFill', () => {
+  it('非数字 → tile 复制（含空格覆盖清空）', () => {
+    const sheet = new Sheet()
+    sheet.setCellValue({ row: 0, col: 0 }, 'a')
+    sheet.setCellValue({ row: 1, col: 0 }, 'b')
+
+    const items = generateFill({
+      source: parseRange('A1:A2')!,
+      target: parseRange('A3:A6')!,
+      direction: 'bottom',
+      getCellData: (addr) => sheet.getCellData(addr)
+    })
+    expect(items).toEqual([
+      { addr: { row: 2, col: 0 }, data: { v: 'a', t: 's' } },
+      { addr: { row: 3, col: 0 }, data: { v: 'b', t: 's' } },
+      { addr: { row: 4, col: 0 }, data: { v: 'a', t: 's' } },
+      { addr: { row: 5, col: 0 }, data: { v: 'b', t: 's' } }
+    ])
+
+    // 空源覆盖：源 B1 空 → 目标格被清
+    sheet.setCellValue({ row: 2, col: 1 }, 'keep')
+    const clearItems = generateFill({
+      source: parseRange('B1')!,
+      target: parseRange('B3')!,
+      direction: 'bottom',
+      getCellData: (addr) => sheet.getCellData(addr)
+    })
+    expect(clearItems).toEqual([{ addr: { row: 2, col: 1 }, data: undefined }])
+  })
+
+  it('数字等差：单格步长 1；多格按 delta 延续', () => {
+    const sheet = new Sheet()
+    sheet.setCellValue({ row: 0, col: 0 }, 1)
+
+    const single = generateFill({
+      source: parseRange('A1')!,
+      target: parseRange('A2:A4')!,
+      direction: 'bottom',
+      getCellData: (addr) => sheet.getCellData(addr)
+    })
+    expect(single.map((item) => item.data?.v)).toEqual([2, 3, 4])
+
+    sheet.setCellValue({ row: 0, col: 1 }, 1)
+    sheet.setCellValue({ row: 1, col: 1 }, 3)
+    const multi = generateFill({
+      source: parseRange('B1:B2')!,
+      target: parseRange('B3:B4')!,
+      direction: 'bottom',
+      getCellData: (addr) => sheet.getCellData(addr)
+    })
+    expect(multi.map((item) => item.data?.v)).toEqual([5, 7])
+  })
+
+  it('日期类型（t=d）按数值序列延续', () => {
+    const sheet = new Sheet()
+    sheet.setCell({ row: 0, col: 0 }, { v: 100, t: 'd' })
+    sheet.setCell({ row: 1, col: 0 }, { v: 101, t: 'd' })
+
+    const items = generateFill({
+      source: parseRange('A1:A2')!,
+      target: parseRange('A3')!,
+      direction: 'bottom',
+      getCellData: (addr) => sheet.getCellData(addr)
+    })
+    expect(items).toEqual([{ addr: { row: 2, col: 0 }, data: { v: 102, t: 'd' } }])
+  })
+
+  it('公式格：相对引用位移，绝对引用锁定', () => {
+    const sheet = new Sheet()
+    sheet.setCellFormula({ row: 0, col: 0 }, '=$B$1+C1')
+
+    const items = generateFill({
+      source: parseRange('A1')!,
+      target: parseRange('A2:A3')!,
+      direction: 'bottom',
+      getCellData: (addr) => sheet.getCellData(addr)
+    })
+    expect(items.map((item) => item.data?.f)).toEqual(['$B$1+C2', '$B$1+C3'])
+  })
+
+  it('经 setCells 写入后可一次 undo', () => {
+    const sheet = new Sheet()
+    sheet.setCellValue({ row: 0, col: 0 }, 10)
+    sheet.history.clear()
+
+    const items = generateFill({
+      source: parseRange('A1')!,
+      target: parseRange('A2:A3')!,
+      direction: 'bottom',
+      getCellData: (addr) => sheet.getCellData(addr)
+    })
+    sheet.setCells(items)
+    expect(sheet.getCellData({ row: 1, col: 0 })?.v).toBe(11)
+    expect(sheet.getCellData({ row: 2, col: 0 })?.v).toBe(12)
+
+    expect(sheet.undo()).toBe(true)
+    expect(sheet.getCellData({ row: 1, col: 0 })).toBeUndefined()
+    expect(sheet.getCellData({ row: 2, col: 0 })).toBeUndefined()
+  })
+})

package/src/core/fill.ts

@@ -0,0 +1,314 @@
+import type { CellAddress, CellRange } from './address'
+import { colIndexToName, colNameToIndex, createRange, iterateRange } from './address'
+import type { CellData, CellType } from './cell-store'
+import type { SetCellValueItem } from './command/set-cell-value'
+
+/** 填充柄拖拽方向（与 VTable drag_fill_handle_end 一致） */
+export type FillDirection = 'top' | 'bottom' | 'left' | 'right'
+
+export interface GenerateFillOptions {
+  /** 拖拽前的源选区（模型坐标） */
+  source: CellRange
+  /** 需要写入的目标区（不含源区，模型坐标） */
+  target: CellRange
+  /** 填充方向 */
+  direction: FillDirection
+  /** 读取源区单元格（原始存储语义） */
+  getCellData: (addr: CellAddress) => CellData | undefined
+}
+
+/**
+ * 由源选区 + 拖拽后扩展选区 + 方向，计算需要填充的目标区（模型坐标）。
+ * 算法对齐 VTable 官方 fill-handle 示例（扩展选区含源区，目标为扩展部分）。
+ */
+export function computeFillTargetRange(
+  source: CellRange,
+  direction: FillDirection,
+  expanded: CellRange
+): CellRange | null {
+  const src = createRange(source.start, source.end)
+  const exp = createRange(expanded.start, expanded.end)
+
+  if (direction === 'bottom') {
+    if (exp.end.row <= src.end.row) return null
+    return {
+      start: { row: src.end.row + 1, col: src.start.col },
+      end: { row: exp.end.row, col: src.end.col }
+    }
+  }
+  if (direction === 'top') {
+    if (exp.start.row >= src.start.row) return null
+    return {
+      start: { row: exp.start.row, col: src.start.col },
+      end: { row: src.start.row - 1, col: src.end.col }
+    }
+  }
+  if (direction === 'right') {
+    if (exp.end.col <= src.end.col) return null
+    return {
+      start: { row: src.start.row, col: src.end.col + 1 },
+      end: { row: src.end.row, col: exp.end.col }
+    }
+  }
+  // left
+  if (exp.start.col >= src.start.col) return null
+  return {
+    start: { row: src.start.row, col: exp.start.col },
+    end: { row: src.end.row, col: src.start.col - 1 }
+  }
+}
+
+/**
+ * 生成填充写入项（tile / 数字日期等差 / 公式相对引用位移）。
+ * 调用方一次 `sheet.setCells(items)` 即可（单 undo 单元）。
+ */
+export function generateFill(options: GenerateFillOptions): SetCellValueItem[] {
+  const { source, target, direction, getCellData } = options
+  const src = createRange(source.start, source.end)
+  const tgt = createRange(target.start, target.end)
+  const srcRows = src.end.row - src.start.row + 1
+  const srcCols = src.end.col - src.start.col + 1
+  const vertical = direction === 'top' || direction === 'bottom'
+
+  const seriesByLane = new Map<number, SeriesInfo | null>()
+  if (vertical) {
+    for (let col = src.start.col; col <= src.end.col; col++) {
+      const values: number[] = []
+      let cellType: CellType | undefined
+      let ok = true
+      for (let row = src.start.row; row <= src.end.row; row++) {
+        const data = getCellData({ row, col })
+        const num = readSeriesNumber(data)
+        if (num == null) {
+          ok = false
+          break
+        }
+        values.push(num.value)
+        cellType = num.t
+      }
+      seriesByLane.set(col, ok ? makeSeriesInfo(values, cellType) : null)
+    }
+  } else {
+    for (let row = src.start.row; row <= src.end.row; row++) {
+      const values: number[] = []
+      let cellType: CellType | undefined
+      let ok = true
+      for (let col = src.start.col; col <= src.end.col; col++) {
+        const data = getCellData({ row, col })
+        const num = readSeriesNumber(data)
+        if (num == null) {
+          ok = false
+          break
+        }
+        values.push(num.value)
+        cellType = num.t
+      }
+      seriesByLane.set(row, ok ? makeSeriesInfo(values, cellType) : null)
+    }
+  }
+
+  const items: SetCellValueItem[] = []
+  for (const addr of iterateRange(tgt)) {
+    const rowOffset = positiveMod(addr.row - src.start.row, srcRows)
+    const colOffset = positiveMod(addr.col - src.start.col, srcCols)
+    const srcAddr: CellAddress = { row: src.start.row + rowOffset, col: src.start.col + colOffset }
+    const srcData = getCellData(srcAddr)
+
+    if (srcData?.f != null && srcData.f !== '') {
+      const deltaRow = addr.row - srcAddr.row
+      const deltaCol = addr.col - srcAddr.col
+      items.push({ addr, data: { f: shiftFormulaRefs(srcData.f, deltaRow, deltaCol) } })
+      continue
+    }
+
+    const lane = vertical ? srcAddr.col : srcAddr.row
+    const series = seriesByLane.get(lane)
+    if (series) {
+      const index = vertical ? addr.row - src.start.row : addr.col - src.start.col
+      const value = series.first + index * series.delta
+      items.push({ addr, data: { v: value, t: series.t ?? 'n' } })
+      continue
+    }
+
+    // tile 复制（含空格 → 清除）
+    items.push({ addr, data: cloneCellData(srcData) })
+  }
+  return items
+}
+
+interface SeriesInfo {
+  first: number
+  delta: number
+  t?: CellType
+}
+
+function makeSeriesInfo(values: number[], t?: CellType): SeriesInfo {
+  const first = values[0]!
+  if (values.length === 1) {
+    return { first, delta: 1, t }
+  }
+  const delta = (values[values.length - 1]! - first) / (values.length - 1)
+  return { first, delta, t }
+}
+
+/** 可参与等差序列的数字/日期格；公式格与其它类型返回 null */
+function readSeriesNumber(data: CellData | undefined): { value: number; t?: CellType } | null {
+  if (!data) return null
+  if (data.f != null && data.f !== '') return null
+  if (typeof data.v !== 'number' || !Number.isFinite(data.v)) return null
+  if (data.t != null && data.t !== 'n' && data.t !== 'd') return null
+  return { value: data.v, t: data.t }
+}
+
+function cloneCellData(data: CellData | undefined): CellData | undefined {
+  if (!data) return undefined
+  const cloned: CellData = {}
+  if (data.v !== undefined) cloned.v = data.v
+  if (data.t !== undefined) cloned.t = data.t
+  if (data.f !== undefined) cloned.f = data.f
+  return cloned
+}
+
+function positiveMod(n: number, mod: number): number {
+  return ((n % mod) + mod) % mod
+}
+
+/**
+ * 公式引用字符串级位移：尊重 `$` 绝对行列；出界 → `#REF!`。
+ * 跳过双引号字符串字面量，避免改写文本中的 A1 片段。
+ */
+export function shiftFormulaRefs(formula: string, deltaRow: number, deltaCol: number): string {
+  if (deltaRow === 0 && deltaCol === 0) return formula
+
+  let result = ''
+  let i = 0
+  while (i < formula.length) {
+    const ch = formula[i]!
+    if (ch === '"') {
+      const end = skipExcelString(formula, i)
+      result += formula.slice(i, end)
+      i = end
+      continue
+    }
+
+    const sheetMatch = matchSheetPrefix(formula, i)
+    const addrStart = sheetMatch ? sheetMatch.end : i
+    const addrMatch = matchCellOrRange(formula, addrStart)
+    if (addrMatch && (sheetMatch || isRefBoundary(formula, i - 1))) {
+      const sheetPrefix = sheetMatch ? formula.slice(sheetMatch.start, sheetMatch.end) : ''
+      // 有 sheet 前缀时，前缀前也需是边界
+      if (sheetMatch && !isRefBoundary(formula, sheetMatch.start - 1)) {
+        result += ch
+        i++
+        continue
+      }
+      const shifted = shiftAddrPart(addrMatch.text, deltaRow, deltaCol)
+      result += sheetPrefix + shifted
+      i = addrMatch.end
+      continue
+    }
+
+    result += ch
+    i++
+  }
+  return result
+}
+
+function skipExcelString(text: string, start: number): number {
+  // start 指向开引号；Excel 字符串内 "" 为转义
+  let i = start + 1
+  while (i < text.length) {
+    if (text[i] === '"') {
+      if (text[i + 1] === '"') {
+        i += 2
+        continue
+      }
+      return i + 1
+    }
+    i++
+  }
+  return text.length
+}
+
+function matchSheetPrefix(text: string, start: number): { start: number; end: number } | null {
+  if (text[start] === "'") {
+    let i = start + 1
+    while (i < text.length) {
+      if (text[i] === "'") {
+        if (text[i + 1] === "'") {
+          i += 2
+          continue
+        }
+        if (text[i + 1] === '!') {
+          return { start, end: i + 2 }
+        }
+        return null
+      }
+      i++
+    }
+    return null
+  }
+
+  // 简单表名：字母/下划线开头
+  if (!/[A-Za-z_]/.test(text[start] ?? '')) return null
+  let i = start + 1
+  while (i < text.length && /[\w.]/.test(text[i]!)) i++
+  if (text[i] === '!') return { start, end: i + 1 }
+  return null
+}
+
+const CELL_REF_RE = /^(\$?)([A-Za-z]+)(\$?)([1-9]\d*)/
+
+function matchCellOrRange(text: string, start: number): { text: string; end: number } | null {
+  const first = matchOneCell(text, start)
+  if (!first) return null
+  if (text[first.end] === ':') {
+    const second = matchOneCell(text, first.end + 1)
+    if (!second) return { text: first.text, end: first.end }
+    return { text: text.slice(start, second.end), end: second.end }
+  }
+  return first
+}
+
+function matchOneCell(text: string, start: number): { text: string; end: number } | null {
+  const slice = text.slice(start)
+  const m = CELL_REF_RE.exec(slice)
+  if (!m) return null
+  const end = start + m[0].length
+  const next = text[end]
+  // 行号后紧跟字母 → 不是 A1；紧跟 `(` → 函数名（如 LOG10(）
+  if (next && (/[A-Za-z]/.test(next) || next === '(')) return null
+  return { text: m[0], end }
+}
+
+function isRefBoundary(text: string, index: number): boolean {
+  if (index < 0) return true
+  const ch = text[index]!
+  // 引用前不能是字母/数字（避免 FOOA1）；`!` 已由 sheet 前缀消费
+  return !/[A-Za-z0-9_$]/.test(ch)
+}
+
+function shiftAddrPart(part: string, deltaRow: number, deltaCol: number): string {
+  if (part.includes(':')) {
+    const [a, b] = part.split(':')
+    const left = shiftOneRef(a!, deltaRow, deltaCol)
+    const right = shiftOneRef(b!, deltaRow, deltaCol)
+    if (left === '#REF!' || right === '#REF!') return '#REF!'
+    return `${left}:${right}`
+  }
+  return shiftOneRef(part, deltaRow, deltaCol)
+}
+
+function shiftOneRef(ref: string, deltaRow: number, deltaCol: number): string {
+  const m = CELL_REF_RE.exec(ref)
+  if (!m) return ref
+  const colAbs = m[1] === '$'
+  const rowAbs = m[3] === '$'
+  let col = colNameToIndex(m[2]!)
+  let row = Number.parseInt(m[4]!, 10) - 1
+  if (col < 0 || row < 0) return '#REF!'
+  if (!colAbs) col += deltaCol
+  if (!rowAbs) row += deltaRow
+  if (col < 0 || row < 0) return '#REF!'
+  return `${colAbs ? '$' : ''}${colIndexToName(col)}${rowAbs ? '$' : ''}${row + 1}`
+}

package/src/core/sheet.ts

@@ -43,6 +43,11 @@ export class Sheet {
   readonly history: HistoryManager
   /** 公式依赖图（工作簿内多 sheet 共享；独立 Sheet 自建） */
   readonly formulaGraph: DependencyGraph
+  /**
+   * 稀疏行高（模型行号 → 像素高度）。
+   * 供 SheetGrid 在 tab 切换重建时还原；本期不进 undo。
+   */
+  private readonly rowHeights = new Map<number, number>()
 
   name: string
 
@@ -66,6 +71,26 @@ export class Sheet {
     return this.store.colCount
   }
 
+  /** 读取自定义行高；未设置返回 undefined（由视图层用默认行高） */
+  getRowHeight(row: number): number | undefined {
+    return this.rowHeights.get(row)
+  }
+
+  /** 设置自定义行高（不进 undo）；height ≤ 0 时清除自定义高度 */
+  setRowHeight(row: number, height: number): void {
+    if (!Number.isInteger(row) || row < 0) return
+    if (!Number.isFinite(height) || height <= 0) {
+      this.rowHeights.delete(row)
+      return
+    }
+    this.rowHeights.set(row, height)
+  }
+
+  /** 遍历已设置的自定义行高（SheetGrid 重建还原用） */
+  getRowHeights(): ReadonlyMap<number, number> {
+    return this.rowHeights
+  }
+
   // ─── 单元格数据 ────────────────────────────────────────────
 
   /** 原始存储语义读取（被覆盖格 → undefined） */

package/src/env.d.ts

@@ -5,3 +5,6 @@ declare module '*.vue' {
 }
 
 declare module '*.scss' {}
+
+// 跨包样式副作用子路径（veltra-dev → src/* 无扩展名，TS 不做扩展探测）
+declare module '@veltra/desktop/components/*/style' {}

package/src/grid/__test__/sheet-grid.test.ts

@@ -31,6 +31,104 @@ describe('SheetGrid（happy-dom smoke）', () => {
     }
   })
 
+  it('主题与交互选项：fillHandle / rowResize / clip / 编辑态方向键不换格', () => {
+    const { grid, table } = createGrid()
+    try {
+      const options = table.options
+      expect(options.excelOptions?.fillHandle).toBe(true)
+      expect(options.resize?.columnResizeMode).toBe('header')
+      expect(options.resize?.rowResizeMode).toBe('all')
+      // 列宽：仅列头；行高：仅行号列（body 格不可拖，避免干扰选区/编辑）
+      expect(table._canResizeColumn(1, 0)).toBe(true) // 列头 A
+      expect(table._canResizeColumn(1, 1)).toBe(false) // body
+      expect(table.isSeriesNumber(0, 1)).toBe(true)
+      expect(table._canResizeRow(0, 1)).toBe(true) // 行号列
+      expect(table._canResizeRow(1, 1)).toBe(false) // body
+      expect(options.keyboardOptions?.moveEditCellOnArrowKeys).toBe(false)
+      expect(options.defaultRowHeight).toBe(28)
+      expect(options.eventOptions?.preventDefaultContextMenu).toBe(true)
+      // theme 为 TableTheme 实例（DEFAULT.extends），读运行时解析值
+      const theme = table.theme
+      expect(theme.bodyStyle?.bgColor).toBe('#FFF')
+      expect(theme.bodyStyle?.textOverflow).toBe('clip')
+      expect(theme.defaultStyle?.textOverflow).toBe('clip')
+      expect(theme.defaultStyle?.borderColor).toBe('#E1E4E8')
+      // VTable DEFAULT 为 [10,16,10,16]；收紧后贴近 Excel
+      expect(theme.defaultStyle?.padding).toEqual([2, 6, 2, 6])
+      expect(theme.bodyStyle?.padding).toEqual([2, 6, 2, 6])
+      expect(theme.frameStyle?.borderColor).toBe('#E1E4E8')
+      expect(theme.selectionStyle?.cellBorderColor).toBe('#2170E7')
+      expect(theme.selectionStyle?.cellBorderColor).not.toBe('#000')
+      expect(options.rowSeriesNumber).toMatchObject({
+        width: 46,
+        style: { bgColor: '#F5F5F5', padding: [2, 6, 2, 6], textOverflow: 'clip' }
+      })
+    } finally {
+      grid.release()
+    }
+  })
+
+  it('右键 CONTEXTMENU_CELL → onContextMenu（client 坐标 + 模型地址）', async () => {
+    const sheet = new Sheet()
+    const container = createContainer()
+    const calls: Array<{ x: number; y: number; addr: { row: number; col: number } | null }> = []
+    const grid = new SheetGrid({
+      container,
+      sheet,
+      rows: 20,
+      cols: 6,
+      onContextMenu: (info) => calls.push(info)
+    })
+    try {
+      const table = grid.getTable()
+      // 表格坐标 (2,3) → 模型 B3（colOffset/rowOffset 各 1）
+      table.fireListeners(ListTable.EVENT_TYPE.CONTEXTMENU_CELL, {
+        col: 2,
+        row: 3,
+        event: { clientX: 120, clientY: 80, preventDefault() {} }
+      })
+      await Promise.resolve() // queueMicrotask
+      expect(calls).toHaveLength(1)
+      expect(calls[0]).toMatchObject({ x: 120, y: 80, addr: { row: 2, col: 1 } })
+    } finally {
+      grid.release()
+    }
+  })
+
+  it('行高：RESIZE_ROW_END 写入 Sheet，重建后还原', () => {
+    const container = createContainer()
+    const sheet = new Sheet()
+    let grid = new SheetGrid({ container, sheet, rows: 20, cols: 6 })
+    try {
+      grid.getTable().fireListeners(ListTable.EVENT_TYPE.RESIZE_ROW_END, { row: 2, rowHeight: 48 })
+      expect(sheet.getRowHeight(1)).toBe(48)
+
+      grid.release()
+      grid = new SheetGrid({ container, sheet, rows: 20, cols: 6 })
+      expect(grid.getTable().getRowHeight(2)).toBe(48)
+    } finally {
+      grid.release()
+    }
+  })
+
+  it('填充柄：DRAG_FILL_HANDLE_END 数字序列写入模型', () => {
+    const { sheet, grid, table } = createGrid()
+    try {
+      sheet.setCellValue({ row: 0, col: 0 }, 1)
+      sheet.selectRange({ start: { row: 0, col: 0 }, end: { row: 0, col: 0 } })
+      // 模拟源选区（表格坐标含偏移）
+      table.getSelectedCellRanges = () => [{ start: { col: 1, row: 1 }, end: { col: 1, row: 1 } }]
+      table.fireListeners(ListTable.EVENT_TYPE.MOUSEDOWN_FILL_HANDLE, {})
+      // 拖到底部扩展至 A1:A3
+      table.getSelectedCellRanges = () => [{ start: { col: 1, row: 1 }, end: { col: 1, row: 3 } }]
+      table.fireListeners(ListTable.EVENT_TYPE.DRAG_FILL_HANDLE_END, { direction: 'bottom' })
+      expect(sheet.getCellData({ row: 1, col: 0 })?.v).toBe(2)
+      expect(sheet.getCellData({ row: 2, col: 0 })?.v).toBe(3)
+    } finally {
+      grid.release()
+    }
+  })
+
   it('模型 → 表格：setCellValue 后表格可见', () => {
     const { sheet, grid, table } = createGrid()
     try {