@veltra/sheet 2.0.0

package/dist/core/command/history.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"history.js","names":[],"sources":["../../../src/core/command/history.ts"],"sourcesContent":["import { TypedEventEmitter } from '../events'\nimport type { Mutation, Patch, PatchDirection } from './types'\n\n/**\n * HistoryManager：undo/redo 栈 + 事务。\n *\n * - 一个 undo 单元 = 一次命令（或一次事务）的全部 Mutation\n * - 事务：beginTransaction / commit，支持嵌套（深度计数，拍平到最外层）；\n *   rollback 回滚缓冲区中已应用的变更并放弃事务\n * - 容量上限（默认 200）：超出淘汰最旧条目\n * - 新命令入栈即清空 redo 栈\n */\n\n/** 历史栈容量默认值 */\nexport const DEFAULT_HISTORY_CAPACITY = 200\n\n/** 历史状态（history-change 事件负载） */\nexport interface HistoryState {\n  canUndo: boolean\n  canRedo: boolean\n}\n\ntype HistoryEvents = { change: HistoryState }\n\n/** 一个 undo 单元 = 一组 Mutation */\ntype HistoryEntry = Mutation[]\n\nexport class HistoryManager {\n  private undoStack: HistoryEntry[] = []\n  private redoStack: HistoryEntry[] = []\n  /** 事务深度（>0 表示事务进行中） */\n  private transactionDepth = 0\n  /** 事务缓冲：commit 时合并为一个 undo 单元 */\n  private transactionBuffer: Mutation[] = []\n  private emitter = new TypedEventEmitter<HistoryEvents>()\n\n  constructor(\n    /** 补丁应用器（由 Sheet 注入，命令执行与回放共用） */\n    private readonly applyPatch: (patch: Patch, direction: PatchDirection) => void,\n    private readonly capacity: number = DEFAULT_HISTORY_CAPACITY\n  ) {}\n\n  get canUndo(): boolean {\n    return this.undoStack.length > 0\n  }\n\n  get canRedo(): boolean {\n    return this.redoStack.length > 0\n  }\n\n  /** undo 栈深度（调试/测试用） */\n  get undoSize(): number {\n    return this.undoStack.length\n  }\n\n  /** redo 栈深度（调试/测试用） */\n  get redoSize(): number {\n    return this.redoStack.length\n  }\n\n  /** 是否处于事务中 */\n  get inTransaction(): boolean {\n    return this.transactionDepth > 0\n  }\n\n  /** 命令执行产生的 mutation 入栈（事务中则缓冲）；空列表直接忽略 */\n  push(mutations: Mutation[]): void {\n    if (mutations.length === 0) return\n    if (this.transactionDepth > 0) {\n      this.transactionBuffer.push(...mutations)\n      return\n    }\n    this.pushEntry(mutations)\n  }\n\n  /** 开启事务（可嵌套，拍平到最外层） */\n  beginTransaction(): void {\n    this.transactionDepth++\n  }\n\n  /** 提交事务：缓冲的 mutation 合并为一个 undo 单元入栈 */\n  commit(): void {\n    if (this.transactionDepth === 0) {\n      throw new Error('HistoryManager.commit：没有进行中的事务')\n    }\n    this.transactionDepth--\n    if (this.transactionDepth === 0 && this.transactionBuffer.length > 0) {\n      const entry = this.transactionBuffer\n      this.transactionBuffer = []\n      this.pushEntry(entry)\n    }\n  }\n\n  /**\n   * 回滚事务：逆序应用缓冲区中各 mutation 的 undo 补丁还原模型，\n   * 丢弃缓冲并结束事务（含嵌套）；不动 undo/redo 栈。\n   */\n  rollback(): void {\n    if (this.transactionDepth === 0) return\n    const buffer = this.transactionBuffer\n    this.transactionBuffer = []\n    this.transactionDepth = 0\n    for (let i = buffer.length - 1; i >= 0; i--) {\n      for (const patch of buffer[i]!.undo) {\n        this.applyPatch(patch, 'undo')\n      }\n    }\n  }\n\n  /** 撤销一个单元；事务进行中或栈空时返回 false */\n  undo(): boolean {\n    if (this.transactionDepth > 0) return false\n    const entry = this.undoStack.pop()\n    if (!entry) return false\n    for (let i = entry.length - 1; i >= 0; i--) {\n      for (const patch of entry[i]!.undo) {\n        this.applyPatch(patch, 'undo')\n      }\n    }\n    this.redoStack.push(entry)\n    this.emitChange()\n    return true\n  }\n\n  /** 重做一个单元；事务进行中或栈空时返回 false */\n  redo(): boolean {\n    if (this.transactionDepth > 0) return false\n    const entry = this.redoStack.pop()\n    if (!entry) return false\n    for (const mutation of entry) {\n      for (const patch of mutation.redo) {\n        this.applyPatch(patch, 'redo')\n      }\n    }\n    this.undoStack.push(entry)\n    this.emitChange()\n    return true\n  }\n\n  /** 清空全部历史（含事务缓冲） */\n  clear(): void {\n    this.undoStack = []\n    this.redoStack = []\n    this.transactionBuffer = []\n    this.transactionDepth = 0\n    this.emitChange()\n  }\n\n  onChange(handler: (state: HistoryState) => void): () => void {\n    return this.emitter.on('change', handler)\n  }\n\n  private pushEntry(entry: HistoryEntry): void {\n    this.undoStack.push(entry)\n    if (this.undoStack.length > this.capacity) {\n      // 淘汰最旧条目；redo 栈不受影响（淘汰只发生在 undo 栈底部）\n      this.undoStack.shift()\n    }\n    // 新命令清空 redo 栈\n    this.redoStack = []\n    this.emitChange()\n  }\n\n  private emitChange(): void {\n    this.emitter.emit('change', { canUndo: this.canUndo, canRedo: this.canRedo })\n  }\n}\n"],"mappings":";;;;;;;;;;;;AAcA,MAAa,2BAA2B;AAaxC,IAAa,iBAAb,MAA4B;CAWP;CACA;CAXnB,YAAoC,CAAC;CACrC,YAAoC,CAAC;;CAErC,mBAA2B;;CAE3B,oBAAwC,CAAC;CACzC,UAAkB,IAAI,kBAAiC;CAEvD,YAEE,YACA,WAAiB,KACjB;EAFiB,KAAA,aAAA;EACA,KAAA,WAAA;CAChB;CAEH,IAAI,UAAmB;EACrB,OAAO,KAAK,UAAU,SAAS;CACjC;CAEA,IAAI,UAAmB;EACrB,OAAO,KAAK,UAAU,SAAS;CACjC;;CAGA,IAAI,WAAmB;EACrB,OAAO,KAAK,UAAU;CACxB;;CAGA,IAAI,WAAmB;EACrB,OAAO,KAAK,UAAU;CACxB;;CAGA,IAAI,gBAAyB;EAC3B,OAAO,KAAK,mBAAmB;CACjC;;CAGA,KAAK,WAA6B;EAChC,IAAI,UAAU,WAAW,GAAG;EAC5B,IAAI,KAAK,mBAAmB,GAAG;GAC7B,KAAK,kBAAkB,KAAK,GAAG,SAAS;GACxC;EACF;EACA,KAAK,UAAU,SAAS;CAC1B;;CAGA,mBAAyB;EACvB,KAAK;CACP;;CAGA,SAAe;EACb,IAAI,KAAK,qBAAqB,GAC5B,MAAM,IAAI,MAAM,gCAAgC;EAElD,KAAK;EACL,IAAI,KAAK,qBAAqB,KAAK,KAAK,kBAAkB,SAAS,GAAG;GACpE,MAAM,QAAQ,KAAK;GACnB,KAAK,oBAAoB,CAAC;GAC1B,KAAK,UAAU,KAAK;EACtB;CACF;;;;;CAMA,WAAiB;EACf,IAAI,KAAK,qBAAqB,GAAG;EACjC,MAAM,SAAS,KAAK;EACpB,KAAK,oBAAoB,CAAC;EAC1B,KAAK,mBAAmB;EACxB,KAAK,IAAI,IAAI,OAAO,SAAS,GAAG,KAAK,GAAG,KACtC,KAAK,MAAM,SAAS,OAAO,EAAE,CAAE,MAC7B,KAAK,WAAW,OAAO,MAAM;CAGnC;;CAGA,OAAgB;EACd,IAAI,KAAK,mBAAmB,GAAG,OAAO;EACtC,MAAM,QAAQ,KAAK,UAAU,IAAI;EACjC,IAAI,CAAC,OAAO,OAAO;EACnB,KAAK,IAAI,IAAI,MAAM,SAAS,GAAG,KAAK,GAAG,KACrC,KAAK,MAAM,SAAS,MAAM,EAAE,CAAE,MAC5B,KAAK,WAAW,OAAO,MAAM;EAGjC,KAAK,UAAU,KAAK,KAAK;EACzB,KAAK,WAAW;EAChB,OAAO;CACT;;CAGA,OAAgB;EACd,IAAI,KAAK,mBAAmB,GAAG,OAAO;EACtC,MAAM,QAAQ,KAAK,UAAU,IAAI;EACjC,IAAI,CAAC,OAAO,OAAO;EACnB,KAAK,MAAM,YAAY,OACrB,KAAK,MAAM,SAAS,SAAS,MAC3B,KAAK,WAAW,OAAO,MAAM;EAGjC,KAAK,UAAU,KAAK,KAAK;EACzB,KAAK,WAAW;EAChB,OAAO;CACT;;CAGA,QAAc;EACZ,KAAK,YAAY,CAAC;EAClB,KAAK,YAAY,CAAC;EAClB,KAAK,oBAAoB,CAAC;EAC1B,KAAK,mBAAmB;EACxB,KAAK,WAAW;CAClB;CAEA,SAAS,SAAoD;EAC3D,OAAO,KAAK,QAAQ,GAAG,UAAU,OAAO;CAC1C;CAEA,UAAkB,OAA2B;EAC3C,KAAK,UAAU,KAAK,KAAK;EACzB,IAAI,KAAK,UAAU,SAAS,KAAK,UAE/B,KAAK,UAAU,MAAM;EAGvB,KAAK,YAAY,CAAC;EAClB,KAAK,WAAW;CAClB;CAEA,aAA2B;EACzB,KAAK,QAAQ,KAAK,UAAU;GAAE,SAAS,KAAK;GAAS,SAAS,KAAK;EAAQ,CAAC;CAC9E;AACF"}

