@elytracms/studio 0.0.42 → 0.0.44

package/dist/components/cms/use-restore-version.d.ts

@@ -0,0 +1,57 @@
+import type { QueryKey } from '@tanstack/react-query';
+import type { CmsDocument, DocumentRef, RestoreScope } from '@elytracms/core/cms-core';
+import type { CollectionViewSource } from '@elytracms/studio/lib/collection-view/collection-view-source';
+/**
+ * EC-325 — the version-restore sequence, single-sourced. The Versions pane's
+ * per-version restore, the Compare view's scoped/whole restore, and the header's
+ * "Discard changes" (a whole-document restore of the pinned published version)
+ * all ran their OWN copy of the identical four steps:
+ *
+ *   1. flush a dirty in-memory buffer FIRST (`flushDirtyDraft`) — `documents.restore`
+ *      snapshots whatever is currently PERSISTED as its pre-restore version, so an
+ *      edit still in the autosave debounce window must reach the server before the
+ *      restore reads it, or it is silently unrecoverable (the undo-guarantee gap
+ *      the Discard path used to have);
+ *   2. `versioning.restore(ref, version, scope?)` — scope absent ⇒ whole document
+ *      (`documents.restore` reads `scope ?? { kind: 'all' }`, so an omitted scope
+ *      and `{ kind: 'all' }` are the same restore);
+ *   3. adopt the restored draft into the open editor (`replaceDraft`);
+ *   4. invalidate the shared version-history cache key so the history re-reads.
+ *
+ * The pure {@link performRestore} pins that ordering (unit-tested with spies); the
+ * {@link useRestoreVersion} hook wraps it with the per-call-site busy flag and the
+ * operations cache. The differing signatures reconcile to `(version, scope?)`:
+ * whole-document callers pass no scope, the Compare view passes its `RestoreScope`,
+ * and Discard passes the pinned published version with `{ kind: 'all' }`.
+ */
+export declare function performRestore(input: {
+    dirty: boolean;
+    save: () => void;
+    restore: (version: number, scope?: RestoreScope) => Promise<CmsDocument | null>;
+    replaceDraft: (doc: CmsDocument) => void;
+    invalidate: () => Promise<void>;
+    version: number;
+    scope?: RestoreScope;
+}): Promise<void>;
+/** Dependencies the restore sequence reads from its call site's editor state. */
+export interface RestoreVersionDeps {
+    source: CollectionViewSource;
+    docRef: DocumentRef;
+    /** The shared version-history cache key ({@link documentVersionsKey}). */
+    versionKey: QueryKey;
+    /** Is the in-memory draft dirty (an unsaved buffer to flush first)? */
+    dirty: boolean;
+    /** Persist the current draft buffer. */
+    save: () => void;
+    /** Adopt the restored snapshot as the open editor's draft. */
+    replaceDraft: (doc: CmsDocument) => void;
+}
+/**
+ * The shared restore action + its in-flight flag. `restore(version, scope?)`
+ * runs the {@link performRestore} sequence; `busy` gates the calling surface's
+ * restore/discard controls while it round-trips.
+ */
+export declare function useRestoreVersion(deps: RestoreVersionDeps): {
+    restore: (version: number, scope?: RestoreScope) => Promise<void>;
+    busy: boolean;
+};

package/dist/components/cms/use-restore-version.js

