@riverbankcms/sdk 0.147.0 → 0.148.0

package/dist/_dts/content-editor/src/ui/editorRefresh.d.ts

@@ -0,0 +1,82 @@
+import { type EditorBlockValues, type EditorBlockVersions, type EditorValueRecord } from '../../../core/src/index';
+import type { OwnWriteSince, RefreshPolicy } from '../sync/valueSync';
+import { type DraftBlockRefresh, type EditorHistorySnapshot } from './editorSnapshot';
+/**
+ * A server read of one value, applied as a `refreshed` sync event (issue 1553). Every path
+ * that sets a baseline without a save response goes through here: the RSC reconciliation
+ * hooks, block seeding, both grant reads and discard draft. Responses to this tab's own
+ * writes are rebased instead (`OwnWrite`).
+ *
+ * A metadata or content refresh without a `revision` keeps the baseline's own: publish and
+ * discard-draft responses don't always carry one, and wiping it would make the next save
+ * fail. `published`, when present, moves the published baseline too.
+ */
+export type ValueRefresh = Readonly<{
+    kind: 'metadata' | 'content';
+    values: EditorValueRecord | null;
+    revision?: string | null;
+    published?: EditorValueRecord | null;
+}> | Readonly<{
+    kind: 'linked-entry';
+    entryId: string;
+    values: EditorValueRecord | null;
+    revision: string | null;
+}> | Readonly<{
+    kind: 'block';
+    block: DraftBlockRefresh;
+    versions?: EditorBlockVersions;
+}>;
+/** A metadata or content refresh, as the value's own facade takes it. */
+export type DocumentValueRefreshInput = Omit<Extract<ValueRefresh, {
+    kind: 'metadata' | 'content';
+}>, 'kind'>;
+/** `discarded` asks for the "edited in another tab" notice: a take-back threw local edits away. */
+export type RefreshTransition = Readonly<{
+    snapshot: EditorHistorySnapshot;
+    discarded: boolean;
+}>;
+export declare function refreshValuesSnapshot(snapshot: EditorHistorySnapshot, refreshes: readonly ValueRefresh[], policy: RefreshPolicy): RefreshTransition;
+/**
+ * What this tab's own write (publish, schedule, cancel, discard draft) returned for one
+ * document value. It's rebased rather than refreshed (`rebaseOnOwnWrite`): an edit typed
+ * during the round trip survives on top of the new baseline (rows P6, R1–R11, X1–X4).
+ * `since` is what the edits are measured from: the baseline when the operation started,
+ * or for discard what was displayed when the person confirmed. A missing `revision`
+ * keeps the baseline's own, as a refresh does.
+ */
+export type OwnWrite = DocumentOwnWrite | Readonly<{
+    kind: 'block';
+    block: DraftBlockRefresh;
+    since: OwnWriteSince<EditorBlockValues | null>;
+}>;
+type DocumentOwnWrite = Readonly<{
+    kind: 'metadata' | 'content';
+    values: EditorValueRecord | null;
+    revision?: string | null;
+    published?: EditorValueRecord | null;
+    since: OwnWriteSince<EditorValueRecord | null>;
+}>;
+export declare function ownWritesSnapshot(snapshot: EditorHistorySnapshot, writes: readonly OwnWrite[]): EditorHistorySnapshot;
+/**
+ * What a successful publish tells the editor. Metadata is the route the publish wrote.
+ * Content is what it wrote (`written`), or `unchanged` when it wrote none, in which case
+ * the content baseline and revision stay and only its published baseline moves (WR5b).
+ */
+export type PublishSuccessRefresh = Readonly<{
+    metadata: Omit<DocumentOwnWrite, 'kind'> & Readonly<{
+        published: EditorValueRecord | null;
+    }>;
+    content: Readonly<{
+        published: EditorValueRecord | null;
+        write: Readonly<{
+            kind: 'written';
+            values: EditorValueRecord;
+            revision: string;
+            since: OwnWriteSince<EditorValueRecord | null>;
+        }> | Readonly<{
+            kind: 'unchanged';
+        }>;
+    }>;
+}>;
+export declare function publishSuccessSnapshot(snapshot: EditorHistorySnapshot, publish: PublishSuccessRefresh): EditorHistorySnapshot;
+export {};

