@heyramzi/ui 2.11.1 → 2.11.2

package/dist/canvas/editor/lock.js

@@ -1,65 +1,66 @@
 export function isLocked(node) {
-    const data = node?.data;
-    return data?.locked === true;
+	const data = node?.data;
+	return data?.locked === true;
 }
+/** What xyflow needs to hold a locked card still. */
 export const LOCK_FLAGS = {
-    draggable: false,
-    deletable: false
+	draggable: false,
+	deletable: false
 };
+/** The card with its flow flags matching `data.locked`. A synced copy keeps its own flags. */
 export function withLockFlags(node) {
-    if (node.data?.syncedCopy) return node;
-    if (isLocked(node)) return {
-        ...node,
-        ...LOCK_FLAGS
-    };
-    if (node.draggable !== false && node.deletable !== false) return node;
-    const { draggable: _drag, deletable: _delete, ...rest } = node;
-    return rest;
+	if (node.data?.syncedCopy) return node;
+	if (isLocked(node)) return {
+		...node,
+		...LOCK_FLAGS
+	};
+	if (node.draggable !== false && node.deletable !== false) return node;
+	const { draggable: _drag, deletable: _delete, ...rest } = node;
+	return rest;
 }
+/** `locked` alone is the one data change a locked card takes: it is how it comes unlocked. */
 function onlyUnlocks(op) {
-    if (op.kind !== "patchNode") return false;
-    const patch = op;
-    return patch.data !== undefined && patch.style === undefined && patch.width === undefined && patch.height === undefined && Object.keys(patch.data).every((key)=>key === "locked");
+	if (op.kind !== "patchNode") return false;
+	const patch = op;
+	return patch.data !== undefined && patch.style === undefined && patch.width === undefined && patch.height === undefined && Object.keys(patch.data).every((key) => key === "locked");
 }
+/**
+* The one gate every dispatched edit passes: ops that don't reach a locked card. An op on an
+* arrow, or a card not on the board, passes.
+*/
 export function refuseLockedOps(nodes, ops) {
-    const locked = new Set(nodes.filter(isLocked).map((node)=>node.id));
-    if (locked.size === 0) return [
-        ...ops
-    ];
-    return ops.filter((op)=>{
-        const nodeId = op.nodeId;
-        return typeof nodeId !== "string" || !locked.has(nodeId) || onlyUnlocks(op);
-    });
+	const locked = new Set(nodes.filter(isLocked).map((node) => node.id));
+	if (locked.size === 0) return [...ops];
+	return ops.filter((op) => {
+		const nodeId = op.nodeId;
+		return typeof nodeId !== "string" || !locked.has(nodeId) || onlyUnlocks(op);
+	});
 }
+/** Of these ids, the ones a delete may take: not locked, and not a group holding something locked. */
 export function deletableIds(nodes, ids) {
-    const parentOf = new Map(nodes.map((node)=>[
-            node.id,
-            node.parentId
-        ]));
-    const holdsLocked = new Set();
-    for (const node of nodes){
-        if (!isLocked(node)) continue;
-        for(let up = node.parentId; up; up = parentOf.get(up))holdsLocked.add(up);
-    }
-    const byId = new Map(nodes.map((node)=>[
-            node.id,
-            node
-        ]));
-    return ids.filter((id)=>!isLocked(byId.get(id)) && !holdsLocked.has(id));
+	const parentOf = new Map(nodes.map((node) => [node.id, node.parentId]));
+	const holdsLocked = new Set();
+	for (const node of nodes) {
+		if (!isLocked(node)) continue;
+		for (let up = node.parentId; up; up = parentOf.get(up)) holdsLocked.add(up);
+	}
+	const byId = new Map(nodes.map((node) => [node.id, node]));
+	return ids.filter((id) => !isLocked(byId.get(id)) && !holdsLocked.has(id));
 }
+/** The board with the picked cards locked, or all unlocked when every one of them already was locked. */
 export function toggleLock(nodes, picked) {
-    const targets = nodes.filter((node)=>picked.has(node.id) && !node.data.syncedCopy);
-    if (targets.length === 0) return null;
-    const locked = !targets.every(isLocked);
-    const ids = new Set(targets.map((node)=>node.id));
-    return {
-        locked,
-        nodes: nodes.map((node)=>ids.has(node.id) ? withLockFlags({
-                ...node,
-                data: {
-                    ...node.data,
-                    locked
-                }
-            }) : node)
-    };
+	const targets = nodes.filter((node) => picked.has(node.id) && !node.data.syncedCopy);
+	if (targets.length === 0) return null;
+	const locked = !targets.every(isLocked);
+	const ids = new Set(targets.map((node) => node.id));
+	return {
+		locked,
+		nodes: nodes.map((node) => ids.has(node.id) ? withLockFlags({
+			...node,
+			data: {
+				...node.data,
+				locked
+			}
+		}) : node)
+	};
 }

