@veltra/sheet 2.0.0

package/dist/core/merge-manager.d.ts

@@ -0,0 +1,64 @@
+import { CellAddress, CellRange } from "./address.js";
+//#region src/core/merge-manager.d.ts
+/**
+ * 合并单元格管理器（只管几何，不管数据）。
+ *
+ * - 锚点恒为区域左上角，数据只存在锚点格（数据搬迁由 Sheet 编排）
+ * - merges：anchorKey → CellRange
+ * - coverIndex：coveredCellKey（不含锚点自身）→ anchorKey，O(1) 查询
+ */
+/** 单元格在合并语义下的种类 */
+type MergedCellKind = 'normal' | 'merged-anchor' | 'merged-covered';
+interface CellInfo {
+  kind: MergedCellKind;
+  /** 锚点地址；普通格为自身 */
+  anchor: CellAddress;
+  /** 所在合并区域；普通格无 */
+  mergeRange?: CellRange;
+}
+interface MergeResult {
+  /** 最终生效的合并区域（与既有合并相交时取包围盒，可能大于入参） */
+  range: CellRange;
+  /** 本次被解除的既有合并 */
+  removed: CellRange[];
+}
+declare class MergeManager {
+  private merges;
+  private coverIndex;
+  /**
+   * 计算合并结果（纯查询，不修改状态）：
+   * 1. 所有与 range 相交的既有合并将被解除
+   * 2. 新区域 = range 与被解除合并的包围盒
+   */
+  computeMerge(range: CellRange): MergeResult;
+  /** 合并区域（解除相交既有合并 + 包围盒，见 computeMerge） */
+  merge(range: CellRange): MergeResult;
+  /**
+   * 精确登记一个合并区域（不做相交解除与包围盒）。
+   * 低层接口，供命令系统回放补丁使用；调用方需保证不与既有合并相交。
+   */
+  addMerge(range: CellRange): void;
+  /** 精确移除一个合并区域（按锚点匹配）；不存在时为空操作 */
+  removeMerge(range: CellRange): void;
+  /** 解除所有与 range 相交的合并，返回被解除的区域 */
+  unmerge(range: CellRange): CellRange[];
+  /** 地址解析到锚点：被覆盖格 → 锚点；锚点/普通格 → 自身 */
+  resolveAnchor(addr: CellAddress): CellAddress;
+  /** 是否在任意合并区域内（含锚点） */
+  isMerged(addr: CellAddress): boolean;
+  /** 是否为被覆盖的非锚点格 */
+  isCovered(addr: CellAddress): boolean;
+  /** 所在合并区域（锚点与被覆盖格均可查）；不在任何合并内返回 undefined */
+  getMergeAt(addr: CellAddress): CellRange | undefined;
+  /** 合并语义下的单元格信息 */
+  getCellInfo(addr: CellAddress): CellInfo;
+  /** 全部合并区域（迭代 merges 的副本） */
+  getMerges(): CellRange[];
+  get size(): number;
+  clear(): void;
+  private register;
+  private unregister;
+}
+//#endregion
+export { CellInfo, MergeManager, MergeResult, MergedCellKind };
+//# sourceMappingURL=merge-manager.d.ts.map

package/dist/core/merge-manager.js

@@ -0,0 +1,111 @@
+import { boundingBox, cellKey, createRange, iterateRange, rangesIntersect } from "./address.js";
+//#region src/core/merge-manager.ts
+var MergeManager = class {
+	merges = /* @__PURE__ */ new Map();
+	coverIndex = /* @__PURE__ */ new Map();
+	/**
+	* 计算合并结果（纯查询，不修改状态）：
+	* 1. 所有与 range 相交的既有合并将被解除
+	* 2. 新区域 = range 与被解除合并的包围盒
+	*/
+	computeMerge(range) {
+		const removed = [];
+		for (const existing of this.merges.values()) if (rangesIntersect(existing, range)) removed.push(existing);
+		return {
+			range: removed.length > 0 ? boundingBox([range, ...removed]) : createRange(range.start, range.end),
+			removed
+		};
+	}
+	/** 合并区域（解除相交既有合并 + 包围盒，见 computeMerge） */
+	merge(range) {
+		const result = this.computeMerge(range);
+		for (const item of result.removed) this.unregister(item);
+		this.register(result.range);
+		return result;
+	}
+	/**
+	* 精确登记一个合并区域（不做相交解除与包围盒）。
+	* 低层接口，供命令系统回放补丁使用；调用方需保证不与既有合并相交。
+	*/
+	addMerge(range) {
+		this.register(range);
+	}
+	/** 精确移除一个合并区域（按锚点匹配）；不存在时为空操作 */
+	removeMerge(range) {
+		this.unregister(range);
+	}
+	/** 解除所有与 range 相交的合并，返回被解除的区域 */
+	unmerge(range) {
+		const removed = [];
+		for (const existing of this.merges.values()) if (rangesIntersect(existing, range)) removed.push(existing);
+		for (const item of removed) this.unregister(item);
+		return removed;
+	}
+	/** 地址解析到锚点：被覆盖格 → 锚点；锚点/普通格 → 自身 */
+	resolveAnchor(addr) {
+		const merge = this.getMergeAt(addr);
+		return merge ? { ...merge.start } : { ...addr };
+	}
+	/** 是否在任意合并区域内（含锚点） */
+	isMerged(addr) {
+		return this.getMergeAt(addr) !== void 0;
+	}
+	/** 是否为被覆盖的非锚点格 */
+	isCovered(addr) {
+		return this.coverIndex.has(cellKey(addr));
+	}
+	/** 所在合并区域（锚点与被覆盖格均可查）；不在任何合并内返回 undefined */
+	getMergeAt(addr) {
+		const key = cellKey(addr);
+		const asAnchor = this.merges.get(key);
+		if (asAnchor) return asAnchor;
+		const anchorKey = this.coverIndex.get(key);
+		return anchorKey === void 0 ? void 0 : this.merges.get(anchorKey);
+	}
+	/** 合并语义下的单元格信息 */
+	getCellInfo(addr) {
+		const merge = this.getMergeAt(addr);
+		if (!merge) return {
+			kind: "normal",
+			anchor: { ...addr }
+		};
+		const anchor = { ...merge.start };
+		if (addr.row === anchor.row && addr.col === anchor.col) return {
+			kind: "merged-anchor",
+			anchor,
+			mergeRange: merge
+		};
+		return {
+			kind: "merged-covered",
+			anchor,
+			mergeRange: merge
+		};
+	}
+	/** 全部合并区域（迭代 merges 的副本） */
+	getMerges() {
+		return [...this.merges.values()].map((range) => ({
+			start: { ...range.start },
+			end: { ...range.end }
+		}));
+	}
+	get size() {
+		return this.merges.size;
+	}
+	clear() {
+		this.merges.clear();
+		this.coverIndex.clear();
+	}
+	register(range) {
+		const anchorKey = cellKey(range.start);
+		this.merges.set(anchorKey, range);
+		for (const addr of iterateRange(range)) if (addr.row !== range.start.row || addr.col !== range.start.col) this.coverIndex.set(cellKey(addr), anchorKey);
+	}
+	unregister(range) {
+		this.merges.delete(cellKey(range.start));
+		for (const addr of iterateRange(range)) if (addr.row !== range.start.row || addr.col !== range.start.col) this.coverIndex.delete(cellKey(addr));
+	}
+};
+//#endregion
+export { MergeManager };
+
+//# sourceMappingURL=merge-manager.js.map