@@ -0,0 +1,66 @@
+import { useCallback, useState } from 'react';
+import { useOperationCache } from '@elytracms/studio/lib/query';
+import { flushDirtyDraft } from './discard-draft';
+/**
+ * EC-325 — the version-restore sequence, single-sourced. The Versions pane's
+ * per-version restore, the Compare view's scoped/whole restore, and the header's
+ * "Discard changes" (a whole-document restore of the pinned published version)
+ * all ran their OWN copy of the identical four steps:
+ *
+ *   1. flush a dirty in-memory buffer FIRST (`flushDirtyDraft`) — `documents.restore`
+ *      snapshots whatever is currently PERSISTED as its pre-restore version, so an
+ *      edit still in the autosave debounce window must reach the server before the
+ *      restore reads it, or it is silently unrecoverable (the undo-guarantee gap
+ *      the Discard path used to have);
+ *   2. `versioning.restore(ref, version, scope?)` — scope absent ⇒ whole document
+ *      (`documents.restore` reads `scope ?? { kind: 'all' }`, so an omitted scope
+ *      and `{ kind: 'all' }` are the same restore);
+ *   3. adopt the restored draft into the open editor (`replaceDraft`);
+ *   4. invalidate the shared version-history cache key so the history re-reads.
+ *
+ * The pure {@link performRestore} pins that ordering (unit-tested with spies); the
+ * {@link useRestoreVersion} hook wraps it with the per-call-site busy flag and the
+ * operations cache. The differing signatures reconcile to `(version, scope?)`:
+ * whole-document callers pass no scope, the Compare view passes its `RestoreScope`,
+ * and Discard passes the pinned published version with `{ kind: 'all' }`.
+ */
+export async function performRestore(input) {
+    // Step 1 — flush before the restore reads the persisted document.
+    flushDirtyDraft({ dirty: input.dirty, save: input.save });
+    // Step 2 — the restore itself (scope absent ⇒ whole document).
+    const restored = await input.restore(input.version, input.scope);
+    // Step 3 — the open editor adopts the restored snapshot as its new draft.
+    if (restored)
+        input.replaceDraft(restored);
+    // Step 4 — re-read the recorded history (the new pre-restore version appears).
+    await input.invalidate();
+}
+/**
+ * The shared restore action + its in-flight flag. `restore(version, scope?)`
+ * runs the {@link performRestore} sequence; `busy` gates the calling surface's
+ * restore/discard controls while it round-trips.
+ */
+export function useRestoreVersion(deps) {
+    const { source, docRef, versionKey, dirty, save, replaceDraft } = deps;
+    const cache = useOperationCache();
+    const [busy, setBusy] = useState(false);
+    const restore = useCallback(async (version, scope) => {
+        setBusy(true);
+        try {
+            await performRestore({
+                dirty,
+                save,
+                restore: async (v, s) => (await source.versioning?.restore(docRef, v, s)) ?? null,
+                replaceDraft,
+                invalidate: () => cache.invalidate(versionKey),
+                version,
+                scope,
+            });
+        }
+        finally {
+            setBusy(false);
+        }
+    }, [source, docRef, versionKey, dirty, save, replaceDraft, cache]);
+    return { restore, busy };
+}
+//# sourceMappingURL=use-restore-version.js.map

