@heyramzi/ui 2.11.1 → 2.11.2

package/dist/canvas/editor/history-core.js

@@ -1,221 +1,193 @@
 import { sortParentsFirst } from "../headless/canvas-cleanup.js";
+// Fields that churn without changing the document. Stripped, so selecting isn't
+// an undo step and undo doesn't restore a stale selection.
 const VOLATILE_NODE_FIELDS = new Set([
-    "selected",
-    "dragging",
-    "measured",
-    "resizing"
-]);
-const VOLATILE_EDGE_FIELDS = new Set([
-    "selected"
+	"selected",
+	"dragging",
+	"measured",
+	"resizing"
 ]);
+const VOLATILE_EDGE_FIELDS = new Set(["selected"]);
 function stripVolatile(record, volatile) {
-    const out = {};
-    for (const [key, value] of Object.entries(record)){
-        if (volatile.has(key) || value === undefined) continue;
-        out[key] = value;
-    }
-    return out;
+	const out = {};
+	for (const [key, value] of Object.entries(record)) {
+		if (volatile.has(key) || value === undefined) continue;
+		out[key] = value;
+	}
+	return out;
 }
 function clone(value) {
-    return JSON.parse(JSON.stringify(value));
+	return JSON.parse(JSON.stringify(value));
 }
 function signature(record, volatile) {
-    return JSON.stringify(stripVolatile(record, volatile));
+	return JSON.stringify(stripVolatile(record, volatile));
 }
+/** True when two versions of a card differ only in fields that churn without changing the document. */
 export function isSameNode(a, b) {
-    return a === b || signature(a, VOLATILE_NODE_FIELDS) === signature(b, VOLATILE_NODE_FIELDS);
+	return a === b || signature(a, VOLATILE_NODE_FIELDS) === signature(b, VOLATILE_NODE_FIELDS);
 }
 export function isSameEdge(a, b) {
-    return a === b || signature(a, VOLATILE_EDGE_FIELDS) === signature(b, VOLATILE_EDGE_FIELDS);
+	return a === b || signature(a, VOLATILE_EDGE_FIELDS) === signature(b, VOLATILE_EDGE_FIELDS);
 }
 function diffOrder(base, current) {
-    const before = base.map((item)=>item.id);
-    const after = current.map((item)=>item.id);
-    const same = before.length === after.length && before.every((id, i)=>id === after[i]);
-    return same ? undefined : {
-        before,
-        after
-    };
+	const before = base.map((item) => item.id);
+	const after = current.map((item) => item.id);
+	const same = before.length === after.length && before.every((id, i) => id === after[i]);
+	return same ? undefined : {
+		before,
+		after
+	};
 }
 function diffCollection(base, current, volatile) {
-    const baseById = new Map(base.map((item)=>[
-            item.id,
-            item
-        ]));
-    const currentById = new Map(current.map((item)=>[
-            item.id,
-            item
-        ]));
-    const before = [];
-    const after = [];
-    for (const item of base){
-        const counterpart = currentById.get(item.id);
-        if (!counterpart) {
-            before.push(clone(stripVolatile(item, volatile)));
-            continue;
-        }
-        if (item !== counterpart && signature(item, volatile) !== signature(counterpart, volatile)) {
-            before.push(clone(stripVolatile(item, volatile)));
-            after.push(clone(stripVolatile(counterpart, volatile)));
-        }
-    }
-    for (const item of current){
-        if (!baseById.has(item.id)) {
-            after.push(clone(stripVolatile(item, volatile)));
-        }
-    }
-    return {
-        before,
-        after
-    };
-}
+	const baseById = new Map(base.map((item) => [item.id, item]));
+	const currentById = new Map(current.map((item) => [item.id, item]));
+	const before = [];
+	const after = [];
+	for (const item of base) {
+		const counterpart = currentById.get(item.id);
+		if (!counterpart) {
+			before.push(clone(stripVolatile(item, volatile)));
+			continue;
+		}
+		// The same object is the same card: an untouched card costs nothing, however big the board.
+		if (item !== counterpart && signature(item, volatile) !== signature(counterpart, volatile)) {
+			before.push(clone(stripVolatile(item, volatile)));
+			after.push(clone(stripVolatile(counterpart, volatile)));
+		}
+	}
+	for (const item of current) {
+		if (!baseById.has(item.id)) {
+			after.push(clone(stripVolatile(item, volatile)));
+		}
+	}
+	return {
+		before,
+		after
+	};
+}
+/**
+* Diff two flow states into a history entry, or null when nothing changed. An order change
+* alone is no step, so a bare reshuffle adds no undo entry.
+*/
 export function diffFlowState(base, current) {
-    const nodes = diffCollection(base.nodes, current.nodes, VOLATILE_NODE_FIELDS);
-    const edges = diffCollection(base.edges, current.edges, VOLATILE_EDGE_FIELDS);
-    if (nodes.before.length === 0 && nodes.after.length === 0 && edges.before.length === 0 && edges.after.length === 0) {
-        return null;
-    }
-    const nodeOrder = diffOrder(base.nodes, current.nodes);
-    const edgeOrder = diffOrder(base.edges, current.edges);
-    return {
-        nodesBefore: nodes.before,
-        nodesAfter: nodes.after,
-        edgesBefore: edges.before,
-        edgesAfter: edges.after,
-        ...nodeOrder && {
-            nodeOrder
-        },
-        ...edgeOrder && {
-            edgeOrder
-        }
-    };
-}
+	const nodes = diffCollection(base.nodes, current.nodes, VOLATILE_NODE_FIELDS);
+	const edges = diffCollection(base.edges, current.edges, VOLATILE_EDGE_FIELDS);
+	if (nodes.before.length === 0 && nodes.after.length === 0 && edges.before.length === 0 && edges.after.length === 0) {
+		return null;
+	}
+	const nodeOrder = diffOrder(base.nodes, current.nodes);
+	const edgeOrder = diffOrder(base.edges, current.edges);
+	return {
+		nodesBefore: nodes.before,
+		nodesAfter: nodes.after,
+		edgesBefore: edges.before,
+		edgesAfter: edges.after,
+		...nodeOrder && { nodeOrder },
+		...edgeOrder && { edgeOrder }
+	};
+}
+/** Stable sort into `order`. An id the entry never saw keeps its place after the known ones. */
 function sortByOrder(items, order) {
-    if (!order) return items;
-    const rank = new Map(order.map((id, index)=>[
-            id,
-            index
-        ]));
-    const at = (item)=>rank.get(item.id) ?? order.length;
-    return items.toSorted((a, b)=>at(a) - at(b));
+	if (!order) return items;
+	const rank = new Map(order.map((id, index) => [id, index]));
+	const at = (item) => rank.get(item.id) ?? order.length;
+	return items.toSorted((a, b) => at(a) - at(b));
 }