package/dist/core/command/merge-cells.d.ts

@@ -0,0 +1,21 @@
+import { CellRange } from "../address.js";
+import { Command } from "./types.js";
+//#region src/core/command/merge-cells.d.ts
+interface MergeCellsParams {
+  range: CellRange;
+}
+/**
+ * 合并命令。Patch 捕获完整 before 状态：
+ * - 被解除的既有合并记录（undo 时逐一恢复）
+ * - 包围盒内每一格的原数据（undo 时连被清空的值一起还原）
+ * 值保留规则同 Excel/univer：行主序第一个有值格的值写入新锚点，其余清空。
+ */
+declare const MergeCellsCommand: Command<MergeCellsParams, CellRange>;
+interface UnmergeCellsParams {
+  range: CellRange;
+}
+/** 取消合并命令：解除与 range 相交的所有合并；undo 恢复合并记录 */
+declare const UnmergeCellsCommand: Command<UnmergeCellsParams>;
+//#endregion
+export { MergeCellsCommand, MergeCellsParams, UnmergeCellsCommand, UnmergeCellsParams };
+//# sourceMappingURL=merge-cells.d.ts.map

package/dist/core/command/merge-cells.js

@@ -0,0 +1,74 @@
+import { iterateRange, rangesIntersect } from "../address.js";
+import { cellDataEqual, isEmptyCellData } from "../cell-store.js";
+//#region src/core/command/merge-cells.ts
+/**
+* 合并命令。Patch 捕获完整 before 状态：
+* - 被解除的既有合并记录（undo 时逐一恢复）
+* - 包围盒内每一格的原数据（undo 时连被清空的值一起还原）
+* 值保留规则同 Excel/univer：行主序第一个有值格的值写入新锚点，其余清空。
+*/
+const MergeCellsCommand = {
+	id: "sheet.command.merge-cells",
+	handler(ctx, params) {
+		const { sheet } = ctx;
+		const { range: finalRange, removed } = sheet.merges.computeMerge(params.range);
+		const cellPatches = [];
+		let retained;
+		let anchorPatch;
+		for (const addr of iterateRange(finalRange)) {
+			const before = sheet.store.getCell(addr);
+			if (before && !retained && !isEmptyCellData(before)) retained = before;
+			const patch = {
+				kind: "cell",
+				addr,
+				before,
+				after: void 0
+			};
+			if (addr.row === finalRange.start.row && addr.col === finalRange.start.col) anchorPatch = patch;
+			cellPatches.push(patch);
+		}
+		if (retained && anchorPatch) anchorPatch.after = { ...retained };
+		const patches = [...[...removed.map((range) => ({
+			kind: "merge",
+			range,
+			before: true,
+			after: false
+		})), {
+			kind: "merge",
+			range: finalRange,
+			before: false,
+			after: true
+		}], ...cellPatches.filter((patch) => !cellDataEqual(patch.before, patch.after))];
+		for (const patch of patches) ctx.applyPatch(patch, "redo");
+		return {
+			mutations: [{
+				redo: patches,
+				undo: [...patches].reverse()
+			}],
+			result: finalRange
+		};
+	}
+};
+/** 取消合并命令：解除与 range 相交的所有合并；undo 恢复合并记录 */
+const UnmergeCellsCommand = {
+	id: "sheet.command.unmerge-cells",
+	handler(ctx, params) {
+		const removed = [];
+		for (const range of ctx.sheet.merges.getMerges()) if (rangesIntersect(range, params.range)) removed.push({
+			kind: "merge",
+			range,
+			before: true,
+			after: false
+		});
+		if (removed.length === 0) return { mutations: [] };
+		for (const patch of removed) ctx.applyPatch(patch, "redo");
+		return { mutations: [{
+			redo: removed,
+			undo: [...removed].reverse()
+		}] };
+	}
+};
+//#endregion
+export { MergeCellsCommand, UnmergeCellsCommand };
+
+//# sourceMappingURL=merge-cells.js.map