package/dist/components/cms/use-restore-version.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"use-restore-version.js","sourceRoot":"","sources":["../../../src/components/cms/use-restore-version.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,WAAW,EAAE,QAAQ,EAAE,MAAM,OAAO,CAAA;AAG7C,OAAO,EAAE,iBAAiB,EAAE,MAAM,6BAA6B,CAAA;AAE/D,OAAO,EAAE,eAAe,EAAE,MAAM,iBAAiB,CAAA;AAEjD;;;;;;;;;;;;;;;;;;;;;;GAsBG;AACH,MAAM,CAAC,KAAK,UAAU,cAAc,CAAC,KAQpC;IACC,kEAAkE;IAClE,eAAe,CAAC,EAAE,KAAK,EAAE,KAAK,CAAC,KAAK,EAAE,IAAI,EAAE,KAAK,CAAC,IAAI,EAAE,CAAC,CAAA;IACzD,+DAA+D;IAC/D,MAAM,QAAQ,GAAG,MAAM,KAAK,CAAC,OAAO,CAAC,KAAK,CAAC,OAAO,EAAE,KAAK,CAAC,KAAK,CAAC,CAAA;IAChE,0EAA0E;IAC1E,IAAI,QAAQ;QAAE,KAAK,CAAC,YAAY,CAAC,QAAQ,CAAC,CAAA;IAC1C,+EAA+E;IAC/E,MAAM,KAAK,CAAC,UAAU,EAAE,CAAA;AAC1B,CAAC;AAgBD;;;;GAIG;AACH,MAAM,UAAU,iBAAiB,CAAC,IAAwB;IAIxD,MAAM,EAAE,MAAM,EAAE,MAAM,EAAE,UAAU,EAAE,KAAK,EAAE,IAAI,EAAE,YAAY,EAAE,GAAG,IAAI,CAAA;IACtE,MAAM,KAAK,GAAG,iBAAiB,EAAE,CAAA;IACjC,MAAM,CAAC,IAAI,EAAE,OAAO,CAAC,GAAG,QAAQ,CAAC,KAAK,CAAC,CAAA;IACvC,MAAM,OAAO,GAAG,WAAW,CACzB,KAAK,EAAE,OAAe,EAAE,KAAoB,EAAE,EAAE;QAC9C,OAAO,CAAC,IAAI,CAAC,CAAA;QACb,IAAI,CAAC;YACH,MAAM,cAAc,CAAC;gBACnB,KAAK;gBACL,IAAI;gBACJ,OAAO,EAAE,KAAK,EAAE,CAAC,EAAE,CAAC,EAAE,EAAE,CAAC,CAAC,MAAM,MAAM,CAAC,UAAU,EAAE,OAAO,CAAC,MAAM,EAAE,CAAC,EAAE,CAAC,CAAC,CAAC,IAAI,IAAI;gBACjF,YAAY;gBACZ,UAAU,EAAE,GAAG,EAAE,CAAC,KAAK,CAAC,UAAU,CAAC,UAAU,CAAC;gBAC9C,OAAO;gBACP,KAAK;aACN,CAAC,CAAA;QACJ,CAAC;gBAAS,CAAC;YACT,OAAO,CAAC,KAAK,CAAC,CAAA;QAChB,CAAC;IACH,CAAC,EACD,CAAC,MAAM,EAAE,MAAM,EAAE,UAAU,EAAE,KAAK,EAAE,IAAI,EAAE,YAAY,EAAE,KAAK,CAAC,CAC/D,CAAA;IACD,OAAO,EAAE,OAAO,EAAE,IAAI,EAAE,CAAA;AAC1B,CAAC","sourcesContent":["import { useCallback, useState } from 'react'\nimport type { QueryKey } from '@tanstack/react-query'\nimport type { CmsDocument, DocumentRef, RestoreScope } from '@elytracms/core/cms-core'\nimport { useOperationCache } from '@elytracms/studio/lib/query'\nimport type { CollectionViewSource } from '@elytracms/studio/lib/collection-view/collection-view-source'\nimport { flushDirtyDraft } from './discard-draft'\n\n/**\n * EC-325 — the version-restore sequence, single-sourced. The Versions pane's\n * per-version restore, the Compare view's scoped/whole restore, and the header's\n * \"Discard changes\" (a whole-document restore of the pinned published version)\n * all ran their OWN copy of the identical four steps:\n *\n *   1. flush a dirty in-memory buffer FIRST (`flushDirtyDraft`) — `documents.restore`\n *      snapshots whatever is currently PERSISTED as its pre-restore version, so an\n *      edit still in the autosave debounce window must reach the server before the\n *      restore reads it, or it is silently unrecoverable (the undo-guarantee gap\n *      the Discard path used to have);\n *   2. `versioning.restore(ref, version, scope?)` — scope absent ⇒ whole document\n *      (`documents.restore` reads `scope ?? { kind: 'all' }`, so an omitted scope\n *      and `{ kind: 'all' }` are the same restore);\n *   3. adopt the restored draft into the open editor (`replaceDraft`);\n *   4. invalidate the shared version-history cache key so the history re-reads.\n *\n * The pure {@link performRestore} pins that ordering (unit-tested with spies); the\n * {@link useRestoreVersion} hook wraps it with the per-call-site busy flag and the\n * operations cache. The differing signatures reconcile to `(version, scope?)`:\n * whole-document callers pass no scope, the Compare view passes its `RestoreScope`,\n * and Discard passes the pinned published version with `{ kind: 'all' }`.\n */\nexport async function performRestore(input: {\n  dirty: boolean\n  save: () => void\n  restore: (version: number, scope?: RestoreScope) => Promise<CmsDocument | null>\n  replaceDraft: (doc: CmsDocument) => void\n  invalidate: () => Promise<void>\n  version: number\n  scope?: RestoreScope\n}): Promise<void> {\n  // Step 1 — flush before the restore reads the persisted document.\n  flushDirtyDraft({ dirty: input.dirty, save: input.save })\n  // Step 2 — the restore itself (scope absent ⇒ whole document).\n  const restored = await input.restore(input.version, input.scope)\n  // Step 3 — the open editor adopts the restored snapshot as its new draft.\n  if (restored) input.replaceDraft(restored)\n  // Step 4 — re-read the recorded history (the new pre-restore version appears).\n  await input.invalidate()\n}\n\n/** Dependencies the restore sequence reads from its call site's editor state. */\nexport interface RestoreVersionDeps {\n  source: CollectionViewSource\n  docRef: DocumentRef\n  /** The shared version-history cache key ({@link documentVersionsKey}). */\n  versionKey: QueryKey\n  /** Is the in-memory draft dirty (an unsaved buffer to flush first)? */\n  dirty: boolean\n  /** Persist the current draft buffer. */\n  save: () => void\n  /** Adopt the restored snapshot as the open editor's draft. */\n  replaceDraft: (doc: CmsDocument) => void\n}\n\n/**\n * The shared restore action + its in-flight flag. `restore(version, scope?)`\n * runs the {@link performRestore} sequence; `busy` gates the calling surface's\n * restore/discard controls while it round-trips.\n */\nexport function useRestoreVersion(deps: RestoreVersionDeps): {\n  restore: (version: number, scope?: RestoreScope) => Promise<void>\n  busy: boolean\n} {\n  const { source, docRef, versionKey, dirty, save, replaceDraft } = deps\n  const cache = useOperationCache()\n  const [busy, setBusy] = useState(false)\n  const restore = useCallback(\n    async (version: number, scope?: RestoreScope) => {\n      setBusy(true)\n      try {\n        await performRestore({\n          dirty,\n          save,\n          restore: async (v, s) => (await source.versioning?.restore(docRef, v, s)) ?? null,\n          replaceDraft,\n          invalidate: () => cache.invalidate(versionKey),\n          version,\n          scope,\n        })\n      } finally {\n        setBusy(false)\n      }\n    },\n    [source, docRef, versionKey, dirty, save, replaceDraft, cache],\n  )\n  return { restore, busy }\n}\n"]}