package/dist/core/merge-manager.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"merge-manager.js","names":[],"sources":["../../src/core/merge-manager.ts"],"sourcesContent":["import {\n  boundingBox,\n  cellKey,\n  createRange,\n  iterateRange,\n  rangesIntersect,\n  type CellAddress,\n  type CellRange\n} from './address'\n\n/**\n * 合并单元格管理器（只管几何，不管数据）。\n *\n * - 锚点恒为区域左上角，数据只存在锚点格（数据搬迁由 Sheet 编排）\n * - merges：anchorKey → CellRange\n * - coverIndex：coveredCellKey（不含锚点自身）→ anchorKey，O(1) 查询\n */\n\n/** 单元格在合并语义下的种类 */\nexport type MergedCellKind = 'normal' | 'merged-anchor' | 'merged-covered'\n\nexport interface CellInfo {\n  kind: MergedCellKind\n  /** 锚点地址；普通格为自身 */\n  anchor: CellAddress\n  /** 所在合并区域；普通格无 */\n  mergeRange?: CellRange\n}\n\nexport interface MergeResult {\n  /** 最终生效的合并区域（与既有合并相交时取包围盒，可能大于入参） */\n  range: CellRange\n  /** 本次被解除的既有合并 */\n  removed: CellRange[]\n}\n\nexport class MergeManager {\n  private merges = new Map<number, CellRange>()\n  private coverIndex = new Map<number, number>()\n\n  /**\n   * 计算合并结果（纯查询，不修改状态）：\n   * 1. 所有与 range 相交的既有合并将被解除\n   * 2. 新区域 = range 与被解除合并的包围盒\n   */\n  computeMerge(range: CellRange): MergeResult {\n    const removed: CellRange[] = []\n    for (const existing of this.merges.values()) {\n      if (rangesIntersect(existing, range)) removed.push(existing)\n    }\n    const finalRange =\n      removed.length > 0 ? boundingBox([range, ...removed]) : createRange(range.start, range.end)\n    return { range: finalRange, removed }\n  }\n\n  /** 合并区域（解除相交既有合并 + 包围盒，见 computeMerge） */\n  merge(range: CellRange): MergeResult {\n    const result = this.computeMerge(range)\n    for (const item of result.removed) this.unregister(item)\n    this.register(result.range)\n    return result\n  }\n\n  /**\n   * 精确登记一个合并区域（不做相交解除与包围盒）。\n   * 低层接口，供命令系统回放补丁使用；调用方需保证不与既有合并相交。\n   */\n  addMerge(range: CellRange): void {\n    this.register(range)\n  }\n\n  /** 精确移除一个合并区域（按锚点匹配）；不存在时为空操作 */\n  removeMerge(range: CellRange): void {\n    this.unregister(range)\n  }\n\n  /** 解除所有与 range 相交的合并，返回被解除的区域 */\n  unmerge(range: CellRange): CellRange[] {\n    const removed: CellRange[] = []\n    for (const existing of this.merges.values()) {\n      if (rangesIntersect(existing, range)) removed.push(existing)\n    }\n    for (const item of removed) this.unregister(item)\n    return removed\n  }\n\n  /** 地址解析到锚点：被覆盖格 → 锚点；锚点/普通格 → 自身 */\n  resolveAnchor(addr: CellAddress): CellAddress {\n    const merge = this.getMergeAt(addr)\n    return merge ? { ...merge.start } : { ...addr }\n  }\n\n  /** 是否在任意合并区域内（含锚点） */\n  isMerged(addr: CellAddress): boolean {\n    return this.getMergeAt(addr) !== undefined\n  }\n\n  /** 是否为被覆盖的非锚点格 */\n  isCovered(addr: CellAddress): boolean {\n    return this.coverIndex.has(cellKey(addr))\n  }\n\n  /** 所在合并区域（锚点与被覆盖格均可查）；不在任何合并内返回 undefined */\n  getMergeAt(addr: CellAddress): CellRange | undefined {\n    const key = cellKey(addr)\n    const asAnchor = this.merges.get(key)\n    if (asAnchor) return asAnchor\n    const anchorKey = this.coverIndex.get(key)\n    return anchorKey === undefined ? undefined : this.merges.get(anchorKey)\n  }\n\n  /** 合并语义下的单元格信息 */\n  getCellInfo(addr: CellAddress): CellInfo {\n    const merge = this.getMergeAt(addr)\n    if (!merge) return { kind: 'normal', anchor: { ...addr } }\n    const anchor = { ...merge.start }\n    if (addr.row === anchor.row && addr.col === anchor.col) {\n      return { kind: 'merged-anchor', anchor, mergeRange: merge }\n    }\n    return { kind: 'merged-covered', anchor, mergeRange: merge }\n  }\n\n  /** 全部合并区域（迭代 merges 的副本） */\n  getMerges(): CellRange[] {\n    return [...this.merges.values()].map((range) => ({\n      start: { ...range.start },\n      end: { ...range.end }\n    }))\n  }\n\n  get size(): number {\n    return this.merges.size\n  }\n\n  clear(): void {\n    this.merges.clear()\n    this.coverIndex.clear()\n  }\n\n  private register(range: CellRange): void {\n    const anchorKey = cellKey(range.start)\n    this.merges.set(anchorKey, range)\n    for (const addr of iterateRange(range)) {\n      if (addr.row !== range.start.row || addr.col !== range.start.col) {\n        this.coverIndex.set(cellKey(addr), anchorKey)\n      }\n    }\n  }\n\n  private unregister(range: CellRange): void {\n    this.merges.delete(cellKey(range.start))\n    for (const addr of iterateRange(range)) {\n      if (addr.row !== range.start.row || addr.col !== range.start.col) {\n        this.coverIndex.delete(cellKey(addr))\n      }\n    }\n  }\n}\n"],"mappings":"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"}

