@parhelia/core 0.3.12771 → 0.3.12788

package/dist/editor/client/operations.js

@@ -14,6 +14,7 @@ import { copyItemsNeedsTerminalCompletion, normalizeOpId, waitForEditOperationTe
 import { isWorkflowMetadataField } from "../workflowFields";
 import { ExternalChangesWarningContent, TreeOperationConfirmContent, UndoDifferentItemContent, } from "./OperationDialogContent";
 import { isSuggestedEditRemoved, markSuggestedEditRemoved, upsertSuggestedEdit, } from "../reviews/suggestedEditState";
+import { preferLatestLocalUndoTarget } from "./undoTargetResolution";
 import { logFieldValueDiagnostic, summarizeFieldDescriptor, summarizeFieldValue, } from "../fieldValueDiagnostics";
 import { getSuggestedEditItemLanguage, getSuggestedEditItemVersion, getSuggestionFieldIdentityKey, } from "../reviews/suggestionDisplayValue";
 import { enqueueSuggestedEditFieldTask, waitForSuggestedEditFieldTasks, } from "./suggestedEditFieldQueue";
@@ -21,9 +22,10 @@ import { enqueueSuggestedEditFieldTask, waitForSuggestedEditFieldTasks, } from "
 const ENABLE_HARD_DELETE_IN_DELETE_DIALOG = false;
 // Track pending suggested edits to prevent creating duplicates before server response
 const pendingSuggestedEdits = new Map();
+const persistedSuggestedEditVersions = new Map();
 const SUGGESTED_EDIT_SAVE_DEBOUNCE_MS = 500;
 const FIELD_LOCK_REQUEST_TIMEOUT_MS = 10_000;
-function createDelayedSuggestedEditSave(suggestedEdit) {
+function createDelayedSuggestedEditSave(suggestedEdit, expectedUpdated) {
     return new Promise((resolve, reject) => {
         globalThis.setTimeout(() => {
             if (isSuggestedEditRemoved(suggestedEdit.id)) {
@@ -32,7 +34,23 @@ function createDelayedSuggestedEditSave(suggestedEdit) {
                 resolve({ type: "ignored" });
                 return;
             }
-            createOrUpdateSuggestedEdit(suggestedEdit).then(resolve, reject);
+            const save = async () => {
+                const result = await createOrUpdateSuggestedEdit(suggestedEdit, {
+                    expectedUpdated,
+                });
+                if (!expectedUpdated &&
+                    result.type === "conflict" &&
+                    result.summary ===
+                        "expectedUpdated is required when updating a suggestion." &&
+                    result.suggestion?.id === suggestedEdit.id &&
+                    result.suggestion.updated) {
+                    return createOrUpdateSuggestedEdit(suggestedEdit, {
+                        expectedUpdated: result.suggestion.updated,
+                    });
+                }
+                return result;
+            };
+            save().then(resolve, reject);
         }, SUGGESTED_EDIT_SAVE_DEBOUNCE_MS);
     });
 }
@@ -80,14 +98,18 @@ function fieldsMatchForLock(left, right) {
 // Helper function to clean up pending operations for a deleted suggested edit
 export function cleanupPendingSuggestedEditOperations(suggestedEdit, user) {
     const userKey = user?.name || "unknown";
-    const pendingFieldKey = `${getSuggestionFieldIdentityKey({
+    const saveKey = getSuggestionFieldIdentityKey({
         itemId: suggestedEdit.itemId,
         language: getSuggestedEditItemLanguage(suggestedEdit),
         version: getSuggestedEditItemVersion(suggestedEdit),
         fieldId: suggestedEdit.fieldId,
-    })}:${userKey}`;
+    });
+    const pendingFieldKey = `${saveKey}:${userKey}`;
     // Remove from pending operations
     pendingSuggestedEdits.delete(pendingFieldKey);
+    if (persistedSuggestedEditVersions.get(saveKey)?.id === suggestedEdit.id) {
+        persistedSuggestedEditVersions.delete(saveKey);
+    }
 }
 export async function waitForPendingSuggestedEditSave(suggestedEdit) {
     const saveKey = getSuggestionFieldIdentityKey({
@@ -103,6 +125,13 @@ export function getOperationsContext(state, ui) {
     const [executingEditOperations, setExecutingEditOperations] = useState([]);
     const lastOp = useRef(undefined);
     const undoing = useRef(false);
+    // The most recent locally executed operation the server confirmed as
+    // undoable. The toolbar resolves its undo target from date-sorted history
+    // state, which can lag behind a just-completed save (inline-typing saves
+    // commit asynchronously and reach the history via save-ack/websocket
+    // merges); this snapshot lets the undo gesture target the operation the
+    // user actually created last instead of a stale history top.
+    const latestLocalUndoableOp = useRef(undefined);
     // 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());
@@ -156,7 +185,6 @@ export function getOperationsContext(state, ui) {
     const executeOp = useCallback(async (op, options = {
         refresh: "immediate",
     }) => {
-        console.log("Executing op", op);
         const removedComponentIds = getRemovedComponentIds(op);
         let keepRemovingIndicatorsUntilSocketCompletion = false;
         if (removedComponentIds.length > 0) {
@@ -178,6 +206,12 @@ export function getOperationsContext(state, ui) {
             //stateRef.current.addToEditHistory(result.data as EditOperation);
             const returnedOp = result.data;
             setEditOperationExecuted(returnedOp);
+            if (returnedOp.canUndo &&
+                !returnedOp.undone &&
+                returnedOp.executionStatus !== "executing" &&
+                returnedOp.executionStatus !== "failed") {
+                latestLocalUndoableOp.current = returnedOp;
+            }
             keepRemovingIndicatorsUntilSocketCompletion =
                 returnedOp.executionStatus === "executing";
             // Only remove from executing operations if it's not a long-running operation
@@ -516,16 +550,6 @@ export function getOperationsContext(state, ui) {
     }, []);
     const editField = useCallback(async ({ field, value, rawValue, forceMode, refresh = "immediate", originatingSlotId, }) => {
         const effectiveMode = forceMode ?? stateRef.current.mode;
-        logFieldValueDiagnostic("operations", "editField requested", {
-            field: summarizeFieldDescriptor(field),
-            value: summarizeFieldValue(value),
-            rawValue: summarizeFieldValue(rawValue),
-            forceMode,
-            effectiveMode,
-            refresh,
-            originatingSlotId,
-            undoing: undoing.current,
-        });
         fieldEditGeneration.current += 1;
         if (effectiveMode === "suggestions" &&
             (stateRef.current.page || stateRef.current.currentItemDescriptor)) {
@@ -564,11 +588,29 @@ export function getOperationsContext(state, ui) {
                 // promise that resolves after the delayed save completes.
                 const saveSnapshot = { ...op };
                 const expectedNewValue = saveSnapshot.newValue;
-                const savePromise = enqueueSuggestedEditFieldTask(fieldKey, () => createDelayedSuggestedEditSave(saveSnapshot))
+                const savePromise = enqueueSuggestedEditFieldTask(fieldKey, () => {
+                    // Input handlers may prepare several snapshots before React state
+                    // receives the first save acknowledgement. Read the durable
+                    // server-issued version at execution time so every queued save is
+                    // based on the immediately preceding one.
+                    const persistedVersion = persistedSuggestedEditVersions.get(fieldKey);
+                    const snapshotForSave = persistedVersion?.id === saveSnapshot.id
+                        ? { ...saveSnapshot, updated: persistedVersion.updated }
+                        : saveSnapshot;
+                    return createDelayedSuggestedEditSave(snapshotForSave, persistedVersion?.id === saveSnapshot.id
+                        ? persistedVersion.updated
+                        : undefined);
+                })
                     .then((result) => {
                     // Update the suggested edits state with the result from the server
                     if (result.type === "success" && result.data) {
                         const updatedEdit = result.data;
+                        if (updatedEdit.updated) {
+                            persistedSuggestedEditVersions.set(fieldKey, {
+                                id: updatedEdit.id,
+                                updated: updatedEdit.updated,
+                            });
+                        }
                         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.
@@ -586,6 +628,12 @@ export function getOperationsContext(state, ui) {
                     }
                     else if (result.type === "conflict") {
                         if (result.suggestion) {
+                            if (result.suggestion.updated) {
+                                persistedSuggestedEditVersions.set(fieldKey, {
+                                    id: result.suggestion.id,
+                                    updated: result.suggestion.updated,
+                                });
+                            }
                             stateRef.current.setSuggestedEdits((current) => upsertSuggestedEdit(current, result.suggestion, {
                                 source: "save-ack",
                             }));
@@ -635,15 +683,6 @@ export function getOperationsContext(state, ui) {
             ai: false,
             agentId: undefined,
         }, true, value, rawValue, fieldModificationStore);
-        logFieldValueDiagnostic("operations", "local field value updated", {
-            field: summarizeFieldDescriptor(field),
-            value: summarizeFieldValue(value),
-            rawValue: summarizeFieldValue(rawValue),
-            saveSequence,
-            refresh,
-            originatingSlotId,
-            hasFieldModificationStore: !!fieldModificationStore,
-        });
         if (refresh === "immediate") {
             logFieldValueDiagnostic("operations", "saving immediately", {
                 field: summarizeFieldDescriptor(field),
@@ -663,21 +702,10 @@ export function getOperationsContext(state, ui) {
             lastEditField.current?.item?.language !== field.item?.language ||
             lastEditField.current?.item?.version !== field.item?.version;
         if (isNewField) {
-            logFieldValueDiagnostic("operations", "flushing previous field debounce", {
-                previousField: summarizeFieldDescriptor(lastEditField.current),
-                nextField: summarizeFieldDescriptor(field),
-            });
             executeEditFieldDebounced.flush();
         }
         lastEditField.current = field;
         // Fix: Pass the saveSequence to avoid calling updateFieldValue twice
-        logFieldValueDiagnostic("operations", "queueing debounced save", {
-            field: summarizeFieldDescriptor(field),
-            value: summarizeFieldValue(value),
-            rawValue: summarizeFieldValue(rawValue),
-            refresh,
-            saveSequence,
-        });
         return executeEditFieldDebounced({
             field,
             value,
@@ -696,15 +724,6 @@ export function getOperationsContext(state, ui) {
         const val = rawValue !== undefined ? rawValue : value;
         if (val === undefined)
             return;
-        logFieldValueDiagnostic("operations", "editFieldImmediate start", {
-            field: summarizeFieldDescriptor(field),
-            value: summarizeFieldValue(value),
-            rawValue: summarizeFieldValue(rawValue),
-            persistedValue: summarizeFieldValue(val),
-            refresh,
-            saveSequence,
-            hasFieldModificationStore: !!fieldModificationStore,
-        });
         const op = await getEditOP(field, rawValue, value);
         // Fix: Handle getEditOP returning undefined (item/field not found)
         // Clear dirty state so the field doesn't get stuck in "saving" state
@@ -721,14 +740,6 @@ export function getOperationsContext(state, ui) {
         }
         try {
             const result = await executeOp(op, { refresh });
-            logFieldValueDiagnostic("operations", "editFieldImmediate result", {
-                field: summarizeFieldDescriptor(field),
-                opId: op.id,
-                executionStatus: result?.executionStatus,
-                refresh,
-                saveSequence,
-                persistedValue: summarizeFieldValue(val),
-            });
             // Fix: Check if the operation actually succeeded
             // If result is undefined/null, the operation likely failed
             if (!result) {
@@ -772,14 +783,6 @@ export function getOperationsContext(state, ui) {
         // Fix: Use the saveSequence passed from editField instead of calling
         // updateFieldValue again. This prevents the race condition where the
         // field gets marked dirty twice with different sequences.
-        logFieldValueDiagnostic("operations", "debounced save executing", {
-            field: summarizeFieldDescriptor(field),
-            value: summarizeFieldValue(value),
-            rawValue: summarizeFieldValue(rawValue),
-            refresh,
-            saveSequence,
-            hasFieldModificationStore: !!fieldModificationStore,
-        });
         return enqueueFieldSave(field, () => editFieldImmediate({
             field,
             value,
@@ -879,6 +882,9 @@ export function getOperationsContext(state, ui) {
             for (const executedOp of result.data) {
                 recentlyUndoneIds.current.add(executedOp.id);
                 recentlyRedoneIds.current.delete(executedOp.id);
+                if (latestLocalUndoableOp.current?.id === executedOp.id) {
+                    latestLocalUndoableOp.current = undefined;
+                }
             }
             // Check if any operations are executing in background (long-running undo)
             const executingOps = result.data.filter((x) => x.executionStatus === "executing");
@@ -973,6 +979,20 @@ export function getOperationsContext(state, ui) {
             if (pendingFieldOperationId) {
                 operationId = pendingFieldOperationId;
             }
+            else {
+                // The toolbar/keyboard gesture resolves its target from history
+                // state that may not include a save that just completed. Prefer the
+                // most recent locally executed undoable operation over a stale
+                // target (a genuinely newer target from another tab/user wins).
+                operationId = preferLatestLocalUndoTarget({
+                    requestedOperationId: operationId,
+                    latestLocalOperation: latestLocalUndoableOp.current,
+                    editHistory: stateRef.current.editHistory,
+                    recentlyUndoneIds: recentlyUndoneIds.current,
+                    historyMode: stateRef.current.historyMode,
+                    currentItem: stateRef.current.item?.descriptor,
+                });
+            }
             const currentItem = stateRef.current.item?.descriptor;
             const filterBySession = stateRef.current.showOnlyMyChanges;
             const historyMode = stateRef.current.historyMode;
@@ -1214,6 +1234,10 @@ export function getOperationsContext(state, ui) {
             for (const executedOp of result.data) {
                 recentlyRedoneIds.current.add(executedOp.id);
                 recentlyUndoneIds.current.delete(executedOp.id);
+                // A redone operation is the newest undoable operation again.
+                if (executedOp.canUndo && !executedOp.undone) {
+                    latestLocalUndoableOp.current = executedOp;
+                }
             }
             // Check if the operation is executing in background (long-running redo)
             const executingOps = result.data.filter((x) => x.executionStatus === "executing");
@@ -1545,7 +1569,8 @@ export function getOperationsContext(state, ui) {
             id: uuid(),
             title: `Moving ${items.length} item(s)...`,
         };
-        await executeOp(op);
+        const result = await executeOp(op);
+        return result?.executionStatus !== "failed";
     }, [executeOp]);
     const createItem = useCallback(async (parent, templateId, name) => {
         const op = {
@@ -1663,7 +1688,7 @@ export function getOperationsContext(state, ui) {
         }
         return [];
     }, [executeOp]);
-    const duplicateItem = useCallback(async (item, target, name) => {
+    const duplicateItem = useCallback(async (item, target, name, options) => {
         // Use generic edit endpoint for long-running operation support
         // Duplicate is a copy to the same parent, positioned after the original
         const op = {
@@ -1676,6 +1701,7 @@ export function getOperationsContext(state, ui) {
             id: uuid(),
             title: `Duplicating item...`,
             name, // Pass the user-provided name to the backend
+            copyChildren: options?.copyChildren ?? true,
         };
         let copyResult = (await executeOp(op));
         if (copyItemsNeedsTerminalCompletion(copyResult)) {
@@ -1925,7 +1951,6 @@ async function getOrMergeSuggestedEditOp(field, rawValue, value, state) {
             itemLanguage: field.item.language,
             itemVersion: field.item.version,
             newValue: nextValue,
-            updated: new Date().toISOString(),
             updatedBy: state.user?.name || "unknown",
         };
         pendingSuggestedEdits.set(fieldKey, updatedEdit);
@@ -1969,7 +1994,6 @@ async function getOrMergeSuggestedEditOp(field, rawValue, value, state) {
             itemLanguage: field.item.language,
             itemVersion: field.item.version,
             newValue: nextValue,
-            updated: new Date().toISOString(),
             updatedBy: state.user?.name || "unknown",
         };
         state.setSuggestedEdits((current) => upsertSuggestedEdit(current, updatedEdit, { source: "local" }));