@veltra/sheet 2.0.1 → 2.2.0

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

@@ -1,10 +0,0 @@
-import { CommandRegistry } from "./registry.js";
-//#region src/core/command/default-registry.d.ts
-/**
- * 默认命令注册表：内置命令模块加载时注册一次，全局共享（命令无状态）。
- * Sheet 默认经此表执行命令；阶段 4 工具扩展可继续注册自定义命令。
- */
-declare const defaultCommandRegistry: CommandRegistry;
-//#endregion
-export { defaultCommandRegistry };
-//# sourceMappingURL=default-registry.d.ts.map

package/dist/core/command/default-registry.js

@@ -1,18 +0,0 @@
-import { MergeCellsCommand, UnmergeCellsCommand } from "./merge-cells.js";
-import { CommandRegistry } from "./registry.js";
-import { SetCellFormulaCommand } from "./set-cell-formula.js";
-import { SetCellValueCommand } from "./set-cell-value.js";
-//#region src/core/command/default-registry.ts
-/**
-* 默认命令注册表：内置命令模块加载时注册一次，全局共享（命令无状态）。
-* Sheet 默认经此表执行命令；阶段 4 工具扩展可继续注册自定义命令。
-*/
-const defaultCommandRegistry = new CommandRegistry();
-defaultCommandRegistry.register(SetCellValueCommand);
-defaultCommandRegistry.register(SetCellFormulaCommand);
-defaultCommandRegistry.register(MergeCellsCommand);
-defaultCommandRegistry.register(UnmergeCellsCommand);
-//#endregion
-export { defaultCommandRegistry };
-
-//# sourceMappingURL=default-registry.js.map

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

@@ -1 +0,0 @@
-{"version":3,"file":"default-registry.js","names":[],"sources":["../../../src/core/command/default-registry.ts"],"sourcesContent":["import { MergeCellsCommand, UnmergeCellsCommand } from './merge-cells'\nimport { CommandRegistry } from './registry'\nimport { SetCellFormulaCommand } from './set-cell-formula'\nimport { SetCellValueCommand } from './set-cell-value'\n\n/**\n * 默认命令注册表：内置命令模块加载时注册一次，全局共享（命令无状态）。\n * Sheet 默认经此表执行命令；阶段 4 工具扩展可继续注册自定义命令。\n */\nexport const defaultCommandRegistry = new CommandRegistry()\n\ndefaultCommandRegistry.register(SetCellValueCommand)\ndefaultCommandRegistry.register(SetCellFormulaCommand)\ndefaultCommandRegistry.register(MergeCellsCommand)\ndefaultCommandRegistry.register(UnmergeCellsCommand)\n"],"mappings":";;;;;;;;;AASA,MAAa,yBAAyB,IAAI,gBAAgB;AAE1D,uBAAuB,SAAS,mBAAmB;AACnD,uBAAuB,SAAS,qBAAqB;AACrD,uBAAuB,SAAS,iBAAiB;AACjD,uBAAuB,SAAS,mBAAmB"}

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

@@ -1,64 +0,0 @@
-import { Mutation, Patch, PatchDirection } from "./types.js";
-//#region src/core/command/history.d.ts
-/**
- * HistoryManager：undo/redo 栈 + 事务。
- *
- * - 一个 undo 单元 = 一次命令（或一次事务）的全部 Mutation
- * - 事务：beginTransaction / commit，支持嵌套（深度计数，拍平到最外层）；
- *   rollback 回滚缓冲区中已应用的变更并放弃事务
- * - 容量上限（默认 200）：超出淘汰最旧条目
- * - 新命令入栈即清空 redo 栈
- */
-/** 历史栈容量默认值 */
-declare const DEFAULT_HISTORY_CAPACITY = 200;
-/** 历史状态（history-change 事件负载） */
-interface HistoryState {
-  canUndo: boolean;
-  canRedo: boolean;
-}
-declare class HistoryManager {
-  /** 补丁应用器（由 Sheet 注入，命令执行与回放共用） */
-  private readonly applyPatch;
-  private readonly capacity;
-  private undoStack;
-  private redoStack;
-  /** 事务深度（>0 表示事务进行中） */
-  private transactionDepth;
-  /** 事务缓冲：commit 时合并为一个 undo 单元 */
-  private transactionBuffer;
-  private emitter;
-  constructor(
-  /** 补丁应用器（由 Sheet 注入，命令执行与回放共用） */
-  applyPatch: (patch: Patch, direction: PatchDirection) => void, capacity?: number);
-  get canUndo(): boolean;
-  get canRedo(): boolean;
-  /** undo 栈深度（调试/测试用） */
-  get undoSize(): number;
-  /** redo 栈深度（调试/测试用） */
-  get redoSize(): number;
-  /** 是否处于事务中 */
-  get inTransaction(): boolean;
-  /** 命令执行产生的 mutation 入栈（事务中则缓冲）；空列表直接忽略 */
-  push(mutations: Mutation[]): void;
-  /** 开启事务（可嵌套，拍平到最外层） */
-  beginTransaction(): void;
-  /** 提交事务：缓冲的 mutation 合并为一个 undo 单元入栈 */
-  commit(): void;
-  /**
-   * 回滚事务：逆序应用缓冲区中各 mutation 的 undo 补丁还原模型，
-   * 丢弃缓冲并结束事务（含嵌套）；不动 undo/redo 栈。
-   */
-  rollback(): void;
-  /** 撤销一个单元；事务进行中或栈空时返回 false */
-  undo(): boolean;
-  /** 重做一个单元；事务进行中或栈空时返回 false */
-  redo(): boolean;
-  /** 清空全部历史（含事务缓冲） */
-  clear(): void;
-  onChange(handler: (state: HistoryState) => void): () => void;
-  private pushEntry;
-  private emitChange;
-}
-//#endregion
-export { DEFAULT_HISTORY_CAPACITY, HistoryManager, HistoryState };
-//# sourceMappingURL=history.d.ts.map