package/dist/canvas/editor/rebase.js

@@ -1,279 +1,256 @@
+// Conflict rebase for the autosave PUT. On a 409, local changes since the last
+// save replay as ops on the server document, instead of overwriting the other writer.
 import { tryCatch } from "../../lib/result.js";
 import { applyOps } from "../ops/ops.js";
 import { sortParentsFirst } from "../headless/canvas-cleanup.js";
 const EDGE_PATCH_FIELDS = [
-    "source",
-    "target",
-    "label",
-    "animated",
-    "type",
-    "style",
-    "sourceHandle",
-    "targetHandle"
+	"source",
+	"target",
+	"label",
+	"animated",
+	"type",
+	"style",
+	"sourceHandle",
+	"targetHandle"
 ];
 function json(value) {
-    return JSON.stringify(value ?? null);
+	return JSON.stringify(value ?? null);
 }
 function objectStyle(node) {
-    return node.style && typeof node.style === "object" ? node.style : undefined;
+	return node.style && typeof node.style === "object" ? node.style : undefined;
 }
 function numberOrUndefined(value) {
-    return typeof value === "number" ? value : undefined;
+	return typeof value === "number" ? value : undefined;
 }
 function addNodeOp(node) {
-    const style = objectStyle(node);
-    const width = numberOrUndefined(node.width);
-    const height = numberOrUndefined(node.height);
-    return {
-        kind: "addNode",
-        node: {
-            id: node.id,
-            type: String(node.type ?? "node"),
-            position: node.position ?? {
-                x: 0,
-                y: 0
-            },
-            data: node.data ?? {},
-            ...style ? {
-                style
-            } : {},
-            ...width !== undefined ? {
-                width
-            } : {},
-            ...height !== undefined ? {
-                height
-            } : {},
-            ...node.parentId ? {
-                parentId: node.parentId
-            } : {}
-        }
-    };
+	const style = objectStyle(node);
+	const width = numberOrUndefined(node.width);
+	const height = numberOrUndefined(node.height);
+	return {
+		kind: "addNode",
+		node: {
+			id: node.id,
+			type: String(node.type ?? "node"),
+			position: node.position ?? {
+				x: 0,
+				y: 0
+			},
+			data: node.data ?? {},
+			...style ? { style } : {},
+			...width !== undefined ? { width } : {},
+			...height !== undefined ? { height } : {},
+			...node.parentId ? { parentId: node.parentId } : {}
+		}
+	};
 }
 function sizePatchOf(before, node) {
-    const patch = {};
-    const style = objectStyle(node);
-    if (style && json(before.style) !== json(node.style)) patch.style = style;
-    const width = numberOrUndefined(node.width);
-    if (width !== undefined && before.width !== node.width) patch.width = width;
-    const height = numberOrUndefined(node.height);
-    if (height !== undefined && before.height !== node.height) patch.height = height;
-    return patch;
+	const patch = {};
+	const style = objectStyle(node);
+	if (style && json(before.style) !== json(node.style)) patch.style = style;
+	const width = numberOrUndefined(node.width);
+	if (width !== undefined && before.width !== node.width) patch.width = width;
+	const height = numberOrUndefined(node.height);
+	if (height !== undefined && before.height !== node.height) patch.height = height;
+	return patch;
 }