package/dist/components/cms/use-save-mode.d.ts

@@ -0,0 +1,35 @@
+import type { CmsDocument } from '@elytracms/core/cms-core';
+import type { CollectionViewSource } from '@elytracms/studio/lib/collection-view/collection-view-source';
+/**
+ * EC-225 / EC-240 — the two persistence disciplines the detail editor supports,
+ * as one pure decision so the autosave scheduler and the unmount flush can never
+ * diverge on WHEN a dirty draft is persisted silently:
+ *
+ * - A **publishing** rail AUTOSAVES: the draft persists 1s after the last edit and
+ *   publish is the deliberate commit — so a dirty draft is flushed both on the
+ *   debounce timer and on unmount (navigating away inside the debounce window).
+ * - A **non-publishing** rail (users, EC-240) SAVES EXPLICITLY: edits stay in the
+ *   draft until the Save button, and an `UnsavedChangesGuard` protects navigation —
+ *   so it NEVER persists silently (returns false here).
+ */
+export declare function shouldPersistDraft(input: {
+    explicitSave: boolean;
+    dirty: boolean;
+}): boolean;
+/**
+ * EC-225 autosave · EC-240 explicit save. Owns the debounced autosave timer and
+ * the unmount flush for a publishing rail; a non-publishing rail persists only via
+ * its Save button (the caller's `UnsavedChangesGuard` covers navigation). Refs let
+ * the unmount flush read the latest values without re-subscribing.
+ *
+ * Returns `explicitSave` — the caller renders the Save button + guard (explicit)
+ * or the autosave status text (autosave) from it.
+ */
+export declare function useSaveMode(input: {
+    canPublish: boolean;
+    dirty: boolean;
+    draft: CmsDocument;
+    source: CollectionViewSource;
+}): {
+    explicitSave: boolean;
+};

package/dist/components/cms/use-save-mode.js