package/dist/core/command/merge-cells.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"merge-cells.js","names":[],"sources":["../../../src/core/command/merge-cells.ts"],"sourcesContent":["import { iterateRange, rangesIntersect, type CellRange } from '../address'\nimport { cellDataEqual, isEmptyCellData, type CellData } from '../cell-store'\nimport type { CellPatch, Command, CommandResult, MergePatch, Patch } from './types'\n\nexport interface MergeCellsParams {\n  range: CellRange\n}\n\n/**\n * 合并命令。Patch 捕获完整 before 状态：\n * - 被解除的既有合并记录（undo 时逐一恢复）\n * - 包围盒内每一格的原数据（undo 时连被清空的值一起还原）\n * 值保留规则同 Excel/univer：行主序第一个有值格的值写入新锚点，其余清空。\n */\nexport const MergeCellsCommand: Command<MergeCellsParams, CellRange> = {\n  id: 'sheet.command.merge-cells',\n\n  handler(ctx, params): CommandResult<CellRange> {\n    const { sheet } = ctx\n    const { range: finalRange, removed } = sheet.merges.computeMerge(params.range)\n\n    // 捕获包围盒内各格 before；同时按行主序找出第一个有值格\n    const cellPatches: CellPatch[] = []\n    let retained: CellData | undefined\n    let anchorPatch: CellPatch | undefined\n    for (const addr of iterateRange(finalRange)) {\n      const before = sheet.store.getCell(addr)\n      if (before && !retained && !isEmptyCellData(before)) retained = before\n      const patch: CellPatch = { kind: 'cell', addr, before, after: undefined }\n      if (addr.row === finalRange.start.row && addr.col === finalRange.start.col) {\n        anchorPatch = patch\n      }\n      cellPatches.push(patch)\n    }\n    if (retained && anchorPatch) {\n      anchorPatch.after = { ...retained }\n    }\n\n    const mergePatches: MergePatch[] = [\n      ...removed.map((range): MergePatch => ({ kind: 'merge', range, before: true, after: false })),\n      { kind: 'merge', range: finalRange, before: false, after: true }\n    ]\n\n    // 过滤无实际变化的 cell 补丁（如被覆盖格本就为空）\n    const patches: Patch[] = [\n      ...mergePatches,\n      ...cellPatches.filter((patch) => !cellDataEqual(patch.before, patch.after))\n    ]\n    for (const patch of patches) ctx.applyPatch(patch, 'redo')\n\n    return { mutations: [{ redo: patches, undo: [...patches].reverse() }], result: finalRange }\n  }\n}\n\nexport interface UnmergeCellsParams {\n  range: CellRange\n}\n\n/** 取消合并命令：解除与 range 相交的所有合并；undo 恢复合并记录 */\nexport const UnmergeCellsCommand: Command<UnmergeCellsParams> = {\n  id: 'sheet.command.unmerge-cells',\n\n  handler(ctx, params): CommandResult {\n    const removed: MergePatch[] = []\n    for (const range of ctx.sheet.merges.getMerges()) {\n      if (rangesIntersect(range, params.range)) {\n        removed.push({ kind: 'merge', range, before: true, after: false })\n      }\n    }\n    if (removed.length === 0) return { mutations: [] }\n    for (const patch of removed) ctx.applyPatch(patch, 'redo')\n    return { mutations: [{ redo: removed, undo: [...removed].reverse() }] }\n  }\n}\n"],"mappings":";;;;;;;;;AAcA,MAAa,oBAA0D;CACrE,IAAI;CAEJ,QAAQ,KAAK,QAAkC;EAC7C,MAAM,EAAE,UAAU;EAClB,MAAM,EAAE,OAAO,YAAY,YAAY,MAAM,OAAO,aAAa,OAAO,KAAK;EAG7E,MAAM,cAA2B,CAAC;EAClC,IAAI;EACJ,IAAI;EACJ,KAAK,MAAM,QAAQ,aAAa,UAAU,GAAG;GAC3C,MAAM,SAAS,MAAM,MAAM,QAAQ,IAAI;GACvC,IAAI,UAAU,CAAC,YAAY,CAAC,gBAAgB,MAAM,GAAG,WAAW;GAChE,MAAM,QAAmB;IAAE,MAAM;IAAQ;IAAM;IAAQ,OAAO,KAAA;GAAU;GACxE,IAAI,KAAK,QAAQ,WAAW,MAAM,OAAO,KAAK,QAAQ,WAAW,MAAM,KACrE,cAAc;GAEhB,YAAY,KAAK,KAAK;EACxB;EACA,IAAI,YAAY,aACd,YAAY,QAAQ,EAAE,GAAG,SAAS;EASpC,MAAM,UAAmB,CACvB,GAAG,CANH,GAAG,QAAQ,KAAK,WAAuB;GAAE,MAAM;GAAS;GAAO,QAAQ;GAAM,OAAO;EAAM,EAAE,GAC5F;GAAE,MAAM;GAAS,OAAO;GAAY,QAAQ;GAAO,OAAO;EAAK,CAKjD,GACd,GAAG,YAAY,QAAQ,UAAU,CAAC,cAAc,MAAM,QAAQ,MAAM,KAAK,CAAC,CAC5E;EACA,KAAK,MAAM,SAAS,SAAS,IAAI,WAAW,OAAO,MAAM;EAEzD,OAAO;GAAE,WAAW,CAAC;IAAE,MAAM;IAAS,MAAM,CAAC,GAAG,OAAO,CAAC,CAAC,QAAQ;GAAE,CAAC;GAAG,QAAQ;EAAW;CAC5F;AACF;;AAOA,MAAa,sBAAmD;CAC9D,IAAI;CAEJ,QAAQ,KAAK,QAAuB;EAClC,MAAM,UAAwB,CAAC;EAC/B,KAAK,MAAM,SAAS,IAAI,MAAM,OAAO,UAAU,GAC7C,IAAI,gBAAgB,OAAO,OAAO,KAAK,GACrC,QAAQ,KAAK;GAAE,MAAM;GAAS;GAAO,QAAQ;GAAM,OAAO;EAAM,CAAC;EAGrE,IAAI,QAAQ,WAAW,GAAG,OAAO,EAAE,WAAW,CAAC,EAAE;EACjD,KAAK,MAAM,SAAS,SAAS,IAAI,WAAW,OAAO,MAAM;EACzD,OAAO,EAAE,WAAW,CAAC;GAAE,MAAM;GAAS,MAAM,CAAC,GAAG,OAAO,CAAC,CAAC,QAAQ;EAAE,CAAC,EAAE;CACxE;AACF"}

