@veltra/sheet 2.0.1 → 2.2.0

package/src/core/command/set-cell-value.ts

@@ -1,38 +0,0 @@
-import type { CellAddress } from '../address'
-import { cellDataEqual, isEmptyCellData, type CellData } from '../cell-store'
-import type { CellPatch, Command, CommandResult } from './types'
-
-/** SetCellValueCommand 的批量写入项 */
-export interface SetCellValueItem {
-  addr: CellAddress
-  /** 目标数据；空数据（无公式且 v 为 null/undefined/''）= 清除 */
-  data?: CellData
-}
-
-export interface SetCellValueParams {
-  /** 批量写入（供粘贴/填充复用）；一次调用 = 一个 undo 单元 */
-  items: SetCellValueItem[]
-}
-
-/**
- * 单元格写入命令：逐项解析锚点、捕获 before/after 差量并立即应用。
- * 与 before 相等的项跳过（不产生补丁）；全部无变化时不入历史。
- */
-export const SetCellValueCommand: Command<SetCellValueParams> = {
-  id: 'sheet.command.set-cell-value',
-
-  handler(ctx, params): CommandResult {
-    const patches: CellPatch[] = []
-    for (const item of params.items) {
-      const anchor = ctx.sheet.merges.resolveAnchor(item.addr)
-      const before = ctx.sheet.store.getCell(anchor)
-      const after = isEmptyCellData(item.data) ? undefined : item.data
-      if (cellDataEqual(before, after)) continue
-      const patch: CellPatch = { kind: 'cell', addr: anchor, before, after }
-      ctx.applyPatch(patch, 'redo')
-      patches.push(patch)
-    }
-    if (patches.length === 0) return { mutations: [] }
-    return { mutations: [{ redo: patches, undo: [...patches].reverse() }] }
-  }
-}

package/src/core/command/types.ts

@@ -1,73 +0,0 @@
-import type { CellAddress, CellRange } from '../address'
-import type { CellData } from '../cell-store'
-import type { Sheet } from '../sheet'
-
-/**
- * 命令系统类型定义（决策 5：命令 + 逆操作补丁）。
- *
- * - 一切模型变更都是 Command，执行时产出 Mutation
- * - Patch 是受影响单元格 / 合并记录的 before/after 差量，不是全量快照
- * - 同一批 Patch 双向回放：redo 方向应用 after，undo 方向应用 before
- */
-
-/** 补丁回放方向 */
-export type PatchDirection = 'undo' | 'redo'
-
-/** 单元格数据差量补丁（原始存储语义；undefined = 该侧无此格） */
-export interface CellPatch {
-  kind: 'cell'
-  addr: CellAddress
-  /**
-   * 目标 sheet（跨表公式重算的派生补丁会落在其它 sheet 上）；
-   * 缺省 = 命令所在 sheet。回放时按此字段路由到目标 sheet 的变更通道。
-   */
-  sheet?: Sheet
-  /** 变更前的数据（undefined = 原本为空格） */
-  before?: CellData
-  /** 变更后的数据（undefined = 变更后为空格） */
-  after?: CellData
-}
-
-/** 合并记录差量补丁（before/after = 该侧是否存在此合并） */
-export interface MergePatch {
-  kind: 'merge'
-  range: CellRange
-  before: boolean
-  after: boolean
-}
-
-export type Patch = CellPatch | MergePatch
-
-/**
- * 一次命令执行产生的变更单元。
- * `redo` 按列表顺序应用；`undo` 取同一批补丁的逆序（命令实现负责构造，
- * 保证 undo 先撤销后登记的副作用，例如先移除新合并再恢复旧合并）。
- */
-export interface Mutation {
-  redo: Patch[]
-  undo: Patch[]
-}
-
-/** 命令执行结果 */
-export interface CommandResult<R = unknown> {
-  /** 产生的 mutation 列表（空数组 = 无实际变更，不入历史） */
-  mutations: Mutation[]
-  /** 命令附带返回值（如 MergeCellsCommand 返回最终生效区域） */
-  result?: R
-}
-
-/** 命令执行上下文 */
-export interface CommandContext {
-  sheet: Sheet
-  /**
-   * 应用单个补丁。命令 handler 执行时对 redo 补丁逐项调用；
-   * HistoryManager 回放 undo/redo 亦走此路径，保证只有一条变更通道。
-   */
-  applyPatch(patch: Patch, direction: PatchDirection): void
-}
-
-/** 命令：id + handler */
-export interface Command<P = unknown, R = unknown> {
-  readonly id: string
-  handler(ctx: CommandContext, params: P): CommandResult<R> | undefined
-}

