@likec4/diagram 1.55.0 → 1.56.0

package/dist/editor/applyChangesToManualLayout.js

@@ -1,183 +1,164 @@
-import { invariant, nonNullable } from '@likec4/core';
-import { BBox, convertPoint, vector } from '@likec4/core/geometry';
-import { setAutoFreeze, produce, castDraft } from 'immer';
-import { map, isNullish } from 'remeda';
-
+import "../_virtual/_rolldown/runtime.js";
+import { isNullish, map } from "remeda";
+import { invariant, nonNullable } from "@likec4/core";
+import { BBox as BBox$1, convertPoint, vector } from "@likec4/core/geometry";
+import "@likec4/core/types";
+import { castDraft, produce, setAutoFreeze } from "immer";
+//#region src/editor/applyChangesToManualLayout.ts
+/**
+* Applies changes to a manual layout.
+*
+* @param manual - The manual layout.
+* @param latest - The latest layout.
+*/
 function applyChangesToManualLayout(manualView, latestView) {
-  try {
-    setAutoFreeze(false);
-    return _applyChangesToManualLayout(manualView, latestView);
-  } finally {
-    setAutoFreeze(true);
-  }
+	try {
+		setAutoFreeze(false);
+		return _applyChangesToManualLayout(manualView, latestView);
+	} finally {
+		setAutoFreeze(true);
+	}
 }
-const isRootNode = (node) => isNullish(node.parent);
+var isRootNode = (node) => isNullish(node.parent);
 function _applyChangesToManualLayout(manualView, latestView) {
-  invariant(manualView.id === latestView.id, "View IDs do not match");
-  invariant(manualView._type === latestView._type, "View types do not match");
-  invariant(manualView._layout === "manual" && latestView._layout === "auto", "Views must be manual and auto");
-  const compounds = /* @__PURE__ */ new Set();
-  const newnodes = /* @__PURE__ */ new Set();
-  const isNotCompound = (node) => !compounds.has(typeof node === "string" ? node : node.id);
-  const isBetweenNewLeafNodes = (edge) => newnodes.has(edge.source) && newnodes.has(edge.target) && isNotCompound(edge.source) && isNotCompound(edge.target);
-  const nodesMap = new Map(
-    latestView.nodes.map((latest) => {
-      if (latest.children && latest.children.length > 0) {
-        compounds.add(latest.id);
-      }
-      const manual = manualView.nodes.find((n) => n.id === latest.id);
-      if (manual) {
-        return [latest.id, applyFromManualNode({ latest, manual })];
-      }
-      newnodes.add(latest.id);
-      return [latest.id, removeDrift(latest)];
-    })
-  );
-  const newNodesOnly = newnodes.size === nodesMap.size;
-  if (newNodesOnly) {
-    return produce(latestView, (draft) => {
-      draft._layout = "manual";
-      draft.nodes = castDraft([...nodesMap.values()]);
-      draft.edges = castDraft(latestView.edges.map(removeDrift));
-      delete draft.drifts;
-    });
-  }
-  if (compounds.size > 0) {
-    expandCompoundNodes(nodesMap);
-  }
-  const nodes = [...nodesMap.values()];
-  const edges = latestView.edges.map((latest) => {
-    const dir = latest.dir ?? "forward";
-    const hasSameEndpoints = (candidate) => candidate.source === latest.source && candidate.target === latest.target && (candidate.dir === dir || !candidate.dir && !latest.dir);
-    let manual = manualView.edges.find((e) => e.id === latest.id && hasSameEndpoints(e));
-    if (!manual) {
-      manual = manualView.edges.find((e) => hasSameEndpoints(e));
-    }
-    if (manual) {
-      return applyFromManualEdge({
-        latest,
-        manual
-      });
-    }
-    if (isBetweenNewLeafNodes(latest)) {
-      return removeDrift(latest);
-    }
-    const sourceNode = nodesMap.get(latest.source);
-    const targetNode = nodesMap.get(latest.target);
-    return makeAsStraightLine(latest, sourceNode, targetNode);
-  });
-  const bounds = BBox.merge(...nodes.filter(isRootNode));
-  return produce(latestView, (draft) => {
-    draft._layout = "manual";
-    draft.nodes = castDraft(nodes);
-    draft.edges = castDraft(edges);
-    draft.bounds = bounds;
-    delete draft.drifts;
-  });
+	invariant(manualView.id === latestView.id, "View IDs do not match");
+	invariant(manualView._type === latestView._type, "View types do not match");
+	invariant(manualView._layout === "manual" && latestView._layout === "auto", "Views must be manual and auto");
+	const compounds = /* @__PURE__ */ new Set();
+	const newnodes = /* @__PURE__ */ new Set();
+	const isNotCompound = (node) => !compounds.has(typeof node === "string" ? node : node.id);
+	const isBetweenNewLeafNodes = (edge) => newnodes.has(edge.source) && newnodes.has(edge.target) && isNotCompound(edge.source) && isNotCompound(edge.target);
+	const nodesMap = new Map(latestView.nodes.map((latest) => {
+		if (latest.children && latest.children.length > 0) compounds.add(latest.id);
+		const manual = manualView.nodes.find((n) => n.id === latest.id);
+		if (manual) return [latest.id, applyFromManualNode({
+			latest,
+			manual
+		})];
+		newnodes.add(latest.id);
+		return [latest.id, removeDrift(latest)];
+	}));
+	if (newnodes.size === nodesMap.size) return produce(latestView, (draft) => {
+		draft._layout = "manual";
+		draft.nodes = castDraft([...nodesMap.values()]);
+		draft.edges = castDraft(latestView.edges.map(removeDrift));
+		delete draft.drifts;
+	});
+	if (compounds.size > 0) expandCompoundNodes(nodesMap);
+	const nodes = [...nodesMap.values()];
+	const edges = latestView.edges.map((latest) => {
+		const dir = latest.dir ?? "forward";
+		const hasSameEndpoints = (candidate) => candidate.source === latest.source && candidate.target === latest.target && (candidate.dir === dir || !candidate.dir && !latest.dir);
+		let manual = manualView.edges.find((e) => e.id === latest.id && hasSameEndpoints(e));
+		if (!manual) manual = manualView.edges.find((e) => hasSameEndpoints(e));
+		if (manual) return applyFromManualEdge({
+			latest,
+			manual
+		});
+		if (isBetweenNewLeafNodes(latest)) return removeDrift(latest);
+		return makeAsStraightLine(latest, nodesMap.get(latest.source), nodesMap.get(latest.target));
+	});
+	const bounds = BBox$1.merge(...nodes.filter(isRootNode));
+	return produce(latestView, (draft) => {
+		draft._layout = "manual";
+		draft.nodes = castDraft(nodes);
+		draft.edges = castDraft(edges);
+		draft.bounds = bounds;
+		delete draft.drifts;
+	});
 }