+/** Only the top-level keys local changed, so a key the server edited alone keeps its value. */
 function changedData(before, data) {
-    if (!data) return undefined;
-    const changed = Object.entries(data).filter(([key, value])=>json(before?.[key]) !== json(value));
-    return changed.length > 0 ? Object.fromEntries(changed) : undefined;
+	if (!data) return undefined;
+	const changed = Object.entries(data).filter(([key, value]) => json(before?.[key]) !== json(value));
+	return changed.length > 0 ? Object.fromEntries(changed) : undefined;
 }
 function changedNodeOps(before, node) {
-    const ops = [];
-    if (node.position && json(before.position) !== json(node.position)) {
-        ops.push({
-            kind: "moveNode",
-            nodeId: node.id,
-            position: node.position
-        });
-    }
-    const parentId = node.parentId ?? null;
-    if ((before.parentId ?? null) !== parentId) {
-        ops.push({
-            kind: "setParent",
-            nodeId: node.id,
-            parentId
-        });
-    }
-    const data = changedData(before.data, node.data);
-    if (data) ops.push({
-        kind: "patchNode",
-        nodeId: node.id,
-        data
-    });
-    const sizePatch = sizePatchOf(before, node);
-    if (Object.keys(sizePatch).length > 0) {
-        ops.push({
-            kind: "patchNode",
-            nodeId: node.id,
-            ...sizePatch
-        });
-    }
-    return ops;
+	const ops = [];
+	if (node.position && json(before.position) !== json(node.position)) {
+		ops.push({
+			kind: "moveNode",
+			nodeId: node.id,
+			position: node.position
+		});
+	}
+	const parentId = node.parentId ?? null;
+	if ((before.parentId ?? null) !== parentId) {
+		ops.push({
+			kind: "setParent",
+			nodeId: node.id,
+			parentId
+		});
+	}
+	const data = changedData(before.data, node.data);
+	if (data) ops.push({
+		kind: "patchNode",
+		nodeId: node.id,
+		data
+	});
+	const sizePatch = sizePatchOf(before, node);
+	if (Object.keys(sizePatch).length > 0) {
+		ops.push({
+			kind: "patchNode",
+			nodeId: node.id,
+			...sizePatch
+		});
+	}
+	return ops;
 }
 function nodeOps(base, current) {
-    const baseNodes = new Map(base.nodes.map((n)=>[
-            n.id,
-            n
-        ]));
-    const currentIds = new Set(current.nodes.map((n)=>n.id));
-    const removed = base.nodes.filter((n)=>!currentIds.has(n.id)).map((n)=>({
-            kind: "removeNode",
-            nodeId: n.id
-        }));
-    const added = sortParentsFirst(current.nodes.filter((n)=>!baseNodes.has(n.id))).map(addNodeOp);
-    const changed = current.nodes.flatMap((node)=>{
-        const before = baseNodes.get(node.id);
-        return before ? changedNodeOps(before, node) : [];
-    });
-    return [
-        ...removed,
-        ...added,
-        ...changed
-    ];
+	const baseNodes = new Map(base.nodes.map((n) => [n.id, n]));
+	const currentIds = new Set(current.nodes.map((n) => n.id));
+	const removed = base.nodes.filter((n) => !currentIds.has(n.id)).map((n) => ({
+		kind: "removeNode",
+		nodeId: n.id
+	}));
+	// WHY parents first: an added child references its added parent in the same
+	// batch, and applyOps validates parent existence at each step.
+	const added = sortParentsFirst(current.nodes.filter((n) => !baseNodes.has(n.id))).map(addNodeOp);
+	const changed = current.nodes.flatMap((node) => {
+		const before = baseNodes.get(node.id);
+		return before ? changedNodeOps(before, node) : [];
+	});
+	return [
+		...removed,
+		...added,
+		...changed
+	];
 }
 function addEdgeOp(edge) {
-    const optional = (key)=>typeof edge[key] === "string" ? {
-            [key]: edge[key]
-        } : {};
-    const record = (key)=>{
-        const value = edge[key];
-        return value && typeof value === "object" && !Array.isArray(value) ? {
-            [key]: value
-        } : {};
-    };
-    return {
-        kind: "addEdge",
-        edge: {
-            id: edge.id,
-            source: String(edge.source),
-            target: String(edge.target),
-            ...optional("sourceHandle"),
-            ...optional("targetHandle"),
-            ...optional("type"),
-            ...optional("label"),
-            ...typeof edge.animated === "boolean" ? {
-                animated: edge.animated
-            } : {},
-            ...record("style"),
-            ...record("data")
-        }
-    };
+	const optional = (key) => typeof edge[key] === "string" ? { [key]: edge[key] } : {};
+	const record = (key) => {
+		const value = edge[key];
+		return value && typeof value === "object" && !Array.isArray(value) ? { [key]: value } : {};
+	};
+	return {
+		kind: "addEdge",
+		edge: {
+			id: edge.id,
+			source: String(edge.source),
+			target: String(edge.target),
+			...optional("sourceHandle"),
+			...optional("targetHandle"),
+			...optional("type"),
+			...optional("label"),
+			...typeof edge.animated === "boolean" ? { animated: edge.animated } : {},
+			...record("style"),
+			...record("data")
+		}
+	};
 }
 function patchEdgeOps(before, edge) {
-    const patch = {};
-    for (const field of EDGE_PATCH_FIELDS){
-        if (edge[field] !== undefined && json(before[field]) !== json(edge[field])) {
-            patch[field] = edge[field];
-        }
-    }
-    if (Object.keys(patch).length === 0) return [];
-    return [
-        {
-            kind: "patchEdge",
-            edgeId: edge.id,
-            patch
-        }
-    ];
+	const patch = {};
+	for (const field of EDGE_PATCH_FIELDS) {
+		if (edge[field] !== undefined && json(before[field]) !== json(edge[field])) {
+			patch[field] = edge[field];
+		}
+	}
+	if (Object.keys(patch).length === 0) return [];
+	return [{
+		kind: "patchEdge",
+		edgeId: edge.id,
+		patch
+	}];
 }
 function edgeOps(base, current) {
-    const baseEdges = new Map(base.edges.map((e)=>[
-            e.id,
-            e
-        ]));
-    const currentIds = new Set(current.edges.map((e)=>e.id));
-    const removed = base.edges.filter((e)=>!currentIds.has(e.id)).map((e)=>({
-            kind: "removeEdge",
-            edgeId: e.id
-        }));
-    const upserted = current.edges.flatMap((edge)=>{
-        const before = baseEdges.get(edge.id);
-        return before ? patchEdgeOps(before, edge) : [
-            addEdgeOp(edge)
-        ];
-    });
-    return [
-        ...removed,
-        ...upserted
-    ];
+	const baseEdges = new Map(base.edges.map((e) => [e.id, e]));
+	const currentIds = new Set(current.edges.map((e) => e.id));
+	const removed = base.edges.filter((e) => !currentIds.has(e.id)).map((e) => ({
+		kind: "removeEdge",
+		edgeId: e.id
+	}));
+	const upserted = current.edges.flatMap((edge) => {
+		const before = baseEdges.get(edge.id);
+		return before ? patchEdgeOps(before, edge) : [addEdgeOp(edge)];
+	});
+	return [...removed, ...upserted];
 }