package/dist/core/selection.d.ts

@@ -0,0 +1,31 @@
+import { CellAddress, CellRange } from "./address.js";
+//#region src/core/selection.d.ts
+/**
+ * 选区模型：activeCell + ranges。
+ * activeCell 永远指向锚点（构造时注入 resolveAnchor）。
+ */
+interface SelectionState {
+  /** 活动单元格（锚点语义）；未选中时为 null */
+  activeCell: CellAddress | null;
+  /** 选中区域列表（本阶段单选区，预留多选区） */
+  ranges: CellRange[];
+}
+declare class SelectionModel {
+  private readonly resolveAnchor;
+  private state;
+  private emitter;
+  constructor(resolveAnchor: (addr: CellAddress) => CellAddress);
+  get activeCell(): CellAddress | null;
+  get ranges(): CellRange[];
+  /** 选中单格；被覆盖格自动解析到锚点 */
+  selectCell(addr: CellAddress): void;
+  /** 选中区域；activeCell 取区域起点的锚点 */
+  selectRange(range: CellRange): void;
+  getState(): SelectionState;
+  clear(): void;
+  on(handler: (state: SelectionState) => void): () => void;
+  private setState;
+}
+//#endregion
+export { SelectionModel, SelectionState };
+//# sourceMappingURL=selection.d.ts.map

package/dist/core/selection.js

@@ -0,0 +1,62 @@
+import { createRange } from "./address.js";
+import { TypedEventEmitter } from "./events.js";
+//#region src/core/selection.ts
+var SelectionModel = class {
+	resolveAnchor;
+	state = {
+		activeCell: null,
+		ranges: []
+	};
+	emitter = new TypedEventEmitter();
+	constructor(resolveAnchor) {
+		this.resolveAnchor = resolveAnchor;
+	}
+	get activeCell() {
+		return this.state.activeCell;
+	}
+	get ranges() {
+		return this.state.ranges;
+	}
+	/** 选中单格；被覆盖格自动解析到锚点 */
+	selectCell(addr) {
+		const anchor = this.resolveAnchor(addr);
+		this.setState({
+			activeCell: anchor,
+			ranges: [createRange(anchor, anchor)]
+		});
+	}
+	/** 选中区域；activeCell 取区域起点的锚点 */
+	selectRange(range) {
+		const anchor = this.resolveAnchor(range.start);
+		this.setState({
+			activeCell: anchor,
+			ranges: [range]
+		});
+	}
+	getState() {
+		return {
+			activeCell: this.state.activeCell ? { ...this.state.activeCell } : null,
+			ranges: this.state.ranges.map((range) => ({
+				start: { ...range.start },
+				end: { ...range.end }
+			}))
+		};
+	}
+	clear() {
+		this.setState({
+			activeCell: null,
+			ranges: []
+		});
+	}
+	on(handler) {
+		return this.emitter.on("change", handler);
+	}
+	setState(state) {
+		this.state = state;
+		this.emitter.emit("change", this.getState());
+	}
+};
+//#endregion
+export { SelectionModel };
+
+//# sourceMappingURL=selection.js.map