-const COMPOUND_PADDING = {
-  Left: 42,
-  Right: 42,
-  Top: 60,
-  Bottom: 42
+/**
+* Padding constants for compound nodes (same as in useLayoutConstraints)
+*/
+var COMPOUND_PADDING = {
+	Left: 42,
+	Right: 42,
+	Top: 60,
+	Bottom: 42
 };
+/**
+* Expands compound nodes to wrap all their children with proper padding.
+* Processes nodes recursively from leaves up to ensure correct bounding boxes.
+*/
 function expandCompoundNodes(nodes) {
-  function expand(nodeId) {
-    const node = nonNullable(nodes.get(nodeId), `Node ${nodeId} not found`);
-    if (node.children.length === 0) {
-      return node;
-    }
-    const childBBoxes = [];
-    for (const childId of node.children) {
-      childBBoxes.push(
-        expand(childId)
-      );
-    }
-    const childrenBBox = BBox.merge(...childBBoxes);
-    node.x = childrenBBox.x - COMPOUND_PADDING.Left;
-    node.y = childrenBBox.y - COMPOUND_PADDING.Top;
-    node.width = childrenBBox.width + COMPOUND_PADDING.Left + COMPOUND_PADDING.Right;
-    node.height = childrenBBox.height + COMPOUND_PADDING.Top + COMPOUND_PADDING.Bottom;
-    return node;
-  }
-  for (const node of nodes.values()) {
-    if (!isRootNode(node) || node.children.length === 0) {
-      continue;
-    }
-    expand(node.id);
-  }
+	function expand(nodeId) {
+		const node = nonNullable(nodes.get(nodeId), `Node ${nodeId} not found`);
+		if (node.children.length === 0) return node;
+		const childBBoxes = [];
+		for (const childId of node.children) childBBoxes.push(expand(childId));
+		const childrenBBox = BBox$1.merge(...childBBoxes);
+		node.x = childrenBBox.x - COMPOUND_PADDING.Left;
+		node.y = childrenBBox.y - COMPOUND_PADDING.Top;
+		node.width = childrenBBox.width + COMPOUND_PADDING.Left + COMPOUND_PADDING.Right;
+		node.height = childrenBBox.height + COMPOUND_PADDING.Top + COMPOUND_PADDING.Bottom;
+		return node;
+	}
+	for (const node of nodes.values()) {
+		if (!isRootNode(node) || node.children.length === 0) continue;
+		expand(node.id);
+	}
 }
 function applyFromManualNode({ latest, manual }) {
-  invariant(manual.id === latest.id, "Node IDs do not match");
-  return produce(latest, (next) => {
-    next.x = manual.x;
-    next.y = manual.y;
-    next.drifts = null;
-  });
+	invariant(manual.id === latest.id, "Node IDs do not match");
+	return produce(latest, (next) => {
+		next.x = manual.x;
+		next.y = manual.y;
+		next.drifts = null;
+	});
 }
 function applyFromManualEdge(edges) {
-  const { manual, latest } = edges;
-  return produce(latest, (draft) => {
-    if (manual.controlPoints) {
-      draft.controlPoints = manual.controlPoints;
-    } else {
-      delete draft.controlPoints;
-    }
-    draft.points = castDraft(manual.points);
-    if (manual.labelBBox) {
-      draft.labelBBox = latest.labelBBox ?? manual.labelBBox;
-      draft.labelBBox.x = manual.labelBBox.x;
-      draft.labelBBox.y = manual.labelBBox.y;
-    }
-    draft.drifts = null;
-  });
+	const { manual, latest } = edges;
+	return produce(latest, (draft) => {
+		if (manual.controlPoints) draft.controlPoints = manual.controlPoints;
+		else delete draft.controlPoints;
+		draft.points = castDraft(manual.points);
+		if (manual.labelBBox) {
+			draft.labelBBox = latest.labelBBox ?? manual.labelBBox;
+			draft.labelBBox.x = manual.labelBBox.x;
+			draft.labelBBox.y = manual.labelBBox.y;
+		}
+		draft.drifts = null;
+	});
 }
 function removeDrift(object) {
-  if ("drifts" in object && object.drifts !== null) {
-    const result = { ...object };
-    result.drifts = null;
-    return result;
-  }
-  return object;
+	if ("drifts" in object && object.drifts !== null) {
+		const result = { ...object };
+		result.drifts = null;
+		return result;
+	}
+	return object;
 }
 function makeAsStraightLine(edge, sourceNode, targetNode) {
-  const controlPoints = edgeControlPoints(sourceNode, targetNode);
-  const labelPos = controlPoints[0];
-  return produce(edge, (draft) => {
-    draft.points = castDraft(map(controlPoints, convertPoint));
-    draft.controlPoints = controlPoints;
-    if (edge.labelBBox) {
-      draft.labelBBox.x = labelPos.x;
-      draft.labelBBox.y = labelPos.y;
-    }
-    delete draft.drifts;
-  });
+	const controlPoints = edgeControlPoints(sourceNode, targetNode);
+	const labelPos = controlPoints[0];
+	return produce(edge, (draft) => {
+		draft.points = castDraft(map(controlPoints, convertPoint));
+		draft.controlPoints = controlPoints;
+		if (edge.labelBBox) {
+			draft.labelBBox.x = labelPos.x;
+			draft.labelBBox.y = labelPos.y;
+		}
+		delete draft.drifts;
+	});
 }
 function getBorderPointOnVector(node, nodeCenter, v) {
-  const xScale = node.width / 2 / v.x;
-  const yScale = node.height / 2 / v.y;
-  const scale = Math.min(Math.abs(xScale), Math.abs(yScale));
-  return vector(v).multiply(scale).add(nodeCenter);
+	const xScale = node.width / 2 / v.x;
+	const yScale = node.height / 2 / v.y;
+	const scale = Math.min(Math.abs(xScale), Math.abs(yScale));
+	return vector(v).multiply(scale).add(nodeCenter);
 }
 function edgeControlPoints(source, target) {
-  const sourceCenter = vector(BBox.center(source));
-  const targetCenter = vector(BBox.center(target));
-  if (source === target) {
-    const loopSize = 80;
-    const centerOfTopBoundary = vector(0, source.height || 0).multiply(-0.5).add(sourceCenter);
-    return [
-      centerOfTopBoundary.add(vector(-loopSize / 2.5, -loopSize)).trunc().toObject(),
-      centerOfTopBoundary.add(vector(loopSize / 2.5, -loopSize)).trunc().toObject()
-    ];
-  }
-  const sourceToTargetVector = targetCenter.subtract(sourceCenter);
-  const sourceBorderPoint = getBorderPointOnVector(source, sourceCenter, sourceToTargetVector);
-  const targetBorderPoint = getBorderPointOnVector(target, targetCenter, sourceToTargetVector.multiply(-1));
-  const sourceToTarget = targetBorderPoint.subtract(sourceBorderPoint);
-  return [
-    sourceBorderPoint.add(sourceToTarget.multiply(0.4)).trunc().toObject(),
-    sourceBorderPoint.add(sourceToTarget.multiply(0.6)).trunc().toObject()
-  ];
+	const sourceCenter = vector(BBox$1.center(source));
+	const targetCenter = vector(BBox$1.center(target));
+	if (source === target) {
+		const loopSize = 80;
+		const centerOfTopBoundary = vector(0, source.height || 0).multiply(-.5).add(sourceCenter);
+		return [centerOfTopBoundary.add(vector(-loopSize / 2.5, -loopSize)).trunc().toObject(), centerOfTopBoundary.add(vector(loopSize / 2.5, -loopSize)).trunc().toObject()];
+	}
+	const sourceToTargetVector = targetCenter.subtract(sourceCenter);
+	const sourceBorderPoint = getBorderPointOnVector(source, sourceCenter, sourceToTargetVector);
+	const sourceToTarget = getBorderPointOnVector(target, targetCenter, sourceToTargetVector.multiply(-1)).subtract(sourceBorderPoint);
+	return [sourceBorderPoint.add(sourceToTarget.multiply(.4)).trunc().toObject(), sourceBorderPoint.add(sourceToTarget.multiply(.6)).trunc().toObject()];
 }
-
+//#endregion
 export { applyChangesToManualLayout };

package/dist/editor/editorActor.actions.js

@@ -1,149 +1,133 @@
-import { last, filter, isNot, omit } from 'remeda';
-import { createViewChange } from '../likec4diagram/state/createViewChange.js';
-import { machine } from './editorActor.setup.js';
-
-const diagramActorRef = (system) => {
-  return system.get("diagram");
+import "../_virtual/_rolldown/runtime.js";
+import { createViewChange } from "../likec4diagram/state/createViewChange.js";
+import { machine } from "./editorActor.setup.js";
+import { filter, isNot, last, omit } from "remeda";
+//#region src/editor/editorActor.actions.ts
+/**
+* Actually this is DiagramActorRef
+* But we can't use it here due to circular type inference
+*/
+var diagramActorRef = (system) => {
+	return system.get("diagram");
 };
-const getDiagramContext = function(system) {
-  return system.get("diagram").getSnapshot().context;
+/**
+* Actually this is DiagramActorRef
+* But we can't use it here due to circular type inference
+*/
+var getDiagramContext = function(system) {
+	return system.get("diagram").getSnapshot().context;
 };
-const raiseSync = () => machine.raise({ type: "sync" }, { delay: 200, id: "sync" });
-const cancelSync = () => machine.cancel("sync");
-const reschedule = (delay = 350) => machine.raise(({ event }) => event, { delay });
-const isLayoutChange = (change) => change.op === "reset-manual-layout" || change.op === "save-view-snapshot";
-const withoutSnapshotChanges = filter(isNot(isLayoutChange));
-const saveStateBeforeEdit = () => machine.assign(({ system }) => {
-  const parentContext = getDiagramContext(system);
-  return {
-    beforeEditing: {
-      xynodes: parentContext.xynodes.map(({ measured, data, ...n }) => ({
-        ...omit(n, ["selected", "dragging", "resizing"]),
-        data: omit(data, ["dimmed", "hovered"]),
-        measured,
-        initialWidth: measured?.width ?? n.width ?? n.initialWidth,
-        initialHeight: measured?.height ?? n.height ?? n.initialHeight
-      })),
-      xyedges: parentContext.xyedges.map(({ data, ...e }) => ({
-        ...omit(e, ["selected"]),
-        data: omit(data, ["active", "dimmed", "hovered"])
-      })),
-      change: createViewChange(parentContext),
-      view: parentContext.view,
-      synched: false
-    }
-  };
+var raiseSync = () => machine.raise({ type: "sync" }, {
+	delay: 200,
+	id: "sync"
 });
-const startEditing = () => machine.enqueueActions(({ enqueue, event }) => {
-  enqueue(saveStateBeforeEdit());
-  if (event.type === "edit.start") {
-    enqueue.assign({
-      editing: event.subject
-    });
-  }
+var cancelSync = () => machine.cancel("sync");
+var reschedule = (delay = 350) => machine.raise(({ event }) => event, { delay });
+var isLayoutChange = (change) => change.op === "reset-manual-layout" || change.op === "save-view-snapshot";
+var withoutSnapshotChanges = filter(isNot(isLayoutChange));
+var saveStateBeforeEdit = () => machine.assign(({ system }) => {
+	const parentContext = getDiagramContext(system);
+	return { beforeEditing: {
+		xynodes: parentContext.xynodes.map(({ measured, data, ...n }) => ({
+			...omit(n, [
+				"selected",
+				"dragging",
+				"resizing"
+			]),
+			data: omit(data, ["dimmed", "hovered"]),
+			measured,
+			initialWidth: measured?.width ?? n.width ?? n.initialWidth,
+			initialHeight: measured?.height ?? n.height ?? n.initialHeight
+		})),
+		xyedges: parentContext.xyedges.map(({ data, ...e }) => ({
+			...omit(e, ["selected"]),
+			data: omit(data, [
+				"active",
+				"dimmed",
+				"hovered"
+			])
+		})),
+		change: createViewChange(parentContext),
+		view: parentContext.view,
+		synched: false
+	} };
 });
-const stopHotkey = () => machine.stopChild("hotkey");
-const ensureHotKey = () => machine.enqueueActions(({ check, enqueue, self }) => {
-  const hasUndo = check("can undo");
-  const hotkey = self.getSnapshot().children["hotkey"];
-  if (!hasUndo && hotkey) {
-    enqueue.stopChild(hotkey);
-    return;
-  }
-  if (hasUndo && !hotkey) {
-    enqueue.spawnChild("hotkey", {
-      id: "hotkey"
-    });
-  }
+var startEditing = () => machine.enqueueActions(({ enqueue, event }) => {
+	enqueue(saveStateBeforeEdit());
+	if (event.type === "edit.start") enqueue.assign({ editing: event.subject });
 });
-const pushHistory = () => machine.assign(({ context }) => {
-  const snapshot = context.beforeEditing;
-  if (!snapshot) {
-    return {
-      editing: null
-    };
-  }
-  const history = [
-    ...context.history,
-    snapshot
-  ];
-  if (history.length > 50) {
-    history.shift();
-  }
-  return {
-    beforeEditing: null,
-    editing: null,
-    history
-  };
+var stopHotkey = () => machine.stopChild("hotkey");
+var ensureHotKey = () => machine.enqueueActions(({ check, enqueue, self }) => {
+	const hasUndo = check("can undo");
+	const hotkey = self.getSnapshot().children["hotkey"];
+	if (!hasUndo && hotkey) {
+		enqueue.stopChild(hotkey);
+		return;
+	}
+	if (hasUndo && !hotkey) enqueue.spawnChild("hotkey", { id: "hotkey" });
 });
-const stopEditing = () => machine.enqueueActions(({ event, enqueue }) => {
-  if (event.type === "edit.finish" && event.wasChanged) {
-    enqueue(pushHistory());
-    enqueue(raiseSync());
-    return;
-  }
-  enqueue.assign({
-    beforeEditing: null,
-    editing: null
-  });
+var pushHistory = () => machine.assign(({ context }) => {
+	const snapshot = context.beforeEditing;
+	if (!snapshot) return { editing: null };
+	const history = [...context.history, snapshot];
+	if (history.length > 50) history.shift();
+	return {
+		beforeEditing: null,
+		editing: null,
+		history
+	};
 });
-const markHistoryAsSynched = () => machine.assign(({ context }) => {
-  return {
-    beforeEditing: context.beforeEditing && context.beforeEditing.synched === false ? {
-      ...context.beforeEditing,
-      synched: true
-    } : context.beforeEditing,
-    history: context.history.map((i) => ({
-      ...i,
-      synched: true
-    }))
-  };
+var stopEditing = () => machine.enqueueActions(({ event, enqueue }) => {
+	if (event.type === "edit.finish" && event.wasChanged) {
+		enqueue(pushHistory());
+		enqueue(raiseSync());
+		return;
+	}
+	enqueue.assign({
+		beforeEditing: null,
+		editing: null
+	});
 });
-const popHistory = () => machine.assign(({ context }) => {
-  if (context.history.length <= 1) {
-    return {
-      history: []
-    };
-  }
-  return {
-    history: context.history.slice(0, context.history.length - 1)
-  };
+var markHistoryAsSynched = () => machine.assign(({ context }) => {
+	return {
+		beforeEditing: context.beforeEditing && context.beforeEditing.synched === false ? {
+			...context.beforeEditing,
+			synched: true
+		} : context.beforeEditing,
+		history: context.history.map((i) => ({
+			...i,
+			synched: true
+		}))
+	};
 });
-const undo = () => machine.enqueueActions(({ context, enqueue, system }) => {
-  const lastHistoryItem = last(context.history);
-  if (!lastHistoryItem) {
-    return;
-  }
-  enqueue(cancelSync());
-  enqueue(popHistory());
-  enqueue(ensureHotKey());
-  const diagramActor = diagramActorRef(system);
-  enqueue.sendTo(diagramActor, {
-    type: "update.view",
-    view: lastHistoryItem.view,
-    xyedges: lastHistoryItem.xyedges,
-    xynodes: lastHistoryItem.xynodes,
-    source: "editor"
-  });
-  enqueue.assign({
-    pendingChanges: []
-  });
-  if (lastHistoryItem.synched) {
-    enqueue.raise({ type: "change", change: lastHistoryItem.change }, { delay: 50 });
-  } else {
-    enqueue(raiseSync());
-  }
+var popHistory = () => machine.assign(({ context }) => {
+	if (context.history.length <= 1) return { history: [] };
+	return { history: context.history.slice(0, context.history.length - 1) };
 });
-const addSnapshotToPendingChanges = () => machine.assign(({ context, system }) => {
-  const parentContext = getDiagramContext(system);
-  const change = createViewChange(parentContext);
-  return {
-    pendingChanges: [
-      // Remove all save-view-snapshot and reset-manual-layout changes
-      ...withoutSnapshotChanges(context.pendingChanges),
-      change
-    ]
-  };
+var undo = () => machine.enqueueActions(({ context, enqueue, system }) => {
+	const lastHistoryItem = last(context.history);
+	if (!lastHistoryItem) return;
+	enqueue(cancelSync());
+	enqueue(popHistory());
+	enqueue(ensureHotKey());
+	const diagramActor = diagramActorRef(system);
+	enqueue.sendTo(diagramActor, {
+		type: "update.view",
+		view: lastHistoryItem.view,
+		xyedges: lastHistoryItem.xyedges,
+		xynodes: lastHistoryItem.xynodes,
+		source: "editor"
+	});
+	enqueue.assign({ pendingChanges: [] });
+	if (lastHistoryItem.synched) enqueue.raise({
+		type: "change",
+		change: lastHistoryItem.change
+	}, { delay: 50 });
+	else enqueue(raiseSync());
 });
-
-export { addSnapshotToPendingChanges, cancelSync, ensureHotKey, isLayoutChange, markHistoryAsSynched, popHistory, pushHistory, raiseSync, reschedule, saveStateBeforeEdit, startEditing, stopEditing, stopHotkey, undo, withoutSnapshotChanges };
+var addSnapshotToPendingChanges = () => machine.assign(({ context, system }) => {
+	const change = createViewChange(getDiagramContext(system));
+	return { pendingChanges: [...withoutSnapshotChanges(context.pendingChanges), change] };
+});
+//#endregion
+export { addSnapshotToPendingChanges, cancelSync, ensureHotKey, isLayoutChange, markHistoryAsSynched, pushHistory, reschedule, saveStateBeforeEdit, startEditing, stopEditing, stopHotkey, undo, withoutSnapshotChanges };