@riverbankcms/sdk 0.79.0 → 0.81.0

package/dist/_dts/blocks/src/system/runtime/nodes/offerings-preview.d.ts

@@ -0,0 +1,21 @@
+import type { PublicCourse } from "../../blocks/courses/shared/types";
+import type { ButtonVariant, PublicEvent } from "../../blocks/events/shared/types";
+import type { CardStylesContent } from "../../fields/boxStyles";
+import { type BookingOfferingPresetSummary, type OfferingsPreviewEventDataKey, type OfferingsPreviewGroupOverride, type OfferingsPreviewRouteCandidate } from "../../blocks/offerings-preview/model";
+type OfferingsPreviewProps = Readonly<{
+    bookingOfferingPresets?: readonly BookingOfferingPresetSummary[] | null;
+    groupOverrides?: readonly OfferingsPreviewGroupOverride[] | null;
+    cardStyles?: CardStylesContent;
+    itemLimit?: string | null;
+    buttonVariant?: ButtonVariant | null;
+    buttonText?: string | null;
+    emptyMessage?: string | null;
+    failedMessage?: string | null;
+    previewStage?: "published" | "preview" | null;
+    routeCandidates?: Readonly<{
+        routes?: readonly OfferingsPreviewRouteCandidate[] | null;
+    }> | null;
+    courses?: readonly PublicCourse[] | null;
+}> & Partial<Record<OfferingsPreviewEventDataKey, readonly PublicEvent[] | null>>;
+export declare function OfferingsPreviewNode(props: OfferingsPreviewProps): import("react/jsx-runtime").JSX.Element | null;
+export default OfferingsPreviewNode;

package/dist/_dts/blocks/src/system/runtime/resolver.d.ts

@@ -3,8 +3,13 @@ import type { NodeDefinition } from "../node";
 import { bindingSchema } from "../node";
 import { type ThemeTokens } from "../theme";
 import type { TransformRegistry, RouteMap, PageIdentifierMap, EntryIdentifierMap } from "../transforms";
+import type { ResolveImageUrlContext } from "./nodes/media";
 export type ViewModel = Record<string, unknown>;
 export type ComponentRegistry = Record<string, React.ElementType>;