package/dist/core/selection.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"selection.js","names":[],"sources":["../../src/core/selection.ts"],"sourcesContent":["import { createRange, type CellAddress, type CellRange } from './address'\nimport { TypedEventEmitter } from './events'\n\n/**\n * 选区模型：activeCell + ranges。\n * activeCell 永远指向锚点（构造时注入 resolveAnchor）。\n */\n\nexport interface SelectionState {\n  /** 活动单元格（锚点语义）；未选中时为 null */\n  activeCell: CellAddress | null\n  /** 选中区域列表（本阶段单选区，预留多选区） */\n  ranges: CellRange[]\n}\n\ntype SelectionEvents = { change: SelectionState }\n\nexport class SelectionModel {\n  private state: SelectionState = { activeCell: null, ranges: [] }\n  private emitter = new TypedEventEmitter<SelectionEvents>()\n\n  constructor(private readonly resolveAnchor: (addr: CellAddress) => CellAddress) {}\n\n  get activeCell(): CellAddress | null {\n    return this.state.activeCell\n  }\n\n  get ranges(): CellRange[] {\n    return this.state.ranges\n  }\n\n  /** 选中单格；被覆盖格自动解析到锚点 */\n  selectCell(addr: CellAddress): void {\n    const anchor = this.resolveAnchor(addr)\n    this.setState({ activeCell: anchor, ranges: [createRange(anchor, anchor)] })\n  }\n\n  /** 选中区域；activeCell 取区域起点的锚点 */\n  selectRange(range: CellRange): void {\n    const anchor = this.resolveAnchor(range.start)\n    this.setState({ activeCell: anchor, ranges: [range] })\n  }\n\n  getState(): SelectionState {\n    return {\n      activeCell: this.state.activeCell ? { ...this.state.activeCell } : null,\n      ranges: this.state.ranges.map((range) => ({\n        start: { ...range.start },\n        end: { ...range.end }\n      }))\n    }\n  }\n\n  clear(): void {\n    this.setState({ activeCell: null, ranges: [] })\n  }\n\n  on(handler: (state: SelectionState) => void): () => void {\n    return this.emitter.on('change', handler)\n  }\n\n  private setState(state: SelectionState): void {\n    this.state = state\n    this.emitter.emit('change', this.getState())\n  }\n}\n"],"mappings":";;;AAiBA,IAAa,iBAAb,MAA4B;CAIG;CAH7B,QAAgC;EAAE,YAAY;EAAM,QAAQ,CAAC;CAAE;CAC/D,UAAkB,IAAI,kBAAmC;CAEzD,YAAY,eAAoE;EAAnD,KAAA,gBAAA;CAAoD;CAEjF,IAAI,aAAiC;EACnC,OAAO,KAAK,MAAM;CACpB;CAEA,IAAI,SAAsB;EACxB,OAAO,KAAK,MAAM;CACpB;;CAGA,WAAW,MAAyB;EAClC,MAAM,SAAS,KAAK,cAAc,IAAI;EACtC,KAAK,SAAS;GAAE,YAAY;GAAQ,QAAQ,CAAC,YAAY,QAAQ,MAAM,CAAC;EAAE,CAAC;CAC7E;;CAGA,YAAY,OAAwB;EAClC,MAAM,SAAS,KAAK,cAAc,MAAM,KAAK;EAC7C,KAAK,SAAS;GAAE,YAAY;GAAQ,QAAQ,CAAC,KAAK;EAAE,CAAC;CACvD;CAEA,WAA2B;EACzB,OAAO;GACL,YAAY,KAAK,MAAM,aAAa,EAAE,GAAG,KAAK,MAAM,WAAW,IAAI;GACnE,QAAQ,KAAK,MAAM,OAAO,KAAK,WAAW;IACxC,OAAO,EAAE,GAAG,MAAM,MAAM;IACxB,KAAK,EAAE,GAAG,MAAM,IAAI;GACtB,EAAE;EACJ;CACF;CAEA,QAAc;EACZ,KAAK,SAAS;GAAE,YAAY;GAAM,QAAQ,CAAC;EAAE,CAAC;CAChD;CAEA,GAAG,SAAsD;EACvD,OAAO,KAAK,QAAQ,GAAG,UAAU,OAAO;CAC1C;CAEA,SAAiB,OAA6B;EAC5C,KAAK,QAAQ;EACb,KAAK,QAAQ,KAAK,UAAU,KAAK,SAAS,CAAC;CAC7C;AACF"}

package/dist/core/sheet.d.ts