package/dist/core/command/history.js

@@ -1,127 +0,0 @@
-import { TypedEventEmitter } from "../events.js";
-//#region src/core/command/history.ts
-/**
-* HistoryManager：undo/redo 栈 + 事务。
-*
-* - 一个 undo 单元 = 一次命令（或一次事务）的全部 Mutation
-* - 事务：beginTransaction / commit，支持嵌套（深度计数，拍平到最外层）；
-*   rollback 回滚缓冲区中已应用的变更并放弃事务
-* - 容量上限（默认 200）：超出淘汰最旧条目
-* - 新命令入栈即清空 redo 栈
-*/
-/** 历史栈容量默认值 */
-const DEFAULT_HISTORY_CAPACITY = 200;
-var HistoryManager = class {
-	applyPatch;
-	capacity;
-	undoStack = [];
-	redoStack = [];
-	/** 事务深度（>0 表示事务进行中） */
-	transactionDepth = 0;
-	/** 事务缓冲：commit 时合并为一个 undo 单元 */
-	transactionBuffer = [];
-	emitter = new TypedEventEmitter();
-	constructor(applyPatch, capacity = 200) {
-		this.applyPatch = applyPatch;
-		this.capacity = capacity;
-	}
-	get canUndo() {
-		return this.undoStack.length > 0;
-	}
-	get canRedo() {
-		return this.redoStack.length > 0;
-	}
-	/** undo 栈深度（调试/测试用） */
-	get undoSize() {
-		return this.undoStack.length;
-	}
-	/** redo 栈深度（调试/测试用） */
-	get redoSize() {
-		return this.redoStack.length;
-	}
-	/** 是否处于事务中 */
-	get inTransaction() {
-		return this.transactionDepth > 0;
-	}
-	/** 命令执行产生的 mutation 入栈（事务中则缓冲）；空列表直接忽略 */
-	push(mutations) {
-		if (mutations.length === 0) return;
-		if (this.transactionDepth > 0) {
-			this.transactionBuffer.push(...mutations);
-			return;
-		}
-		this.pushEntry(mutations);
-	}
-	/** 开启事务（可嵌套，拍平到最外层） */
-	beginTransaction() {
-		this.transactionDepth++;
-	}
-	/** 提交事务：缓冲的 mutation 合并为一个 undo 单元入栈 */
-	commit() {
-		if (this.transactionDepth === 0) throw new Error("HistoryManager.commit：没有进行中的事务");
-		this.transactionDepth--;
-		if (this.transactionDepth === 0 && this.transactionBuffer.length > 0) {
-			const entry = this.transactionBuffer;
-			this.transactionBuffer = [];
-			this.pushEntry(entry);
-		}
-	}
-	/**
-	* 回滚事务：逆序应用缓冲区中各 mutation 的 undo 补丁还原模型，
-	* 丢弃缓冲并结束事务（含嵌套）；不动 undo/redo 栈。
-	*/
-	rollback() {
-		if (this.transactionDepth === 0) return;
-		const buffer = this.transactionBuffer;
-		this.transactionBuffer = [];
-		this.transactionDepth = 0;
-		for (let i = buffer.length - 1; i >= 0; i--) for (const patch of buffer[i].undo) this.applyPatch(patch, "undo");
-	}
-	/** 撤销一个单元；事务进行中或栈空时返回 false */
-	undo() {
-		if (this.transactionDepth > 0) return false;
-		const entry = this.undoStack.pop();
-		if (!entry) return false;
-		for (let i = entry.length - 1; i >= 0; i--) for (const patch of entry[i].undo) this.applyPatch(patch, "undo");
-		this.redoStack.push(entry);
-		this.emitChange();
-		return true;
-	}
-	/** 重做一个单元；事务进行中或栈空时返回 false */
-	redo() {
-		if (this.transactionDepth > 0) return false;
-		const entry = this.redoStack.pop();
-		if (!entry) return false;
-		for (const mutation of entry) for (const patch of mutation.redo) this.applyPatch(patch, "redo");
-		this.undoStack.push(entry);
-		this.emitChange();
-		return true;
-	}
-	/** 清空全部历史（含事务缓冲） */
-	clear() {
-		this.undoStack = [];
-		this.redoStack = [];
-		this.transactionBuffer = [];
-		this.transactionDepth = 0;
-		this.emitChange();
-	}
-	onChange(handler) {
-		return this.emitter.on("change", handler);
-	}
-	pushEntry(entry) {
-		this.undoStack.push(entry);
-		if (this.undoStack.length > this.capacity) this.undoStack.shift();
-		this.redoStack = [];
-		this.emitChange();
-	}
-	emitChange() {
-		this.emitter.emit("change", {
-			canUndo: this.canUndo,
-			canRedo: this.canRedo
-		});
-	}
-};
-//#endregion
-export { DEFAULT_HISTORY_CAPACITY, HistoryManager };
-
-//# sourceMappingURL=history.js.map

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

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

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

@@ -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"}