package/dist/core/command/registry.d.ts

@@ -0,0 +1,17 @@
+import { Command, CommandContext, CommandResult } from "./types.js";
+//#region src/core/command/registry.d.ts
+/**
+ * 命令注册表：register / execute。
+ * 命令无状态，可全局共享（见 default-registry）；阶段 4 工具扩展可注册自定义命令。
+ */
+declare class CommandRegistry {
+  private commands;
+  /** 注册命令；同 id 重复注册视为错误 */
+  register(command: Command): void;
+  get(id: string): Command | undefined;
+  /** 执行命令；未注册的 id 抛错 */
+  execute<R>(ctx: CommandContext, id: string, params: unknown): CommandResult<R> | undefined;
+}
+//#endregion
+export { CommandRegistry };
+//# sourceMappingURL=registry.d.ts.map

package/dist/core/command/registry.js

@@ -0,0 +1,26 @@
+//#region src/core/command/registry.ts
+/**
+* 命令注册表：register / execute。
+* 命令无状态，可全局共享（见 default-registry）；阶段 4 工具扩展可注册自定义命令。
+*/
+var CommandRegistry = class {
+	commands = /* @__PURE__ */ new Map();
+	/** 注册命令；同 id 重复注册视为错误 */
+	register(command) {
+		if (this.commands.has(command.id)) throw new Error(`命令重复注册: ${command.id}`);
+		this.commands.set(command.id, command);
+	}
+	get(id) {
+		return this.commands.get(id);
+	}
+	/** 执行命令；未注册的 id 抛错 */
+	execute(ctx, id, params) {
+		const command = this.commands.get(id);
+		if (!command) throw new Error(`命令未注册: ${id}`);
+		return command.handler(ctx, params);
+	}
+};
+//#endregion
+export { CommandRegistry };
+
+//# sourceMappingURL=registry.js.map