@@ -0,0 +1,105 @@
+import { CellAddress, CellRange } from "./address.js";
+import { CellData, CellStore, CellValue } from "./cell-store.js";
+import { CellInfo, MergeManager } from "./merge-manager.js";
+import { SelectionModel, SelectionState } from "./selection.js";
+import { HistoryManager, HistoryState } from "./command/history.js";
+import { SetCellValueItem } from "./command/set-cell-value.js";
+import { DependencyGraph } from "./formula/dependency-graph.js";
+//#region src/core/sheet.d.ts
+/**
+ * Sheet = cell-store + merge-manager + selection + history 的组合，统一操作入口。
+ *
+ * 语义约定：
+ * - `getCellData`：原始存储语义，被合并覆盖的非锚点格 → undefined
+ * - `getDisplayValue`：锚点解析语义，被覆盖格返回锚点的值
+ * - `setCellValue` / `selectCell`：内部先 resolveAnchor（用户操作永远落锚点）
+ * - 一切写操作（setCellValue / setCell / setCells / setCellFormula / mergeCells / unmergeCells）
+ *   都经命令系统执行（applyPatch 是唯一变更通道），天然获得 undo/redo 能力
+ * - 公式：`setCellValue` 识别 '=' 前缀走 `setCellFormula`；命令执行后自动增量重算，
+ *   重算派生变更（含跨表）并入同一 undo 单元
+ */
+type SheetEvents = {
+  /** 单元格数据变化（含删除） */
+  'cell-change': {
+    addr: CellAddress;
+  };
+  /** 合并结构变化（合并/取消合并） */
+  'merge-change': {
+    range: CellRange;
+  };
+  /** 选区变化 */
+  'selection-change': SelectionState;
+  /** 历史栈变化（undo/redo 可用状态，供工具栏按钮置灰） */
+  'history-change': HistoryState;
+};
+declare class Sheet {
+  readonly store: CellStore;
+  readonly merges: MergeManager;
+  readonly selection: SelectionModel;
+  /**  undo/redo 历史（命令系统） */
+  readonly history: HistoryManager;
+  /** 公式依赖图（工作簿内多 sheet 共享；独立 Sheet 自建） */
+  readonly formulaGraph: DependencyGraph;
+  name: string;
+  private emitter;
+  constructor(name?: string, formulaGraph?: DependencyGraph);
+  get rowCount(): number;
+  get colCount(): number;
+  /** 原始存储语义读取（被覆盖格 → undefined） */
+  getCellData(addr: CellAddress): CellData | undefined;
+  /** 锚点解析语义读取（被覆盖格 → 锚点的值） */
+  getDisplayValue(addr: CellAddress): CellValue | undefined;
+  /** 写入原始值（解析到锚点；空值 = 清除）；'=' 前缀按公式处理；经命令执行，可撤销 */
+  setCellValue(addr: CellAddress, value: CellValue): void;
+  /** 写入完整 CellData（解析到锚点；空数据 = 清除）；经命令执行，可撤销 */
+  setCell(addr: CellAddress, data?: CellData): void;
+  /**
+   * 写入公式（可带 '=' 前缀；空白公式 = 清除）；经命令执行，可撤销。
+   * 公式原文存 CellData.f，计算缓存（v/t）由增量重算填充；解析失败 → #ERROR!。
+   */
+  setCellFormula(addr: CellAddress, formula: string): void;
+  /** 批量写入（一次调用 = 一个 undo 单元，供粘贴/填充复用） */
+  setCells(items: SetCellValueItem[]): void;
+  /** 合并语义下的单元格信息（普通格 / 合并锚点 / 被覆盖格） */
+  getCellInfo(addr: CellAddress): CellInfo;
+  /**
+   * 合并区域。值保留规则（同 Excel/univer）：
+   * 仅保留包围盒内按行主序第一个有值格的值，写入新锚点，其余被覆盖格清空。
+   * @returns 最终生效的合并区域（与既有合并相交时取包围盒）
+   */
+  mergeCells(range: CellRange): CellRange;
+  /** 解除与 range 相交的所有合并；仅原锚点保留值（被覆盖格本就无值） */
+  unmergeCells(range: CellRange): void;
+  /** 经默认注册表执行命令；产生的 mutation 与公式重算派生 mutation 一并推入历史 */
+  executeCommand<R = void>(commandId: string, params: unknown): R | undefined;
+  /** 开启事务（事务内所有命令合并为一个 undo 单元；可嵌套，拍平到最外层） */
+  beginTransaction(): void;
+  /** 提交事务 */
+  commit(): void;
+  /** 回滚事务：还原缓冲中已应用的变更并放弃事务 */
+  rollback(): void;
+  /** 撤销一步；无可撤销时返回 false */
+  undo(): boolean;
+  /** 重做一步；无可重做时返回 false */
+  redo(): boolean;
+  get canUndo(): boolean;
+  get canRedo(): boolean;
+  getSelection(): SelectionState;
+  /** 选中单格（被覆盖格自动定位锚点） */
+  selectCell(addr: CellAddress): void;
+  selectRange(range: CellRange): void;
+  on<K extends keyof SheetEvents>(type: K, handler: (payload: SheetEvents[K]) => void): () => void;
+  off<K extends keyof SheetEvents>(type: K, handler: (payload: SheetEvents[K]) => void): void;
+  private readonly boundApplyPatch;
+  /** 应用补丁：命令执行与 undo/redo 回放共用的唯一变更通道 */
+  private applyPatch;
+  /**
+   * 命令执行后的公式增量重算：从命令 mutation 提取变更格 → 依赖图标脏 +
+   * 拓扑序重算 → 派生补丁立即应用，作为附加 mutation 并入同一 undo 单元。
+   * undo/redo 纯补丁回放（不重算），图状态由 applyPatch 内的 syncCell 维持。
+   */
+  private recalcAfterCommand;
+}
+//#endregion
+export { Sheet, SheetEvents };
+//# sourceMappingURL=sheet.d.ts.map

package/dist/core/sheet.js