@@ -0,0 +1,54 @@
+import { useEffect, useRef } from 'react';
+/**
+ * EC-225 / EC-240 — the two persistence disciplines the detail editor supports,
+ * as one pure decision so the autosave scheduler and the unmount flush can never
+ * diverge on WHEN a dirty draft is persisted silently:
+ *
+ * - A **publishing** rail AUTOSAVES: the draft persists 1s after the last edit and
+ *   publish is the deliberate commit — so a dirty draft is flushed both on the
+ *   debounce timer and on unmount (navigating away inside the debounce window).
+ * - A **non-publishing** rail (users, EC-240) SAVES EXPLICITLY: edits stay in the
+ *   draft until the Save button, and an `UnsavedChangesGuard` protects navigation —
+ *   so it NEVER persists silently (returns false here).
+ */
+export function shouldPersistDraft(input) {
+    return !input.explicitSave && input.dirty;
+}
+/**
+ * EC-225 autosave · EC-240 explicit save. Owns the debounced autosave timer and
+ * the unmount flush for a publishing rail; a non-publishing rail persists only via
+ * its Save button (the caller's `UnsavedChangesGuard` covers navigation). Refs let
+ * the unmount flush read the latest values without re-subscribing.
+ *
+ * Returns `explicitSave` — the caller renders the Save button + guard (explicit)
+ * or the autosave status text (autosave) from it.
+ */
+export function useSaveMode(input) {
+    const { canPublish, dirty, draft, source } = input;
+    const explicitSave = !canPublish;
+    const draftRef = useRef(draft);
+    draftRef.current = draft;
+    const dirtyRef = useRef(dirty);
+    dirtyRef.current = dirty;
+    const sourceRef = useRef(source);
+    sourceRef.current = source;
+    const explicitSaveRef = useRef(explicitSave);
+    explicitSaveRef.current = explicitSave;
+    useEffect(() => {
+        if (explicitSave)
+            return; // explicit rails persist only via the Save button
+        if (!dirty)
+            return;
+        const timer = window.setTimeout(() => sourceRef.current.save(draftRef.current), 1000);
+        return () => window.clearTimeout(timer);
+    }, [dirty, draft, explicitSave]);
+    // Flush a still-pending AUTOSAVE edit on unmount (navigating away inside the
+    // debounce window) so nothing is lost. Explicit rails never flush silently —
+    // their `UnsavedChangesGuard` catches the navigation instead. Unmount-only.
+    useEffect(() => () => {
+        if (shouldPersistDraft({ explicitSave: explicitSaveRef.current, dirty: dirtyRef.current }))
+            sourceRef.current.save(draftRef.current);
+    }, []);
+    return { explicitSave };
+}
+//# sourceMappingURL=use-save-mode.js.map