package/dist/core/command/registry.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"registry.js","names":[],"sources":["../../../src/core/command/registry.ts"],"sourcesContent":["import type { Command, CommandContext, CommandResult } from './types'\n\n/**\n * 命令注册表：register / execute。\n * 命令无状态，可全局共享（见 default-registry）；阶段 4 工具扩展可注册自定义命令。\n */\nexport class CommandRegistry {\n  private commands = new Map<string, Command>()\n\n  /** 注册命令；同 id 重复注册视为错误 */\n  register(command: Command): void {\n    if (this.commands.has(command.id)) {\n      throw new Error(`命令重复注册: ${command.id}`)\n    }\n    this.commands.set(command.id, command)\n  }\n\n  get(id: string): Command | undefined {\n    return this.commands.get(id)\n  }\n\n  /** 执行命令；未注册的 id 抛错 */\n  execute<R>(ctx: CommandContext, id: string, params: unknown): CommandResult<R> | undefined {\n    const command = this.commands.get(id)\n    if (!command) {\n      throw new Error(`命令未注册: ${id}`)\n    }\n    return command.handler(ctx, params) as CommandResult<R> | undefined\n  }\n}\n"],"mappings":";;;;;AAMA,IAAa,kBAAb,MAA6B;CAC3B,2BAAmB,IAAI,IAAqB;;CAG5C,SAAS,SAAwB;EAC/B,IAAI,KAAK,SAAS,IAAI,QAAQ,EAAE,GAC9B,MAAM,IAAI,MAAM,WAAW,QAAQ,IAAI;EAEzC,KAAK,SAAS,IAAI,QAAQ,IAAI,OAAO;CACvC;CAEA,IAAI,IAAiC;EACnC,OAAO,KAAK,SAAS,IAAI,EAAE;CAC7B;;CAGA,QAAW,KAAqB,IAAY,QAA+C;EACzF,MAAM,UAAU,KAAK,SAAS,IAAI,EAAE;EACpC,IAAI,CAAC,SACH,MAAM,IAAI,MAAM,UAAU,IAAI;EAEhC,OAAO,QAAQ,QAAQ,KAAK,MAAM;CACpC;AACF"}

package/dist/core/command/set-cell-formula.d.ts

@@ -0,0 +1,17 @@
+import { CellAddress } from "../address.js";
+import { Command } from "./types.js";
+//#region src/core/command/set-cell-formula.d.ts
+interface SetCellFormulaParams {
+  addr: CellAddress;
+  /** 公式文本（不含 '='） */
+  formula: string;
+}
+/**
+ * 公式写入命令：只登记公式原文（f）；计算缓存（v/t）由命令执行后的
+ * 增量重算以派生补丁填充（见 Sheet.executeCommand），重算波及的所有变更
+ * 与源补丁并入同一 undo 单元。
+ */
+declare const SetCellFormulaCommand: Command<SetCellFormulaParams>;
+//#endregion
+export { SetCellFormulaCommand, SetCellFormulaParams };
+//# sourceMappingURL=set-cell-formula.d.ts.map

package/dist/core/command/set-cell-formula.js

@@ -0,0 +1,29 @@
+//#region src/core/command/set-cell-formula.ts
+/**
+* 公式写入命令：只登记公式原文（f）；计算缓存（v/t）由命令执行后的
+* 增量重算以派生补丁填充（见 Sheet.executeCommand），重算波及的所有变更
+* 与源补丁并入同一 undo 单元。
+*/
+const SetCellFormulaCommand = {
+	id: "sheet.command.set-cell-formula",
+	handler(ctx, params) {
+		const anchor = ctx.sheet.merges.resolveAnchor(params.addr);
+		const before = ctx.sheet.store.getCell(anchor);
+		if (before?.f === params.formula) return { mutations: [] };
+		const patch = {
+			kind: "cell",
+			addr: anchor,
+			before,
+			after: { f: params.formula }
+		};
+		ctx.applyPatch(patch, "redo");
+		return { mutations: [{
+			redo: [patch],
+			undo: [patch]
+		}] };
+	}
+};
+//#endregion
+export { SetCellFormulaCommand };
+
+//# sourceMappingURL=set-cell-formula.js.map

package/dist/core/command/set-cell-formula.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"set-cell-formula.js","names":[],"sources":["../../../src/core/command/set-cell-formula.ts"],"sourcesContent":["import type { CellAddress } from '../address'\nimport type { CellData } from '../cell-store'\nimport type { CellPatch, Command, CommandResult } from './types'\n\nexport interface SetCellFormulaParams {\n  addr: CellAddress\n  /** 公式文本（不含 '='） */\n  formula: string\n}\n\n/**\n * 公式写入命令：只登记公式原文（f）；计算缓存（v/t）由命令执行后的\n * 增量重算以派生补丁填充（见 Sheet.executeCommand），重算波及的所有变更\n * 与源补丁并入同一 undo 单元。\n */\nexport const SetCellFormulaCommand: Command<SetCellFormulaParams> = {\n  id: 'sheet.command.set-cell-formula',\n\n  handler(ctx, params): CommandResult {\n    const anchor = ctx.sheet.merges.resolveAnchor(params.addr)\n    const before = ctx.sheet.store.getCell(anchor)\n    // 同公式重复输入 = 无实际变更，不入历史\n    if (before?.f === params.formula) return { mutations: [] }\n    const after: CellData = { f: params.formula }\n    const patch: CellPatch = { kind: 'cell', addr: anchor, before, after }\n    ctx.applyPatch(patch, 'redo')\n    return { mutations: [{ redo: [patch], undo: [patch] }] }\n  }\n}\n"],"mappings":";;;;;;AAeA,MAAa,wBAAuD;CAClE,IAAI;CAEJ,QAAQ,KAAK,QAAuB;EAClC,MAAM,SAAS,IAAI,MAAM,OAAO,cAAc,OAAO,IAAI;EACzD,MAAM,SAAS,IAAI,MAAM,MAAM,QAAQ,MAAM;EAE7C,IAAI,QAAQ,MAAM,OAAO,SAAS,OAAO,EAAE,WAAW,CAAC,EAAE;EAEzD,MAAM,QAAmB;GAAE,MAAM;GAAQ,MAAM;GAAQ;GAAQ,OAAA,EADrC,GAAG,OAAO,QAC+B;EAAE;EACrE,IAAI,WAAW,OAAO,MAAM;EAC5B,OAAO,EAAE,WAAW,CAAC;GAAE,MAAM,CAAC,KAAK;GAAG,MAAM,CAAC,KAAK;EAAE,CAAC,EAAE;CACzD;AACF"}