@@ -0,0 +1,202 @@
+import { TypedEventEmitter } from "./events.js";
+import { CellStore, inferCellType } from "./cell-store.js";
+import { MergeManager } from "./merge-manager.js";
+import { SelectionModel } from "./selection.js";
+import { MergeCellsCommand, UnmergeCellsCommand } from "./command/merge-cells.js";
+import { SetCellFormulaCommand } from "./command/set-cell-formula.js";
+import { SetCellValueCommand } from "./command/set-cell-value.js";
+import { defaultCommandRegistry } from "./command/default-registry.js";
+import { HistoryManager } from "./command/history.js";
+import { DependencyGraph } from "./formula/dependency-graph.js";
+//#region src/core/sheet.ts
+var Sheet = class {
+	store = new CellStore();
+	merges = new MergeManager();
+	selection;
+	/**  undo/redo 历史（命令系统） */
+	history;
+	/** 公式依赖图（工作簿内多 sheet 共享；独立 Sheet 自建） */
+	formulaGraph;
+	name;
+	emitter = new TypedEventEmitter();
+	constructor(name = "Sheet1", formulaGraph) {
+		this.name = name;
+		this.selection = new SelectionModel((addr) => this.merges.resolveAnchor(addr));
+		this.selection.on((state) => this.emitter.emit("selection-change", state));
+		this.history = new HistoryManager(this.boundApplyPatch);
+		this.history.onChange((state) => this.emitter.emit("history-change", state));
+		this.formulaGraph = formulaGraph ?? new DependencyGraph();
+		this.formulaGraph.registerSheet(this);
+	}
+	get rowCount() {
+		return this.store.rowCount;
+	}
+	get colCount() {
+		return this.store.colCount;
+	}
+	/** 原始存储语义读取（被覆盖格 → undefined） */
+	getCellData(addr) {
+		return this.store.getCell(addr);
+	}
+	/** 锚点解析语义读取（被覆盖格 → 锚点的值） */
+	getDisplayValue(addr) {
+		const anchor = this.merges.resolveAnchor(addr);
+		return this.store.getCell(anchor)?.v ?? void 0;
+	}
+	/** 写入原始值（解析到锚点；空值 = 清除）；'=' 前缀按公式处理；经命令执行，可撤销 */
+	setCellValue(addr, value) {
+		if (typeof value === "string" && value.startsWith("=")) {
+			this.setCellFormula(addr, value);
+			return;
+		}
+		const data = value == null || value === "" ? void 0 : {
+			v: value,
+			t: inferCellType(value)
+		};
+		this.setCells([{
+			addr,
+			data
+		}]);
+	}
+	/** 写入完整 CellData（解析到锚点；空数据 = 清除）；经命令执行，可撤销 */
+	setCell(addr, data) {
+		this.setCells([{
+			addr,
+			data
+		}]);
+	}
+	/**
+	* 写入公式（可带 '=' 前缀；空白公式 = 清除）；经命令执行，可撤销。
+	* 公式原文存 CellData.f，计算缓存（v/t）由增量重算填充；解析失败 → #ERROR!。
+	*/
+	setCellFormula(addr, formula) {
+		const text = formula.startsWith("=") ? formula.slice(1) : formula;
+		if (text.trim() === "") {
+			this.setCells([{
+				addr,
+				data: void 0
+			}]);
+			return;
+		}
+		this.executeCommand(SetCellFormulaCommand.id, {
+			addr,
+			formula: text
+		});
+	}
+	/** 批量写入（一次调用 = 一个 undo 单元，供粘贴/填充复用） */
+	setCells(items) {
+		this.executeCommand(SetCellValueCommand.id, { items });
+	}
+	/** 合并语义下的单元格信息（普通格 / 合并锚点 / 被覆盖格） */
+	getCellInfo(addr) {
+		return this.merges.getCellInfo(addr);
+	}
+	/**
+	* 合并区域。值保留规则（同 Excel/univer）：
+	* 仅保留包围盒内按行主序第一个有值格的值，写入新锚点，其余被覆盖格清空。
+	* @returns 最终生效的合并区域（与既有合并相交时取包围盒）
+	*/
+	mergeCells(range) {
+		return this.executeCommand(MergeCellsCommand.id, { range });
+	}
+	/** 解除与 range 相交的所有合并；仅原锚点保留值（被覆盖格本就无值） */
+	unmergeCells(range) {
+		this.executeCommand(UnmergeCellsCommand.id, { range });
+	}
+	/** 经默认注册表执行命令；产生的 mutation 与公式重算派生 mutation 一并推入历史 */
+	executeCommand(commandId, params) {
+		const result = defaultCommandRegistry.execute({
+			sheet: this,
+			applyPatch: this.boundApplyPatch
+		}, commandId, params);
+		if (result && result.mutations.length > 0) {
+			const mutations = [...result.mutations];
+			const recalcMutation = this.recalcAfterCommand(result.mutations);
+			if (recalcMutation) mutations.push(recalcMutation);
+			this.history.push(mutations);
+		}
+		return result?.result;
+	}
+	/** 开启事务（事务内所有命令合并为一个 undo 单元；可嵌套，拍平到最外层） */
+	beginTransaction() {
+		this.history.beginTransaction();
+	}
+	/** 提交事务 */
+	commit() {
+		this.history.commit();
+	}
+	/** 回滚事务：还原缓冲中已应用的变更并放弃事务 */
+	rollback() {
+		this.history.rollback();
+	}
+	/** 撤销一步；无可撤销时返回 false */
+	undo() {
+		return this.history.undo();
+	}
+	/** 重做一步；无可重做时返回 false */
+	redo() {
+		return this.history.redo();
+	}
+	get canUndo() {
+		return this.history.canUndo;
+	}
+	get canRedo() {
+		return this.history.canRedo;
+	}
+	getSelection() {
+		return this.selection.getState();
+	}
+	/** 选中单格（被覆盖格自动定位锚点） */
+	selectCell(addr) {
+		this.selection.selectCell(addr);
+	}
+	selectRange(range) {
+		this.selection.selectRange(range);
+	}
+	on(type, handler) {
+		return this.emitter.on(type, handler);
+	}
+	off(type, handler) {
+		this.emitter.off(type, handler);
+	}
+	boundApplyPatch = (patch, direction) => {
+		(patch.kind === "cell" ? patch.sheet ?? this : this).applyPatch(patch, direction);
+	};
+	/** 应用补丁：命令执行与 undo/redo 回放共用的唯一变更通道 */
+	applyPatch(patch, direction) {
+		if (patch.kind === "cell") {
+			const data = direction === "redo" ? patch.after : patch.before;
+			const previous = direction === "redo" ? patch.before : patch.after;
+			this.store.setCell(patch.addr, data);
+			this.formulaGraph.syncCell(this, patch.addr, previous, data);
+			this.emitter.emit("cell-change", { addr: patch.addr });
+			return;
+		}
+		if (direction === "redo" ? patch.after : patch.before) this.merges.addMerge(patch.range);
+		else this.merges.removeMerge(patch.range);
+		this.emitter.emit("merge-change", { range: patch.range });
+	}
+	/**
+	* 命令执行后的公式增量重算：从命令 mutation 提取变更格 → 依赖图标脏 +
+	* 拓扑序重算 → 派生补丁立即应用，作为附加 mutation 并入同一 undo 单元。
+	* undo/redo 纯补丁回放（不重算），图状态由 applyPatch 内的 syncCell 维持。
+	*/
+	recalcAfterCommand(mutations) {
+		const changed = [];
+		for (const mutation of mutations) for (const patch of mutation.redo) if (patch.kind === "cell") changed.push({
+			sheet: patch.sheet ?? this,
+			addr: patch.addr
+		});
+		const derived = this.formulaGraph.recalc(changed);
+		if (derived.length === 0) return void 0;
+		for (const patch of derived) this.boundApplyPatch(patch, "redo");
+		return {
+			redo: derived,
+			undo: [...derived].reverse()
+		};
+	}
+};
+//#endregion
+export { Sheet };
+
+//# sourceMappingURL=sheet.js.map