package/dist/_dts/content-editor/src/ui/editorSnapshot.d.ts

@@ -1,5 +1,9 @@
-import { unsafeAsEditorBlockId, unsafeAsEditorBlockValues, unsafeAsEditorContentValues, unsafeAsEditorEntryId, unsafeAsEditorMetadataValues, unsafeAsEditorPageId, unsafeAsEditorSiteId, type EditorBlockBaselineInput, type EditorBlockId, type EditorBlockPublishedBaselineInput, type EditorDraftBlockBaselineUpdateMetaInput, type EditorDraftBlockInitMetaInput, type EditorBlockValues, type EditorContentValues, type EditorEntryId, type EditorMetadataValues, type EditorPageId, type EditorPersistedBlock, type BlockContentIdentity, type EditorSiteId, type EditorStructuralCommand, type EditorStructuralDraftSnapshot, type EditorSyncState, type EditorValueRecord } from '../../../core/src/index';
+import { type EditorBlockVersions } from '../../../core/src/index';
+import { type EditorBlockCollectionOwner, type EditorBlockCollectionReadBaseline, unsafeAsEditorBlockId, unsafeAsEditorBlockValues, unsafeAsEditorContentValues, unsafeAsEditorEntryId, unsafeAsEditorMetadataValues, unsafeAsEditorPageId, unsafeAsEditorSiteId, type EditorBlockBaselineInput, type EditorBlockId, type EditorDraftBlockBaselineUpdateMetaInput, type EditorDraftBlockInitMetaInput, type EditorBlockValues, type EditorContentValues, type EditorEntryId, type EditorMetadataValues, type EditorPageId, type EditorPersistedBlock, type EditorSiteId, type EditorStructuralCommand, type EditorStructuralDraftSnapshot, type EditorValueRecord, type BaselineRevision, type SendId, type ValueSync } from '../../../core/src/index';
 import { type LinkedContentEntryId, type LinkedContentTypeKey } from '../linkedEntries/domain';