package/dist/components/cms/use-save-mode.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"use-save-mode.js","sourceRoot":"","sources":["../../../src/components/cms/use-save-mode.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,SAAS,EAAE,MAAM,EAAE,MAAM,OAAO,CAAA;AAIzC;;;;;;;;;;;GAWG;AACH,MAAM,UAAU,kBAAkB,CAAC,KAAgD;IACjF,OAAO,CAAC,KAAK,CAAC,YAAY,IAAI,KAAK,CAAC,KAAK,CAAA;AAC3C,CAAC;AAED;;;;;;;;GAQG;AACH,MAAM,UAAU,WAAW,CAAC,KAK3B;IACC,MAAM,EAAE,UAAU,EAAE,KAAK,EAAE,KAAK,EAAE,MAAM,EAAE,GAAG,KAAK,CAAA;IAClD,MAAM,YAAY,GAAG,CAAC,UAAU,CAAA;IAChC,MAAM,QAAQ,GAAG,MAAM,CAAC,KAAK,CAAC,CAAA;IAC9B,QAAQ,CAAC,OAAO,GAAG,KAAK,CAAA;IACxB,MAAM,QAAQ,GAAG,MAAM,CAAC,KAAK,CAAC,CAAA;IAC9B,QAAQ,CAAC,OAAO,GAAG,KAAK,CAAA;IACxB,MAAM,SAAS,GAAG,MAAM,CAAC,MAAM,CAAC,CAAA;IAChC,SAAS,CAAC,OAAO,GAAG,MAAM,CAAA;IAC1B,MAAM,eAAe,GAAG,MAAM,CAAC,YAAY,CAAC,CAAA;IAC5C,eAAe,CAAC,OAAO,GAAG,YAAY,CAAA;IAEtC,SAAS,CAAC,GAAG,EAAE;QACb,IAAI,YAAY;YAAE,OAAM,CAAC,kDAAkD;QAC3E,IAAI,CAAC,KAAK;YAAE,OAAM;QAClB,MAAM,KAAK,GAAG,MAAM,CAAC,UAAU,CAAC,GAAG,EAAE,CAAC,SAAS,CAAC,OAAO,CAAC,IAAI,CAAC,QAAQ,CAAC,OAAO,CAAC,EAAE,IAAI,CAAC,CAAA;QACrF,OAAO,GAAG,EAAE,CAAC,MAAM,CAAC,YAAY,CAAC,KAAK,CAAC,CAAA;IACzC,CAAC,EAAE,CAAC,KAAK,EAAE,KAAK,EAAE,YAAY,CAAC,CAAC,CAAA;IAEhC,6EAA6E;IAC7E,6EAA6E;IAC7E,4EAA4E;IAC5E,SAAS,CACP,GAAG,EAAE,CAAC,GAAG,EAAE;QACT,IAAI,kBAAkB,CAAC,EAAE,YAAY,EAAE,eAAe,CAAC,OAAO,EAAE,KAAK,EAAE,QAAQ,CAAC,OAAO,EAAE,CAAC;YACxF,SAAS,CAAC,OAAO,CAAC,IAAI,CAAC,QAAQ,CAAC,OAAO,CAAC,CAAA;IAC5C,CAAC,EACD,EAAE,CACH,CAAA;IAED,OAAO,EAAE,YAAY,EAAE,CAAA;AACzB,CAAC","sourcesContent":["import { useEffect, useRef } from 'react'\nimport type { CmsDocument } from '@elytracms/core/cms-core'\nimport type { CollectionViewSource } from '@elytracms/studio/lib/collection-view/collection-view-source'\n\n/**\n * EC-225 / EC-240 — the two persistence disciplines the detail editor supports,\n * as one pure decision so the autosave scheduler and the unmount flush can never\n * diverge on WHEN a dirty draft is persisted silently:\n *\n * - A **publishing** rail AUTOSAVES: the draft persists 1s after the last edit and\n *   publish is the deliberate commit — so a dirty draft is flushed both on the\n *   debounce timer and on unmount (navigating away inside the debounce window).\n * - A **non-publishing** rail (users, EC-240) SAVES EXPLICITLY: edits stay in the\n *   draft until the Save button, and an `UnsavedChangesGuard` protects navigation —\n *   so it NEVER persists silently (returns false here).\n */\nexport function shouldPersistDraft(input: { explicitSave: boolean; dirty: boolean }): boolean {\n  return !input.explicitSave && input.dirty\n}\n\n/**\n * EC-225 autosave · EC-240 explicit save. Owns the debounced autosave timer and\n * the unmount flush for a publishing rail; a non-publishing rail persists only via\n * its Save button (the caller's `UnsavedChangesGuard` covers navigation). Refs let\n * the unmount flush read the latest values without re-subscribing.\n *\n * Returns `explicitSave` — the caller renders the Save button + guard (explicit)\n * or the autosave status text (autosave) from it.\n */\nexport function useSaveMode(input: {\n  canPublish: boolean\n  dirty: boolean\n  draft: CmsDocument\n  source: CollectionViewSource\n}): { explicitSave: boolean } {\n  const { canPublish, dirty, draft, source } = input\n  const explicitSave = !canPublish\n  const draftRef = useRef(draft)\n  draftRef.current = draft\n  const dirtyRef = useRef(dirty)\n  dirtyRef.current = dirty\n  const sourceRef = useRef(source)\n  sourceRef.current = source\n  const explicitSaveRef = useRef(explicitSave)\n  explicitSaveRef.current = explicitSave\n\n  useEffect(() => {\n    if (explicitSave) return // explicit rails persist only via the Save button\n    if (!dirty) return\n    const timer = window.setTimeout(() => sourceRef.current.save(draftRef.current), 1000)\n    return () => window.clearTimeout(timer)\n  }, [dirty, draft, explicitSave])\n\n  // Flush a still-pending AUTOSAVE edit on unmount (navigating away inside the\n  // debounce window) so nothing is lost. Explicit rails never flush silently —\n  // their `UnsavedChangesGuard` catches the navigation instead. Unmount-only.\n  useEffect(\n    () => () => {\n      if (shouldPersistDraft({ explicitSave: explicitSaveRef.current, dirty: dirtyRef.current }))\n        sourceRef.current.save(draftRef.current)\n    },\n    [],\n  )\n\n  return { explicitSave }\n}\n"]}