package/src/core/events.ts

@@ -1,37 +0,0 @@
-/**
- * 包内轻量类型化事件发射器（core 内部基建，不对外导出实现细节）。
- */
-
-export type EventHandler<T> = (payload: T) => void
-
-export class TypedEventEmitter<EventMap extends Record<string, unknown>> {
-  private handlers = new Map<keyof EventMap, Set<EventHandler<EventMap[keyof EventMap]>>>()
-
-  /** 订阅事件，返回取消订阅函数 */
-  on<K extends keyof EventMap>(type: K, handler: EventHandler<EventMap[K]>): () => void {
-    let set = this.handlers.get(type)
-    if (!set) {
-      set = new Set()
-      this.handlers.set(type, set)
-    }
-    set.add(handler as EventHandler<EventMap[keyof EventMap]>)
-    return () => this.off(type, handler)
-  }
-
-  off<K extends keyof EventMap>(type: K, handler: EventHandler<EventMap[K]>): void {
-    this.handlers.get(type)?.delete(handler as EventHandler<EventMap[keyof EventMap]>)
-  }
-
-  emit<K extends keyof EventMap>(type: K, payload: EventMap[K]): void {
-    const set = this.handlers.get(type)
-    if (!set) return
-    // Set 迭代天然容忍遍历中取消订阅
-    for (const handler of set) {
-      ;(handler as EventHandler<EventMap[K]>)(payload)
-    }
-  }
-
-  clear(): void {
-    this.handlers.clear()
-  }
-}

package/src/core/fill.ts

@@ -1,314 +0,0 @@
-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/formula/ast.ts

@@ -1,66 +0,0 @@
-import type { CellAddress, CellRange } from '../address'
-
-/**
- * 公式 AST 节点。
- * 引用节点携带可选 sheet 名（跨表引用）；缺省 = 公式所在 sheet。
- */
-
-export type BinaryOperator =
-  | '+'
-  | '-'
-  | '*'
-  | '/'
-  | '^'
-  | '&'
-  | '='
-  | '<>'
-  | '<'
-  | '<='
-  | '>'
-  | '>='
-
-export type AstNode =
-  | { kind: 'number'; value: number }
-  | { kind: 'string'; value: string }
-  | { kind: 'boolean'; value: boolean }
-  /** 未知名称（如裸写的 Sheet2 / 未定义命名）；求值为 #NAME? */
-  | { kind: 'name'; name: string }
-  | { kind: 'cell'; sheet?: string; addr: CellAddress }
-  | { kind: 'range'; sheet?: string; range: CellRange }
-  | { kind: 'unary'; op: '-' | '+'; operand: AstNode }
-  /** 百分号后缀运算（除以 100） */
-  | { kind: 'percent'; operand: AstNode }
-  | { kind: 'binary'; op: BinaryOperator; left: AstNode; right: AstNode }
-  | { kind: 'call'; name: string; args: AstNode[] }
-
-/** 公式中的引用（依赖图提取用）：sheet 缺省由所属公式节点补齐 */
-export interface AstReference {
-  sheet?: string
-  range: CellRange
-}
-
-/** 遍历 AST，收集全部引用（单格视为 1×1 区域） */
-export function collectReferences(node: AstNode, out: AstReference[] = []): AstReference[] {
-  switch (node.kind) {
-    case 'cell':
-      out.push({ sheet: node.sheet, range: { start: node.addr, end: node.addr } })
-      break
-    case 'range':
-      out.push({ sheet: node.sheet, range: node.range })
-      break
-    case 'unary':
-    case 'percent':
-      collectReferences(node.operand, out)
-      break
-    case 'binary':
-      collectReferences(node.left, out)
-      collectReferences(node.right, out)
-      break
-    case 'call':
-      for (const arg of node.args) collectReferences(arg, out)
-      break
-    default:
-      break
-  }
-  return out
-}