+/** Only a child ahead of its parent breaks SvelteFlow, so a valid order is never regrouped. */
 function parentsFirst(nodes) {
-    const seen = new Set();
-    const ids = new Set(nodes.map((node)=>node.id));
-    for (const node of nodes){
-        if (node.parentId && ids.has(node.parentId) && !seen.has(node.parentId)) {
-            return sortParentsFirst(nodes);
-        }
-        seen.add(node.id);
-    }
-    return nodes;
+	const seen = new Set();
+	const ids = new Set(nodes.map((node) => node.id));
+	for (const node of nodes) {
+		if (node.parentId && ids.has(node.parentId) && !seen.has(node.parentId)) {
+			return sortParentsFirst(nodes);
+		}
+		seen.add(node.id);
+	}
+	return nodes;
 }
 function applyCollection(items, restore, discard) {
-    const restoreById = new Map(restore.map((item)=>[
-            item.id,
-            item
-        ]));
-    const discardIds = new Set(discard.map((item)=>item.id));
-    let next = items.filter((item)=>!(discardIds.has(item.id) && !restoreById.has(item.id)));
-    const present = new Set(next.map((item)=>item.id));
-    next = next.map((item)=>{
-        const restored = restoreById.get(item.id);
-        if (!restored) return item;
-        const selected = item.selected;
-        return {
-            ...clone(restored),
-            ...selected !== undefined && {
-                selected
-            }
-        };
-    });
-    for (const item of restore){
-        if (!present.has(item.id)) next.push(clone(item));
-    }
-    return next;
-}
+	const restoreById = new Map(restore.map((item) => [item.id, item]));
+	const discardIds = new Set(discard.map((item) => item.id));
+	// Drop pure additions of the direction being reverted.
+	let next = items.filter((item) => !(discardIds.has(item.id) && !restoreById.has(item.id)));
+	// Restore changed items in place.
+	const present = new Set(next.map((item) => item.id));
+	next = next.map((item) => {
+		const restored = restoreById.get(item.id);
+		if (!restored) return item;
+		// Selection is where you are, not what the document held, so an undo leaves it be.
+		const selected = item.selected;
+		return {
+			...clone(restored),
+			...selected !== undefined && { selected }
+		};
+	});
+	// Re-add items that were removed in the direction being reverted.
+	for (const item of restore) {
+		if (!present.has(item.id)) next.push(clone(item));
+	}
+	return next;
+}
+/** Apply a history entry to a state: "undo" restores the before side, "redo" the after side. */
 export function applyHistoryEntry(state, entry, direction) {
-    const [restoreNodes, discardNodes] = direction === "undo" ? [
-        entry.nodesBefore,
-        entry.nodesAfter
-    ] : [
-        entry.nodesAfter,
-        entry.nodesBefore
-    ];
-    const [restoreEdges, discardEdges] = direction === "undo" ? [
-        entry.edgesBefore,
-        entry.edgesAfter
-    ] : [
-        entry.edgesAfter,
-        entry.edgesBefore
-    ];
-    const side = direction === "undo" ? "before" : "after";
-    return {
-        nodes: parentsFirst(sortByOrder(applyCollection(state.nodes, restoreNodes, discardNodes), entry.nodeOrder?.[side])),
-        edges: sortByOrder(applyCollection(state.edges, restoreEdges, discardEdges), entry.edgeOrder?.[side])
-    };
-}
+	const [restoreNodes, discardNodes] = direction === "undo" ? [entry.nodesBefore, entry.nodesAfter] : [entry.nodesAfter, entry.nodesBefore];
+	const [restoreEdges, discardEdges] = direction === "undo" ? [entry.edgesBefore, entry.edgesAfter] : [entry.edgesAfter, entry.edgesBefore];
+	const side = direction === "undo" ? "before" : "after";
+	return {
+		// WHY parentsFirst: SvelteFlow requires parents before children; a
+		// re-added container must land ahead of the children it re-adopts.
+		nodes: parentsFirst(sortByOrder(applyCollection(state.nodes, restoreNodes, discardNodes), entry.nodeOrder?.[side])),
+		edges: sortByOrder(applyCollection(state.edges, restoreEdges, discardEdges), entry.edgeOrder?.[side])
+	};
+}
+/** An id's earliest before and latest after, so a node touched by both steps keeps its outer states. */
 function mergeSides(first, second) {
-    const firstTouched = new Set([
-        ...first.before,
-        ...first.after
-    ].map((item)=>item.id));
-    const secondTouched = new Set([
-        ...second.before,
-        ...second.after
-    ].map((item)=>item.id));
-    const before = [
-        ...first.before,
-        ...second.before.filter((item)=>!firstTouched.has(item.id))
-    ];
-    const after = [
-        ...first.after.filter((item)=>!secondTouched.has(item.id)),
-        ...second.after
-    ];
-    return {
-        before,
-        after
-    };
+	const firstTouched = new Set([...first.before, ...first.after].map((item) => item.id));
+	const secondTouched = new Set([...second.before, ...second.after].map((item) => item.id));
+	const before = [...first.before, ...second.before.filter((item) => !firstTouched.has(item.id))];
+	const after = [...first.after.filter((item) => !secondTouched.has(item.id)), ...second.after];
+	return {
+		before,
+		after
+	};
 }
 function sameIds(a, b) {
-    return a.length === b.length && a.every((id, i)=>id === b[i]);
+	return a.length === b.length && a.every((id, i) => id === b[i]);
 }