+/**
+* Diff two persisted documents into ops. Data patches carry only changed keys. A deleted
+* data key, and a node's `type` or `zIndex`, have no op: `nodeFieldPatches` carries those.
+*/
 export function diffToOps(base, current) {
-    return [
-        ...nodeOps(base, current),
-        ...edgeOps(base, current)
-    ];
+	return [...nodeOps(base, current), ...edgeOps(base, current)];
 }
-const NODE_FIELDS = [
-    "type",
-    "zIndex"
-];
+const NODE_FIELDS = ["type", "zIndex"];
+/** What changed on a node that `patchNode` can't say: `type`, `zIndex` and deleted data keys. */
 function nodeFieldPatches(base, current) {
-    const baseNodes = new Map(base.nodes.map((n)=>[
-            n.id,
-            n
-        ]));
-    const patches = [];
-    for (const node of current.nodes){
-        const before = baseNodes.get(node.id);
-        if (!before) continue;
-        const set = {};
-        const unset = [];
-        for (const field of NODE_FIELDS){
-            if (json(before[field]) === json(node[field])) continue;
-            if (node[field] === undefined) unset.push(field);
-            else set[field] = node[field];
-        }
-        const unsetData = Object.keys(before.data ?? {}).filter((key)=>!(key in (node.data ?? {})));
-        if (unset.length + unsetData.length + Object.keys(set).length > 0) {
-            patches.push({
-                nodeId: node.id,
-                set,
-                unset,
-                unsetData
-            });
-        }
-    }
-    return patches;
+	const baseNodes = new Map(base.nodes.map((n) => [n.id, n]));
+	const patches = [];
+	for (const node of current.nodes) {
+		const before = baseNodes.get(node.id);
+		if (!before) continue;
+		const set = {};
+		const unset = [];
+		for (const field of NODE_FIELDS) {
+			if (json(before[field]) === json(node[field])) continue;
+			if (node[field] === undefined) unset.push(field);
+			else set[field] = node[field];
+		}
+		const unsetData = Object.keys(before.data ?? {}).filter((key) => !(key in (node.data ?? {})));
+		if (unset.length + unsetData.length + Object.keys(set).length > 0) {
+			patches.push({
+				nodeId: node.id,
+				set,
+				unset,
+				unsetData
+			});
+		}
+	}
+	return patches;
 }
 function withoutKeys(record, keys) {
-    return Object.fromEntries(Object.entries(record).filter(([key])=>!keys.includes(key)));
+	return Object.fromEntries(Object.entries(record).filter(([key]) => !keys.includes(key)));
 }
