@parhelia/core 0.1.12886 → 0.1.12889

package/dist/editor/client/operations.js

@@ -9,24 +9,21 @@ import { createOrUpdateSuggestedEdit, deleteSuggestedEdit, } from "../services/s
 import { hasSuggestionContentChange, shouldRemoveNoOpSuggestion, } from "../reviews/suggestionContentChange";
 import { GUID_REGEX_EXACT, getItemDescriptor } from "../utils";
 import { cleanId } from "../utils/id-helper";
-import { copyItemsNeedsTerminalCompletion, waitForEditOperationTerminal, } from "./waitForEditOperationTerminal";
+import { copyItemsNeedsTerminalCompletion, normalizeOpId, waitForEditOperationTerminal, } from "./waitForEditOperationTerminal";
+import { isWorkflowMetadataField } from "../workflowFields";
 import { ExternalChangesWarningContent, TreeOperationConfirmContent, UndoDifferentItemContent, } from "./OperationDialogContent";
-import { upsertSuggestedEdit } from "../reviews/suggestedEditState";
+import { isSuggestedEditRemoved, markSuggestedEditRemoved, upsertSuggestedEdit, } from "../reviews/suggestedEditState";
 /** 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
 const pendingSuggestedEdits = new Map();
-// Suggestions that were reverted to a no-op while a debounced save was still in
-// flight. A pending save must not (re-)create or re-add them on the server or in
-// local state. Ids are uuids and never reused, so retaining them is safe.
-const removedSuggestedEditIds = new Set();
 const SUGGESTED_EDIT_SAVE_DEBOUNCE_MS = 500;
 function createDelayedSuggestedEditSave(suggestedEdit) {
     return new Promise((resolve, reject) => {
         globalThis.setTimeout(() => {
-            if (removedSuggestedEditIds.has(suggestedEdit.id)) {
+            if (isSuggestedEditRemoved(suggestedEdit.id)) {
                 // The suggestion was reverted to a no-op while this save was pending.
                 // It never reached the server, so there is nothing to persist or delete.
                 resolve({ type: "ignored" });
@@ -124,6 +121,12 @@ export function getOperationsContext(state, ui) {
         if (returnedOp.executionStatus !== "executing") {
             setExecutingEditOperations((ops) => ops ? ops.filter((x) => x.id !== op.id) : []);
         }
+        else {
+            // Swap in the server's "executing" version so consumers (e.g. the
+            // operations indicator) can tell long-running ops apart from ops that
+            // are merely awaiting their HTTP response
+            setExecutingEditOperations((ops) => (ops ?? []).map((x) => (x.id === op.id ? returnedOp : x)));
+        }
         return returnedOp;
     }, []);
     const duplicateComponents = useCallback(({ componentIds }) => {
@@ -288,6 +291,9 @@ export function getOperationsContext(state, ui) {
         else
             stateRef.current.requestRefresh("immediate");
     }, []);
+    const refreshWorkboxAfterWorkflowChange = useDebouncedCallback(() => {
+        stateRef.current.refreshWorkbox?.();
+    }, 300, { trailing: true });
     const executeWorkflowCommandAndRefresh = useCallback(async (item, commandId) => {
         const result = await executeWorkflowCommand(item, commandId, "");
         if (result.type === "success") {
@@ -298,9 +304,12 @@ export function getOperationsContext(state, ui) {
                 };
                 ui.showErrorToast(errorMessage);
             }
+            if (result.data.succeeded) {
+                refreshWorkboxAfterWorkflowChange();
+            }
             stateRef.current.requestRefresh("immediate");
         }
-    }, [ui]);
+    }, [refreshWorkboxAfterWorkflowChange, ui]);
     const renameItem = useCallback(async (item, newName) => {
         await executeOp({
             type: "rename-item",
@@ -382,6 +391,7 @@ export function getOperationsContext(state, ui) {
                 user: stateRef.current.user,
                 itemsRepository: itemsRepository,
                 comments: stateRef.current.comments,
+                commentsLoaded: stateRef.current.commentsLoaded,
                 suggestedEdits: stateRef.current.suggestedEdits,
                 setSuggestedEdits: stateRef.current.setSuggestedEdits,
             });
@@ -412,10 +422,14 @@ export function getOperationsContext(state, ui) {
                     // Update the suggested edits state with the result from the server
                     if (result.type === "success" && result.data) {
                         const updatedEdit = result.data;
-                        if (removedSuggestedEditIds.has(updatedEdit.id)) {
+                        if (isSuggestedEditRemoved(updatedEdit.id)) {
                             // Reverted to a no-op while this save was in flight; make sure
                             // it stays gone on the server and do not re-add it locally.
-                            void deleteSuggestedEdit(updatedEdit).catch(() => undefined);
+                            void deleteSuggestedEdit(updatedEdit).then((deleteResult) => {
+                                if (deleteResult.type !== "success") {
+                                    console.warn("Failed to delete reverted suggestion after save:", deleteResult.summary, deleteResult.details);
+                                }
+                            }, () => undefined);
                             return result;
                         }
                         stateRef.current.setSuggestedEdits((current) => upsertSuggestedEdit(current, updatedEdit, {
@@ -425,11 +439,15 @@ export function getOperationsContext(state, ui) {
                     }
                     else if (result.type === "error" ||
                         result.type === "unauthorized") {
-                        // Show error toast for failed suggested edit save
-                        ui.showErrorToast({
-                            summary: result.summary || "Failed to save suggestion",
-                            details: result.details,
-                        });
+                        // Show error toast for failed suggested edit save — unless the
+                        // suggestion was reverted while the request was in flight, in
+                        // which case there is nothing for the user to see or retry.
+                        if (!isSuggestedEditRemoved(saveSnapshot.id)) {
+                            ui.showErrorToast({
+                                summary: result.summary || "Failed to save suggestion",
+                                details: result.details,
+                            });
+                        }
                     }
                     return result;
                 })
@@ -515,6 +533,10 @@ export function getOperationsContext(state, ui) {
             // Don't refresh here - the websocket handler will trigger a refresh when
             // it receives the item-changed notification from the server. This avoids
             // duplicate refresh calls for the same edit.
+            if (result.executionStatus !== "failed" &&
+                isWorkflowMetadataField(op.fieldId, op.fieldName)) {
+                refreshWorkboxAfterWorkflowChange();
+            }
             itemsRepository.onFieldSaved(field, val, saveSequence || 0, fieldModificationStore);
         }
         catch (error) {
@@ -523,7 +545,7 @@ export function getOperationsContext(state, ui) {
             console.error("[editFieldImmediate] Error saving field:", error);
             itemsRepository.clearDirtyState(field, fieldModificationStore);
         }
-    }, [itemsRepository, executeOp]);
+    }, [itemsRepository, executeOp, refreshWorkboxAfterWorkflowChange]);
     const executeEditFieldDebounced = useDebouncedCallback(async ({ field, value, rawValue, refresh, saveSequence, fieldModificationStore, }) => {
         // Fix: Use the saveSequence passed from editField instead of calling
         // updateFieldValue again. This prevents the race condition where the
@@ -1367,19 +1389,14 @@ export function getOperationsContext(state, ui) {
                 const terminal = await waitForEditOperationTerminal(cloneResult.id, 120_000);
                 cloneResult = { ...cloneResult, ...terminal };
             }
-            catch (e) {
-                ui.showErrorToast({
-                    summary: "Clone failed",
-                    details: e?.message || "Operation timed out",
-                });
+            catch {
+                // No terminal message within the timeout; the central lifecycle
+                // toast keeps tracking the operation
                 return [];
             }
         }
         if (cloneResult?.errorMessage) {
-            ui.showErrorToast({
-                summary: "Clone failed",
-                details: cloneResult.errorMessage,
-            });
+            // operation:failed already produced the central error toast
             return [];
         }
         if (cloneResult?.createdItemIds) {
@@ -1390,7 +1407,7 @@ export function getOperationsContext(state, ui) {
             }));
         }
         return [];
-    }, [executeOp, ui]);
+    }, [executeOp]);
     const duplicateItem = useCallback(async (item, target, name) => {
         // Use generic edit endpoint for long-running operation support
         // Duplicate is a copy to the same parent, positioned after the original
@@ -1411,19 +1428,14 @@ export function getOperationsContext(state, ui) {
                 const terminal = await waitForEditOperationTerminal(copyResult.id, 120_000);
                 copyResult = { ...copyResult, ...terminal };
             }
-            catch (e) {
-                ui.showErrorToast({
-                    summary: "Duplicate failed",
-                    details: e?.message || "Operation timed out",
-                });
+            catch {
+                // No terminal message within the timeout; the central lifecycle
+                // toast keeps tracking the operation
                 return;
             }
         }
         if (copyResult.errorMessage) {
-            ui.showErrorToast({
-                summary: "Duplicate failed",
-                details: copyResult.errorMessage,
-            });
+            // operation:failed already produced the central error toast
             return;
         }
         itemsRepository.refreshItems([target]);
@@ -1436,7 +1448,7 @@ export function getOperationsContext(state, ui) {
             };
         }
         return undefined;
-    }, [executeOp, itemsRepository, ui]);
+    }, [executeOp, itemsRepository]);
     const publishItem = useCallback(async (operation) => {
         const result = (await executeOp(operation, {
             refresh: "immediate",
@@ -1509,11 +1521,32 @@ export function getOperationsContext(state, ui) {
     // This prevents fields from getting stuck in "saving" state when navigating away
     const cleanup = useCallback(() => {
         executeEditFieldDebounced.flush();
-    }, []);
+        refreshWorkboxAfterWorkflowChange.cancel();
+    }, [executeEditFieldDebounced, refreshWorkboxAfterWorkflowChange]);
     // Function to mark an operation as no longer executing
     // Called when WebSocket receives operation:completed or operation:failed
     const markOperationComplete = useCallback((operationId) => {
-        setExecutingEditOperations((ops) => ops ? ops.filter((x) => x.id !== operationId) : []);
+        const key = normalizeOpId(operationId);
+        setExecutingEditOperations((ops) => ops ? ops.filter((x) => normalizeOpId(x.id) !== key) : []);
+    }, []);
+    // Upsert a long-running operation reported by the WebSocket. Covers ops
+    // started in another tab of the same user, which never pass through
+    // executeOp in this tab.
+    const addExecutingOperation = useCallback((operation) => {
+        const key = normalizeOpId(operation.id);
+        setExecutingEditOperations((ops) => {
+            const list = ops ?? [];
+            const existing = list.find((x) => normalizeOpId(x.id) === key);
+            if (existing) {
+                return list.map((x) => normalizeOpId(x.id) === key ? { ...x, ...operation } : x);
+            }
+            return [...list, operation];
+        });
+    }, []);
+    // Live progress for an executing operation (from operation:progress messages)
+    const updateExecutingOperationProgress = useCallback((operationId, progress, statusMessage) => {
+        const key = normalizeOpId(operationId);
+        setExecutingEditOperations((ops) => (ops ?? []).map((x) => normalizeOpId(x.id) === key ? { ...x, progress, statusMessage } : x));
     }, []);
     return useMemo(() => ({
         ops,
@@ -1521,40 +1554,46 @@ export function getOperationsContext(state, ui) {
             editOperationExecuted,
             executingEditOperations,
             markOperationComplete,
+            addExecutingOperation,
+            updateExecutingOperationProgress,
         },
         cleanup,
     }), [
         executingEditOperations,
         editOperationExecuted,
         markOperationComplete,
+        addExecutingOperation,
+        updateExecutingOperationProgress,
         ops,
         cleanup,
     ]);
 }
-function removeSuggestedEditFromState(edit, state, pendingFieldKey) {
-    // Mark as removed first so any in-flight debounced save neither re-creates the
+function removeSuggestedEditFromState(edit, state, keys) {
+    // Tombstone first so any in-flight debounced save neither re-creates the
     // suggestion on the server nor re-adds it to local state via its save-ack.
-    removedSuggestedEditIds.add(edit.id);
-    const saveKey = `${edit.itemId}:${edit.mainItemLanguage}:${edit.mainItemVersion}:${edit.fieldId}`;
-    const pendingSave = pendingSuggestedEditSaves.get(saveKey);
-    pendingSuggestedEdits.delete(pendingFieldKey);
+    // The tombstone is permanent for the session: a save scheduled while this
+    // removal is settling (e.g. an edit queued behind the in-flight save) would
+    // otherwise fire after an early release and resurrect the suggestion.
+    markSuggestedEditRemoved(edit.id);
+    // The saves map is keyed by the field's own item descriptor (which can have
+    // a different version/language than the page the suggestion is stored
+    // under), so the caller passes the exact keys it used.
+    const pendingSave = pendingSuggestedEditSaves.get(keys.saveKey);
+    pendingSuggestedEdits.delete(keys.pendingFieldKey);
     cleanupPendingSuggestedEditOperations(edit, state.user);
-    const nextSuggestedEdits = state.suggestedEdits.filter((candidate) => candidate.id !== edit.id);
-    state.suggestedEdits = nextSuggestedEdits;
-    state.setSuggestedEdits(nextSuggestedEdits);
+    state.setSuggestedEdits((current) => current.filter((candidate) => candidate.id !== edit.id));
     // Delete on the server only after any in-flight save settles, otherwise the
     // delete can race ahead of a pending create and the suggestion comes back.
-    // Once that latest save has resolved, all earlier debounced timers for this
-    // field have already fired and checked the removed set, so the id can be
-    // dropped to keep the set from growing unbounded over a long session.
     void Promise.resolve(pendingSave)
         .catch(() => undefined)
         .then(() => deleteSuggestedEdit(edit))
+        .then((result) => {
+        if (result.type !== "success") {
+            console.warn("Failed to delete no-op suggestion:", result.summary, result.details);
+        }
+    })
         .catch((error) => {
         console.warn("Failed to delete no-op suggestion:", error);
-    })
-        .finally(() => {
-        removedSuggestedEditIds.delete(edit.id);
     });
 }
 function getSuggestionCommentCount(edit, state) {
@@ -1578,14 +1617,37 @@ async function getOrMergeSuggestedEditOp(field, rawValue, value, state) {
     if (!pageDescriptor) {
         return;
     }
-    // Create a unique key for this field to check for pending edits
-    const fieldKey = `${field.item.id}:${field.item.language}:${field.item.version}:${field.fieldId}:${state.user?.name || "unknown"}`;
-    // First check if there's a pending suggested edit for this field
-    const pendingEdit = pendingSuggestedEdits.get(fieldKey);
+    // Keys for the per-field bookkeeping maps. The saves map must use the same
+    // key format as editField (the field's own item descriptor — NOT the
+    // suggestion's mainItem fields, which hold the page's language/version and
+    // diverge for datasource items).
+    const saveKey = `${field.item.id}:${field.item.language}:${field.item.version}:${field.fieldId}`;
+    const fieldKey = `${saveKey}:${state.user?.name || "unknown"}`;
+    const shouldRemoveAsNoOp = (edit, nextValue) => 
+    // Comments load asynchronously; deleting on the strength of a not-yet-
+    // loaded comments array would destroy another reviewer's thread (the
+    // server cascade-deletes a suggestion's comments along with it).
+    state.commentsLoaded === true &&
+        shouldRemoveNoOpSuggestion(edit.oldValue, nextValue, () => getSuggestionCommentCount(edit, state)) &&
+        // Only auto-remove when the typed value is also a no-op against the
+        // field's live value: if the field changed underneath the suggestion, the
+        // typed content still differs from the page and must stay recorded.
+        !hasSuggestionContentChange(fieldItem.rawValue, nextValue);
+    // First check if there's a pending suggested edit for this field. A draft
+    // whose suggestion was already reverted must not be revived — a new edit
+    // mints a fresh suggestion instead.
+    let pendingEdit = pendingSuggestedEdits.get(fieldKey);
+    if (pendingEdit && isSuggestedEditRemoved(pendingEdit.id)) {
+        pendingSuggestedEdits.delete(fieldKey);
+        pendingEdit = undefined;
+    }
     if (pendingEdit) {
         const nextValue = newVal || "";
-        if (shouldRemoveNoOpSuggestion(pendingEdit.oldValue, nextValue, getSuggestionCommentCount(pendingEdit, state))) {
-            removeSuggestedEditFromState(pendingEdit, state, fieldKey);
+        if (shouldRemoveAsNoOp(pendingEdit, nextValue)) {
+            removeSuggestedEditFromState(pendingEdit, state, {
+                pendingFieldKey: fieldKey,
+                saveKey,
+            });
             return;
         }
         // Update the pending edit instead of creating a new one.
@@ -1596,9 +1658,7 @@ async function getOrMergeSuggestedEditOp(field, rawValue, value, state) {
             updatedBy: state.user?.name || "unknown",
         };
         pendingSuggestedEdits.set(fieldKey, updatedEdit);
-        const nextSuggestedEdits = upsertSuggestedEdit(state.suggestedEdits, updatedEdit, { source: "local" });
-        state.suggestedEdits = nextSuggestedEdits;
-        state.setSuggestedEdits(nextSuggestedEdits);
+        state.setSuggestedEdits((current) => upsertSuggestedEdit(current, updatedEdit, { source: "local" }));
         return updatedEdit;
     }
     const matchingSuggestions = state.suggestedEdits.filter((edit) => edit.mainItemId === pageDescriptor.id &&
@@ -1606,17 +1666,24 @@ async function getOrMergeSuggestedEditOp(field, rawValue, value, state) {
         edit.itemId === item.id &&
         edit.fieldId === field.fieldId);
     // Attempt to find an existing suggested edit by the same user for this field.
+    // Tombstoned ids are skipped: the state snapshot can still contain a
+    // suggestion that was just reverted, and reusing its id would tie the new
+    // edit to a save pipeline that permanently ignores it.
     const existing = matchingSuggestions.find((edit) => edit.mainItemId === pageDescriptor.id &&
         edit.mainItemLanguage === pageDescriptor.language &&
         edit.mainItemVersion === pageDescriptor.version &&
         edit.itemId === item.id &&
         edit.fieldId === field.fieldId &&
         edit.author === (state.user?.name || "unknown") &&
-        edit.status === "pending");
+        edit.status === "pending" && // or any status that indicates it's open for further editing.
+        !isSuggestedEditRemoved(edit.id));
     if (existing) {
         const nextValue = newVal || "";
-        if (shouldRemoveNoOpSuggestion(existing.oldValue, nextValue, getSuggestionCommentCount(existing, state))) {
-            removeSuggestedEditFromState(existing, state, fieldKey);
+        if (shouldRemoveAsNoOp(existing, nextValue)) {
+            removeSuggestedEditFromState(existing, state, {
+                pendingFieldKey: fieldKey,
+                saveKey,
+            });
             return;
         }
         // Update the existing suggestion.
@@ -1626,10 +1693,7 @@ async function getOrMergeSuggestedEditOp(field, rawValue, value, state) {
             updated: new Date().toISOString(),
             updatedBy: state.user?.name || "unknown",
         };
-        const nextSuggestedEdits = upsertSuggestedEdit(state.suggestedEdits, updatedEdit, { source: "local" });
-        state.suggestedEdits = nextSuggestedEdits;
-        // Optionally, you might update the comments or other fields.
-        state.setSuggestedEdits(nextSuggestedEdits);
+        state.setSuggestedEdits((current) => upsertSuggestedEdit(current, updatedEdit, { source: "local" }));
         return updatedEdit;
     }
     else {
@@ -1657,11 +1721,7 @@ async function getOrMergeSuggestedEditOp(field, rawValue, value, state) {
         };
         // Add to pending edits to prevent race conditions
         pendingSuggestedEdits.set(fieldKey, newEdit);
-        const nextSuggestedEdits = upsertSuggestedEdit(state.suggestedEdits, newEdit, {
-            source: "local",
-        });
-        state.suggestedEdits = nextSuggestedEdits;
-        state.setSuggestedEdits(nextSuggestedEdits);
+        state.setSuggestedEdits((current) => upsertSuggestedEdit(current, newEdit, { source: "local" }));
         return newEdit;
     }
 }