@elytracms/studio 0.0.74 → 0.0.76

package/dist/components/cms/cms-store.js

@@ -117,7 +117,7 @@ function defaultView(collection, pseudo = []) {
  * layer (`documents.*` / `schema.*` commands) through {@link createCmsPersister}.
  * Failed/denied commands surface as {@link CmsStore.persistError}.
  */
-export function CmsProvider({ children, projectId, initialCollections, initialDocuments, initialPublishedKeys, initialTimestamps, initialLocaleConfig, }) {
+export function CmsProvider({ children, projectId, initialCollections, initialDocuments, initialPublishedKeys, initialTimestamps, initialPublishTimestamps, initialChangedKeys, initialLocaleConfig, }) {
     const [documents, setDocuments] = useState(() => {
         const seeded = (initialDocuments ?? sampleDocuments).map((d) => structuredClone(d));
         // EC-320 (0.0.44 follow-up): merge any documents STAGED by the
@@ -166,6 +166,71 @@ export function CmsProvider({ children, projectId, initialCollections, initialDo
         });
     }, []);
     const documentUpdatedAt = useCallback((ref) => updatedAtByKey.get(documentKey(ref)), [updatedAtByKey]);
+    // EC-447: per-document FIRST-publish instants behind the `$publishedAt` column.
+    // Seeded from hydration (the persisted `cmsDocuments.publishedAt`); UNLIKE
+    // `$updatedAt` there is NO session-start fallback — an absent entry is a real "no
+    // publish date" (EmDash). The store re-stamps/clears it authoritatively on
+    // publish/unpublish (the set-once + clear semantics live in the persistence spine).
+    const [publishedAtByKey, setPublishedAtByKey] = useState(() => {
+        const map = new Map();
+        if (initialPublishTimestamps) {
+            for (const [key, value] of Object.entries(initialPublishTimestamps))
+                map.set(key, value);
+        }
+        return map;
+    });
+    // Adopt the AUTHORITATIVE publish instant from the reconciled record: an ISO value
+    // stamps it (set-once is enforced server-side, so this only ever adopts the pinned
+    // first-publish value); `undefined` CLEARS it (unpublish). Mirrors `stampUpdatedAt`
+    // but supports clearing — the column shows a date iff the doc is currently published.
+    const stampPublishedAt = useCallback((ref, iso) => {
+        setPublishedAtByKey((prev) => {
+            const key = documentKey(ref);
+            if (iso === undefined) {
+                if (!prev.has(key))
+                    return prev;
+                const next = new Map(prev);
+                next.delete(key);
+                return next;
+            }
+            if (prev.get(key) === iso)
+                return prev;
+            const next = new Map(prev);
+            next.set(key, iso);
+            return next;
+        });
+    }, []);
+    const documentPublishedAt = useCallback((ref) => publishedAtByKey.get(documentKey(ref)), [publishedAtByKey]);
+    // EC-449: the documents whose draft carries unpublished changes — the amber
+    // "changed" `$state` dot. A SET like `publishedKeys` (membership = the
+    // materialized `hasUnpublishedChanges === true`); seeded from hydration, then
+    // re-stamped authoritatively from returned records — the verdict is computed
+    // ONCE at the write chokepoint (both adapters), never client-side per render.
+    const [changedKeys, setChangedKeys] = useState(() => new Set(initialChangedKeys ?? []));
+    // Adopt the authoritative flag: `true` adds the key; `false`/`undefined` (not
+    // changed / cleared at unpublish / not materialized) both remove it — the dot
+    // renders those identically, so the set stores no tri-state.
+    const stampHasUnpublishedChanges = useCallback((ref, changed) => {
+        setChangedKeys((prev) => {
+            const key = documentKey(ref);
+            if (prev.has(key) === (changed === true))
+                return prev;
+            const next = new Set(prev);
+            if (changed === true)
+                next.add(key);
+            else
+                next.delete(key);
+            return next;
+        });
+    }, []);
+    const documentHasUnpublishedChanges = useCallback((ref) => changedKeys.has(documentKey(ref)), [changedKeys]);
+    // The one adoption seam for a SAVED document record (persister queue upsert,
+    // inline cell edit, bulk set-field, restore): stamp the server-computed
+    // changed verdict for the record's ref. Referentially stable — the persister
+    // closes over it once.
+    const adoptSavedRecord = useCallback((record) => {
+        stampHasUnpublishedChanges({ collection: record.document.collection, id: record.document.id }, record.hasUnpublishedChanges);
+    }, [stampHasUnpublishedChanges]);
     const [activeViews, setActiveViews] = useState({});
     // The live table state per collection where it diverges from the active
     // view; absent key = exactly the active view's state (not dirty).
@@ -203,6 +268,10 @@ export function CmsProvider({ children, projectId, initialCollections, initialDo
             // the schema alone (above); the registry adds blocks/embed prop coverage.
             lookupManifest: studioManifestLookup(),
             onError: setPersistError,
+            // EC-449: adopt the server-computed `hasUnpublishedChanges` verdict from
+            // every queued upsert's authoritative record (saves, imports, bulk-cleaned
+            // drafts) — the amber list dot follows the chokepoint, never a client guess.
+            onDocumentSaved: adoptSavedRecord,
         });
     }
     const registry = useMemo(() => createCollectionRegistry(collections), [collections]);
@@ -282,12 +351,17 @@ export function CmsProvider({ children, projectId, initialCollections, initialDo
                         // landed first, then issue the commit's single command.
                         await persister.ensureBaseline();
                         const { operations } = await getStudioOperations();
-                        return operations.documents.upsert({ projectId, document: next });
+                        const result = await operations.documents.upsert({ projectId, document: next });
+                        // EC-449: adopt the chokepoint's changed verdict (inline edits
+                        // bypass the persister queue, so its hook doesn't see them).
+                        if (result.ok)
+                            adoptSavedRecord(result.value);
+                        return result;
                     },
                 }
                 : {}),
         }, input);