+/** No order change on one side means that step left the order alone, so the other side's end stands in. */
 function mergeOrder(first, second) {
-    const before = first?.before ?? second?.before;
-    const after = second?.after ?? first?.after;
-    if (!before || !after) return undefined;
-    return sameIds(before, after) ? undefined : {
-        before,
-        after
-    };
-}
+	const before = first?.before ?? second?.before;
+	const after = second?.after ?? first?.after;
+	if (!before || !after) return undefined;
+	return sameIds(before, after) ? undefined : {
+		before,
+		after
+	};
+}
+/** Fold two consecutive steps into one: undoing it restores the state before `first`. */
 export function mergeHistoryEntries(first, second) {
-    const nodes = mergeSides({
-        before: first.nodesBefore,
-        after: first.nodesAfter
-    }, {
-        before: second.nodesBefore,
-        after: second.nodesAfter
-    });
-    const edges = mergeSides({
-        before: first.edgesBefore,
-        after: first.edgesAfter
-    }, {
-        before: second.edgesBefore,
-        after: second.edgesAfter
-    });
-    const nodeOrder = mergeOrder(first.nodeOrder, second.nodeOrder);
-    const edgeOrder = mergeOrder(first.edgeOrder, second.edgeOrder);
-    return {
-        nodesBefore: nodes.before,
-        nodesAfter: nodes.after,
-        edgesBefore: edges.before,
-        edgesAfter: edges.after,
-        ...nodeOrder && {
-            nodeOrder
-        },
-        ...edgeOrder && {
-            edgeOrder
-        }
-    };
+	const nodes = mergeSides({
+		before: first.nodesBefore,
+		after: first.nodesAfter
+	}, {
+		before: second.nodesBefore,
+		after: second.nodesAfter
+	});
+	const edges = mergeSides({
+		before: first.edgesBefore,
+		after: first.edgesAfter
+	}, {
+		before: second.edgesBefore,
+		after: second.edgesAfter
+	});
+	const nodeOrder = mergeOrder(first.nodeOrder, second.nodeOrder);
+	const edgeOrder = mergeOrder(first.edgeOrder, second.edgeOrder);
+	return {
+		nodesBefore: nodes.before,
+		nodesAfter: nodes.after,
+		edgesBefore: edges.before,
+		edgesAfter: edges.after,
+		...nodeOrder && { nodeOrder },
+		...edgeOrder && { edgeOrder }
+	};
 }