@tmagic/editor 1.8.0-beta.8 → 1.8.0-manmanyu.8

package/dist/es/services/history.js

@@ -1,7 +1,7 @@
 import BaseService from "./BaseService.js";
 import { getEditorConfig } from "../utils/config.js";
 import { UndoRedo } from "../utils/undo-redo.js";
-import { deserializeStacks, getOrCreateStack, markStackSaved, mergeSteps, serializeStacks, undoFloor } from "../utils/history.js";
+import { createStackStep, deserializeStacks, getOrCreateStack, markStackSaved, mergePageSteps, mergeStackSteps, serializeStacks, undoFloor } from "../utils/history.js";
 import { idbGet, idbSet } from "../utils/indexed-db.js";
 import editor_default from "./editor.js";
 import { guid } from "@tmagic/utils";
@@ -9,92 +9,78 @@ import { reactive } from "vue";
 //#region packages/editor/src/services/history.ts
 var canUsePluginMethods = { sync: [
 	"push",
+	"pushCodeBlock",
+	"pushDataSource",
+	"undoCodeBlock",
+	"redoCodeBlock",
+	"undoDataSource",
+	"redoDataSource",
 	"undo",
 	"redo"
 ] };
-/** 各内置历史类型的默认展示名称（用于历史面板 tab / 分组标题等）。扩展类型可通过 registerStepType / setStepName 登记。 */
-var DEFAULT_STEP_NAMES = {
-	page: "页面",
-	codeBlock: "代码块",
-	dataSource: "数据源"
-};
-/** 各历史类型对应的分组 `kind`（展示用）：page→page，codeBlock→code-block，dataSource→data-source。扩展类型缺省回退到 stepType 本身。 */
-var STEP_TYPE_KIND = {
-	page: "page",
-	codeBlock: "code-block",
-	dataSource: "data-source"
-};
 /** 历史记录持久化快照的默认存储位置与结构版本。 */
 var DEFAULT_DB_NAME = "tmagic-editor";
 var DEFAULT_STORE_NAME = "history";
 var DEFAULT_KEY = "default";