package/dist/core/command/set-cell-value.d.ts

@@ -0,0 +1,22 @@
+import { CellAddress } from "../address.js";
+import { CellData } from "../cell-store.js";
+import { Command } from "./types.js";
+//#region src/core/command/set-cell-value.d.ts
+/** SetCellValueCommand 的批量写入项 */
+interface SetCellValueItem {
+  addr: CellAddress;
+  /** 目标数据；空数据（无公式且 v 为 null/undefined/''）= 清除 */
+  data?: CellData;
+}
+interface SetCellValueParams {
+  /** 批量写入（供粘贴/填充复用）；一次调用 = 一个 undo 单元 */
+  items: SetCellValueItem[];
+}
+/**
+ * 单元格写入命令：逐项解析锚点、捕获 before/after 差量并立即应用。
+ * 与 before 相等的项跳过（不产生补丁）；全部无变化时不入历史。
+ */
+declare const SetCellValueCommand: Command<SetCellValueParams>;
+//#endregion
+export { SetCellValueCommand, SetCellValueItem, SetCellValueParams };
+//# sourceMappingURL=set-cell-value.d.ts.map

package/dist/core/command/set-cell-value.js

@@ -0,0 +1,35 @@
+import { cellDataEqual, isEmptyCellData } from "../cell-store.js";
+//#region src/core/command/set-cell-value.ts
+/**
+* 单元格写入命令：逐项解析锚点、捕获 before/after 差量并立即应用。
+* 与 before 相等的项跳过（不产生补丁）；全部无变化时不入历史。
+*/
+const SetCellValueCommand = {
+	id: "sheet.command.set-cell-value",
+	handler(ctx, params) {
+		const patches = [];
+		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) ? void 0 : item.data;
+			if (cellDataEqual(before, after)) continue;
+			const patch = {
+				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()
+		}] };
+	}
+};
+//#endregion
+export { SetCellValueCommand };
+
+//# sourceMappingURL=set-cell-value.js.map

package/dist/core/command/set-cell-value.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"set-cell-value.js","names":[],"sources":["../../../src/core/command/set-cell-value.ts"],"sourcesContent":["import type { CellAddress } from '../address'\nimport { cellDataEqual, isEmptyCellData, type CellData } from '../cell-store'\nimport type { CellPatch, Command, CommandResult } from './types'\n\n/** SetCellValueCommand 的批量写入项 */\nexport interface SetCellValueItem {\n  addr: CellAddress\n  /** 目标数据；空数据（无公式且 v 为 null/undefined/''）= 清除 */\n  data?: CellData\n}\n\nexport interface SetCellValueParams {\n  /** 批量写入（供粘贴/填充复用）；一次调用 = 一个 undo 单元 */\n  items: SetCellValueItem[]\n}\n\n/**\n * 单元格写入命令：逐项解析锚点、捕获 before/after 差量并立即应用。\n * 与 before 相等的项跳过（不产生补丁）；全部无变化时不入历史。\n */\nexport const SetCellValueCommand: Command<SetCellValueParams> = {\n  id: 'sheet.command.set-cell-value',\n\n  handler(ctx, params): CommandResult {\n    const patches: CellPatch[] = []\n    for (const item of params.items) {\n      const anchor = ctx.sheet.merges.resolveAnchor(item.addr)\n      const before = ctx.sheet.store.getCell(anchor)\n      const after = isEmptyCellData(item.data) ? undefined : item.data\n      if (cellDataEqual(before, after)) continue\n      const patch: CellPatch = { kind: 'cell', addr: anchor, before, after }\n      ctx.applyPatch(patch, 'redo')\n      patches.push(patch)\n    }\n    if (patches.length === 0) return { mutations: [] }\n    return { mutations: [{ redo: patches, undo: [...patches].reverse() }] }\n  }\n}\n"],"mappings":";;;;;;AAoBA,MAAa,sBAAmD;CAC9D,IAAI;CAEJ,QAAQ,KAAK,QAAuB;EAClC,MAAM,UAAuB,CAAC;EAC9B,KAAK,MAAM,QAAQ,OAAO,OAAO;GAC/B,MAAM,SAAS,IAAI,MAAM,OAAO,cAAc,KAAK,IAAI;GACvD,MAAM,SAAS,IAAI,MAAM,MAAM,QAAQ,MAAM;GAC7C,MAAM,QAAQ,gBAAgB,KAAK,IAAI,IAAI,KAAA,IAAY,KAAK;GAC5D,IAAI,cAAc,QAAQ,KAAK,GAAG;GAClC,MAAM,QAAmB;IAAE,MAAM;IAAQ,MAAM;IAAQ;IAAQ;GAAM;GACrE,IAAI,WAAW,OAAO,MAAM;GAC5B,QAAQ,KAAK,KAAK;EACpB;EACA,IAAI,QAAQ,WAAW,GAAG,OAAO,EAAE,WAAW,CAAC,EAAE;EACjD,OAAO,EAAE,WAAW,CAAC;GAAE,MAAM;GAAS,MAAM,CAAC,GAAG,OAAO,CAAC,CAAC,QAAQ;EAAE,CAAC,EAAE;CACxE;AACF"}

package/dist/core/command/types.d.ts

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

package/dist/core/events.js