+import { type EditorValueSnapshot } from './editorValueSnapshot';
+import { type OwnWriteSince, type RefreshPolicy, type ValueSyncEvent, type ValueSyncOutcome } from '../sync/valueSync';
+export type { EditorValueSnapshot } from './editorValueSnapshot';
 export { unsafeAsEditorBlockId, unsafeAsEditorBlockValues, unsafeAsEditorContentValues, unsafeAsEditorEntryId, unsafeAsEditorMetadataValues, unsafeAsEditorPageId, unsafeAsEditorSiteId, type EditorBlockId, type EditorBlockValues, type EditorContentValues, type EditorEntryId, type EditorMetadataValues, type EditorPageId, type EditorSiteId, };
 export type EditorCommand = {
     type: 'set-metadata-value';
@@ -52,13 +56,6 @@ type PersistRemoveEffect = Readonly<{
     blockId: EditorBlockId;
 }>;
 export type EditorEffect = PersistReorderEffect | PersistInsertEffect | PersistRemoveEffect;
-export type EditorValueSnapshot<TValue extends EditorValueRecord | null> = Readonly<{
-    version: number;
-    baseline: TValue;
-    current: TValue;
-    publishedBaseline: TValue;
-    syncState: EditorSyncState;
-}>;
 export type EditorValuePublicationState<TValue extends EditorValueRecord | null> = Readonly<{
     kind: 'empty';
     hasUnpublishedChanges: false;
@@ -81,27 +78,15 @@ export type EditorValuePublicationState<TValue extends EditorValueRecord | null>
     hasUnpublishedChanges: true;
 }>;
 export declare function deriveEditorValuePublicationState<TValue extends EditorValueRecord | null>(snapshot: EditorValueSnapshot<TValue>): EditorValuePublicationState<TValue>;
-export type EditorPublishSuccessTransition = Readonly<{
-    metadata: Readonly<{
-        baseline: EditorMetadataValues | null;
-        current: EditorMetadataValues | null;
-        published: EditorMetadataValues | null;
-    }>;
-    content: Readonly<{
-        published: EditorContentValues | null;
-        versionAtPublishStart: number;
-    }>;
-    blockPublishedBaselines: readonly BlockPublishedBaselineInput[] | null;
-}>;
 type EditorMetadataSnapshot = EditorValueSnapshot<EditorMetadataValues | null>;
 type EditorContentSnapshot = EditorValueSnapshot<EditorContentValues | null>;
+/** The linked entry's baseline revision (its optimistic hash) lives in `sync`. */
 export type EditorLinkedEntryMeta = Readonly<{
     entryId: LinkedContentEntryId;
     contentTypeKey: LinkedContentTypeKey;
     contentTypeLabel: string;
     title: string;
     titleField: string | null;
-    optimisticHash: string | null;
     fields: readonly EditorValueRecord[];
 }>;
 export type EditorLinkedEntrySnapshot = EditorValueSnapshot<EditorContentValues | null> & Readonly<{
@@ -111,31 +96,26 @@ export type EditorBlockMeta = Readonly<{
     kind: string;
     purpose: string | null;
     orderIndex: number | null;
-    publishedContent: EditorBlockValues | null;
-    optimisticHash: string | null;
 }>;
 export type EditorDraftSnapshot = EditorStructuralDraftSnapshot;
 export type DraftBlockInitMetaInput = EditorDraftBlockInitMetaInput;
 export type DraftBlockBaselineUpdateMetaInput = EditorDraftBlockBaselineUpdateMetaInput;
 export type DraftBlockBaselineInput = EditorBlockBaselineInput;
-export type BlockPublishedBaselineInput = EditorBlockPublishedBaselineInput;
-export type EditorBlockItem = Partial<BlockContentIdentity> & Readonly<{
+export type EditorBlockItem = Readonly<{
     id?: string | null;
     kind: string;
     content?: EditorValueRecord | null;
     orderIndex?: number | null;
     draftContent?: EditorValueRecord | null;
-    publishedContent?: EditorValueRecord | null;
     bindings?: EditorValueRecord | null;
     purpose?: string | null;
     optimisticHash?: string | null;
 }>;
-type NormalizedEditorBlockBase = BlockContentIdentity & Readonly<{
+type NormalizedEditorBlockBase = Readonly<{
     kind: string;
     content: EditorBlockValues | null;
     orderIndex: number | null;
     draftContent: EditorBlockValues | null;
-    publishedContent: EditorBlockValues | null;
     bindings: EditorBlockValues | null;
     purpose: string | null;
     optimisticHash: string | null;
@@ -153,10 +133,30 @@ export type EditorHistorySnapshot = Readonly<{
      * Structural/history operations and baseline acknowledgements keep this list in sync,
      * while draft-only validation/edit metadata continues to live in `drafts`.
      */
+    blockCollectionOwner: EditorBlockCollectionOwner | null;
+    collectionReadBaselines: Readonly<Record<string, EditorBlockCollectionReadBaseline>>;
     blockList: readonly NormalizedEditorBlockItem[];
     drafts: Readonly<Record<EditorBlockId, EditorDraftSnapshot>>;
     linkedEntries: Readonly<Record<string, EditorLinkedEntrySnapshot>>;
 }>;
+/** Which value a sync event applies to. A linked entry that is the document itself routes to content. */
+export type EditorValueKey = Readonly<{
+    kind: 'metadata';
+}> | Readonly<{
+    kind: 'content';
+}> | Readonly<{
+    kind: 'block';
+    blockId: EditorBlockId;
+}> | Readonly<{
+    kind: 'linked-entry';
+    entryId: string;
+}>;
+/** Events arrive unbranded; each family brands (and clones) the values it stores. */
+export type EditorValueSyncEvent = ValueSyncEvent<EditorValueRecord | null>;
+export type EditorValueTransition = Readonly<{
+    snapshot: EditorHistorySnapshot;
+    outcome: ValueSyncOutcome;
+}>;
 export declare function requirePersistedEditorBlock(block: EditorBlockItem | NormalizedEditorBlockItem): PersistedEditorBlockItem;
 export declare function createEditorDraftSnapshotFromBlock(block: PersistedEditorBlockItem): EditorDraftSnapshot;
 export declare function createEditorHistorySnapshot(): EditorHistorySnapshot;
@@ -171,78 +171,24 @@ export type EditorUserOperation = {
     type: 'user-command';
     command: EditorCommand;
 };
+/**
+ * History-free operations. Save requests don't appear here: the store applies their
+ * sync events (`send-started`, `send-succeeded`, `send-failed`) through `applyValueEvent`.
+ */
 export type EditorSystemOperation = {
-    type: 'hydrate-metadata';
-    baseline: EditorMetadataValues | null;
-    current?: EditorMetadataValues | null;
-    published?: EditorMetadataValues | null;
-} | {
-    type: 'hydrate-content';
-    baseline: EditorContentValues | null;
-    current?: EditorContentValues | null;
-    published?: EditorContentValues | null;
-} | {
     type: 'set-metadata-published-baseline';
     published: EditorMetadataValues | null;
 } | {
     type: 'set-content-published-baseline';
     published: EditorContentValues | null;
-} | {
-    type: 'apply-publish-success';
-    transition: EditorPublishSuccessTransition;
-} | {
-    type: 'autosave-metadata-succeeded';
-    savedValues: EditorMetadataValues | null;
-    acknowledgedVersion: number;
-} | {
-    type: 'autosave-content-succeeded';
-    savedValues: EditorContentValues | null;
-    acknowledgedVersion: number;
-} | {
-    type: 'autosave-metadata-failed';
-    message?: string;
-} | {
-    type: 'autosave-content-failed';
-    message?: string;
-} | {
-    type: 'clear-metadata-error';
-} | {
-    type: 'clear-content-error';
 } | {
     type: 'init-new-draft-block';
     blockId: EditorBlockId;
     baseline: DraftBlockBaselineInput;
     meta: DraftBlockInitMetaInput;
-} | {
-    type: 'update-draft-block-baseline';
-    blockId: EditorBlockId;
-    baseline: DraftBlockBaselineInput;
-    meta?: DraftBlockBaselineUpdateMetaInput;
 } | {
     type: 'remove-draft-block';
     blockId: EditorBlockId;
-} | {
-    type: 'set-draft-published-baselines';
-    blocks: readonly BlockPublishedBaselineInput[];
-} | {
-    type: 'autosave-draft-succeeded';
-    blockId: EditorBlockId;
-    savedValues: EditorBlockValues | null;
-    acknowledgedVersion: number;
-    optimisticHash: string | null;
-} | {
-    type: 'autosave-draft-failed';
-    blockId: EditorBlockId;
-    message?: string;
-} | {
-    type: 'clear-draft-error';
-    blockId: EditorBlockId;
-} | {
-    type: 'set-draft-pending';
-    blockId: EditorBlockId;
-} | {
-    type: 'clear-draft-pending';
-    blockId: EditorBlockId;
 } | {
     type: 'hydrate-linked-entry';
     entryId: string;
@@ -253,23 +199,14 @@ export type EditorSystemOperation = {
     optimisticHash?: string | null;
     fields: readonly EditorValueRecord[];
     baseline: EditorContentValues | null;
-    current?: EditorContentValues | null;
-} | {
-    type: 'discard-linked-entry';
-    entryId: string;
 } | {
-    type: 'save-linked-entry-succeeded';
-    entryId: string;
-    savedValues: EditorContentValues | null;
-    acknowledgedVersion: number;
-    optimisticHash?: string | null;
+    /** An `edited` event outside history: a preview runtime showing values it drives. */
+    type: 'edit-without-history';
+    key: EditorValueKey;
+    values: EditorValueRecord | null;
 } | {
-    type: 'save-linked-entry-failed';
-    entryId: string;
-    message?: string;
-} | {
-    type: 'clear-linked-entry-error';
-    entryId: string;
+    type: 'discard-local-edits';
+    contentOwnerEntryId?: string;
 } | {
     type: 'replace-block-list';
     next: readonly EditorBlockItem[];
@@ -279,36 +216,73 @@ export declare function applyEditorCommand(snapshot: EditorHistorySnapshot, comm
 export declare function applyUserOperation(snapshot: EditorHistorySnapshot, operation: EditorUserOperation): EditorHistorySnapshot;
 export declare function applySystemOperation(snapshot: EditorHistorySnapshot, operation: EditorSystemOperation): EditorHistorySnapshot;
 export declare function applyEditorOperation(snapshot: EditorHistorySnapshot, operation: EditorOperation): EditorHistorySnapshot;
-export declare function hydrateMetadataSnapshot(snapshot: EditorHistorySnapshot, baseline: EditorMetadataValues | null, current?: EditorMetadataValues | null, published?: EditorMetadataValues | null): EditorHistorySnapshot;
-export declare function hydrateContentSnapshot(snapshot: EditorHistorySnapshot, baseline: EditorContentValues | null, current?: EditorContentValues | null, published?: EditorContentValues | null): EditorHistorySnapshot;
+/** The sync state of one value, or `undefined` when that block or linked entry isn't loaded. */
+export declare function valueSyncAt(snapshot: EditorHistorySnapshot, key: EditorValueKey): ValueSync<EditorValueRecord | null> | undefined;
+/** Applies one sync event to one value; the single path every family's transitions take. */
+export declare function applyValueEvent(snapshot: EditorHistorySnapshot, key: EditorValueKey, event: EditorValueSyncEvent): EditorValueTransition;
+/** What one started request carries: the values sent and the revision they were based on. */
+export type StartedSend = Readonly<{
+    key: EditorValueKey;
+    id: SendId;
+    values: EditorValueRecord | null;
+    basis: BaselineRevision;
+}>;
+export declare function startedSendAt(snapshot: EditorHistorySnapshot, key: EditorValueKey, id: SendId): StartedSend | null;
+export declare function aggregateSyncState(snapshot: EditorHistorySnapshot): 'baseline' | 'pending' | 'failed';
 export declare function setMetadataPublishedBaseline(snapshot: EditorHistorySnapshot, published: EditorMetadataValues | null): EditorHistorySnapshot;
 export declare function setContentPublishedBaseline(snapshot: EditorHistorySnapshot, published: EditorContentValues | null): EditorHistorySnapshot;
-export declare function applyPublishSuccessTransition(snapshot: EditorHistorySnapshot, transition: EditorPublishSuccessTransition): EditorHistorySnapshot;
-export declare function autosaveMetadataSucceeded(snapshot: EditorHistorySnapshot, savedValues: EditorMetadataValues | null, acknowledgedVersion: number): EditorHistorySnapshot;
-export declare function autosaveContentSucceeded(snapshot: EditorHistorySnapshot, savedValues: EditorContentValues | null, acknowledgedVersion: number): EditorHistorySnapshot;
-export declare function autosaveMetadataFailed(snapshot: EditorHistorySnapshot, message?: string): EditorHistorySnapshot;
-export declare function autosaveContentFailed(snapshot: EditorHistorySnapshot, message?: string): EditorHistorySnapshot;
-export declare function clearMetadataError(snapshot: EditorHistorySnapshot): EditorHistorySnapshot;
-export declare function clearContentError(snapshot: EditorHistorySnapshot): EditorHistorySnapshot;
 export declare function getCurrentValues<TValue extends EditorValueRecord | null>(snapshot: EditorValueSnapshot<TValue>): TValue;
-export declare function getSnapshotStatus(syncState: EditorSyncState): 'baseline' | 'pending' | 'failed';
-export declare function getSnapshotError(syncState: EditorSyncState): string | null;
+/**
+ * How a server block value arrives (issue 1553): a read is a refresh under its policy;
+ * a response to this tab's own write (discard draft's block result) is rebased against
+ * what the person's edits are measured from.
+ */
+export type DraftBlockArrival = Readonly<{
+    kind: 'refreshed';
+    policy: RefreshPolicy;
+}> | Readonly<{
+    kind: 'own-write';
+    since: OwnWriteSince<EditorBlockValues | null>;
+}>;
 export declare function initNewDraftBlock(snapshot: EditorHistorySnapshot, blockId: EditorBlockId, baseline: DraftBlockBaselineInput, meta: DraftBlockInitMetaInput): EditorHistorySnapshot;
-export declare function updateDraftBlockBaseline(snapshot: EditorHistorySnapshot, blockId: EditorBlockId, baseline: DraftBlockBaselineInput, meta?: DraftBlockBaselineUpdateMetaInput): EditorHistorySnapshot;
+/** What a server block refresh carries; the shape of editor-blocks' baseline seed. */
+export type DraftBlockRefresh = Readonly<{
+    blockId: EditorBlockId;
+    baseline: DraftBlockBaselineInput;
+    initMeta?: DraftBlockInitMetaInput;
+    refreshMeta?: DraftBlockBaselineUpdateMetaInput;
+}>;
+/**
+ * Refreshes one block from the server: an existing draft moves under the policy, a
+ * missing one is created pristine (when the refresh says how to create it).
+ */
+export declare function refreshDraftBlock(snapshot: EditorHistorySnapshot, refresh: DraftBlockRefresh, arrival: DraftBlockArrival): EditorValueTransition;
 export declare function removeDraftBlock(snapshot: EditorHistorySnapshot, blockId: EditorBlockId): EditorHistorySnapshot;
-export declare function setDraftPublishedBaselines(snapshot: EditorHistorySnapshot, blocks: readonly BlockPublishedBaselineInput[]): EditorHistorySnapshot;
-export declare function autosaveDraftSucceeded(snapshot: EditorHistorySnapshot, blockId: EditorBlockId, savedValues: EditorBlockValues | null, acknowledgedVersion: number, optimisticHash: string | null): EditorHistorySnapshot;
-export declare function autosaveDraftFailed(snapshot: EditorHistorySnapshot, blockId: EditorBlockId, message?: string): EditorHistorySnapshot;
-export declare function clearDraftError(snapshot: EditorHistorySnapshot, blockId: EditorBlockId): EditorHistorySnapshot;
-export declare function setDraftPending(snapshot: EditorHistorySnapshot, blockId: EditorBlockId): EditorHistorySnapshot;
-export declare function clearDraftPending(snapshot: EditorHistorySnapshot, blockId: EditorBlockId): EditorHistorySnapshot;
-export declare function hydrateLinkedEntrySnapshot(snapshot: EditorHistorySnapshot, input: Extract<EditorSystemOperation, {
+type LinkedEntryHydration = Extract<EditorSystemOperation, {
     type: 'hydrate-linked-entry';
-}>): EditorHistorySnapshot;
-export declare function discardLinkedEntrySnapshot(snapshot: EditorHistorySnapshot, entryId: string): EditorHistorySnapshot;
-export declare function saveLinkedEntrySucceeded(snapshot: EditorHistorySnapshot, entryId: string, savedValues: EditorContentValues | null, acknowledgedVersion: number, optimisticHash?: string | null): EditorHistorySnapshot;
-export declare function saveLinkedEntryFailed(snapshot: EditorHistorySnapshot, entryId: string, message?: string): EditorHistorySnapshot;
-export declare function clearLinkedEntryError(snapshot: EditorHistorySnapshot, entryId: string): EditorHistorySnapshot;
+}>;
+/**
+ * Opening a linked entry from the rendered page is an ordinary keep-local refresh of its
+ * record. A render without a revision keeps the record's own rather than wiping it.
+ */
+export declare function hydrateLinkedEntrySnapshot(snapshot: EditorHistorySnapshot, input: LinkedEntryHydration): EditorHistorySnapshot;
+/**
+ * Throw away every unsaved local edit, synchronously and locally: each value is
+ * `discarded`, so it shows its baseline and any request still outstanding becomes
+ * abandoned (issue 1553, D1–D3). Linked entries keep their record (D2); the document's
+ * own entry is routed through content. Nothing is read from the server, so it can't
+ * fail; newer server values arrive by the usual paths.
+ */
+export declare function discardLocalEditsSnapshot(snapshot: EditorHistorySnapshot, contentOwnerEntryId?: string): EditorHistorySnapshot;
+/** The linked entries whose local edits a discard would throw away. */
+export declare function editedLinkedEntryIds(snapshot: EditorHistorySnapshot): readonly string[];
+/**
+ * Undo and redo restore what the person sees, never sync state (issue 1553, D4).
+ * Displayed values and structure come from the target; baselines, revisions, requests
+ * and published baselines come from the present. A block record brought back by
+ * structure has no request (U3); other records missing from the target keep the present's.
+ */
+export declare function restoreDisplay(present: EditorHistorySnapshot, target: EditorHistorySnapshot): EditorHistorySnapshot;
 export declare function replaceEditorBlockList(snapshot: EditorHistorySnapshot, blockList: readonly EditorBlockItem[]): EditorHistorySnapshot;
 export declare function getDraftSnapshot(snapshot: EditorHistorySnapshot, blockId: string): EditorDraftSnapshot | null;
 export declare function inspectDrafts(snapshot: EditorHistorySnapshot): EditorDraftSnapshot[];
@@ -320,5 +294,6 @@ export type EditorDraftUnpublishedBlockChange = Readonly<{
     currentContent: EditorBlockValues | null;
     publishedContent: EditorBlockValues | null;
 }>;
-export declare function getFirstUnpublishedDraftChange(snapshot: EditorHistorySnapshot): EditorDraftUnpublishedBlockChange | null;
-export declare function hasUnpublishedDraftChanges(snapshot: EditorHistorySnapshot): boolean;
+export declare function blockPublicationState(draft: EditorDraftSnapshot, versions: EditorBlockVersions): EditorValuePublicationState<EditorBlockValues | null>;
+export declare function getFirstUnpublishedDraftChange(snapshot: EditorHistorySnapshot, versionsFor: (blockId: EditorBlockId) => EditorBlockVersions): EditorDraftUnpublishedBlockChange | null;
+export declare function hasUnpublishedDraftChanges(snapshot: EditorHistorySnapshot, versionsFor: (blockId: EditorBlockId) => EditorBlockVersions): boolean;

package/dist/_dts/content-editor/src/ui/editorTransactionState.d.ts

@@ -87,7 +87,7 @@ export declare function confirmStagedSession<TSnapshot, THistoryEntry, TTargetKe
 export declare function rejectStagedSession<TSnapshot, THistoryEntry, TTargetKey extends string = string>(state: EditorStagedSessionState<TSnapshot, THistoryEntry, TTargetKey>, failure: EditorTransactionFailure): EditorStagedSessionState<TSnapshot, THistoryEntry, TTargetKey>;
 export declare function cancelStagedSession<TSnapshot, THistoryEntry, TTargetKey extends string = string>(state: EditorStagedSessionState<TSnapshot, THistoryEntry, TTargetKey>): EditorStagedSessionState<TSnapshot, THistoryEntry, TTargetKey>;
 export declare function enqueueTransaction<TAction, THistoryEntry, TTargetKey extends string = string>(state: EditorTransactionQueueState<TAction, THistoryEntry, TTargetKey>, transaction: EditorTransaction<TAction, THistoryEntry, TTargetKey>): EditorTransactionQueueState<TAction, THistoryEntry, TTargetKey>;
-export declare function beginAutosaveBatch<TAction, THistoryEntry, TTargetKey extends string = string>(state: EditorTransactionQueueState<TAction, THistoryEntry, TTargetKey>): EditorTransactionQueueState<TAction, THistoryEntry, TTargetKey>;
+export declare function beginAutosaveBatch<TAction, THistoryEntry, TTargetKey extends string = string>(state: EditorTransactionQueueState<TAction, THistoryEntry, TTargetKey>, captured?: EditorSaveBatch<TAction, THistoryEntry, TTargetKey>): EditorTransactionQueueState<TAction, THistoryEntry, TTargetKey>;
 export declare function confirmAutosaveBatch<TAction, THistoryEntry, TTargetKey extends string = string>(state: EditorTransactionQueueState<TAction, THistoryEntry, TTargetKey>): EditorTransactionQueueState<TAction, THistoryEntry, TTargetKey>;
 export declare function rejectAutosaveBatch<TAction, THistoryEntry, TTargetKey extends string = string>(state: EditorTransactionQueueState<TAction, THistoryEntry, TTargetKey>, failure: EditorTransactionFailure): EditorTransactionQueueState<TAction, THistoryEntry, TTargetKey>;
 export declare function coalesceQueuedTransactions<TAction, THistoryEntry, TTargetKey extends string = string>(queue: readonly EditorTransaction<TAction, THistoryEntry, TTargetKey>[], transaction: EditorTransaction<TAction, THistoryEntry, TTargetKey>): readonly EditorTransaction<TAction, THistoryEntry, TTargetKey>[];