+/** Null when a patched node is gone, the same answer `applyOps` gives for an op on a missing node. */
 function applyNodeFieldPatches(nodes, patches) {
-    const byId = new Map(patches.map((patch)=>[
-            patch.nodeId,
-            patch
-        ]));
-    const seen = new Set();
-    const next = nodes.map((node)=>{
-        const patch = typeof node.id === "string" ? byId.get(node.id) : undefined;
-        if (!patch) return node;
-        seen.add(patch.nodeId);
-        const patched = withoutKeys({
-            ...node,
-            ...patch.set
-        }, patch.unset);
-        if (patch.unsetData.length === 0 || typeof node.data !== "object" || node.data === null) {
-            return patched;
-        }
-        return {
-            ...patched,
-            data: withoutKeys(node.data, patch.unsetData)
-        };
-    });
-    return seen.size === byId.size ? next : null;
+	const byId = new Map(patches.map((patch) => [patch.nodeId, patch]));
+	const seen = new Set();
+	const next = nodes.map((node) => {
+		const patch = typeof node.id === "string" ? byId.get(node.id) : undefined;
+		if (!patch) return node;
+		seen.add(patch.nodeId);
+		const patched = withoutKeys({
+			...node,
+			...patch.set
+		}, patch.unset);
+		if (patch.unsetData.length === 0 || typeof node.data !== "object" || node.data === null) {
+			return patched;
+		}
+		return {
+			...patched,
+			data: withoutKeys(node.data, patch.unsetData)
+		};
+	});
+	return seen.size === byId.size ? next : null;
 }
+/** A local reparent can name a container that sits later in the server's order. */
 function parentsFirst(nodes) {
-    const ids = new Set(nodes.map((node)=>node.id));
-    const seen = new Set();
-    const misordered = nodes.some((node)=>{
-        const early = ids.has(node.parentId) && !seen.has(node.parentId);
-        seen.add(node.id);
-        return early;
-    });
-    if (!misordered) return nodes;
-    const wrapped = nodes.map((node)=>({
-            id: String(node.id),
-            parentId: typeof node.parentId === "string" ? node.parentId : undefined,
-            node
-        }));
-    return sortParentsFirst(wrapped).map(({ node })=>node);
+	const ids = new Set(nodes.map((node) => node.id));
+	const seen = new Set();
+	const misordered = nodes.some((node) => {
+		const early = ids.has(node.parentId) && !seen.has(node.parentId);
+		seen.add(node.id);
+		return early;
+	});
+	if (!misordered) return nodes;
+	const wrapped = nodes.map((node) => ({
+		id: String(node.id),
+		parentId: typeof node.parentId === "string" ? node.parentId : undefined,
+		node
+	}));
+	return sortParentsFirst(wrapped).map(({ node }) => node);
 }
+/**
+* Replay local changes (lastSaved -> local) on the server document. Returns
+* null when impossible, like a patched node deleted, so the save error shows.
+*/
 export function rebaseDiagram(serverDoc, lastSaved, local) {
-    const ops = diffToOps(lastSaved, local);
-    const res = tryCatch(()=>applyOps({
-            nodes: serverDoc.nodes,
-            edges: serverDoc.edges
-        }, ops));
-    if (!res.ok) return null;
-    const nodes = applyNodeFieldPatches(res.value.nodes, nodeFieldPatches(lastSaved, local));
-    return nodes ? {
-        ...res.value,
-        nodes: parentsFirst(nodes)
-    } : null;
+	const ops = diffToOps(lastSaved, local);
+	const res = tryCatch(() => applyOps({
+		nodes: serverDoc.nodes,
+		edges: serverDoc.edges
+	}, ops));
+	if (!res.ok) return null;
+	const nodes = applyNodeFieldPatches(res.value.nodes, nodeFieldPatches(lastSaved, local));
+	return nodes ? {
+		...res.value,
+		nodes: parentsFirst(nodes)
+	} : null;
 }