@@ -0,0 +1,29 @@
+//#region src/core/events.ts
+var TypedEventEmitter = class {
+	handlers = /* @__PURE__ */ new Map();
+	/** 订阅事件，返回取消订阅函数 */
+	on(type, handler) {
+		let set = this.handlers.get(type);
+		if (!set) {
+			set = /* @__PURE__ */ new Set();
+			this.handlers.set(type, set);
+		}
+		set.add(handler);
+		return () => this.off(type, handler);
+	}
+	off(type, handler) {
+		this.handlers.get(type)?.delete(handler);
+	}
+	emit(type, payload) {
+		const set = this.handlers.get(type);
+		if (!set) return;
+		for (const handler of set) handler(payload);
+	}
+	clear() {
+		this.handlers.clear();
+	}
+};
+//#endregion
+export { TypedEventEmitter };
+
+//# sourceMappingURL=events.js.map

package/dist/core/events.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"events.js","names":[],"sources":["../../src/core/events.ts"],"sourcesContent":["/**\n * 包内轻量类型化事件发射器（core 内部基建，不对外导出实现细节）。\n */\n\nexport type EventHandler<T> = (payload: T) => void\n\nexport class TypedEventEmitter<EventMap extends Record<string, unknown>> {\n  private handlers = new Map<keyof EventMap, Set<EventHandler<EventMap[keyof EventMap]>>>()\n\n  /** 订阅事件，返回取消订阅函数 */\n  on<K extends keyof EventMap>(type: K, handler: EventHandler<EventMap[K]>): () => void {\n    let set = this.handlers.get(type)\n    if (!set) {\n      set = new Set()\n      this.handlers.set(type, set)\n    }\n    set.add(handler as EventHandler<EventMap[keyof EventMap]>)\n    return () => this.off(type, handler)\n  }\n\n  off<K extends keyof EventMap>(type: K, handler: EventHandler<EventMap[K]>): void {\n    this.handlers.get(type)?.delete(handler as EventHandler<EventMap[keyof EventMap]>)\n  }\n\n  emit<K extends keyof EventMap>(type: K, payload: EventMap[K]): void {\n    const set = this.handlers.get(type)\n    if (!set) return\n    // Set 迭代天然容忍遍历中取消订阅\n    for (const handler of set) {\n      ;(handler as EventHandler<EventMap[K]>)(payload)\n    }\n  }\n\n  clear(): void {\n    this.handlers.clear()\n  }\n}\n"],"mappings":";AAMA,IAAa,oBAAb,MAAyE;CACvE,2BAAmB,IAAI,IAAiE;;CAGxF,GAA6B,MAAS,SAAgD;EACpF,IAAI,MAAM,KAAK,SAAS,IAAI,IAAI;EAChC,IAAI,CAAC,KAAK;GACR,sBAAM,IAAI,IAAI;GACd,KAAK,SAAS,IAAI,MAAM,GAAG;EAC7B;EACA,IAAI,IAAI,OAAiD;EACzD,aAAa,KAAK,IAAI,MAAM,OAAO;CACrC;CAEA,IAA8B,MAAS,SAA0C;EAC/E,KAAK,SAAS,IAAI,IAAI,CAAC,EAAE,OAAO,OAAiD;CACnF;CAEA,KAA+B,MAAS,SAA4B;EAClE,MAAM,MAAM,KAAK,SAAS,IAAI,IAAI;EAClC,IAAI,CAAC,KAAK;EAEV,KAAK,MAAM,WAAW,KACnB,QAAuC,OAAO;CAEnD;CAEA,QAAc;EACZ,KAAK,SAAS,MAAM;CACtB;AACF"}

package/dist/core/formula/ast.d.ts

@@ -0,0 +1,58 @@
+import { CellAddress, CellRange } from "../address.js";
+//#region src/core/formula/ast.d.ts
+/**
+ * 公式 AST 节点。
+ * 引用节点携带可选 sheet 名（跨表引用）；缺省 = 公式所在 sheet。
+ */
+type BinaryOperator = '+' | '-' | '*' | '/' | '^' | '&' | '=' | '<>' | '<' | '<=' | '>' | '>=';
+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 缺省由所属公式节点补齐 */
+interface AstReference {
+  sheet?: string;
+  range: CellRange;
+}
+/** 遍历 AST，收集全部引用（单格视为 1×1 区域） */
+declare function collectReferences(node: AstNode, out?: AstReference[]): AstReference[];
+//#endregion
+export { AstNode, AstReference, BinaryOperator, collectReferences };
+//# sourceMappingURL=ast.d.ts.map

package/dist/core/formula/ast.js

@@ -0,0 +1,38 @@
+//#region src/core/formula/ast.ts
+/** 遍历 AST，收集全部引用（单格视为 1×1 区域） */
+function collectReferences(node, out = []) {
+	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;
+}
+//#endregion
+export { collectReferences };
+
+//# sourceMappingURL=ast.js.map