-var PERSIST_VERSION = 3;
+var PERSIST_VERSION = 2;
 var History = class extends BaseService {
 	state = reactive({
-		steps: {
-			page: {},
-			codeBlock: {},
-			dataSource: {}
-		},
-		stepNames: { ...DEFAULT_STEP_NAMES }
+		pageSteps: {},
+		pageId: void 0,
+		canRedo: false,
+		canUndo: false,
+		codeBlockState: {},
+		dataSourceState: {}
 	});
 	constructor() {
 		super([...canUsePluginMethods.sync.map((methodName) => ({
 			name: methodName,
 			isAsync: false
 		}))]);
-	}
-	/**
-	* 注册一个扩展历史类型，使其可与内置 `page` / `codeBlock` / `dataSource` 一样走统一的
-	* {@link push} / {@link undo} / {@link redo}（按 id 分栈、独立 undo/redo）。
-	*
-	* @param stepType 自定义历史类型标识（勿与内置类型重名）
-	* @param options.event push/undo/redo 后派发的事件名，缺省为 `${stepType}-history-change`
-	* @param options.name 历史面板中的展示名称（tab / 分组标题等），缺省回退到 stepType 本身
-	*/
-	registerStepType(stepType, options = {}) {
-		this.getStepBucket(stepType);
-		if (options.name !== void 0) this.state.stepNames[stepType] = options.name;
-	}
-	/**
-	* 读取指定历史类型的展示名称（用于历史面板 tab / 分组标题等）。
-	* 未登记名称时回退到 stepType 本身。
-	*/
-	getStepName(stepType) {
-		return this.state.stepNames[stepType] ?? `${stepType}`;
-	}
-	/**
-	* 设置指定历史类型的展示名称（用于历史面板 tab / 分组标题等）。
-	* 内置 `page` / `codeBlock` / `dataSource` 也可在此覆盖默认中文名。
-	*/
-	setStepName(stepType, name) {
-		this.state.stepNames[stepType] = name;
+		this.on("change", this.setCanUndoRedo);
 	}
 	reset() {
-		this.clearAllSteps();
+		this.state.pageSteps = {};
+		this.state.codeBlockState = {};
+		this.state.dataSourceState = {};
+		this.resetPage();
+	}
+	resetPage() {
+		this.state.pageId = void 0;
+		this.state.canRedo = false;
+		this.state.canUndo = false;
+	}
+	changePage(page) {
+		if (!page) return;
+		this.state.pageId = page.id;
+		if (!this.state.pageSteps[this.state.pageId]) this.state.pageSteps[this.state.pageId] = new UndoRedo();
+		this.setCanUndoRedo();
+		this.emit("page-change", this.state.pageSteps[this.state.pageId]);
 	}
 	resetState() {
-		this.clearAllSteps();
+		this.state.pageId = void 0;
+		this.state.pageSteps = {};
+		this.state.canRedo = false;
+		this.state.canUndo = false;
+		this.state.codeBlockState = {};
+		this.state.dataSourceState = {};
 	}
 	/**
-	* 为指定历史栈（默认 `page`，也适用于 codeBlock / dataSource / 扩展类型）种入一条「初始基线」记录。
+	* 为指定页面 / 页面片种入一条「初始基线」记录（如加载 DSL 时的「初始 / 加载」基线）。
 	*
-	* 该记录是一条 `opType: 'initial'` 的 step，作为对应栈 **index 0 的固定底线**：
+	* 该记录是一条 `opType: 'initial'` 的 {@link StepValue}，作为页面历史栈 **index 0 的固定底线**：
 	* - 它是一条真实入栈的 step（随栈一起持久化），但被钉为撤销/回滚的下限——cursor 永不低于它，
-	*   因此不会被 undo / goto / revert 触达（详见 {@link undo} / {@link undoFloor}）；
-	* - 历史面板把它过滤出分组列表（见 {@link getHistoryGroups}），改由底部「初始」行展示。
-	*
-	* 仅当目标栈为空时种入（保证 initial 一定位于 index 0）；已存在 initial 底线时不重复种入。
+	*   因此不会被 undo / goto / revert 触达（详见 {@link undo} / {@link setCanUndoRedo}）；
+	* - 历史面板把它过滤出分组列表（见 {@link getPageHistoryGroups}），改由底部「初始」行展示。
 	*
-	* @param stepType 历史类型
-	* @param id       目标栈 id（page 为 pageId，其余类型为对应资源 id）
-	* @param options  基线展示信息（名称 / 描述 / 来源）
+	* 仅当目标页面栈为空时种入（保证 initial 一定位于 index 0）；已存在 initial 底线时默认不重复种入，
+	* 传 `force=true` 且栈为空时按新基线种入。
 	*/
-	setMarker(stepType, id, options = {}) {
-		if (!this.isValidStackId(id)) return null;
-		const existing = this.getMarker(stepType, id);
+	setPageMarker(pageId, options = {}) {
+		if (pageId === void 0 || pageId === null || `${pageId}` === "") return null;
+		const existing = this.getPageMarker(pageId);
 		if (existing) return existing;
-		const stack = getOrCreateStack(this.getStepBucket(stepType), id);
+		const stack = getOrCreateStack(this.state.pageSteps, pageId);
 		if (stack.getLength() > 0) return null;
 		const marker = {
 			uuid: guid(),
@@ -102,95 +88,164 @@ var History = class extends BaseService {
 			diff: [],
 			data: {
 				name: options.name || "",
-				id
-			},
-			extra: {
-				...options.extra || {},
-				...stepType === "page" ? {
-					selectedBefore: [],
-					selectedAfter: [],
-					modifiedNodeIds: /* @__PURE__ */ new Map()
-				} : {}
+				id: pageId
 			},
+			selectedBefore: [],
+			selectedAfter: [],
+			modifiedNodeIds: /* @__PURE__ */ new Map(),
 			historyDescription: options.description || "未修改的初始状态",
 			timestamp: Date.now(),
 			...options.source ? { source: options.source } : {}
 		};
 		stack.pushElement(marker);
-		this.emit("marker-change", {
-			id,
-			marker,
-			stepType
-		});
+		if (`${pageId}` === `${this.state.pageId}`) this.setCanUndoRedo();
+		this.emit("page-marker-change", marker);
 		return marker;
 	}
 	/**
-	* 读取指定历史栈的初始基线 step（栈 index 0 且 `opType: 'initial'`）；
-	* 不存在或 id 缺省时返回 undefined。
+	* 读取指定页面（缺省当前活动页）的初始基线 step（页面栈 index 0 且 `opType: 'initial'`）；
+	* 不存在时返回 undefined。
 	*/
-	getMarker(stepType, id) {
-		if (!this.isValidStackId(id)) return void 0;
-		const first = this.state.steps[stepType]?.[id]?.getElementList()[0];
+	getPageMarker(pageId) {
+		const targetPageId = pageId ?? this.state.pageId;
+		if (!targetPageId) return void 0;
+		const first = this.state.pageSteps[targetPageId]?.getElementList()[0];
 		return first?.opType === "initial" ? first : void 0;
 	}
-	push(stepType, step, id) {
-		if (!this.isValidStackId(id)) return null;
-		this.fillStepMeta(step);
-		getOrCreateStack(this.getStepBucket(stepType), id).pushElement(step);
-		this.emit("change", step, stepType, id);
+	/**
+	* 把一条步骤推入指定页面的栈；不指定 pageId 时落到当前活动页。
+	*
+	* 跨页操作（例如 `moveToContainer` 把节点搬到其它页）必须显式传入 `pageId`，
+	* 否则会把记录错误地落到操作发起页 / 当前激活页，破坏目标页 / 源页的撤销栈语义。
+	*/
+	push(state, pageId) {
+		const undoRedo = this.getUndoRedo(pageId);
+		if (!undoRedo) return null;
+		if (state.uuid === void 0) state.uuid = guid();
+		if (state.timestamp === void 0) state.timestamp = Date.now();
+		undoRedo.pushElement(state);
+		if (pageId === void 0 || `${pageId}` === `${this.state.pageId}`) this.emit("change", state);
+		return state;
+	}
+	/** 读取指定页面（缺省当前活动页）历史栈当前游标所在的 step（cursor - 1）；无则返回 null。 */
+	getCurrentPageStep(pageId) {
+		const targetPageId = pageId ?? this.state.pageId;
+		if (!targetPageId) return null;
+		return this.state.pageSteps[targetPageId]?.getCurrentElement() ?? null;
+	}
+	/**
+	* 用 `state` 替换指定页面栈当前游标所在的 step（并丢弃其后的重做尾部），游标不变。
+	* 用于「连续 set root 记录合并」等就地替换最新一条的场景；替换成功后按需刷新 / 通知。
+	*/
+	replaceCurrentPageStep(state, pageId) {
+		const undoRedo = this.getUndoRedo(pageId);
+		if (!undoRedo) return null;
+		if (state.uuid === void 0) state.uuid = guid();
+		if (state.timestamp === void 0) state.timestamp = Date.now();
+		if (!undoRedo.replaceCurrentElement(state)) return null;
+		this.emit("change", state);
+		return state;
+	}
+	/**
+	* 推入一条代码块变更记录（与页面/节点完全无关），按 `codeBlockId` 维度独立一份 UndoRedo 栈。
+	*
+	* - 新增：oldContent = null，newContent = 新内容
+	* - 更新：oldContent / newContent 都为对应内容
+	* - 删除：newContent = null，oldContent = 删除前内容
+	* - `changeRecords` 来自 form 端，撤销/重做时若有则按 propPath 局部覆盖；缺省才退化为整内容替换。
+	* - 不直接驱动 codeBlockService，调用方负责实际写回。
+	*/
+	pushCodeBlock(codeBlockId, payload) {
+		const step = createStackStep(codeBlockId, {
+			oldValue: payload.oldContent,
+			newValue: payload.newContent,
+			changeRecords: payload.changeRecords,
+			historyDescription: payload.historyDescription,
+			source: payload.source
+		});
+		if (!step) return null;
+		getOrCreateStack(this.state.codeBlockState, codeBlockId).pushElement(step);
+		this.emit("code-block-history-change", codeBlockId, step);
+		return step;
+	}
+	/**
+	* 推入一条数据源变更记录（与页面/节点完全无关），按 `dataSourceId` 维度独立一份 UndoRedo 栈。
+	* 行为同 pushCodeBlock（新增 oldSchema=null；删除 newSchema=null）。
+	*/
+	pushDataSource(dataSourceId, payload) {
+		const step = createStackStep(dataSourceId, {
+			oldValue: payload.oldSchema,
+			newValue: payload.newSchema,
+			changeRecords: payload.changeRecords,
+			historyDescription: payload.historyDescription,
+			source: payload.source
+		});
+		if (!step) return null;
+		getOrCreateStack(this.state.dataSourceState, dataSourceId).pushElement(step);
+		this.emit("data-source-history-change", dataSourceId, step);
 		return step;
 	}
-	undo(stepType, id) {
-		if (!this.isValidStackId(id)) return null;
-		const undoRedo = this.state.steps[stepType]?.[id];
+	/** 撤销指定代码块的最近一次变更。 */
+	undoCodeBlock(codeBlockId) {
+		const undoRedo = this.state.codeBlockState[codeBlockId];
 		if (!undoRedo) return null;
-		if (undoRedo.getCursor() <= undoFloor(undoRedo)) return null;
 		const step = undoRedo.undo();
-		if (step) this.emit("change", step, stepType, id);
+		if (step) this.emit("code-block-history-change", codeBlockId, step);
 		return step;
 	}
-	redo(stepType, id) {
-		if (!this.isValidStackId(id)) return null;
-		const undoRedo = this.state.steps[stepType]?.[id];
+	/** 重做指定代码块的下一次变更。 */
+	redoCodeBlock(codeBlockId) {
+		const undoRedo = this.state.codeBlockState[codeBlockId];
 		if (!undoRedo) return null;
 		const step = undoRedo.redo();
-		if (step) this.emit("change", step, stepType, id);
+		if (step) this.emit("code-block-history-change", codeBlockId, step);
 		return step;
 	}
-	/**
-	* 是否可对指定历史栈撤销（cursor 高于 initial 基线底线）。
-	* @param stepType 历史类型
-	* @param id       目标栈 id；缺省 / 无效时返回 false
-	*/
-	canUndo(stepType, id) {
-		if (!this.isValidStackId(id)) return false;
-		const undoRedo = this.state.steps[stepType]?.[id];
-		return undoRedo ? undoRedo.getCursor() > undoFloor(undoRedo) : false;
+	/** 是否可对指定代码块撤销。 */
+	canUndoCodeBlock(codeBlockId) {
+		return this.state.codeBlockState[codeBlockId]?.canUndo() ?? false;
 	}
-	/**
-	* 是否可对指定历史栈重做。
-	* @param stepType 历史类型
-	* @param id       目标栈 id；缺省 / 无效时返回 false
-	*/
-	canRedo(stepType, id) {
-		if (!this.isValidStackId(id)) return false;
-		return this.state.steps[stepType]?.[id]?.canRedo() ?? false;
+	/** 是否可对指定代码块重做。 */
+	canRedoCodeBlock(codeBlockId) {
+		return this.state.codeBlockState[codeBlockId]?.canRedo() ?? false;
 	}
-	/** 读取指定页面历史栈当前游标所在的 step（cursor - 1）；无则返回 null。 */
-	getCurrentPageStep(pageId) {
-		if (!this.isValidStackId(pageId)) return null;
-		return this.state.steps.page[pageId]?.getCurrentElement() ?? null;
+	/** 撤销指定数据源的最近一次变更。 */
+	undoDataSource(dataSourceId) {
+		const undoRedo = this.state.dataSourceState[dataSourceId];
+		if (!undoRedo) return null;
+		const step = undoRedo.undo();
+		if (step) this.emit("data-source-history-change", dataSourceId, step);
+		return step;
 	}
-	/**
-	* 用 `state` 替换指定页面栈当前游标所在的 step（并丢弃其后的重做尾部），游标不变。
-	* 用于「连续 set root 记录合并」等就地替换最新一条的场景；替换成功后派发 `change`。
-	*/
-	replaceCurrentStep(stepType, state, id) {
-		if (!this.isValidStackId(id)) return null;
-		const undoRedo = getOrCreateStack(this.getStepBucket(stepType), id);
-		this.fillStepMeta(state);
-		if (!undoRedo.replaceCurrentElement(state)) return null;
-		this.emit("change", state, stepType, id);
+	/** 重做指定数据源的下一次变更。 */
+	redoDataSource(dataSourceId) {
+		const undoRedo = this.state.dataSourceState[dataSourceId];
+		if (!undoRedo) return null;
+		const step = undoRedo.redo();
+		if (step) this.emit("data-source-history-change", dataSourceId, step);
+		return step;
+	}
+	/** 是否可对指定数据源撤销。 */
+	canUndoDataSource(dataSourceId) {
+		return this.state.dataSourceState[dataSourceId]?.canUndo() ?? false;
+	}
+	/** 是否可对指定数据源重做。 */
+	canRedoDataSource(dataSourceId) {
+		return this.state.dataSourceState[dataSourceId]?.canRedo() ?? false;
+	}
+	undo() {
+		const undoRedo = this.getUndoRedo();
+		if (!undoRedo) return null;
+		if (undoRedo.getCursor() <= undoFloor(undoRedo)) return null;
+		const state = undoRedo.undo();
+		this.emit("change", state);
+		return state;
+	}
+	redo() {
+		const undoRedo = this.getUndoRedo();
+		if (!undoRedo) return null;
+		const state = undoRedo.redo();
+		this.emit("change", state);
 		return state;
 	}
 	destroy() {
@@ -199,52 +254,84 @@ var History = class extends BaseService {
 		this.removeAllPlugins();
 	}
 	/**
-	* 清空历史记录栈。统一入口，所有类型（page / codeBlock / dataSource / 扩展）行为一致：
-	* - 传入 `id`：仅清空 `stepType` 下该 id 对应的栈；
-	* - 缺省 `id`：清空 `stepType` 下的全部栈。
-	*
-	* 仅删除撤销/重做记录，不会改动 DSL / 代码块 / 数据源本身。清空时会**保留各栈原有的
-	* initial 基线**（文案 / 来源），无基线时清空成空栈。清空后派发 `clear`（签名 `(id, stepType)`）。
-	*
-	* @param stepType 历史类型
-	* @param id       目标栈 id；缺省表示清空该类型下全部栈
+	* 清空指定页面（缺省当前活动页）的历史记录栈。
+	* 仅删除撤销/重做记录，不会改动当前 DSL；清空后该页将无法再撤销/重做之前的操作。
 	*/
-	clear(stepType, id) {
-		const bucket = this.state.steps[stepType];
-		if (!bucket) return;
-		if (this.isValidStackId(id)) this.clearStack(stepType, id);
-		else if (id === void 0) Object.keys(bucket).forEach((stackId) => this.clearStack(stepType, stackId));
-		else return;
-		this.emit("clear", {
-			id,
-			stepType
+	clearPage(pageId) {
+		const targetPageId = pageId ?? this.state.pageId;
+		if (!targetPageId) return;
+		const marker = this.getPageMarker(targetPageId);
+		this.state.pageSteps[targetPageId] = new UndoRedo();
+		if (marker) this.setPageMarker(targetPageId, {
+			name: marker.data?.name,
+			description: marker.historyDescription,
+			source: marker.source
 		});
+		if (`${targetPageId}` === `${this.state.pageId}`) {
+			this.setCanUndoRedo();
+			this.emit("clear-page", null);
+		}
 	}
 	/**
-	* 标记历史记录为「已保存」（把对应栈当前游标所在的记录标为 `saved`）。统一入口：
-	* - 缺省 `id`：标记**全部类型、全部栈**（整份 DSL 落库场景），派发 `mark-saved` 且 `kind: 'all'`；
-	* - 传入 `id`：仅标记 `stepType` 下该 id 对应的栈，派发 `mark-saved` 且 `kind` 为 `stepType`。
-	*
-	* 同一栈内任意时刻最多只有一条记录为 `saved`；从 IndexedDB 恢复时游标会被定位到最近一条已保存记录之后。
-	*
-	* @param stepType 历史类型
-	* @param id       目标栈 id；缺省表示标记全部类型 / 全部栈
+	* 清空数据源历史记录栈：传入 `dataSourceId` 仅清空该数据源，缺省清空全部数据源。
+	* 仅删除撤销/重做记录，不会改动数据源本身。
 	*/
-	markSaved(stepType, id) {
-		if (id === void 0) {
-			Object.values(this.state.steps).forEach((bucket) => Object.values(bucket).forEach(markStackSaved));
-			this.emit("mark-saved", { kind: "all" });
-			return;
-		}
-		if (!this.isValidStackId(id)) return;
-		markStackSaved(this.state.steps[stepType]?.[id]);
+	clearDataSource(dataSourceId) {
+		if (dataSourceId !== void 0) delete this.state.dataSourceState[dataSourceId];
+		else this.state.dataSourceState = {};
+	}
+	/**
+	* 清空代码块历史记录栈：传入 `codeBlockId` 仅清空该代码块，缺省清空全部代码块。
+	* 仅删除撤销/重做记录，不会改动代码块本身。
+	*/
+	clearCodeBlock(codeBlockId) {
+		if (codeBlockId !== void 0) delete this.state.codeBlockState[codeBlockId];
+		else this.state.codeBlockState = {};
+	}
+	/**
+	* 标记「整份 DSL 已保存」：把页面 / 代码块 / 数据源所有栈当前游标所在的记录都标为 `saved`。
+	* 适用于「整体落库」场景；若只保存了其中一类，请改用更细粒度的
+	* {@link markPageSaved} / {@link markCodeBlockSaved} / {@link markDataSourceSaved}。
+	*/
+	markSaved() {
+		Object.values(this.state.pageSteps).forEach(markStackSaved);
+		Object.values(this.state.codeBlockState).forEach(markStackSaved);
+		Object.values(this.state.dataSourceState).forEach(markStackSaved);
+		this.emit("mark-saved", { kind: "all" });
+	}
+	/**
+	* 标记指定页面（缺省为当前活动页）的历史栈当前记录为已保存。
+	* 仅影响该页面自己的栈，不波及代码块 / 数据源 / 其它页面。
+	*/
+	markPageSaved(pageId) {
+		const targetPageId = pageId ?? this.state.pageId;
+		if (!targetPageId) return;
+		markStackSaved(this.state.pageSteps[targetPageId]);
+		this.emit("mark-saved", {
+			kind: "page",
+			id: targetPageId
+		});
+	}
+	/** 标记指定代码块的历史栈当前记录为已保存，仅影响该代码块自己的栈。 */
+	markCodeBlockSaved(codeBlockId) {
+		if (!codeBlockId) return;
+		markStackSaved(this.state.codeBlockState[codeBlockId]);
+		this.emit("mark-saved", {
+			kind: "code-block",
+			id: codeBlockId
+		});
+	}
+	/** 标记指定数据源的历史栈当前记录为已保存，仅影响该数据源自己的栈。 */
+	markDataSourceSaved(dataSourceId) {
+		if (!dataSourceId) return;
+		markStackSaved(this.state.dataSourceState[dataSourceId]);
 		this.emit("mark-saved", {
-			kind: stepType,
-			id
+			kind: "data-source",
+			id: dataSourceId
 		});
 	}
 	/**
-	* 把当前内存中的全部历史栈（页面 / 代码块 / 数据源 / 扩展类型）序列化后写入本地 IndexedDB。
+	* 把当前内存中的全部历史栈（页面 / 代码块 / 数据源）序列化后写入本地 IndexedDB。
 	*
 	* - 每个 UndoRedo 栈连同其游标、容量一并保存，恢复后可继续 undo/redo；
 	* - `key` 用于区分不同活动页 / 项目（同一 store 下可保存多份快照），缺省为 `default`；
@@ -253,17 +340,12 @@ var History = class extends BaseService {
 	*/
 	async saveToIndexedDB(options = {}) {
 		const { dbName = DEFAULT_DB_NAME, storeName = DEFAULT_STORE_NAME, key = DEFAULT_KEY, appId } = options;
-		const steps = {
-			page: {},
-			codeBlock: {},
-			dataSource: {}
-		};
-		Object.entries(this.state.steps).forEach(([stepType, bucket]) => {
-			steps[stepType] = serializeStacks(bucket);
-		});
 		const snapshot = {
 			version: PERSIST_VERSION,
-			steps,
+			pageId: this.state.pageId,
+			pageSteps: serializeStacks(this.state.pageSteps),
+			codeBlockState: serializeStacks(this.state.codeBlockState),
+			dataSourceState: serializeStacks(this.state.dataSourceState),
 			savedAt: Date.now()
 		};
 		await idbSet(this.resolveDbName(dbName, appId), storeName, key, snapshot);
@@ -274,7 +356,7 @@ var History = class extends BaseService {
 	* 从本地 IndexedDB 读取此前保存的历史快照并重建全部撤销/重做栈。
 	*
 	* - 读取到的每个栈都会经 {@link UndoRedo.fromSerialized} 还原（含游标），随后可直接 undo/redo；
-	* - 会整体覆盖当前内存中的历史状态（活动页由 editorService 维护，不在此恢复）；
+	* - 会整体覆盖当前内存中的历史状态，并把活动页恢复为快照中的 pageId；
 	* - 找不到对应记录时返回 null，且不改动当前状态；
 	* - 不支持 IndexedDB 的环境（如 SSR）会 reject。
 	*/
@@ -283,21 +365,23 @@ var History = class extends BaseService {
 		const snapshot = await idbGet(this.resolveDbName(dbName, appId), storeName, key);
 		if (!snapshot) return null;
 		const parseDSL = getEditorConfig("parseDSL");
-		const steps = {
-			page: {},
-			codeBlock: {},
-			dataSource: {}
-		};
-		Object.entries(snapshot.steps).forEach(([stepType, bucket]) => {
-			steps[stepType] = deserializeStacks(bucket, parseDSL);
-		});
-		this.state.steps = steps;
+		this.state.pageSteps = deserializeStacks(snapshot.pageSteps, parseDSL);
+		this.state.codeBlockState = deserializeStacks(snapshot.codeBlockState, parseDSL);
+		this.state.dataSourceState = deserializeStacks(snapshot.dataSourceState, parseDSL);
+		this.state.pageId = snapshot.pageId;
+		this.setCanUndoRedo();
 		this.emit("restore-from-indexed-db", snapshot);
 		return snapshot;
 	}
-	getStepList(stepType, id) {
-		if (!this.isValidStackId(id)) return [];
-		const undoRedo = this.state.steps[stepType]?.[id];
+	/**
+	* 取出当前活动页的历史步骤平铺列表（包含已应用 + 已撤销）。
+	* 列表按时间正序，最早一步在最前面。
+	* 通常 UI 应使用 `getPageHistoryGroups` 取已合并分组的版本；本方法仅为兼容/调试保留。
+	*/
+	getPageStepList(pageId) {
+		const targetPageId = pageId ?? this.state.pageId;
+		if (!targetPageId) return [];
+		const undoRedo = this.state.pageSteps[targetPageId];
 		if (!undoRedo) return [];
 		const list = undoRedo.getElementList();
 		const cursor = undoRedo.getCursor();
@@ -307,103 +391,147 @@ var History = class extends BaseService {
 			applied: index < cursor
 		}));
 	}
-	getHistoryGroups(stepType, id) {
-		const bucket = this.state.steps[stepType];
-		if (!bucket) return [];
-		const kind = STEP_TYPE_KIND[stepType] ?? stepType;
-		const collect = (stackId) => {
-			const undoRedo = bucket[stackId];
-			if (!undoRedo) return [];
+	/**
+	* 取出当前活动页的历史栈，按"目标节点"做相邻合并：
+	* - 连续修改同一节点（单节点 update）的多步合并为一个 group，组内可展开查看每步；
+	* - add / remove / 多节点 update 始终独立成组。
+	* 用于历史面板的"页面"tab 展示。
+	*/
+	getPageHistoryGroups(pageId) {
+		const targetPageId = pageId ?? this.state.pageId;
+		if (!targetPageId) return [];
+		const undoRedo = this.state.pageSteps[targetPageId];
+		if (!undoRedo) return [];
+		const list = undoRedo.getElementList();
+		if (!list.length) return [];
+		return mergePageSteps(targetPageId, list, undoRedo.getCursor()).filter((group) => group.opType !== "initial");
+	}
+	/**
+	* 取出全部代码块的历史栈，按 codeBlockId 分桶展示。
+	* 同一栈内每条操作记录独立成组，不做相邻 update 合并。
+	*/
+	getCodeBlockHistoryGroups() {
+		const groups = [];
+		Object.entries(this.state.codeBlockState).forEach(([id, undoRedo]) => {
+			if (!undoRedo) return;
 			const list = undoRedo.getElementList();
-			if (!list.length) return [];
-			return mergeSteps(kind, stackId, list, undoRedo.getCursor()).filter((group) => group.opType !== "initial");
-		};
-		if (this.isValidStackId(id)) return collect(id);
-		return Object.keys(bucket).flatMap((stackId) => collect(stackId));
+			if (!list.length) return;
+			const cursor = undoRedo.getCursor();
+			groups.push(...mergeStackSteps("code-block", id, list, cursor));
+		});
+		return groups;
 	}
 	/**
-	* 读取指定历史栈的当前游标（已应用步骤数量）。统一入口，替代旧的
-	* `getPageCursor` / `getCodeBlockCursor` / `getDataSourceCursor`。
-	* - `id` 缺省或非法、或对应栈不存在时返回 0；
-	* - `stepType` 支持 `page` / `codeBlock` / `dataSource` / 扩展类型。
+	* 读取指定页面历史栈的当前游标（已应用步骤数量）。不传则取当前活动页。
+	* 没有对应栈时返回 0。
 	*/
-	getCursor(stepType, id) {
-		if (!this.isValidStackId(id)) return 0;
-		return this.state.steps[stepType]?.[id]?.getCursor() ?? 0;
+	getPageCursor(pageId) {
+		const targetPageId = pageId ?? this.state.pageId;
+		if (!targetPageId) return 0;
+		return this.state.pageSteps[targetPageId]?.getCursor() ?? 0;
+	}
+	/** 读取指定代码块历史栈的当前游标。 */
+	getCodeBlockCursor(codeBlockId) {
+		return this.state.codeBlockState[codeBlockId]?.getCursor() ?? 0;
+	}
+	/** 读取指定数据源历史栈的当前游标。 */
+	getDataSourceCursor(dataSourceId) {
+		return this.state.dataSourceState[dataSourceId]?.getCursor() ?? 0;
 	}
 	/**
-	* 按历史记录 uuid 在指定历史类型的栈中查找其所属 id 与索引，统一入口，替代旧的
-	* `getPageStepIndexByUuid` / `findCodeBlockStepLocationByUuid` / `findDataSourceStepLocationByUuid`。
-	*
-	* - 传入 `id`：仅在该 id 对应的单个栈中查找（如页面历史按活动页查看，传入 pageId）；
-	* - 缺省 `id`：遍历该类型下全部栈查找（代码块 / 数据源等按全部资源分桶的场景）。
-	*
-	* 找不到时返回 null。供「按 uuid 回滚」等需要把 uuid 映射回 (id, index) 的场景使用。
-	*
-	* @param stepType 历史类型
-	* @param uuid     目标历史记录的 uuid
-	* @param id       目标栈 id；缺省表示遍历该类型下全部栈
+	* 取出指定代码块历史栈的平铺步骤列表（含 applied 标记）。供 revert 等按 index 索引步骤使用。
+	*/
+	getCodeBlockStepList(codeBlockId) {
+		const undoRedo = this.state.codeBlockState[codeBlockId];
+		if (!undoRedo) return [];
+		const list = undoRedo.getElementList();
+		const cursor = undoRedo.getCursor();
+		return list.map((step, index) => ({
+			step,
+			index,
+			applied: index < cursor
+		}));
+	}
+	/**
+	* 取出指定数据源历史栈的平铺步骤列表（含 applied 标记）。供 revert 等按 index 索引步骤使用。
 	*/
-	findStepLocationByUuid(stepType, uuid, id) {
+	getDataSourceStepList(dataSourceId) {
+		const undoRedo = this.state.dataSourceState[dataSourceId];
+		if (!undoRedo) return [];
+		const list = undoRedo.getElementList();
+		const cursor = undoRedo.getCursor();
+		return list.map((step, index) => ({
+			step,
+			index,
+			applied: index < cursor
+		}));
+	}
+	/**
+	* 按历史记录 uuid 在指定页面（默认当前活动页）的栈中查找其索引。
+	* 找不到时返回 -1。供「按 uuid 回滚」等需要把 uuid 映射回 index 的场景使用。
+	*/
+	getPageStepIndexByUuid(uuid, pageId) {
+		if (!uuid) return -1;
+		return this.getPageStepList(pageId).findIndex((entry) => entry.step.uuid === uuid);
+	}
+	/**
+	* 按历史记录 uuid 在全部代码块栈中查找其所属 codeBlockId 与索引。
+	* 找不到时返回 null。
+	*/
+	findCodeBlockStepLocationByUuid(uuid) {
 		if (!uuid) return null;
-		const bucket = this.state.steps[stepType];
-		if (!bucket) return null;
-		if (this.isValidStackId(id)) {
-			const index = this.getStepList(stepType, id).findIndex((entry) => entry.step.uuid === uuid);
-			return index >= 0 ? {
-				id,
-				index
-			} : null;
-		}
-		for (const stackId of Object.keys(bucket)) {
-			const index = this.getStepList(stepType, stackId).findIndex((entry) => entry.step.uuid === uuid);
+		for (const id of Object.keys(this.state.codeBlockState)) {
+			const index = this.getCodeBlockStepList(id).findIndex((entry) => entry.step.uuid === uuid);
 			if (index >= 0) return {
-				id: stackId,
+				id,
 				index
 			};
 		}
 		return null;
 	}
-	usePlugin(options) {
-		super.usePlugin(options);
-	}
-	emit(eventName, ...args) {
-		return super.emit(eventName, ...args);
-	}
 	/**
-	* 取出指定历史类型的栈桶（`Record<id, UndoRedo>`）；不存在时按需创建空桶，
-	* 从而支持通过 {@link registerStepType} 或首次 push 动态扩展历史类型。
+	* 按历史记录 uuid 在全部数据源栈中查找其所属 dataSourceId 与索引。
+	* 找不到时返回 null。
 	*/
-	getStepBucket(stepType) {
-		if (!this.state.steps[stepType]) this.state.steps[stepType] = {};
-		return this.state.steps[stepType];
+	findDataSourceStepLocationByUuid(uuid) {
+		if (!uuid) return null;
+		for (const id of Object.keys(this.state.dataSourceState)) {
+			const index = this.getDataSourceStepList(id).findIndex((entry) => entry.step.uuid === uuid);
+			if (index >= 0) return {
+				id,
+				index
+			};
+		}
+		return null;
 	}
 	/**
-	* 清空单个历史栈并按需重建其 initial 基线（保留原基线的文案 / 来源）。
+	* 取出全部数据源的历史栈，按 dataSourceId 分桶展示。同上，每条操作独立成组。
 	*/
-	clearStack(stepType, id) {
-		const marker = this.getMarker(stepType, id);
-		this.getStepBucket(stepType)[id] = new UndoRedo();
-		if (marker) this.setMarker(stepType, id, {
-			name: marker.data?.name,
-			description: marker.historyDescription,
-			source: marker.source
+	getDataSourceHistoryGroups() {
+		const groups = [];
+		Object.entries(this.state.dataSourceState).forEach(([id, undoRedo]) => {
+			if (!undoRedo) return;
+			const list = undoRedo.getElementList();
+			if (!list.length) return;
+			const cursor = undoRedo.getCursor();
+			groups.push(...mergeStackSteps("data-source", id, list, cursor));
 		});
+		return groups;
 	}
-	/** 入栈前补全 step 的 uuid / timestamp（调用方未指定时）。 */
-	fillStepMeta(step) {
-		if (step.uuid === void 0) step.uuid = guid();
-		if (step.timestamp === void 0) step.timestamp = Date.now();
-	}
-	/** 校验「按 id 分栈」类型（codeBlock / dataSource / 扩展）的 id 是否有效。 */
-	isValidStackId(id) {
-		return id !== void 0 && id !== null && `${id}` !== "";
+	usePlugin(options) {
+		super.usePlugin(options);
 	}
-	/** 清空全部历史栈内容（保留已注册的类型键，使扩展类型在 reset 后仍可用）。 */
-	clearAllSteps() {
-		Object.keys(this.state.steps).forEach((stepType) => {
-			this.state.steps[stepType] = {};
-		});
+	/**
+	* 取出指定页面的栈；不传 pageId 时按当前活动页取。
+	*
+	* 跨页 push 时如果目标页的栈尚不存在（用户从未进入过该页），会按需创建一条空栈，
+	* 这样切到目标页时 Ctrl+Z 也能撤回该步骤。
+	*/
+	getUndoRedo(pageId) {
+		const targetPageId = pageId ?? this.state.pageId;
+		if (!targetPageId) return null;
+		if (!this.state.pageSteps[targetPageId]) this.state.pageSteps[targetPageId] = new UndoRedo();
+		return this.state.pageSteps[targetPageId];
 	}
 	/**
 	* 把基础 dbName 与当前 DSL（root app）的 id 拼成最终库名，实现不同应用历史隔离。
@@ -413,6 +541,11 @@ var History = class extends BaseService {
 		const resolvedAppId = appId ?? editor_default.get("root")?.id;
 		return resolvedAppId ? `${dbName}-${resolvedAppId}` : dbName;
 	}
+	setCanUndoRedo() {
+		const undoRedo = this.getUndoRedo();
+		this.state.canRedo = undoRedo?.canRedo() || false;
+		this.state.canUndo = undoRedo ? undoRedo.getCursor() > undoFloor(undoRedo) : false;
+	}
 };
 var history_default = new History();
 //#endregion