@arcmantle/chronicle 0.0.4

package/src/undo-redo.ts

@@ -0,0 +1,249 @@
+import { ensureHistory, historyGet, nextGroupId } from './history.ts';
+import { deleteAtPath, ensureParents, getParentAndKey, isArrayIndexKey, setAtPath } from './path.ts';
+import type { ChangeRecord } from './types.ts';
+
+
+// Redo cache per root
+const redoCache: WeakMap<object, ChangeRecord[]> = new WeakMap();
+
+// Write suspension counter per root (used to avoid recording/dispatch during programmatic changes)
+const suspendWriteCounter: WeakMap<object, number> = new WeakMap();
+
+export const isSuspended = (root: object): boolean => (suspendWriteCounter.get(root) ?? 0) > 0;
+export const suspendWrites = (root: object): void => { suspendWriteCounter.set(root, (suspendWriteCounter.get(root) ?? 0) + 1); };
+export const resumeWrites = (root: object): void => {
+	const n = (suspendWriteCounter.get(root) ?? 0) - 1;
+	if (n <= 0)
+		suspendWriteCounter.delete(root);
+	else
+		suspendWriteCounter.set(root, n);
+};
+
+const getRedo = (root: object): ChangeRecord[] => {
+	let r = redoCache.get(root);
+	if (!r) {
+		r = [];
+		redoCache.set(root, r);
+	}
+
+	return r;
+};
+
+export const clearRedoCache = (root: object): void => { redoCache.delete(root); };
+
+export const canUndo = (root: object): boolean => (historyGet(root) ?? []).length > 0;
+export const canRedo = (root: object): boolean => (redoCache.get(root) ?? []).length > 0;
+
+// Helper to get object at path
+const getAtPath = (rootNode: any, p: string[]) => {
+	let node = rootNode;
+	for (const seg of p) {
+		if (node == null)
+			return undefined;
+
+		node = node[seg as any];
+	}
+
+	return node;
+};
+
+// Apply a change record forward (redo side) without emitting notifications
+const applyForward = (root: any, rec: ChangeRecord) => {
+	if (rec.collection === 'map') {
+		const m: Map<any, any> | undefined = getAtPath(root, rec.path);
+		if (m && m instanceof Map) {
+			if (rec.type === 'set')
+				m.set(rec.key, rec.newValue);
+			else if (rec.type === 'delete')
+				m.delete(rec.key);
+		}
+
+		return;
+	}
+
+	if (rec.collection === 'set') {
+		const s: Set<any> | undefined = getAtPath(root, rec.path);
+		if (s && s instanceof Set) {
+			if (rec.type === 'set')
+				s.add(rec.key);
+			else if (rec.type === 'delete')
+				s.delete(rec.key);
+		}
+
+		return;
+	}
+
+	if (rec.type === 'set') {
+		setAtPath(root, rec.path, rec.newValue);
+	}
+	else if (rec.type === 'delete') {
+		const parentAndKey = getParentAndKey(root, rec.path);
+		if (parentAndKey) {
+			const [ parent, key ] = parentAndKey;
+			if (Array.isArray(parent) && isArrayIndexKey(String(key)))
+				(parent as any).splice(Number(key), 1);
+			else
+				Reflect.deleteProperty(parent, key as any);
+		}
+	}
+};
+
+export const undo = (root: object, steps: number = Number.POSITIVE_INFINITY): void => {
+	const history = historyGet(root);
+	if (!history || history.length === 0)
+		return;
+
+	suspendWrites(root);
+	try {
+		let remaining = steps;
+		const undone: ChangeRecord[] = [];
+		while (history.length > 0 && remaining > 0) {
+			const rec = history.pop()!;
+
+			if (rec.collection === 'map') {
+				const m: Map<any, any> | undefined = getAtPath(root as any, rec.path);
+				if (m && m instanceof Map) {
+					if (rec.type === 'set') {
+						if (rec.existedBefore === false)
+							m.delete(rec.key);
+						else
+							m.set(rec.key, rec.oldValue);
+					}
+					else if (rec.type === 'delete') {
+						m.set(rec.key, rec.oldValue);
+					}
+				}
+			}
+			else if (rec.collection === 'set') {
+				const s: Set<any> | undefined = getAtPath(root as any, rec.path);
+				if (s && s instanceof Set) {
+					if (rec.type === 'set')
+						s.delete(rec.key);
+					else if (rec.type === 'delete')
+						s.add(rec.key);
+				}
+			}
+			else {
+				// Ensure parent containers exist for plain object/array paths
+				ensureParents(root as any, rec.path);
+				if (rec.type === 'set') {
+					if (rec.existedBefore === false)
+						deleteAtPath(root as any, rec.path);
+					else
+						setAtPath(root as any, rec.path, rec.oldValue);
+				}
+				else if (rec.type === 'delete') {
+					// If the path points into an array at a numeric index, use splice to re-insert
+					const parentAndKey = getParentAndKey(root as any, rec.path);
+					if (parentAndKey) {
+						const [ parent, key ] = parentAndKey;
+						if (Array.isArray(parent) && isArrayIndexKey(String(key)))
+							(parent as any).splice(Number(key), 0, rec.oldValue);
+						else
+							setAtPath(root as any, rec.path, rec.oldValue);
+					}
+				}
+			}
+
+			remaining--;
+			undone.push(rec);
+		}
+		if (undone.length > 0)
+			getRedo(root).push(...undone);
+	}
+	finally {
+		resumeWrites(root);
+	}
+};
+
+export const undoSince = (root: object, historyLengthBefore: number): void => {
+	const history = historyGet(root);
+	if (!history)
+		return;
+
+	const steps = Math.max(0, history.length - Math.max(0, historyLengthBefore | 0));
+	if (steps > 0)
+		undo(root, steps);
+};
+
+export const undoGroups = (root: object, groups: number = 1): void => {
+	const history = historyGet(root);
+	if (!history || history.length === 0)
+		return;
+
+	const toUndo = Math.max(0, groups | 0);
+	if (toUndo === 0)
+		return;
+
+	let steps = 0;
+	const seen: Set<string> = new Set();
+	for (let i = history.length - 1; i >= 0; i--) {
+		const gid = (history[i]!.groupId ?? `__g#${ i }`);
+		if (seen.size === toUndo && !seen.has(gid))
+			break;
+
+		seen.add(gid);
+		steps++;
+	}
+
+	if (steps > 0)
+		undo(root, steps);
+};
+
+export const redo = (root: object, steps: number = Number.POSITIVE_INFINITY): void => {
+	const redo = redoCache.get(root);
+	if (!redo || redo.length === 0)
+		return;
+
+	suspendWrites(root);
+	try {
+		let remaining = steps;
+		const gid = nextGroupId(root);
+		while (redo.length > 0 && remaining > 0) {
+			const rec = redo.pop()!; // get earliest undone first due to push order
+			applyForward(root as any, rec);
+			const history = ensureHistory(root);
+			const copy: ChangeRecord = { ...rec, groupId: gid, timestamp: Date.now() };
+			history.push(copy);
+			remaining--;
+		}
+	}
+	finally {
+		resumeWrites(root);
+	}
+};
+
+export const redoGroups = (root: object, groups: number = 1): void => {
+	const redo = redoCache.get(root);
+	if (!redo || redo.length === 0)
+		return;
+
+	const toRedo = Math.max(0, groups | 0);
+	if (toRedo === 0)
+		return;
+
+	suspendWrites(root);
+	try {
+		let doneGroups = 0;
+		while (redo.length > 0 && doneGroups < toRedo) {
+			const lastGid = redo[redo.length - 1]!.groupId ?? `__g#${ redo.length - 1 }`;
+			const gidNew = nextGroupId(root);
+			// pop until group boundary changes
+			while (redo.length > 0) {
+				const rec = redo[redo.length - 1]!;
+				const recG = rec.groupId ?? `__g#${ redo.length - 1 }`;
+				if (recG !== lastGid)
+					break;
+
+				redo.pop();
+				applyForward(root as any, rec);
+				const history = ensureHistory(root);
+				history.push({ ...rec, groupId: gidNew, timestamp: Date.now() });
+			}
+			doneGroups++;
+		}
+	}
+	finally {
+		resumeWrites(root);
+	}
+};