package/dist/components/cms/version-compare.js

@@ -4,17 +4,17 @@ import { ArrowRight, ChevronDown, ChevronLeft, ChevronRight, Image as ImageIcon,
 import { diffDocuments } from '@elytracms/core/content';
 import { assetSubfieldsOf, isAssetNode, readAssetId, readDocumentRef } from '@elytracms/core/cms-core';
 import { Badge, Button, Code, DropdownMenu, DropdownMenuContent, DropdownMenuItem, DropdownMenuTrigger, Row, Spacer, Stack, Text, } from '@elytracms/studio/ui';
-import { useOperationCache } from '@elytracms/studio/lib/query';
 import { translate } from '@elytracms/studio/lib/i18n';
 import { localeChipLabel } from '@elytracms/studio/lib/locale';
 import { cn } from '@elytracms/studio/lib/utils';
 import { readDiffViewMode, storeDiffViewMode } from '@elytracms/studio/lib/diff-view-preference';
 import { useCollectionView } from '../collection-view/collection-view-context';
-import { fieldLabel } from './cms-store';
+import { fieldLabel } from './cms-labels';
 import { toRefArray } from './cell';
 import { DIFF_TRUNCATE_THRESHOLD, mergeWordDiff, richTextToText, truncateText, truncateTokens, wordDiff, } from './version-compare-text';
 import { useDocumentEditor } from './document-editor-context';
 import { useDocumentVersionsQuery } from './use-document-versions';
+import { useRestoreVersion } from './use-restore-version';
 import { formatVersionTimestamp } from './versions-model';
 /**
  * EC-298 — the version compare view. Renders as the sticky **Compare** content tab
@@ -35,8 +35,16 @@ export function VersionCompare() {
     const source = useCollectionView();
     const { collection, docRef, draft, dirty, viewReadOnly, save, replaceDraft, compare, setCompareBase, setCompareTarget, } = useDocumentEditor();
     const { versionsQuery, versionKey } = useDocumentVersionsQuery(docRef);
-    const cache = useOperationCache();
-    const [busy, setBusy] = useState(false);
+    // EC-325 — the shared restore sequence (flush → restore → replaceDraft →
+    // invalidate). `busy` gates the restore controls below while it round-trips.
+    const { restore: restoreVersion, busy } = useRestoreVersion({
+        source,
+        docRef,
+        versionKey,
+        dirty,
+        save,
+        replaceDraft,
+    });
     // EC-317 — the unified/side-by-side toggle is a transient, personal-local view
     // preference (same class as the theme/rail prefs): read once at mount, written
     // back on every change, never round-tripped through the project graph.
@@ -97,19 +105,8 @@ export function VersionCompare() {
     const restore = useCallback(async (scope) => {
         if (!compare)
             return;
-        setBusy(true);
-        try {
-            if (dirty)
-                save();
-            const restored = await source.versioning?.restore(docRef, compare.base, scope);
-            if (restored)
-                replaceDraft(restored);
-            await cache.invalidate(versionKey);
-        }
-        finally {
-            setBusy(false);
-        }
-    }, [compare, dirty, save, source, docRef, replaceDraft, cache, versionKey]);
+        await restoreVersion(compare.base, scope);
+    }, [compare, restoreVersion]);
     if (!compare)
         return null;
     if (view === null)