superdoc 2.24.0-next.1 → 2.24.0-next.11

package/dist/chunks/{create-super-doc-ui-DFNXiKvQ.es.js → create-super-doc-ui-8UTu16Lw.es.js}

@@ -5938,6 +5938,7 @@ function buildTableCommandInput(action, context) {
 		};
 		case "delete-table": return { nodeId };
 		case "merge-cells": {
+			if (!context.canMerge) return null;
 			const range = mergeRange ?? {
 				start: {
 					rowIndex,
@@ -6073,6 +6074,18 @@ function createSuperDocUI(options) {
 		const host = getEditor()?.host;
 		return host && typeof host === "object" ? host : null;
 	};
+	/**
+	* The host selection snapshot a selection read, slice, or capture was
+	* resolved from. The host replaces its snapshot object on every selection
+	* change, so an identical object means the selection has not moved since.
+	*/
+	const selectionHostSnapshots = /* @__PURE__ */ new WeakMap();
+	const readHostSelectionSnapshot = () => {
+		const selectionHandle = (safeCall(() => getHost()?.getHandles?.() ?? null, null)?.editing)?.selection;
+		if (typeof selectionHandle?.getSnapshot !== "function") return null;
+		const snapshot = safeCall(() => selectionHandle.getSnapshot(), null);
+		return snapshot && typeof snapshot === "object" ? snapshot : null;
+	};
 	const createFirstPartyCommandDoc = () => {
 		const editor = getEditor();
 		const doc = editor?.doc;
@@ -6244,7 +6257,7 @@ function createSuperDocUI(options) {
 	};
 	const resolveTableContext = () => {
 		const snapshot = readHostTableContext();
-		if (!snapshot || snapshot.inTable !== true) return null;
+		if (!snapshot || snapshot.inTable !== true || snapshot.status && snapshot.status !== "ready") return null;
 		const table = snapshot.table;
 		const tableNodeId = typeof table?.nodeId === "string" && table.nodeId.length > 0 ? table.nodeId : null;
 		if (!tableNodeId) return null;
@@ -6256,12 +6269,15 @@ function createSuperDocUI(options) {
 		if (rowIndex == null || columnIndex == null) return null;
 		const cellNodeId = typeof cell?.nodeId === "string" && cell.nodeId.length > 0 ? cell.nodeId : null;
 		const range = snapshot.cellRange;
+		const mergeRange = readMergeRange(range);
+		const metadata = snapshot.tableSelection;
 		return {
 			tableNodeId,
 			rowIndex,
 			columnIndex,
 			cellNodeId,
-			mergeRange: readMergeRange(range)
+			mergeRange,
+			canMerge: metadata == null || metadata.selectionMode === "cells" && metadata.isRectangular === true
 		};
 	};
 	const customCommands = /* @__PURE__ */ new Map();
@@ -7277,12 +7293,21 @@ function createSuperDocUI(options) {
 			...EMPTY_SELECTION,
 			status
 		};
+		const slice = buildSelectionSlice(info, status);
+		const hostSelection = selectionHostSnapshots.get(info);
+		if (hostSelection) selectionHostSnapshots.set(slice, hostSelection);
+		return slice;
+	};
+	const buildSelectionSlice = (info, status) => {
 		const target = info.target ?? null;
 		const quotedText = typeof info.text === "string" ? info.text : "";
 		return {
 			status,
 			empty: info.empty === true,
 			target,
+			trackedTarget: info.trackedTarget ?? null,
+			trackedChangeRangeDecisionSupported: info.trackedChangeRangeDecisionSupported,
+			trackedChangesWhollySelected: info.trackedChangesWhollySelected,
 			selectionTarget: info.selectionTarget ?? null,
 			tableSelection: info.tableSelection ?? null,
 			activeMarks: Array.isArray(info.activeMarks) ? info.activeMarks : [],
@@ -7291,18 +7316,22 @@ function createSuperDocUI(options) {
 			quotedText
 		};
 	};
-	const readSelectionInfoLive = () => {
-		const selectionApi = getDoc()?.selection;
-		return readAsync("selection", selectionReadToken(), () => selectionApi?.current ? selectionApi.current({ includeText: true }) : void 0, normalizeSelectionInfo);
-	};
+	const readSelectionInfoLive = () => readAsync("selection", selectionReadToken(), selectionCurrentRun, normalizeSelectionInfo);
 	const computeSelection = () => {
 		const { value: info, status } = readSelectionInfoLive();
 		return selectionSliceFromInfo(info, status);
 	};
-	const selectionCurrentRun = () => {
+	function selectionCurrentRun() {
 		const selectionApi = getDoc()?.selection;
-		return selectionApi?.current ? selectionApi.current({ includeText: true }) : void 0;
-	};
+		if (!selectionApi?.current) return void 0;
+		const hostSelection = readHostSelectionSnapshot();
+		const tag = (info) => {
+			if (hostSelection && info && typeof info === "object") selectionHostSnapshots.set(info, hostSelection);
+			return info;
+		};
+		const result = selectionApi.current({ includeText: true });
+		return isPromiseLike(result) ? Promise.resolve(result).then(tag) : tag(result);
+	}
 	/** True when a host sync snapshot is a resolved collapsed caret (not a range). */
 	const isCollapsedCaretSnapshot = (info) => {
 		if (info.empty !== true) return false;
@@ -8282,6 +8311,10 @@ function createSuperDocUI(options) {
 		if (!supported) return command.scope === "all" ? SUPERDOC_UI_REASONS.bulkDecisionsDisabled : unavailableRouteReason(doc);
 		if (disabledReason) return disabledReason;
 		if (command.scope !== "all" && selection.activeChangeIds.length === 0) return SUPERDOC_UI_REASONS.selectionRequired;
+		if (command.scope !== "all") {
+			const plan = planSelectionTrackDecision(selection, true);
+			if (plan?.kind === "blocked") return plan.reason;
+		}
 	};
 	const findTrackChangeForPermission = (id) => {
 		syncCoordinatorEditor();
@@ -8301,20 +8334,22 @@ function createSuperDocUI(options) {
 		if (typeof canPerform !== "function" || ids.length === 0) return void 0;
 		const currentUser = superdoc.config && typeof superdoc.config === "object" ? superdoc.config.user : null;
 		for (const id of ids) {
-			const trackedChange = findTrackChangeForPermission(id) ?? { id };
-			const isOwn = trackedChangeOwnedByCurrentUser(trackedChange, currentUser);
-			const permission = kind === "accept" ? isOwn ? "RESOLVE_OWN" : "RESOLVE_OTHER" : isOwn ? "REJECT_OWN" : "REJECT_OTHER";
-			let allowed;
-			try {
-				allowed = canPerform.call(superdoc, {
-					permission,
-					trackedChange,
-					comment: null
-				});
-			} catch {
-				return;
+			const trackedChange = findTrackChangeForPermission(id);
+			const isOwn = trackedChange ? trackedChangeOwnedByCurrentUser(trackedChange, currentUser) : false;
+			const permissions = trackedChange ? [kind === "accept" ? isOwn ? "RESOLVE_OWN" : "RESOLVE_OTHER" : isOwn ? "REJECT_OWN" : "REJECT_OTHER"] : kind === "accept" ? ["RESOLVE_OWN", "RESOLVE_OTHER"] : ["REJECT_OWN", "REJECT_OTHER"];
+			for (const candidate of permissions) {
+				let allowed;
+				try {
+					allowed = canPerform.call(superdoc, {
+						permission: candidate,
+						trackedChange: trackedChange ?? { id },
+						comment: null
+					});
+				} catch {
+					return trackedChange ? void 0 : SUPERDOC_UI_REASONS.permissionDenied;
+				}
+				if (allowed === false || !trackedChange && allowed !== true) return SUPERDOC_UI_REASONS.permissionDenied;
 			}
-			if (allowed === false) return SUPERDOC_UI_REASONS.permissionDenied;
 		}
 	};
 	const hostCommandSupport = (command) => {
@@ -9155,7 +9190,7 @@ function createSuperDocUI(options) {
 			reason: SUPERDOC_UI_REASONS.documentReadonly
 		}, "builtin");
 		const context = resolveTableContext();
-		if (!(context != null && (!descriptor.table.requiresCell || context.cellNodeId != null))) return normalizeCommandState({
+		if (!(context != null && (!descriptor.table.requiresCell || context.cellNodeId != null) && (descriptor.table.action !== "merge-cells" || context.canMerge))) return normalizeCommandState({
 			enabled: false,
 			active: false,
 			supported: true,
@@ -9994,14 +10029,22 @@ function createSuperDocUI(options) {
 	* ordinary/insertion selections are visible-space, while a selection that
 	* reaches painted deleted text is projected in tracked space by the host.
 	*
-	* A cross-block or malformed selection fails closed. Its intermediate block
-	* coverage cannot be reconstructed from two endpoints without guessing.
+	* Cross-block coverage must come from the model-backed tracked target;
+	* intermediate block lengths cannot be inferred from the endpoints.
 	*/
 	function trackDecisionRangeFromSelection(selection) {
 		if (selection.empty) return null;
 		const explicit = selection.selectionTarget;
 		const start = explicit?.start;
 		const end = explicit?.end;
+		if (start?.kind === "text" && end?.kind === "text" && start.blockId !== end.blockId) {
+			const range = selection.trackedTarget;
+			return range ? {
+				kind: "range",
+				coordinateSpace: "tracked",
+				range
+			} : null;
+		}
 		if (explicit?.kind !== "selection" || start?.kind !== "text" || end?.kind !== "text" || typeof start.blockId !== "string" || start.blockId !== end.blockId || !Number.isInteger(start.offset) || !Number.isInteger(end.offset) || start.offset < 0 || end.offset < 0 || start.offset === end.offset) return null;
 		const rangeStart = Math.min(start.offset, end.offset);
 		const rangeEnd = Math.max(start.offset, end.offset);
@@ -10046,32 +10089,20 @@ function createSuperDocUI(options) {
 	function normalizeTrackDecisionText(value) {
 		return typeof value === "string" ? value.replace(/\s+/g, " ").trim() : "";
 	}
-	function activeChangePartialDecisionRoute() {
-		const activeId = state.selection.activeChangeIds[0];
+	function activeChangePartialDecisionRoute(selection = state.selection) {
+		const activeId = selection.activeChangeIds[0];
 		if (!activeId) return "unavailable";
-		const story = selectionStoryLocator(state.selection);
-		const item = (state.trackChanges.status === "ready" ? state.trackChanges.items.find((candidate) => entityRowMatchesRequest(candidate, activeId, story)) : void 0) ?? readBodyTrackChangeForDecision(activeId, story) ?? readAllStoryTrackChanges()?.find((candidate) => entityRowMatchesRequest(candidate, activeId, story));
+		const story = selectionStoryLocator(selection);
+		const trackChanges = state?.trackChanges;
+		const item = (trackChanges?.status === "ready" ? trackChanges.items.find((candidate) => entityRowMatchesRequest(candidate, activeId, story)) : void 0) ?? readBodyTrackChangeForDecision(activeId, story) ?? readAllStoryTrackChanges()?.find((candidate) => entityRowMatchesRequest(candidate, activeId, story));
 		if (!item) return "unavailable";
 		const change = trackChangesItemPayload(item);
 		const type = change.type;
 		const grouping = change.grouping;
-		if (selectedTextCoversTrackChangeText(state.selection, item)) return "id";
+		if (selectedTextCoversTrackChangeText(selection, item)) return "id";
 		if (type === "replacement" && grouping === "replacement-pair") return "range";
 		return (type === "insertion" || type === "deletion" || type === "insert" || type === "delete") && grouping === "standalone" ? "range" : "id";
 	}
-	function executeTrackDecisionRangeWithIdFallback(kind, rangeTarget, changeId, story) {
-		const fallback = () => callTrackDecisionTarget(kind, trackDecisionIdTarget(changeId, story), changeId, story);
-		try {
-			const result = callTrackDecisionTarget(kind, rangeTarget, changeId, story);
-			if (isPromiseLike(result)) return settleCommandExecution(Promise.resolve(result).then((settled) => {
-				return commandResultSucceeded(commandResultFromOperationResult(settled)) ? settled : fallback();
-			}));
-			const commandResult = commandResultFromOperationResult(result);
-			return settleCommandExecution(commandResultSucceeded(commandResult) ? result : fallback());
-		} catch {
-			return false;
-		}
-	}
 	/** A decision target carried by the payload itself, independent of the selection. */
 	function explicitTrackDecisionTarget(payload) {
 		if (typeof payload === "string" && payload.length > 0) return {
@@ -10115,29 +10146,88 @@ function createSuperDocUI(options) {
 			story
 		} : null;
 	}
+	/**
+	* The selection-derived decision for a review command. The command gate and
+	* execution share these rules so an enabled command always has a target.
+	* `null` means the selection does not drive the decision (no active change
+	* or a collapsed caret) and the caller falls back to the active change id.
+	* `gateOnly` stops after the blocking rules and returns only a block or null.
+	*/
+	function planSelectionTrackDecision(selection, gateOnly = false) {
+		if (selection.tableSelection?.kind === "tableCells" && (selection.tableSelection.type === "cells" || selection.tableSelection.type === "table")) return {
+			kind: "blocked",
+			reason: SUPERDOC_UI_REASONS.operationUnavailable
+		};
+		const ids = selection.activeChangeIds;
+		if (ids.length > 1) {
+			if (selection.empty || selection.trackedChangesWhollySelected === true) return {
+				kind: "ids",
+				ids
+			};
+			if (selection.trackedChangeRangeDecisionSupported === false) return {
+				kind: "blocked",
+				reason: SUPERDOC_UI_REASONS.operationUnavailable
+			};
+			const target = trackDecisionRangeFromSelection(selection);
+			return target ? {
+				kind: "range",
+				target,
+				changeId: null,
+				permissionIds: ids
+			} : {
+				kind: "blocked",
+				reason: SUPERDOC_UI_REASONS.targetUnresolved
+			};
+		}
+		if (ids.length !== 1 || selection.empty) return null;
+		const activeId = ids[0];
+		let routeValue;
+		const route = () => routeValue ??= selection.trackedChangesWhollySelected === true ? "id" : activeChangePartialDecisionRoute(selection);
+		if (selection.trackedChangeRangeDecisionSupported === false && route() !== "id") return {
+			kind: "blocked",
+			reason: SUPERDOC_UI_REASONS.operationUnavailable
+		};
+		if (!selection.selectionTarget) return null;
+		const target = trackDecisionRangeFromSelection(selection);
+		if (!target && route() !== "id") return {
+			kind: "blocked",
+			reason: SUPERDOC_UI_REASONS.targetUnresolved
+		};
+		if (gateOnly) return null;
+		if (route() === "id") {
+			const selectedStory = selectionStoryLocator(selection);
+			return {
+				kind: "id",
+				id: activeId,
+				story: selectedStory && storyLocatorSignature(selectedStory) !== storyLocatorSignature(null) ? selectedStory : void 0
+			};
+		}
+		if (route() === "unavailable" && !selection.trackedTarget) return { kind: "unavailable" };
+		return target ? {
+			kind: "range",
+			target,
+			changeId: activeId,
+			story: nonBodySelectionStoryLocator(selection)
+		} : {
+			kind: "blocked",
+			reason: SUPERDOC_UI_REASONS.targetUnresolved
+		};
+	}
 	function executeTrackDecisionCommand(command, payload) {
 		if (command.scope === "id" && payload == null) {
-			if (state.selection.activeChangeIds.length > 1) return executeTrackDecisionTarget(command.kind, {
-				kind: "ids",
-				ids: state.selection.activeChangeIds
-			}, null);
-			if (state.selection.activeChangeIds.length === 1 && !state.selection.empty && state.selection.selectionTarget) {
-				const route = activeChangePartialDecisionRoute();
-				if (route === "unavailable") return false;
-				if (route === "range") {
-					const target = trackDecisionRangeFromSelection(state.selection);
-					const story = nonBodySelectionStoryLocator(state.selection);
-					return target ? executeTrackDecisionRangeWithIdFallback(command.kind, target, state.selection.activeChangeIds[0], story) : false;
-				}
-				if (route === "id") {
-					const activeId = state.selection.activeChangeIds[0];
-					const selectedStory = selectionStoryLocator(state.selection);
-					const story = selectedStory && storyLocatorSignature(selectedStory) !== storyLocatorSignature(null) ? selectedStory : void 0;
-					return executeTrackDecision(command.kind, story ? {
-						id: activeId,
-						story
-					} : activeId);
-				}
+			const plan = planSelectionTrackDecision(state.selection);
+			switch (plan?.kind) {
+				case "blocked":
+				case "unavailable": return false;
+				case "ids": return executeTrackDecisionTarget(command.kind, {
+					kind: "ids",
+					ids: plan.ids
+				}, null, void 0, plan.ids);
+				case "range": return executeTrackDecisionTarget(command.kind, plan.target, plan.changeId, plan.story, plan.permissionIds);
+				case "id": return executeTrackDecision(command.kind, plan.story ? {
+					id: plan.id,
+					story: plan.story
+				} : plan.id);
 			}
 		}
 		const resolved = resolveTrackDecisionTarget(command, payload);
@@ -11806,11 +11896,14 @@ function createSuperDocUI(options) {
 			if (snapshot.empty) return null;
 			const cells = currentCellSelectionTarget();
 			if (!snapshot.target && !snapshot.selectionTarget && !cells) return null;
-			return {
+			const capture = {
 				...snapshot,
 				capturedAt: Date.now(),
 				...cells ? { _tableCellSelectionTarget: cells } : {}
 			};
+			const hostSelection = selectionHostSnapshots.get(snapshot);
+			if (hostSelection) selectionHostSnapshots.set(capture, hostSelection);
+			return capture;
 		},
 		restore: (capture) => {
 			const done = (result) => {
@@ -11839,6 +11932,8 @@ function createSuperDocUI(options) {
 				ok: false,
 				reason: SUPERDOC_UI_REASONS.targetUnresolved
 			});
+			const heldHostSelection = selectionHostSnapshots.get(capture);
+			if (!hasCellTarget && target.coordinateSpace === "tracked" && heldHostSelection !== void 0 && readHostSelectionSnapshot() === heldHostSelection) return done({ ok: true });
 			const resolved = getSelectionApplyHelper();
 			if (!("helper" in resolved)) return done({
 				ok: false,
@@ -12675,20 +12770,20 @@ function createSuperDocUI(options) {
 		if (run() === false) return Promise.resolve(false);
 		return lastCommandSettlement;
 	};
-	const executeTrackDecisionTarget = (kind, target, changeId, story) => {
+	const executeTrackDecisionTarget = (kind, target, changeId, story, selectionChangeIds) => {
 		try {
-			return settleCommandExecution(callTrackDecisionTarget(kind, target, changeId, story));
+			return settleCommandExecution(callTrackDecisionTarget(kind, target, changeId, story, selectionChangeIds));
 		} catch {
 			return false;
 		}
 	};
-	const callTrackDecisionTarget = (kind, target, changeId, story) => {
+	const callTrackDecisionTarget = (kind, target, changeId, story, selectionChangeIds) => {
 		if (trackedChangeDecisionsAreDisabled()) return false;
 		const tcApi = getDoc()?.trackChanges;
 		const isAllTarget = target.kind === "all" || target.scope === "all";
 		const isRangeTarget = target.kind === "range";
 		const isMultiIdTarget = target.kind === "ids";
-		const permissionIds = isAllTarget ? [] : isMultiIdTarget && Array.isArray(target.ids) ? target.ids.filter((id) => typeof id === "string" && id.length > 0) : changeId ? [changeId] : [];
+		const permissionIds = isAllTarget ? [] : selectionChangeIds ?? (isMultiIdTarget && Array.isArray(target.ids) ? target.ids.filter((id) => typeof id === "string" && id.length > 0) : changeId ? [changeId] : []);
 		if (permissionIds.length > 0 && trackedChangeDecisionPermissionReason(kind, permissionIds)) return false;
 		if (bulkTrackDecisionBlockedReason({
 			kind,
@@ -13060,7 +13155,13 @@ function createSuperDocUI(options) {
 		return {
 			point,
 			entities: validInput ? entityAt(point) : [],
-			selection: state.selection,
+			selection: (() => {
+				const current = computeSelection();
+				return current.status === "ready" ? current : {
+					...current,
+					tableSelection: null
+				};
+			})(),
 			position: null,
 			insideSelection: false
 		};
@@ -13277,21 +13378,67 @@ function createSuperDocUI(options) {
 		columnIndex: null,
 		cellNodeId: null,
 		rows: null,
-		columns: null
+		columns: null,
+		status: "ready",
+		cellRange: null,
+		tableSelection: null
+	};
+	const publicTableContext = (snapshot) => {
+		const status = snapshot?.status === "pending" || snapshot?.status === "stale" ? snapshot.status : "ready";
+		if (!snapshot || snapshot.inTable !== true || status !== "ready") return {
+			...EMPTY_TABLE_CONTEXT,
+			status
+		};
+		const table = snapshot.table;
+		const row = snapshot.row;
+		const column = snapshot.column;
+		const cell = snapshot.cell;
+		if (typeof table?.nodeId !== "string") return {
+			...EMPTY_TABLE_CONTEXT,
+			status
+		};
+		return {
+			inTable: true,
+			status,
+			tableNodeId: table.nodeId,
+			rowIndex: typeof row?.index === "number" ? row.index : null,
+			columnIndex: typeof column?.index === "number" ? column.index : null,
+			cellNodeId: typeof cell?.nodeId === "string" ? cell.nodeId : null,
+			rows: typeof table.rows === "number" ? table.rows : null,
+			columns: typeof table.columns === "number" ? table.columns : null,
+			cellRange: readMergeRange(snapshot.cellRange),
+			tableSelection: snapshot.tableSelection ?? null
+		};
 	};
 	const tables = {
-		getContext: () => {
-			const context = resolveTableContext();
-			if (!context) return { ...EMPTY_TABLE_CONTEXT };
-			const table = readHostTableContext()?.table;
+		getContext: () => publicTableContext(readHostTableContext()),
+		getContextAsync: async () => {
+			for (let attempt = 0; attempt < 2; attempt += 1) {
+				const token = selectionReadToken();
+				const host = getHost();
+				const read = host?.getTableContextAsync;
+				if (typeof read !== "function") return publicTableContext(readHostTableContext());
+				let snapshot = null;
+				try {
+					snapshot = await read.call(host);
+				} catch {
+					return {
+						...EMPTY_TABLE_CONTEXT,
+						status: "pending"
+					};
+				}
+				if (disposed) return {
+					...EMPTY_TABLE_CONTEXT,
+					status: "pending"
+				};
+				if (token !== selectionReadToken() || host !== getHost()) continue;
+				const context = publicTableContext(snapshot);
+				if (context.status === "stale") continue;
+				return context;
+			}
 			return {
-				inTable: true,
-				tableNodeId: context.tableNodeId,
-				rowIndex: context.rowIndex,
-				columnIndex: context.columnIndex,
-				cellNodeId: context.cellNodeId,
-				rows: typeof table?.rows === "number" ? table.rows : null,
-				columns: typeof table?.columns === "number" ? table.columns : null
+				...EMPTY_TABLE_CONTEXT,
+				status: "stale"
 			};
 		},
 		isInTable: () => resolveTableContext() != null