-    }, [registry, localeConfig, projectId, stampUpdatedAt]);
+    }, [registry, localeConfig, projectId, stampUpdatedAt, adoptSavedRecord]);
     // Shared insert sequence (EC-326): existingIds/mint/seedDefaults (via
     // `buildNewDocument`) + optimistic append + persist, consumed by both
     // `createDocument` (always inserts) and `ensureSingletonDocument`'s empty
@@ -379,8 +453,15 @@ export function CmsProvider({ children, projectId, initialCollections, initialDo
             // value so the $updatedAt column reflects the actual write, not a guess.
             if (record.value.updatedAt)
                 stampUpdatedAt(ref, record.value.updatedAt);
+            // EC-447: adopt the authoritative `publishedAt` — set-once on the first
+            // publish, absent after unpublish. Passing `undefined` CLEARS the column, so
+            // an unpublish reverts $publishedAt to EmDash and a republish records fresh.
+            stampPublishedAt(ref, record.value.publishedAt);
+            // EC-449: adopt the authoritative changed flag — `false` after a publish
+            // (the draft became the baseline), absent after an unpublish (cleared).
+            stampHasUnpublishedChanges(ref, record.value.hasUnpublishedChanges);
         }
-    }, [projectId, setPublished, stampUpdatedAt]);
+    }, [projectId, setPublished, stampUpdatedAt, stampPublishedAt, stampHasUnpublishedChanges]);
     const publishDocument = useCallback(async (ref) => {
         setPublished(ref, true); // optimistic
         // EC-273: no clearing here — the draft is already free of conditionally-hidden
@@ -439,8 +520,12 @@ export function CmsProvider({ children, projectId, initialCollections, initialDo
         // Pure map-replace: a restore always targets a document already open in
         // the session.
         setDocuments((prev) => replaceDoc(prev, restored));
+        // EC-449: a restore is a save-shaped write — adopt the chokepoint's fresh
+        // changed verdict from the returned record (e.g. restoring a published
+        // doc's draft to an older version flips the dot to amber immediately).
+        adoptSavedRecord(result.value);
         return restored;
-    }, [projectId]);
+    }, [projectId, adoptSavedRecord]);
     const validate = useCallback((doc) => validateDocument(registry, doc, {
         store,
         localeConfig,
@@ -620,7 +705,15 @@ export function CmsProvider({ children, projectId, initialCollections, initialDo
                         },
                     });
                 }
-                return operations.documents.upsert({ projectId, document: setFieldDoc(current) });
+                return operations.documents
+                    .upsert({ projectId, document: setFieldDoc(current) })
+                    .then((result) => {
+                    // EC-449: adopt the chokepoint's changed verdict per set-field item
+                    // (bulk dispatch bypasses the persister queue and its hook).
+                    if (result.ok)
+                        adoptSavedRecord(result.value);
+                    return result;
+                });
             };
         }
         return runBulkAction({
@@ -659,7 +752,13 @@ export function CmsProvider({ children, projectId, initialCollections, initialDo
             // (`publishedKeys`) via setPublished — there is no separate flat
             // `state` mirror to keep in sync (published-ness is derived from the
             // pointer set).
-            applyState: (ref, state) => setPublished(ref, state === 'published'),
+            // EC-449: either transition resolves the changed flag — publish writes
+            // `false` (the draft became the baseline), unpublish clears it — and
+            // bulk has no per-item record reconcile, so mirror that here.
+            applyState: (ref, state) => {
+                setPublished(ref, state === 'published');
+                stampHasUnpublishedChanges(ref, false);
+            },
             applyDelete: (ref) => setDocuments((prev) => removeDoc(prev, ref)),
             // EC-247: fold the new value into the session document (same
             // locale-aware path the dispatched upsert used). Not a plain
@@ -668,7 +767,17 @@ export function CmsProvider({ children, projectId, initialCollections, initialDo
             applySetField: (ref) => setDocuments((prev) => prev.map((d) => (matchesRef(d, ref) ? setFieldDoc(d) : d))),
             ...(dispatch ? { dispatch } : {}),
         }, collectionId, ids, action, setField);
-    }, [projectId, titleOf, registry, localeConfig, activeLocale, setPublished, assetExists]);
+    }, [
+        projectId,
+        titleOf,
+        registry,
+        localeConfig,
+        activeLocale,
+        setPublished,
+        assetExists,
+        adoptSavedRecord,
+        stampHasUnpublishedChanges,
+    ]);
     const store$ = useMemo(() => ({
         ...(projectId !== undefined ? { projectId } : {}),
         collections,
@@ -685,6 +794,8 @@ export function CmsProvider({ children, projectId, initialCollections, initialDo
         deleteDocument,
         isPublished,
         documentUpdatedAt,
+        documentPublishedAt,
+        documentHasUnpublishedChanges,
         publishDocument,
         unpublishDocument,
         loadDocumentVersions,
@@ -738,6 +849,8 @@ export function CmsProvider({ children, projectId, initialCollections, initialDo
         deleteDocument,
         isPublished,
         documentUpdatedAt,
+        documentPublishedAt,
+        documentHasUnpublishedChanges,
         publishDocument,
         unpublishDocument,
         loadDocumentVersions,