@veltra/sheet 2.0.0 → 2.1.1

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

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

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

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

@@ -1,26 +0,0 @@
-//#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

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

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

@@ -1,29 +0,0 @@
-//#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

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

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

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

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

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

@@ -1,29 +0,0 @@
-//#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

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

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

@@ -1,38 +0,0 @@
-//#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

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

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