package/dist/core/formula/ast.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"ast.js","names":[],"sources":["../../../src/core/formula/ast.ts"],"sourcesContent":["import type { CellAddress, CellRange } from '../address'\n\n/**\n * 公式 AST 节点。\n * 引用节点携带可选 sheet 名（跨表引用）；缺省 = 公式所在 sheet。\n */\n\nexport type BinaryOperator =\n  | '+'\n  | '-'\n  | '*'\n  | '/'\n  | '^'\n  | '&'\n  | '='\n  | '<>'\n  | '<'\n  | '<='\n  | '>'\n  | '>='\n\nexport type AstNode =\n  | { kind: 'number'; value: number }\n  | { kind: 'string'; value: string }\n  | { kind: 'boolean'; value: boolean }\n  /** 未知名称（如裸写的 Sheet2 / 未定义命名）；求值为 #NAME? */\n  | { kind: 'name'; name: string }\n  | { kind: 'cell'; sheet?: string; addr: CellAddress }\n  | { kind: 'range'; sheet?: string; range: CellRange }\n  | { kind: 'unary'; op: '-' | '+'; operand: AstNode }\n  /** 百分号后缀运算（除以 100） */\n  | { kind: 'percent'; operand: AstNode }\n  | { kind: 'binary'; op: BinaryOperator; left: AstNode; right: AstNode }\n  | { kind: 'call'; name: string; args: AstNode[] }\n\n/** 公式中的引用（依赖图提取用）：sheet 缺省由所属公式节点补齐 */\nexport interface AstReference {\n  sheet?: string\n  range: CellRange\n}\n\n/** 遍历 AST，收集全部引用（单格视为 1×1 区域） */\nexport function collectReferences(node: AstNode, out: AstReference[] = []): AstReference[] {\n  switch (node.kind) {\n    case 'cell':\n      out.push({ sheet: node.sheet, range: { start: node.addr, end: node.addr } })\n      break\n    case 'range':\n      out.push({ sheet: node.sheet, range: node.range })\n      break\n    case 'unary':\n    case 'percent':\n      collectReferences(node.operand, out)\n      break\n    case 'binary':\n      collectReferences(node.left, out)\n      collectReferences(node.right, out)\n      break\n    case 'call':\n      for (const arg of node.args) collectReferences(arg, out)\n      break\n    default:\n      break\n  }\n  return out\n}\n"],"mappings":";;AA0CA,SAAgB,kBAAkB,MAAe,MAAsB,CAAC,GAAmB;CACzF,QAAQ,KAAK,MAAb;EACE,KAAK;GACH,IAAI,KAAK;IAAE,OAAO,KAAK;IAAO,OAAO;KAAE,OAAO,KAAK;KAAM,KAAK,KAAK;IAAK;GAAE,CAAC;GAC3E;EACF,KAAK;GACH,IAAI,KAAK;IAAE,OAAO,KAAK;IAAO,OAAO,KAAK;GAAM,CAAC;GACjD;EACF,KAAK;EACL,KAAK;GACH,kBAAkB,KAAK,SAAS,GAAG;GACnC;EACF,KAAK;GACH,kBAAkB,KAAK,MAAM,GAAG;GAChC,kBAAkB,KAAK,OAAO,GAAG;GACjC;EACF,KAAK;GACH,KAAK,MAAM,OAAO,KAAK,MAAM,kBAAkB,KAAK,GAAG;GACvD;EACF,SACE;CACJ;CACA,OAAO;AACT"}

package/dist/core/formula/dependency-graph.d.ts

@@ -0,0 +1,70 @@
+import { CellAddress, CellRange } from "../address.js";
+import { CellData } from "../cell-store.js";
+import { CellPatch } from "../command/types.js";
+import { AstNode } from "./ast.js";
+import { Sheet } from "../sheet.js";
+//#region src/core/formula/dependency-graph.d.ts
+/**
+ * 依赖图（工作簿级计算中枢）：
+ * - sheet 注册表：跨表引用按名解析（不存在 → #REF!）
+ * - 正向索引：公式格 → 引用格集合（节点 deps）；反向索引：引用格 → 依赖者
+ *   （单格引用走 cellKey 精确索引 O(1)，区域引用走线性扫描）
+ * - 变更时标脏（向上 BFS 收集全部依赖者）+ 拓扑序增量重算（递归向下，memo 去重）
+ * - 循环引用检测：求值在途栈遇回边 → 环上所有格 #CYCLE!；依赖环外格只传播错误，
+ *   打破循环（编辑环上格）后经标脏重算自动恢复
+ *
+ * 图状态与单元格存储严格同步：所有 f 变更（命令/undo/redo/rollback 回放）都经
+ * Sheet.applyPatch → syncCell 维护节点；重算只发生在命令执行后（见 Sheet.executeCommand），
+ * undo/redo 靠派生补丁精确回放缓存值，不重算。
+ */
+/** 公式节点的一个依赖（sheet 名已补齐为具体值） */
+interface FormulaDependency {
+  sheetName: string;
+  range: CellRange;
+}
+/** 公式节点（依赖图管理的公式格状态；依赖图外部只读使用） */
+interface FormulaNode {
+  readonly sheetName: string;
+  readonly addr: CellAddress;
+  readonly formula: string;
+  /** null = 解析失败（求值 #ERROR!，无依赖） */
+  readonly ast: AstNode | null;
+  readonly deps: FormulaDependency[];
+  /** 反向索引清理器（removeNode 时执行） */
+  readonly cleanups: (() => void)[];
+}
+declare class DependencyGraph {
+  private readonly sheets;
+  /** 正向索引宿主：sheetName → cellKey → 公式节点 */
+  private readonly nodes;
+  /** 反向索引（单格引用）：sheetName → cellKey → 依赖者集合 */
+  private readonly exact;
+  /** 反向索引（区域引用）：sheetName → { 区域, 依赖者 } 集合（线性扫描） */
+  private readonly ranged;
+  registerSheet(sheet: Sheet): void;
+  /** 注销 sheet 并移除其全部公式节点（引用它的公式在下次重算时得 #REF!） */
+  unregisterSheet(sheet: Sheet): void;
+  getSheet(name: string): Sheet | undefined;
+  getNode(sheetName: string, addr: CellAddress): FormulaNode | undefined;
+  /** 公式节点总数（测试/调试用） */
+  get nodeCount(): number;
+  /**
+   * 单元格补丁后的图同步：f 增/删/改 → 节点增/删/重建。
+   * 由 Sheet.applyPatch（唯一变更通道）调用，命令与 undo/redo 回放均覆盖。
+   */
+  syncCell(sheet: Sheet, addr: CellAddress, before?: CellData, after?: CellData): void;
+  /**
+   * 变更集 → 标脏 + 拓扑序重算 → 派生补丁（未应用）。
+   * 调用方（Sheet.executeCommand）负责应用补丁并并入同一 undo 单元。
+   */
+  recalc(changed: readonly {
+    sheet: Sheet;
+    addr: CellAddress;
+  }[]): CellPatch[];
+  private addNode;
+  private removeNode;
+  private dependentsOf;
+}
+//#endregion
+export { DependencyGraph, FormulaDependency, FormulaNode };
+//# sourceMappingURL=dependency-graph.d.ts.map