+export type PreviewTextFieldConstraints = Readonly<{
+    maxLength?: number;
+}>;
+export type PreviewFieldConstraintsMap = Readonly<Record<string, PreviewTextFieldConstraints | undefined>>;
 export type ResolverContext = {
     viewModel: ViewModel;
     registry: ComponentRegistry;
@@ -22,6 +27,8 @@ export type ResolverContext = {
     blockBindings?: Record<string, unknown>;
     editableRouteMetadataFieldIds?: ReadonlyArray<string>;
     fragmentRegistry?: Record<string, unknown>;
+    fieldConstraints?: PreviewFieldConstraintsMap;
+    imageResolveContext?: ResolveImageUrlContext;
 };
 /** @internal Exported for testing */
 export type ScopeEntry = {

package/dist/_dts/blocks/src/system/transforms/registry/_utils/sectionForegroundStyles.d.ts

@@ -0,0 +1,2 @@
+import type { TransformContext } from "../core";
+export declare function resolveSectionForegroundStyles(value: unknown, context: TransformContext): Record<string, string>;

package/dist/_dts/blocks/src/system/transforms/registry/boxStyles.d.ts

@@ -60,6 +60,9 @@ export declare const boxStylesCompositeTransform: TransformDefinition<{
     baseClass?: string;
     includeSpacing?: boolean;
 }>;
+export declare const cardVariantClassTransform: TransformDefinition<{
+    baseClass?: string;
+}>;
 export declare const boxStylesBorderColorTransform: TransformDefinition<{
     fallbackToken?: string;
     returnEmptyForDefault?: boolean;
@@ -144,14 +147,16 @@ type SectionHeadingColorOptions = {
  */
 export declare const sectionHeadingColorStyleTransform: TransformDefinition<SectionHeadingColorOptions>;
 /**
- * Resolves section text and heading colors from the background object.
+ * Resolves section foreground colors from the background object.
  *
  * The value should be the full `_sectionStyles.background` object.
  * Outputs:
  * - `color` and `--section-text-color` from background.textColor
  * - `--section-heading-color` from background.headingColor (falls back to textColor if not set)
+ * - `--section-link-color` from background.linkColor (falls back to textColor if not set)
+ * - `--section-supporting-color` from background.supportingColor (falls back to textColor if not set)
  *
- * This combined transform replaces separate textColor/headingColor transforms
+ * This combined transform replaces separate foreground color transforms
  * when both need to be applied to the same style prop.
  */
 export declare const sectionColorsStyleTransform: TransformDefinition<Record<string, never>>;

package/dist/_dts/blocks/src/system/transforms/registry/layout.d.ts

@@ -2,6 +2,12 @@ import { z } from 'zod';
 import type { ThemeHeader } from '../../../../../theme-core/src/schema';
 import type { ThemeTokens } from '../../theme';
 import { type TransformDefinition } from './core';
+declare const headerLogoClassSchema: z.ZodObject<{
+    base: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>;
+export declare const headerLogoClassTransform: TransformDefinition<z.infer<typeof headerLogoClassSchema>>;
+export declare const headerLogoMediaClassTransform: TransformDefinition<z.infer<typeof headerLogoClassSchema>>;
+export declare const headerLogoTextVisibleTransform: TransformDefinition;
 declare const maxWidthClassSchema: z.ZodObject<{
     base: z.ZodOptional<z.ZodString>;
     container: z.ZodOptional<z.ZodString>;
@@ -81,6 +87,8 @@ declare const footerBottomBarContainerClassSchema: z.ZodObject<{
 export declare const footerBottomBarContainerClassTransform: TransformDefinition<z.infer<typeof footerBottomBarContainerClassSchema>>;
 export declare const footerBottomBarStyleTransform: TransformDefinition;
 export declare const footerSplitNavSingleClassTransform: TransformDefinition;
+export declare const footerSimpleRootClassTransform: TransformDefinition;
+export declare const footerSimpleNavClassTransform: TransformDefinition;
 declare const footerSplitMainClassSchema: z.ZodObject<{
     base: z.ZodOptional<z.ZodString>;
     reverseClass: z.ZodOptional<z.ZodString>;
@@ -88,6 +96,7 @@ declare const footerSplitMainClassSchema: z.ZodObject<{
 export declare const footerSplitMainClassTransform: TransformDefinition<z.infer<typeof footerSplitMainClassSchema>>;
 declare const footerLogoClassSchema: z.ZodObject<{
     base: z.ZodOptional<z.ZodString>;
+    requireExplicitShow: z.ZodOptional<z.ZodBoolean>;
 }, z.core.$strip>;
 export declare const footerLogoClassTransform: TransformDefinition<z.infer<typeof footerLogoClassSchema>>;
 declare const footerLogoMediaClassSchema: z.ZodObject<{

package/dist/_dts/blocks/src/system/transforms/typed.d.ts

@@ -18,6 +18,13 @@ export declare const transformDefinitions: {
         stickyTransparent?: string | undefined;
         invert?: string | undefined;
     }>;
+    readonly "layout.headerLogoClass": TransformDefinition<{
+        base?: string | undefined;
+    }>;
+    readonly "layout.headerLogoMediaClass": TransformDefinition<{
+        base?: string | undefined;
+    }>;
+    readonly "layout.headerLogoTextVisible": TransformDefinition;
     readonly "layout.footerRootClass": TransformDefinition<{
         base?: string | undefined;
         surface?: string | undefined;
@@ -41,8 +48,11 @@ export declare const transformDefinitions: {
         base?: string | undefined;
         reverseClass?: string | undefined;
     }>;
+    readonly "layout.footerSimpleRootClass": TransformDefinition;
+    readonly "layout.footerSimpleNavClass": TransformDefinition;
     readonly "layout.footerLogoClass": TransformDefinition<{
         base?: string | undefined;
+        requireExplicitShow?: boolean | undefined;
     }>;
     readonly "layout.footerLogoMediaClass": TransformDefinition<{
         base?: string | undefined;
@@ -92,6 +102,9 @@ export declare const transformDefinitions: {
     readonly "boxStyles.semanticGapValue": TransformDefinition<{
         fallback?: import("../spacing").SemanticSpacing;
     }>;
+    readonly "boxStyles.cardVariantClass": TransformDefinition<{
+        baseClass?: string;
+    }>;
 };
 export type TransformId = keyof typeof transformDefinitions;
 type OptionsOf<T> = T extends TransformDefinition<infer O> ? O : never;
@@ -112,7 +125,7 @@ export declare function bindProp(from: string, opts?: {
     readonly $bind: {
         readonly pick?: "value" | "collection" | "context" | undefined;
         readonly fallback?: {} | null | undefined;
-        readonly transforms?: TransformStep<"date.formatShort" | "boxStyles.semanticGap" | "boxStyles.semanticGapValue" | "ui.twoColumnContainerClass" | "ui.twoColumnFlexBasis" | "ui.sectionStateTone" | "string.uppercase" | "value.fallback" | "value.csv" | "layout.maxWidthClass" | "layout.headerRootClass" | "layout.footerRootClass" | "layout.headerRootStyle" | "layout.headerSectionBackground" | "layout.footerRootStyle" | "ui.headerNavLinkClass" | "ui.headingClassFromAlignment" | "ui.bodyClassFromAlignment" | "ui.stackAlignFromAlignment" | "ui.heroContentWrapperClass" | "ui.heroCtaJustify" | "ui.heroStackJustifyFromVerticalAlignment" | "ui.heroGridClassFromVerticalAlignment" | "ui.conditionalClass" | "media.fromUrl" | "content.interpolateRichTextTokens" | "layout.footerBottomBarClass" | "layout.footerBottomBarContainerClass" | "layout.footerBottomBarStyle" | "layout.footerSplitNavSingleClass" | "layout.footerSplitMainClass" | "layout.footerLogoClass" | "layout.footerLogoMediaClass" | "layout.footerLogoTextVisible">[] | undefined;
+        readonly transforms?: TransformStep<"date.formatShort" | "boxStyles.cardVariantClass" | "boxStyles.semanticGap" | "boxStyles.semanticGapValue" | "ui.twoColumnContainerClass" | "ui.twoColumnFlexBasis" | "ui.sectionStateTone" | "string.uppercase" | "value.fallback" | "value.csv" | "layout.maxWidthClass" | "layout.headerRootClass" | "layout.footerRootClass" | "layout.headerRootStyle" | "layout.headerSectionBackground" | "layout.footerRootStyle" | "ui.headerNavLinkClass" | "ui.headingClassFromAlignment" | "ui.bodyClassFromAlignment" | "ui.stackAlignFromAlignment" | "ui.heroContentWrapperClass" | "ui.heroCtaJustify" | "ui.heroStackJustifyFromVerticalAlignment" | "ui.heroGridClassFromVerticalAlignment" | "ui.conditionalClass" | "media.fromUrl" | "content.interpolateRichTextTokens" | "layout.headerLogoClass" | "layout.headerLogoMediaClass" | "layout.headerLogoTextVisible" | "layout.footerBottomBarClass" | "layout.footerBottomBarContainerClass" | "layout.footerBottomBarStyle" | "layout.footerSplitNavSingleClass" | "layout.footerSimpleRootClass" | "layout.footerSimpleNavClass" | "layout.footerSplitMainClass" | "layout.footerLogoClass" | "layout.footerLogoMediaClass" | "layout.footerLogoTextVisible">[] | undefined;
         readonly from: string;
     };
 };

package/dist/_dts/calendar/src/grid.d.ts

@@ -6,6 +6,21 @@
  * cells with `groupItemsByDate` from `./group`.
  */
 export type WeekStart = 'sunday' | 'monday';
+export type CalendarViewportKind = 'month' | 'week';
+export type WeekCalendarDays = readonly [Date, Date, Date, Date, Date, Date, Date];
+export type MonthCalendarViewport = Readonly<{
+    kind: 'month';
+    anchorDate: Date;
+    days: readonly Date[];
+    title: string;
+}>;
+export type WeekCalendarViewport = Readonly<{
+    kind: 'week';
+    anchorDate: Date;
+    days: WeekCalendarDays;
+    title: string;
+}>;
+export type CalendarViewport = MonthCalendarViewport | WeekCalendarViewport;
 export declare const DAY_NAMES: readonly ["Sun", "Mon", "Tue", "Wed", "Thu", "Fri", "Sat"];
 export declare const MONTH_NAMES: readonly ["January", "February", "March", "April", "May", "June", "July", "August", "September", "October", "November", "December"];
 /**
@@ -31,6 +46,10 @@ export declare function getEndOfMonth(date: Date): Date;
  * in non-leap years).
  */
 export declare function addMonths(date: Date, months: number): Date;
+/** Add (or subtract) days while preserving local time-of-day fields. */
+export declare function addDays(date: Date, days: number): Date;
+/** Shift a calendar anchor by the natural unit for a viewport kind. */
+export declare function shiftCalendarAnchorDate(date: Date, view: CalendarViewportKind, steps: number): Date;
 /**
  * Get an inclusive 3-month window around `date`, returned as ISO strings
  * with UTC midnight bounds. Suitable for prefetching event windows when
@@ -47,6 +66,8 @@ export declare function getThreeMonthRange(date: Date): {
 export declare function getMonthCalendarDays(year: number, month: number, startOfWeek: WeekStart): Date[];
 /** Build the 7 dates of the week containing `baseDate`. */
 export declare function getWeekCalendarDays(baseDate: Date, startOfWeek: WeekStart): Date[];
+/** Build the 7 dates of the week containing `baseDate` as a fixed-width tuple. */
+export declare function getWeekCalendarDayTuple(baseDate: Date, startOfWeek: WeekStart): WeekCalendarDays;
 /**
  * Day-name labels reordered for the chosen week start. Pass a custom
  * `dayNames` array (length 7, Sunday-first) to localize.
@@ -58,3 +79,9 @@ export declare function getOrderedDayNames(startOfWeek: WeekStart, dayNames?: re
  *   - week:  "January 5 - 11, 2025" or "December 30 - January 5, 2025"
  */
 export declare function formatCalendarTitle(viewDate: Date, view: 'month' | 'week', days: Date[], monthNames?: readonly string[]): string;
+export declare function buildCalendarViewport(input: Readonly<{
+    view: CalendarViewportKind;
+    anchorDate: Date;
+    startOfWeek: WeekStart;
+    monthNames?: readonly string[];
+}>): CalendarViewport;

package/dist/_dts/calendar/src/index.d.ts

@@ -1,5 +1,5 @@
-export type { WeekStart } from './grid';
-export { getMonthCalendarDays, getWeekCalendarDays, getOrderedDayNames, formatCalendarTitle, formatDateKey, isToday, isSameLocalDay, addMonths, getStartOfMonth, getEndOfMonth, getThreeMonthRange, DAY_NAMES, MONTH_NAMES, MAX_EVENTS_PER_DAY, } from './grid';
+export type { CalendarViewport, CalendarViewportKind, MonthCalendarViewport, WeekCalendarDays, WeekCalendarViewport, WeekStart, } from './grid';
+export { addDays, buildCalendarViewport, getMonthCalendarDays, getWeekCalendarDays, getWeekCalendarDayTuple, getOrderedDayNames, formatCalendarTitle, formatDateKey, isToday, isSameLocalDay, addMonths, shiftCalendarAnchorDate, getStartOfMonth, getEndOfMonth, getThreeMonthRange, DAY_NAMES, MONTH_NAMES, MAX_EVENTS_PER_DAY, } from './grid';
 export type { TimetableInput, TimetableModel, TimetableDay, TimetableCell, TimetableBounds, TimetableDiagnostic, InvalidItemReason, TimetableView, } from './timetable';
 export { buildTimetableModel } from './timetable';
 export type { GroupItemsByDateAccessors } from './group';

package/dist/_dts/content-editor/src/controller/useAutosaveTriggers.d.ts

@@ -1,10 +1,12 @@
 import type { useStoreAutosave } from '../hooks/useStoreAutosave';
 import type { useBlockAutosave } from '../hooks/useBlockAutosave';
+import type { AutosaveHandle } from '../hooks/useSimpleAutosave';
 import type { createEditorUiStore } from '../ui/editorUiStore';
 type UseAutosaveTriggersProps = {
     uiStore: ReturnType<typeof createEditorUiStore>;
     metadataAutosave: ReturnType<typeof useStoreAutosave>;
     blockAutosave: ReturnType<typeof useBlockAutosave>;
+    linkedEntryAutosave?: AutosaveHandle | null;
     /** Content autosave - only provided for content entries (not pages) */
     contentAutosave?: ReturnType<typeof useStoreAutosave> | null;
     hasRoute: boolean;
@@ -23,5 +25,5 @@ type UseAutosaveTriggersProps = {
  * transition tracking. When a user continues editing during/after save,
  * status stays 'pending' but version increments, so we still trigger.
  */
-export declare function useAutosaveTriggers({ uiStore, metadataAutosave, blockAutosave, contentAutosave, hasRoute, enableTriggers, }: UseAutosaveTriggersProps): void;
+export declare function useAutosaveTriggers({ uiStore, metadataAutosave, blockAutosave, linkedEntryAutosave, contentAutosave, hasRoute, enableTriggers, }: UseAutosaveTriggersProps): void;
 export {};

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

@@ -0,0 +1 @@
+export * from './ui/editorTransactionState';

package/dist/_dts/content-editor/src/hooks/autosaveScopePlanning.d.ts

@@ -0,0 +1,26 @@
+import type { EditorSyncState } from '../../../core/src/index';
+import type { LinkedContentEntryId } from '../linkedEntries/domain';
+import type { AutosaveStatus } from '../ui/stores/types';
+export { unsafeAsLinkedContentEntryId, type LinkedContentEntryId, } from '../linkedEntries/domain';
+export type EditorAutosaveScope = Readonly<{
+    kind: 'metadata';
+}> | Readonly<{
+    kind: 'content';
+}> | Readonly<{
+    kind: 'blocks';
+}> | Readonly<{
+    kind: 'linkedEntry';
+    entryId: LinkedContentEntryId;
+}>;
+export type EditorAutosaveSchedulerKey = 'metadata' | 'content' | 'blocks' | 'linkedEntries';
+export type AutosaveScopeSnapshot = Readonly<{
+    scope: EditorAutosaveScope;
+    syncState: EditorSyncState;
+}>;
+export type AutosaveStatusByScheduler = Readonly<Record<EditorAutosaveSchedulerKey, AutosaveStatus>>;
+export declare function autosaveScopeKey(scope: EditorAutosaveScope): string;
+export declare function autosaveSchedulerKey(scope: EditorAutosaveScope): EditorAutosaveSchedulerKey;
+export declare function uniqueAutosaveSchedulerKeys(scopes: readonly EditorAutosaveScope[]): EditorAutosaveSchedulerKey[];
+export declare function deriveDirtyAutosaveScopes(snapshots: readonly AutosaveScopeSnapshot[]): EditorAutosaveScope[];
+export declare function hasAutosaveStatusFailure(statuses: AutosaveStatusByScheduler): boolean;
+export declare function allAutosaveStatusesComplete(statuses: AutosaveStatusByScheduler): boolean;

package/dist/_dts/content-editor/src/hooks/publishability.d.ts

@@ -31,6 +31,7 @@ export type PublishabilityAutosaveState = Readonly<{
     metadata: AutosaveStatus;
     content: AutosaveStatus;
     blocks: AutosaveStatus;
+    linkedEntries: AutosaveStatus;
 }>;
 export type DerivePublishabilityInput = Readonly<{
     unpublishedState: EditorUnpublishedState;

package/dist/_dts/content-editor/src/hooks/useLinkedEntryAutosave.d.ts

@@ -0,0 +1,23 @@
+import type { ApiClient } from '../services';
+import type { LinkedContentEntryId, LinkedContentTypeKey } from '../linkedEntries/domain';
+import type { EditorUiStoreInstance } from '../ui/editorUiStore';
+export type PendingLinkedEntrySave = Readonly<{
+    entryId: LinkedContentEntryId;
+    contentTypeKey: LinkedContentTypeKey;
+    content: Record<string, unknown>;
+    optimisticHash: string | null;
+    acknowledgedVersion: number;
+}>;
+export type LinkedEntrySaveResult = Readonly<{
+    entryId: LinkedContentEntryId;
+    content: Record<string, unknown>;
+    optimisticHash: string | null;
+}>;
+export type LinkedEntryAutosaveOptions = Readonly<{
+    uiStore: EditorUiStoreInstance;
+    apiClient: ApiClient;
+    siteId: string;
+    saveLinkedEntry?: (save: PendingLinkedEntrySave) => Promise<LinkedEntrySaveResult>;
+}>;
+export declare function collectPendingLinkedEntrySaves(uiStore: EditorUiStoreInstance): PendingLinkedEntrySave[];
+export declare function useLinkedEntryAutosave({ uiStore, apiClient, siteId, saveLinkedEntry, }: LinkedEntryAutosaveOptions): import("./useSimpleAutosave").AutosaveHandle;

package/dist/_dts/content-editor/src/hooks/useReactiveToolbar.d.ts

@@ -1,4 +1,4 @@
-import type { EditorStatusBarToolbar } from "@riverbankcms/editor";
+import type { EditorStatusBarToolbar } from "../../../editor/src/index";
 /**
  * Builds a reactive toolbar for the editor status bar.
  *

package/dist/_dts/content-editor/src/hooks/useSimpleAutosave.d.ts

@@ -23,8 +23,8 @@ type AutosaveConfig<TValues, TPayload> = {
     enabled?: boolean;
     /** UI store instance for updating autosave status */
     uiStore: EditorUiStoreInstance;
-    /** Which autosave type: 'metadata', 'blocks', or 'content' */
-    type: 'metadata' | 'blocks' | 'content';
+    /** Which autosave scheduler this hook updates */
+    type: 'metadata' | 'blocks' | 'content' | 'linkedEntries';
 };
 export type AutosaveHandle = {
     trigger: () => void;

package/dist/_dts/content-editor/src/index.d.ts

@@ -4,6 +4,8 @@ export { useDebouncedLatestSave, type DebouncedLatestSaveConfig, type DebouncedL
 export { useSimpleAutosave, useMultiAutosave } from './hooks/useSimpleAutosave';
 export { useStoreAutosave, type StoreAutosaveConfig, type AutosaveScope } from './hooks/useStoreAutosave';
 export { useBlockAutosave, type BlockAutosaveOptions } from './hooks/useBlockAutosave';
+export { collectPendingLinkedEntrySaves, useLinkedEntryAutosave, type LinkedEntryAutosaveOptions, type LinkedEntrySaveResult, type PendingLinkedEntrySave, } from './hooks/useLinkedEntryAutosave';
+export { unsafeAsLinkedContentEntryId, unsafeAsLinkedContentTypeKey, type LinkedContentEntryId, type LinkedContentTypeKey, } from './linkedEntries/domain';
 export { useEntryActions, type EntryActionsOptions } from './hooks/useEntryActions';
 export { useReactiveToolbar } from './hooks/useReactiveToolbar';
 export { isInvalidSaveability, selectHasInvalidBlocks } from './hooks/invalidBlockSelectors';
@@ -16,7 +18,7 @@ export { EditableBlockProvider, useBlockData } from './components/EditableBlockP
 export { ContentFieldsForm, type ContentFieldsFormProps } from './components/ContentFieldsForm';
 export { useUISelector } from './ui/useUISelector';
 export { EditorUiStoreProvider, useEditorUiStore, useEditorUiStoreInstance, useOptionalEditorUiStoreInstance, createEditorUiStore } from './ui/editorUiStore';
-export type { ActivePreviewField, EditorUiStoreInstance, EditorUiState, PreviewSidebarTab, ViewportMode, ViewportWidth, ViewportState, ZoomLevel, } from './ui/editorUiStore';
+export type { ActivePreviewField, EditorUiStoreInstance, EditorUiState, EditorPreviewInspectorStore, EditorLinkedEntrySnapshot, PreviewInspection, PreviewSidebarTab, ViewportMode, ViewportWidth, ViewportState, ZoomLevel, } from './ui/editorUiStore';
 export { PreviewTextEditor } from './primitives/PreviewTextEditor';
 export { PreviewRichTextEditor } from './primitives/PreviewRichTextEditor';
 export { useStoreBinding, parseEditorPath } from './primitives/shared';

package/dist/_dts/content-editor/src/lib/json.d.ts

@@ -0,0 +1,2 @@
+import type { JsonValue } from '../../../api/src/content-editor';
+export declare function toJsonObject(value: Record<string, unknown>): Record<string, JsonValue>;

package/dist/_dts/content-editor/src/linkedEntries/domain.d.ts

@@ -0,0 +1,8 @@
+export type LinkedContentEntryId = string & {
+    readonly __linkedContentEntryId: unique symbol;
+};
+export type LinkedContentTypeKey = string & {
+    readonly __linkedContentTypeKey: unique symbol;
+};
+export declare function unsafeAsLinkedContentEntryId(value: string): LinkedContentEntryId;
+export declare function unsafeAsLinkedContentTypeKey(value: string): LinkedContentTypeKey;

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

@@ -1,4 +1,5 @@
 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 EditorSiteId, type EditorStructuralCommand, type EditorStructuralDraftSnapshot, type EditorSyncState, type EditorValueRecord } from '../../../core/src/index';
+import { type LinkedContentEntryId, type LinkedContentTypeKey } from '../linkedEntries/domain';
 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';
@@ -23,6 +24,15 @@ export type EditorCommand = {
     type: 'replace-block';
     blockId: EditorBlockId;
     value: EditorBlockValues | null;
+} | {
+    type: 'set-linked-entry-value';
+    entryId: string;
+    path: string;
+    value: unknown;
+} | {
+    type: 'replace-linked-entry';
+    entryId: string;
+    value: EditorContentValues | null;
 } | EditorStructuralCommand | {
     type: 'batch';
     changes: readonly EditorCommand[];
@@ -51,6 +61,18 @@ export type EditorValueSnapshot<TValue extends EditorValueRecord | null> = Reado
 }>;
 type EditorMetadataSnapshot = EditorValueSnapshot<EditorMetadataValues | null>;
 type EditorContentSnapshot = EditorValueSnapshot<EditorContentValues | null>;
+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<{
+    meta: EditorLinkedEntryMeta;
+}>;
 export type EditorBlockMeta = Readonly<{
     kind: string;
     purpose: string | null;
@@ -96,6 +118,7 @@ export type EditorHistorySnapshot = Readonly<{
      */
     blockList: readonly NormalizedEditorBlockItem[];
     drafts: Readonly<Record<EditorBlockId, EditorDraftSnapshot>>;
+    linkedEntries: Readonly<Record<string, EditorLinkedEntrySnapshot>>;
 }>;
 export declare function requirePersistedEditorBlock(block: EditorBlockItem | NormalizedEditorBlockItem): PersistedEditorBlockItem;
 export declare function createEditorDraftSnapshotFromBlock(block: PersistedEditorBlockItem): EditorDraftSnapshot;
@@ -179,6 +202,33 @@ export type EditorSystemOperation = {
 } | {
     type: 'clear-draft-pending';
     blockId: EditorBlockId;
+} | {
+    type: 'hydrate-linked-entry';
+    entryId: string;
+    contentTypeKey: string;
+    contentTypeLabel: string;
+    title: string;
+    titleField?: string | null;
+    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;
+} | {
+    type: 'save-linked-entry-failed';
+    entryId: string;
+    message?: string;
+} | {
+    type: 'clear-linked-entry-error';
+    entryId: string;
 } | {
     type: 'replace-block-list';
     next: readonly EditorBlockItem[];
@@ -210,7 +260,15 @@ export declare function autosaveDraftFailed(snapshot: EditorHistorySnapshot, blo
 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: '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;
 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[];
+export declare function getLinkedEntrySnapshot(snapshot: EditorHistorySnapshot, entryId: string): EditorLinkedEntrySnapshot | null;
 export declare function hasUnpublishedDraftChanges(snapshot: EditorHistorySnapshot): boolean;

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

@@ -0,0 +1,93 @@
+export type EditorTransaction<TAction, THistoryEntry, TTargetKey extends string = string> = Readonly<{
+    targetKey: TTargetKey;
+    action: TAction;
+    historyEntry: THistoryEntry | null;
+}>;
+export type EditorCommitPolicy = Readonly<{
+    kind: 'autosave-latest';
+}> | Readonly<{
+    kind: 'staged';
+}> | Readonly<{
+    kind: 'manual-flush';
+}>;
+export type EditorSaveBatch<TAction, THistoryEntry, TTargetKey extends string = string> = Readonly<{
+    transactions: readonly EditorTransaction<TAction, THistoryEntry, TTargetKey>[];
+}>;
+export type EditorTransactionFailure = Readonly<{
+    kind: 'retryable';
+    message: string;
+} | {
+    kind: 'stale';
+    message: string;
+}>;
+export type EditorTransactionQueueState<TAction, THistoryEntry, TTargetKey extends string = string> = Readonly<{
+    kind: 'idle';
+}> | Readonly<{
+    kind: 'dirty';
+    transactions: readonly EditorTransaction<TAction, THistoryEntry, TTargetKey>[];
+}> | Readonly<{
+    kind: 'saving';
+    batch: EditorSaveBatch<TAction, THistoryEntry, TTargetKey>;
+    followUpTransactions: readonly EditorTransaction<TAction, THistoryEntry, TTargetKey>[];
+}> | Readonly<{
+    kind: 'failed';
+    message: string;
+    transactions: readonly EditorTransaction<TAction, THistoryEntry, TTargetKey>[];
+}> | Readonly<{
+    kind: 'stale';
+    message: string;
+    transactions: readonly EditorTransaction<TAction, THistoryEntry, TTargetKey>[];
+}>;
+export type EditorTransactionCapabilities = Readonly<{
+    canApplyTransaction: boolean;
+    canStartAutosave: boolean;
+    canUseHistory: boolean;
+    requiresReload: boolean;
+}>;
+export type EditorStagedTransaction<TSnapshot, THistoryEntry, TTargetKey extends string = string> = Readonly<{
+    commitPolicy: Extract<EditorCommitPolicy, {
+        kind: 'staged';
+    }>;
+    targetKey: TTargetKey;
+    base: TSnapshot;
+    preview: TSnapshot;
+    historyEntry: THistoryEntry | null;
+}>;
+export type EditorStagedSessionState<TSnapshot, THistoryEntry, TTargetKey extends string = string> = Readonly<{
+    kind: 'idle';
+}> | Readonly<{
+    kind: 'active';
+    transaction: EditorStagedTransaction<TSnapshot, THistoryEntry, TTargetKey>;
+}> | Readonly<{
+    kind: 'applying';
+    transaction: EditorStagedTransaction<TSnapshot, THistoryEntry, TTargetKey>;
+}> | Readonly<{
+    kind: 'failed';
+    message: string;
+    transaction: EditorStagedTransaction<TSnapshot, THistoryEntry, TTargetKey>;
+}> | Readonly<{
+    kind: 'stale';
+    message: string;
+    transaction: EditorStagedTransaction<TSnapshot, THistoryEntry, TTargetKey>;
+}>;
+export type EditorStagedSessionCapabilities = Readonly<{
+    canPreviewStaged: boolean;
+    canApplyStaged: boolean;
+    canCancelStaged: boolean;
+    isApplyingStaged: boolean;
+    requiresReload: boolean;
+}>;
+export declare function idleEditorTransactionQueueState<TAction, THistoryEntry, TTargetKey extends string = string>(): EditorTransactionQueueState<TAction, THistoryEntry, TTargetKey>;
+export declare function idleEditorStagedSessionState<TSnapshot, THistoryEntry, TTargetKey extends string = string>(): EditorStagedSessionState<TSnapshot, THistoryEntry, TTargetKey>;
+export declare function deriveTransactionCapabilities(state: EditorTransactionQueueState<unknown, unknown>): EditorTransactionCapabilities;
+export declare function deriveStagedSessionCapabilities(state: EditorStagedSessionState<unknown, unknown>): EditorStagedSessionCapabilities;
+export declare function beginStagedSession<TSnapshot, THistoryEntry, TTargetKey extends string = string>(state: EditorStagedSessionState<TSnapshot, THistoryEntry, TTargetKey>, transaction: EditorStagedTransaction<TSnapshot, THistoryEntry, TTargetKey>): EditorStagedSessionState<TSnapshot, THistoryEntry, TTargetKey>;
+export declare function applyStagedSession<TSnapshot, THistoryEntry, TTargetKey extends string = string>(state: EditorStagedSessionState<TSnapshot, THistoryEntry, TTargetKey>): EditorStagedSessionState<TSnapshot, THistoryEntry, TTargetKey>;
+export declare function confirmStagedSession<TSnapshot, THistoryEntry, TTargetKey extends string = string>(state: EditorStagedSessionState<TSnapshot, THistoryEntry, TTargetKey>): EditorStagedSessionState<TSnapshot, THistoryEntry, TTargetKey>;
+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 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>[];