@parhelia/core 0.1.12556 → 0.1.12560

package/dist/editor/client/operations.js

@@ -8,7 +8,10 @@ import { useDebouncedCallback } from "use-debounce";
 import { createOrUpdateSuggestedEdit } from "../services/suggestedEditsService";
 import { decode } from "html-entities";
 import { GUID_REGEX_EXACT, getItemDescriptor } from "../utils";
+import { copyItemsNeedsTerminalCompletion, waitForEditOperationTerminal, } from "./waitForEditOperationTerminal";
 import { ExternalChangesWarningContent, TreeOperationConfirmContent, UndoDifferentItemContent, } from "./OperationDialogContent";
+/** When true, the delete dialog shows "permanently delete (bypass recycle bin)". */
+const ENABLE_HARD_DELETE_IN_DELETE_DIALOG = false;
 // Track pending suggested edit save requests to prevent race conditions
 const pendingSuggestedEditSaves = new Map();
 // Track pending suggested edits to prevent creating duplicates before server response
@@ -41,6 +44,10 @@ export function getOperationsContext(state, ui) {
     const [executingEditOperations, setExecutingEditOperations] = useState([]);
     const lastOp = useRef(undefined);
     const undoing = useRef(false);
+    // Track operation IDs that were successfully undone/redone but whose React state update
+    // hasn't been rendered yet. Cleared on each render (when stateRef.current is up-to-date).
+    const recentlyUndoneIds = useRef(new Set());
+    const recentlyRedoneIds = useRef(new Set());
     // Cache for field items (template field definitions) - these are static and don't change during editing
     // This prevents refetching on every keystroke since itemsRepository always refetches version 0
     const fieldItemsCache = useRef(new Map());
@@ -48,6 +55,10 @@ export function getOperationsContext(state, ui) {
     // Update ref synchronously during render (not via useEffect) to avoid stale state issues
     // This ensures stateRef.current always has the latest state when undo/redo is called
     stateRef.current = state;
+    // The render means React has processed pending state updates, so the editHistory in
+    // stateRef is now authoritative. Clear the recently-processed tracking sets.
+    recentlyUndoneIds.current.clear();
+    recentlyRedoneIds.current.clear();
     // Extract values to avoid state object reference issues
     const itemsRepository = stateRef.current.itemsRepository;
     // Debounced version of createOrUpdateSuggestedEdit to prevent excessive API calls
@@ -114,6 +125,22 @@ export function getOperationsContext(state, ui) {
         const result = await executeOp(op);
         return result;
     }, [executeOp]);
+    const updateRenderingParameters = useCallback(async (componentId, parameters) => {
+        const pageItem = stateRef.current.page?.item?.descriptor;
+        if (!pageItem) {
+            return;
+        }
+        const op = {
+            type: "update-rendering-parameters",
+            componentId,
+            parameters,
+            mainItem: pageItem,
+            date: new Date().toISOString(),
+            id: uuid(),
+            title: "Update rendering parameters",
+        };
+        await executeOp(op, { refresh: "immediate" });
+    }, [executeOp]);
     const handleResult = (result, options) => {
         if (handleErrorResult(result, ui, stateRef.current)) {
             return;
@@ -239,12 +266,28 @@ export function getOperationsContext(state, ui) {
             title: "Rename item",
         });
         stateRef.current.requestRefresh("immediate");
-        // Only properties changed (name), not children
-        // Await the refresh to ensure cache is updated and events are fired before returning
-        await itemsRepository.refreshItems([item], {
+        // Only properties changed (name/path), not children.
+        // Refresh both the operation descriptor and (when applicable) the currently loaded
+        // descriptor to handle latest-version descriptor mismatches.
+        const currentLoadedItem = stateRef.current.item;
+        const descriptorsToRefresh = [item];
+        if (currentLoadedItem &&
+            currentLoadedItem.id === item.id &&
+            currentLoadedItem.language === item.language) {
+            descriptorsToRefresh.push(currentLoadedItem.descriptor);
+        }
+        // Await the refresh to ensure cache is updated and events are fired before returning.
+        await itemsRepository.refreshItems(descriptorsToRefresh, {
             properties: true,
             children: false,
         });
+        // If the renamed item is currently loaded, force a descriptor reload so
+        // UI panels (e.g. Item Info) don't remain one rename behind.
+        if (currentLoadedItem &&
+            currentLoadedItem.id === item.id &&
+            currentLoadedItem.language === item.language) {
+            await stateRef.current.loadItem(currentLoadedItem.descriptor);
+        }
     }, [itemsRepository, executeOp]);
     const lastEditField = useRef(undefined);
     const editField = useCallback(async ({ field, value, rawValue, refresh = "immediate", }) => {
@@ -451,6 +494,9 @@ export function getOperationsContext(state, ui) {
         // This ensures the UI only changes when the operation truly completes
         handleResult(result, { refresh: "immediate" });
         if (result.type === "success") {
+            for (const op of ops) {
+                recentlyUndoneIds.current.add(op.id);
+            }
             // Check if any operations are executing in background (long-running undo)
             const executingOps = result.data.filter((x) => x.executionStatus === "executing");
             if (executingOps.length > 0) {
@@ -494,12 +540,21 @@ export function getOperationsContext(state, ui) {
         }
         else {
             ui.showErrorToast({ summary: result.summary, details: result.details });
+            // Refresh history so toolbar state matches server (fixes inconsistent UI under load)
+            stateRef.current.refreshHistory?.(stateRef.current.historyMode, stateRef.current.showOnlyMyChanges);
             return false;
         }
     }, [ui, itemsRepository]);
     const undoOperations = useCallback(async (operationIds) => {
-        if (undoing.current || !operationIds.length) {
+        if (!operationIds.length)
             return false;
+        if (undoing.current) {
+            const deadline = Date.now() + 5000;
+            while (undoing.current && Date.now() < deadline) {
+                await new Promise((r) => setTimeout(r, 50));
+            }
+            if (undoing.current)
+                return false;
         }
         undoing.current = true;
         try {
@@ -525,7 +580,12 @@ export function getOperationsContext(state, ui) {
     }, [executeUndoOperation]);
     const undo = useCallback(async (operationId) => {
         if (undoing.current) {
-            return false;
+            const deadline = Date.now() + 5000;
+            while (undoing.current && Date.now() < deadline) {
+                await new Promise((r) => setTimeout(r, 50));
+            }
+            if (undoing.current)
+                return false;
         }
         undoing.current = true;
         try {
@@ -533,11 +593,27 @@ export function getOperationsContext(state, ui) {
             const filterBySession = stateRef.current.showOnlyMyChanges;
             const historyMode = stateRef.current.historyMode;
             let ops;
-            // If a specific operationId is provided, use that operation directly
-            // This ensures we undo the exact operation the UI showed, avoiding stale state issues
+            // If the caller supplied an operationId that was already undone in this session
+            // (React hasn't re-rendered yet, so the UI may hold a stale reference), discard it
+            // and fall through to the general selection logic below.
+            if (operationId && recentlyUndoneIds.current.has(operationId)) {
+                operationId = undefined;
+            }
+            // If a specific operationId is provided (from the UI), always honor it so the UI and
+            // server stay in sync under load. Use the op from history if present (for confirmations),
+            // otherwise call the API with just the id (server is source of truth).
             if (operationId) {
                 const targetOp = stateRef.current.editHistory.find((x) => x.id === operationId && x.canUndo);
-                ops = targetOp ? [targetOp] : [];
+                if (targetOp) {
+                    ops = [targetOp];
+                }
+                else {
+                    // Not in local state (e.g. history refreshed under load). Call API with this id
+                    // so we don't silently do nothing; server will accept or return an error.
+                    ops = [
+                        { id: operationId, type: "unknown" },
+                    ];
+                }
             }
             else {
                 // Select undoable operations respecting showOnlyMyChanges and historyMode filters
@@ -545,6 +621,8 @@ export function getOperationsContext(state, ui) {
                     .filter((x) => {
                     if (!x.canUndo)
                         return false;
+                    if (recentlyUndoneIds.current.has(x.id))
+                        return false;
                     // Session filter (showOnlyMyChanges)
                     if (filterBySession &&
                         x.sessionId !== stateRef.current.sessionId) {
@@ -580,6 +658,10 @@ export function getOperationsContext(state, ui) {
                 undoing.current = false;
                 return false;
             }
+            // When we only have an id (op not in local history), skip confirmations and call API
+            if (firstOp.type === "unknown") {
+                return await executeUndoOperation(ops);
+            }
             // Check if this is a cross-session operation and show warning first
             const isCrossSession = firstOp.sessionId !== stateRef.current.sessionId;
             if (isCrossSession) {
@@ -740,6 +822,7 @@ export function getOperationsContext(state, ui) {
         // which merges server responses + websocket updates while enforcing scope filtering.
         handleResult(result, { refresh: "immediate" });
         if (result.type === "success") {
+            recentlyRedoneIds.current.add(op.id);
             // Check if the operation is executing in background (long-running redo)
             const executingOps = result.data.filter((x) => x.executionStatus === "executing");
             if (executingOps.length > 0) {
@@ -769,12 +852,19 @@ export function getOperationsContext(state, ui) {
         }
         else {
             ui.showErrorToast({ summary: result.summary, details: result.details });
+            stateRef.current.refreshHistory?.(stateRef.current.historyMode, stateRef.current.showOnlyMyChanges);
             return false;
         }
     }, [ui, itemsRepository]);
     const redo = useCallback(async (operationId) => {
-        if (undoing.current)
-            return false;
+        if (undoing.current) {
+            const deadline = Date.now() + 5000;
+            while (undoing.current && Date.now() < deadline) {
+                await new Promise((r) => setTimeout(r, 50));
+            }
+            if (undoing.current)
+                return false;
+        }
         undoing.current = true;
         try {
             const currentItem = stateRef.current.item?.descriptor;
@@ -783,16 +873,28 @@ export function getOperationsContext(state, ui) {
             const filterBySession = stateRef.current.showOnlyMyChanges;
             const historyMode = stateRef.current.historyMode;
             let op;
-            // If a specific operationId is provided, use that operation directly
-            // This ensures we redo the exact operation the UI showed, avoiding stale state issues
+            if (operationId && recentlyRedoneIds.current.has(operationId)) {
+                operationId = undefined;
+            }
+            // If a specific operationId is provided (from the UI), always honor it so the UI and
+            // server stay in sync under load. Use the op from history if present (for confirmations),
+            // otherwise call the API with just the id (server is source of truth).
             if (operationId) {
                 op = stateRef.current.editHistory.find((x) => x.id === operationId && x.canRedo);
+                if (!op) {
+                    op = {
+                        id: operationId,
+                        type: "unknown",
+                    };
+                }
             }
             else {
                 // Select redoable operations respecting showOnlyMyChanges and historyMode filters
                 op = [...stateRef.current.editHistory].reverse().find((x) => {
                     if (!x.canRedo)
                         return false;
+                    if (recentlyRedoneIds.current.has(x.id))
+                        return false;
                     // Session filter (showOnlyMyChanges)
                     if (filterBySession && x.sessionId !== stateRef.current.sessionId) {
                         return false;
@@ -819,6 +921,10 @@ export function getOperationsContext(state, ui) {
             }
             if (!op)
                 return false;
+            // When we only have an id (op not in local history), skip confirmations and call API
+            if (op.type === "unknown") {
+                return await executeRedoOperation(op);
+            }
             // Check if this is a cross-session operation and show warning first
             const isCrossSession = op.sessionId !== stateRef.current.sessionId;
             if (isCrossSession) {
@@ -954,19 +1060,36 @@ export function getOperationsContext(state, ui) {
         // Show confirmation dialog (with reference warning if applicable)
         const result = await new Promise((resolve) => {
             const undoCheckboxId = `delete-enable-undo-${Date.now()}`;
-            const undoCheckbox = (_jsx("div", { className: "mt-4", children: _jsxs("label", { className: "flex cursor-pointer items-center gap-2", children: [_jsx("input", { type: "checkbox", id: undoCheckboxId, defaultChecked: true, className: "h-4 w-4 rounded border-gray-300" }), _jsx("span", { className: "text-sm", children: "Enable undo (serializes complete content)" })] }) }));
+            const hardDeleteCheckboxId = `delete-hard-delete-${Date.now()}`;
+            const deleteOptions = (_jsxs("div", { className: "mt-4 space-y-3", children: [ENABLE_HARD_DELETE_IN_DELETE_DIALOG ? (_jsx("div", { className: "rounded-md border border-red-200 bg-red-50/60 p-3", children: _jsxs("label", { className: "flex cursor-pointer items-start gap-2", children: [_jsx("input", { type: "checkbox", id: hardDeleteCheckboxId, "data-testid": "delete-hard-delete-checkbox", defaultChecked: options?.hardDelete ?? false, className: "mt-0.5 h-4 w-4 rounded border-gray-300" }), _jsxs("span", { className: "space-y-1", children: [_jsx("span", { className: "block text-sm font-medium text-red-900", children: "Permanently delete (bypass recycle bin)" }), _jsx("span", { className: "block text-xs text-red-800", children: "This skips the recycle bin. Items can only be restored if undo is enabled for this operation." })] })] }) })) : null, _jsxs("label", { className: "flex cursor-pointer items-center gap-2", children: [_jsx("input", { type: "checkbox", id: undoCheckboxId, "data-testid": "delete-enable-undo-checkbox", defaultChecked: options?.canUndo ?? true, className: "h-4 w-4 rounded border-gray-300" }), _jsx("span", { className: "text-sm", children: "Enable undo (serializes complete content)" })] })] }));
             const getEnableUndo = () => {
                 const checkbox = document.getElementById(undoCheckboxId);
-                return checkbox?.checked ?? true;
+                return checkbox?.checked ?? options?.canUndo ?? true;
+            };
+            const getHardDelete = () => {
+                if (!ENABLE_HARD_DELETE_IN_DELETE_DIALOG)
+                    return false;
+                const checkbox = document.getElementById(hardDeleteCheckboxId);
+                return checkbox?.checked ?? options?.hardDelete ?? false;
             };
             if (hasReferences) {
                 ui.confirmationDialogRef.current?.confirm({
                     header: "Delete Items with References",
-                    message: (_jsxs("div", { className: "space-y-2", children: [_jsx("p", { children: "You are about to delete the following items which are referenced by other content:" }), _jsx(DeleteItemsWarning, { references: references }), _jsx("p", { className: "text-muted-foreground mt-4 text-sm", children: "Deleting these items may break links in your content. Are you sure you want to proceed?" }), undoCheckbox] })),
+                    message: (_jsxs("div", { className: "space-y-2", children: [_jsx("p", { children: "You are about to delete the following items which are referenced by other content:" }), _jsx(DeleteItemsWarning, { references: references }), _jsx("p", { className: "text-muted-foreground mt-4 text-sm", children: "Deleting these items may break links in your content. Are you sure you want to proceed?" }), deleteOptions] })),
                     acceptLabel: "Delete Anyway",
                     rejectLabel: "Cancel",
-                    accept: () => resolve({ confirmed: true, enableUndo: getEnableUndo() }),
-                    reject: () => resolve({ confirmed: false, enableUndo: true }),
+                    accept: () => resolve({
+                        confirmed: true,
+                        enableUndo: getEnableUndo(),
+                        hardDelete: getHardDelete(),
+                    }),
+                    reject: () => resolve({
+                        confirmed: false,
+                        enableUndo: options?.canUndo ?? true,
+                        hardDelete: ENABLE_HARD_DELETE_IN_DELETE_DIALOG
+                            ? (options?.hardDelete ?? false)
+                            : false,
+                    }),
                     showCancel: false,
                 });
             }
@@ -974,11 +1097,21 @@ export function getOperationsContext(state, ui) {
                 // No references - use simple confirmation
                 ui.confirmationDialogRef.current?.confirm({
                     header: "Delete Items",
-                    message: (_jsxs("div", { children: [_jsxs("p", { children: ["Are you sure you want to delete ", items.length === 1 ? "this item" : `these ${items.length} items`, "?"] }), undoCheckbox] })),
+                    message: (_jsxs("div", { children: [_jsxs("p", { children: ["Are you sure you want to delete", " ", _jsx("span", { className: "font-semibold", children: itemNames }), "?"] }), deleteOptions] })),
                     acceptLabel: "Delete",
                     rejectLabel: "Cancel",
-                    accept: () => resolve({ confirmed: true, enableUndo: getEnableUndo() }),
-                    reject: () => resolve({ confirmed: false, enableUndo: true }),
+                    accept: () => resolve({
+                        confirmed: true,
+                        enableUndo: getEnableUndo(),
+                        hardDelete: getHardDelete(),
+                    }),
+                    reject: () => resolve({
+                        confirmed: false,
+                        enableUndo: options?.canUndo ?? true,
+                        hardDelete: ENABLE_HARD_DELETE_IN_DELETE_DIALOG
+                            ? (options?.hardDelete ?? false)
+                            : false,
+                    }),
                     showCancel: false,
                 });
             }
@@ -986,6 +1119,7 @@ export function getOperationsContext(state, ui) {
         if (!result.confirmed)
             return;
         const canUndoValue = result.enableUndo;
+        const hardDeleteValue = result.hardDelete;
         const op = {
             type: "delete-items",
             items: items.map(getItemDescriptor),
@@ -993,8 +1127,9 @@ export function getOperationsContext(state, ui) {
                 getItemDescriptor(items[0]),
             date: new Date().toISOString(),
             id: uuid(),
-            title: `Delete ${itemNames}`,
+            title: `${hardDeleteValue ? "Hard delete" : "Delete"} ${itemNames}`,
             canUndo: canUndoValue,
+            hardDelete: hardDeleteValue,
         };
         const returnedOp = await executeOp(op);
         itemsRepository.onItemsDeleted(itemsToDelete.map((x) => ({
@@ -1002,6 +1137,7 @@ export function getOperationsContext(state, ui) {
             parentId: x.parentId,
         })));
         stateRef.current.requestRefresh("immediate");
+        return true;
     }, [itemsRepository, executeOp, ui]);
     const moveItems = useCallback(async (items, target, index) => {
         // Use generic edit endpoint for long-running operation support
@@ -1077,9 +1213,17 @@ export function getOperationsContext(state, ui) {
             id: uuid(),
             title: `Copying ${items.length} item(s)...`,
         };
-        const result = await executeOp(op);
+        let copyResult = (await executeOp(op));
+        if (copyItemsNeedsTerminalCompletion(copyResult)) {
+            try {
+                const terminal = await waitForEditOperationTerminal(copyResult.id, 120_000);
+                copyResult = { ...copyResult, ...terminal };
+            }
+            catch {
+                return [];
+            }
+        }
         // Return created item descriptors from the operation result
-        const copyResult = result;
         if (copyResult?.createdItemIds) {
             return copyResult.createdItemIds.map((id) => ({
                 id,
@@ -1103,17 +1247,29 @@ export function getOperationsContext(state, ui) {
             title: `Duplicating item...`,
             name, // Pass the user-provided name to the backend
         };
-        const result = await executeOp(op);
-        if (result.errorMessage) {
+        let copyResult = (await executeOp(op));
+        if (copyItemsNeedsTerminalCompletion(copyResult)) {
+            try {
+                const terminal = await waitForEditOperationTerminal(copyResult.id, 120_000);
+                copyResult = { ...copyResult, ...terminal };
+            }
+            catch (e) {
+                ui.showErrorToast({
+                    summary: "Duplicate failed",
+                    details: e?.message || "Operation timed out",
+                });
+                return;
+            }
+        }
+        if (copyResult.errorMessage) {
             ui.showErrorToast({
                 summary: "Duplicate failed",
-                details: result.errorMessage,
+                details: copyResult.errorMessage,
             });
             return;
         }
         itemsRepository.refreshItems([target]);
         // Return created item descriptor from the operation result
-        const copyResult = result;
         if (copyResult?.createdItemIds?.length > 0) {
             return {
                 id: copyResult.createdItemIds[0],
@@ -1123,6 +1279,12 @@ export function getOperationsContext(state, ui) {
         }
         return undefined;
     }, [executeOp, itemsRepository, ui]);
+    const publishItem = useCallback(async (operation) => {
+        const result = (await executeOp(operation, {
+            refresh: "immediate",
+        }));
+        return result;
+    }, [executeOp]);
     const onFieldBlur = useCallback(() => {
         // Reset the last operation to force creation of a new operation
         // when the user returns to edit any field after losing focus
@@ -1138,6 +1300,7 @@ export function getOperationsContext(state, ui) {
         unlockItems: unlockItemsAndRefresh,
         executeWorkflowCommand: executeWorkflowCommandAndRefresh,
         editField,
+        updateRenderingParameters,
         undo,
         undoOperations,
         redo,
@@ -1147,6 +1310,7 @@ export function getOperationsContext(state, ui) {
         createItem,
         createVersion,
         removeVersion,
+        publishItem,
         duplicateComponents,
         undoing: undoing.current,
         moveItems,
@@ -1160,6 +1324,7 @@ export function getOperationsContext(state, ui) {
         unlockItemsAndRefresh,
         executeWorkflowCommandAndRefresh,
         editField,
+        updateRenderingParameters,
         undo,
         undoOperations,
         redo,
@@ -1169,6 +1334,7 @@ export function getOperationsContext(state, ui) {
         createItem,
         createVersion,
         removeVersion,
+        publishItem,
         duplicateComponents,
         moveItems,
         mode,
@@ -1230,8 +1396,12 @@ async function getOrMergeSuggestedEditOp(field, rawValue, value, state) {
         pendingEdit.updatedBy = state.user?.name || "unknown";
         return pendingEdit;
     }
+    const matchingSuggestions = state.suggestedEdits.filter((edit) => edit.mainItemId === page.item.descriptor.id &&
+        edit.mainItemLanguage === page.item.descriptor.language &&
+        edit.itemId === item.id &&
+        edit.fieldId === field.fieldId);
     // Attempt to find an existing suggested edit by the same user for this field.
-    const existing = state.suggestedEdits.find((edit) => edit.mainItemId === page.item.descriptor.id &&
+    const existing = matchingSuggestions.find((edit) => edit.mainItemId === page.item.descriptor.id &&
         edit.mainItemLanguage === page.item.descriptor.language &&
         edit.mainItemVersion === page.item.descriptor.version &&
         edit.itemId === item.id &&
@@ -1243,8 +1413,10 @@ async function getOrMergeSuggestedEditOp(field, rawValue, value, state) {
         existing.newValue = newVal || "";
         existing.updated = new Date().toISOString();
         existing.updatedBy = state.user?.name || "unknown";
+        const nextSuggestedEdits = [...state.suggestedEdits];
+        state.suggestedEdits = nextSuggestedEdits;
         // Optionally, you might update the comments or other fields.
-        state.setSuggestedEdits([...state.suggestedEdits]);
+        state.setSuggestedEdits(nextSuggestedEdits);
         return existing;
     }
     else {
@@ -1262,12 +1434,18 @@ async function getOrMergeSuggestedEditOp(field, rawValue, value, state) {
             fieldId: field.fieldId,
             oldValue: fieldItem.rawValue || "",
             newValue: newVal || "",
+            author: state.user?.name || "unknown",
             status: "pending",
+            updatedBy: state.user?.name || "unknown",
+            created: new Date().toISOString(),
+            updated: new Date().toISOString(),
             type: "FieldValue",
         };
         // Add to pending edits to prevent race conditions
         pendingSuggestedEdits.set(fieldKey, newEdit);
-        state.setSuggestedEdits([...state.suggestedEdits, newEdit]);
+        const nextSuggestedEdits = [...state.suggestedEdits, newEdit];
+        state.suggestedEdits = nextSuggestedEdits;
+        state.setSuggestedEdits(nextSuggestedEdits);
         return newEdit;
     }
 }