package/dist/core/sheet.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"sheet.js","names":[],"sources":["../../src/core/sheet.ts"],"sourcesContent":["import type { CellAddress, CellRange } from './address'\nimport { inferCellType, CellStore, type CellData, type CellValue } from './cell-store'\nimport { defaultCommandRegistry } from './command/default-registry'\nimport { HistoryManager, type HistoryState } from './command/history'\nimport { MergeCellsCommand, UnmergeCellsCommand } from './command/merge-cells'\nimport { SetCellFormulaCommand } from './command/set-cell-formula'\nimport { SetCellValueCommand, type SetCellValueItem } from './command/set-cell-value'\nimport type { Mutation, Patch, PatchDirection } from './command/types'\nimport { TypedEventEmitter } from './events'\nimport { DependencyGraph } from './formula/dependency-graph'\nimport { MergeManager, type CellInfo } from './merge-manager'\nimport { SelectionModel, type SelectionState } from './selection'\n\n/**\n * Sheet = cell-store + merge-manager + selection + history 的组合，统一操作入口。\n *\n * 语义约定：\n * - `getCellData`：原始存储语义，被合并覆盖的非锚点格 → undefined\n * - `getDisplayValue`：锚点解析语义，被覆盖格返回锚点的值\n * - `setCellValue` / `selectCell`：内部先 resolveAnchor（用户操作永远落锚点）\n * - 一切写操作（setCellValue / setCell / setCells / setCellFormula / mergeCells / unmergeCells）\n *   都经命令系统执行（applyPatch 是唯一变更通道），天然获得 undo/redo 能力\n * - 公式：`setCellValue` 识别 '=' 前缀走 `setCellFormula`；命令执行后自动增量重算，\n *   重算派生变更（含跨表）并入同一 undo 单元\n */\n\nexport type SheetEvents = {\n  /** 单元格数据变化（含删除） */\n  'cell-change': { addr: CellAddress }\n  /** 合并结构变化（合并/取消合并） */\n  'merge-change': { range: CellRange }\n  /** 选区变化 */\n  'selection-change': SelectionState\n  /** 历史栈变化（undo/redo 可用状态，供工具栏按钮置灰） */\n  'history-change': HistoryState\n}\n\nexport class Sheet {\n  readonly store = new CellStore()\n  readonly merges = new MergeManager()\n  readonly selection: SelectionModel\n  /**  undo/redo 历史（命令系统） */\n  readonly history: HistoryManager\n  /** 公式依赖图（工作簿内多 sheet 共享；独立 Sheet 自建） */\n  readonly formulaGraph: DependencyGraph\n\n  name: string\n\n  private emitter = new TypedEventEmitter<SheetEvents>()\n\n  constructor(name = 'Sheet1', formulaGraph?: DependencyGraph) {\n    this.name = name\n    this.selection = new SelectionModel((addr) => this.merges.resolveAnchor(addr))\n    this.selection.on((state) => this.emitter.emit('selection-change', state))\n    this.history = new HistoryManager(this.boundApplyPatch)\n    this.history.onChange((state) => this.emitter.emit('history-change', state))\n    this.formulaGraph = formulaGraph ?? new DependencyGraph()\n    this.formulaGraph.registerSheet(this)\n  }\n\n  get rowCount(): number {\n    return this.store.rowCount\n  }\n\n  get colCount(): number {\n    return this.store.colCount\n  }\n\n  // ─── 单元格数据 ────────────────────────────────────────────\n\n  /** 原始存储语义读取（被覆盖格 → undefined） */\n  getCellData(addr: CellAddress): CellData | undefined {\n    return this.store.getCell(addr)\n  }\n\n  /** 锚点解析语义读取（被覆盖格 → 锚点的值） */\n  getDisplayValue(addr: CellAddress): CellValue | undefined {\n    const anchor = this.merges.resolveAnchor(addr)\n    return this.store.getCell(anchor)?.v ?? undefined\n  }\n\n  /** 写入原始值（解析到锚点；空值 = 清除）；'=' 前缀按公式处理；经命令执行，可撤销 */\n  setCellValue(addr: CellAddress, value: CellValue): void {\n    if (typeof value === 'string' && value.startsWith('=')) {\n      this.setCellFormula(addr, value)\n      return\n    }\n    const data = value == null || value === '' ? undefined : { v: value, t: inferCellType(value) }\n    this.setCells([{ addr, data }])\n  }\n\n  /** 写入完整 CellData（解析到锚点；空数据 = 清除）；经命令执行，可撤销 */\n  setCell(addr: CellAddress, data?: CellData): void {\n    this.setCells([{ addr, data }])\n  }\n\n  /**\n   * 写入公式（可带 '=' 前缀；空白公式 = 清除）；经命令执行，可撤销。\n   * 公式原文存 CellData.f，计算缓存（v/t）由增量重算填充；解析失败 → #ERROR!。\n   */\n  setCellFormula(addr: CellAddress, formula: string): void {\n    const text = formula.startsWith('=') ? formula.slice(1) : formula\n    if (text.trim() === '') {\n      this.setCells([{ addr, data: undefined }])\n      return\n    }\n    this.executeCommand(SetCellFormulaCommand.id, { addr, formula: text })\n  }\n\n  /** 批量写入（一次调用 = 一个 undo 单元，供粘贴/填充复用） */\n  setCells(items: SetCellValueItem[]): void {\n    this.executeCommand(SetCellValueCommand.id, { items })\n  }\n\n  // ─── 合并 ────────────────────────────────────────────────\n\n  /** 合并语义下的单元格信息（普通格 / 合并锚点 / 被覆盖格） */\n  getCellInfo(addr: CellAddress): CellInfo {\n    return this.merges.getCellInfo(addr)\n  }\n\n  /**\n   * 合并区域。值保留规则（同 Excel/univer）：\n   * 仅保留包围盒内按行主序第一个有值格的值，写入新锚点，其余被覆盖格清空。\n   * @returns 最终生效的合并区域（与既有合并相交时取包围盒）\n   */\n  mergeCells(range: CellRange): CellRange {\n    return this.executeCommand<CellRange>(MergeCellsCommand.id, { range })!\n  }\n\n  /** 解除与 range 相交的所有合并；仅原锚点保留值（被覆盖格本就无值） */\n  unmergeCells(range: CellRange): void {\n    this.executeCommand(UnmergeCellsCommand.id, { range })\n  }\n\n  // ─── 命令与历史 ──────────────────────────────────────────\n\n  /** 经默认注册表执行命令；产生的 mutation 与公式重算派生 mutation 一并推入历史 */\n  executeCommand<R = void>(commandId: string, params: unknown): R | undefined {\n    const result = defaultCommandRegistry.execute<R>(\n      { sheet: this, applyPatch: this.boundApplyPatch },\n      commandId,\n      params\n    )\n    if (result && result.mutations.length > 0) {\n      const mutations = [...result.mutations]\n      const recalcMutation = this.recalcAfterCommand(result.mutations)\n      if (recalcMutation) mutations.push(recalcMutation)\n      this.history.push(mutations)\n    }\n    return result?.result\n  }\n\n  /** 开启事务（事务内所有命令合并为一个 undo 单元；可嵌套，拍平到最外层） */\n  beginTransaction(): void {\n    this.history.beginTransaction()\n  }\n\n  /** 提交事务 */\n  commit(): void {\n    this.history.commit()\n  }\n\n  /** 回滚事务：还原缓冲中已应用的变更并放弃事务 */\n  rollback(): void {\n    this.history.rollback()\n  }\n\n  /** 撤销一步；无可撤销时返回 false */\n  undo(): boolean {\n    return this.history.undo()\n  }\n\n  /** 重做一步；无可重做时返回 false */\n  redo(): boolean {\n    return this.history.redo()\n  }\n\n  get canUndo(): boolean {\n    return this.history.canUndo\n  }\n\n  get canRedo(): boolean {\n    return this.history.canRedo\n  }\n\n  // ─── 选区 ────────────────────────────────────────────────\n\n  getSelection(): SelectionState {\n    return this.selection.getState()\n  }\n\n  /** 选中单格（被覆盖格自动定位锚点） */\n  selectCell(addr: CellAddress): void {\n    this.selection.selectCell(addr)\n  }\n\n  selectRange(range: CellRange): void {\n    this.selection.selectRange(range)\n  }\n\n  // ─── 事件 ────────────────────────────────────────────────\n\n  on<K extends keyof SheetEvents>(type: K, handler: (payload: SheetEvents[K]) => void): () => void {\n    return this.emitter.on(type, handler)\n  }\n\n  off<K extends keyof SheetEvents>(type: K, handler: (payload: SheetEvents[K]) => void): void {\n    this.emitter.off(type, handler)\n  }\n\n  // ─── 内部 ────────────────────────────────────────────────\n\n  private readonly boundApplyPatch = (patch: Patch, direction: PatchDirection): void => {\n    // 跨表重算的派生补丁路由到目标 sheet（回放经源 sheet 历史时同样按此路由）\n    const target = patch.kind === 'cell' ? (patch.sheet ?? this) : this\n    target.applyPatch(patch, direction)\n  }\n\n  /** 应用补丁：命令执行与 undo/redo 回放共用的唯一变更通道 */\n  private applyPatch(patch: Patch, direction: PatchDirection): void {\n    if (patch.kind === 'cell') {\n      const data = direction === 'redo' ? patch.after : patch.before\n      const previous = direction === 'redo' ? patch.before : patch.after\n      this.store.setCell(patch.addr, data)\n      // 公式依赖图同步（f 增/删/改 → 节点增/删/重建；undo/redo 回放同样覆盖）\n      this.formulaGraph.syncCell(this, patch.addr, previous, data)\n      this.emitter.emit('cell-change', { addr: patch.addr })\n      return\n    }\n    const exists = direction === 'redo' ? patch.after : patch.before\n    if (exists) {\n      this.merges.addMerge(patch.range)\n    } else {\n      this.merges.removeMerge(patch.range)\n    }\n    this.emitter.emit('merge-change', { range: patch.range })\n  }\n\n  /**\n   * 命令执行后的公式增量重算：从命令 mutation 提取变更格 → 依赖图标脏 +\n   * 拓扑序重算 → 派生补丁立即应用，作为附加 mutation 并入同一 undo 单元。\n   * undo/redo 纯补丁回放（不重算），图状态由 applyPatch 内的 syncCell 维持。\n   */\n  private recalcAfterCommand(mutations: Mutation[]): Mutation | undefined {\n    const changed: { sheet: Sheet; addr: CellAddress }[] = []\n    for (const mutation of mutations) {\n      for (const patch of mutation.redo) {\n        if (patch.kind === 'cell') changed.push({ sheet: patch.sheet ?? this, addr: patch.addr })\n      }\n    }\n    const derived = this.formulaGraph.recalc(changed)\n    if (derived.length === 0) return undefined\n    for (const patch of derived) this.boundApplyPatch(patch, 'redo')\n    return { redo: derived, undo: [...derived].reverse() }\n  }\n}\n"],"mappings":"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"}