@riverbankcms/sdk 0.80.0 → 0.81.0

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

@@ -11,9 +11,11 @@ export type AutosaveState = {
     metadata: AutosaveStatus;
     content: AutosaveStatus;
     blocks: AutosaveStatus;
+    linkedEntries: AutosaveStatus;
     setMetadataStatus: (status: Partial<AutosaveStatus>) => void;
     setContentStatus: (status: Partial<AutosaveStatus>) => void;
     setBlocksStatus: (status: Partial<AutosaveStatus>) => void;
+    setLinkedEntriesStatus: (status: Partial<AutosaveStatus>) => void;
     registerAutosave: (type: AutosaveType, handle: AutosaveHandle) => void;
     unregisterAutosave: (type: AutosaveType) => void;
     /**

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

@@ -11,7 +11,7 @@ export type AutosaveHandle = {
     flush: () => void;
     isPending: () => boolean;
 };
-export type AutosaveType = 'metadata' | 'content' | 'blocks';
+export type AutosaveType = 'metadata' | 'content' | 'blocks' | 'linkedEntries';
 export type FocusRequest = {
     requestId: number;
     blockId: EditorBlockId;

package/dist/_dts/content-model/src/content-types/builtins.d.ts

@@ -475,4 +475,47 @@ export declare const BUILTIN_CONTENT_TYPE_FIELD_IDS: {
     readonly page: ReadonlySet<string>;
     readonly 'product-category': ReadonlySet<string>;
 };
+export type BuiltinPreviewLinkedEntryEditing = Readonly<{
+    kind: 'generic';
+}> | Readonly<{
+    kind: 'unsupported-domain-backed';
+    reason: string;
+}>;
+/**
+ * Preview editing support for built-in content entries when they appear as
+ * linked data inside a block. Generic editorial content can use the shared
+ * content-entry form; domain-backed content stays closed until its workflow
+ * can preserve domain invariants such as occurrences, booking, or commerce.
+ */
+export declare const BUILTIN_PREVIEW_LINKED_ENTRY_EDITING: {
+    readonly post: {
+        readonly kind: "generic";
+    };
+    readonly event: {
+        readonly kind: "unsupported-domain-backed";
+        readonly reason: "Domain-backed entries need a dedicated editor workflow.";
+    };
+    readonly course: {
+        readonly kind: "unsupported-domain-backed";
+        readonly reason: "Domain-backed entries need a dedicated editor workflow.";
+    };
+    readonly 'team-member': {
+        readonly kind: "generic";
+    };
+    readonly product: {
+        readonly kind: "unsupported-domain-backed";
+        readonly reason: "Domain-backed entries need a dedicated editor workflow.";
+    };
+    readonly testimonial: {
+        readonly kind: "generic";
+    };
+    readonly page: {
+        readonly kind: "generic";
+    };
+    readonly 'product-category': {
+        readonly kind: "unsupported-domain-backed";
+        readonly reason: "Domain-backed entries need a dedicated editor workflow.";
+    };
+};
+export declare function getBuiltinPreviewLinkedEntryEditing(key: string): BuiltinPreviewLinkedEntryEditing | null;
 export {};

package/dist/_dts/content-model/src/metadataConfig.d.ts

@@ -1,77 +1,113 @@
-type VisibilityRole = "admin" | "designer" | "author";
-type BlockManifestUi = {
-    showSlugPreview?: boolean;
-    showCharCount?: number | {
-        max: number;
-    };
-    visibleWhen?: {
-        field: string;
-        equals?: unknown;
-        notEquals?: unknown;
-        oneOf?: unknown[];
-        notIn?: unknown[];
-    };
+import type { ContentEntrySnapshot } from "./types";
+declare const nonEmptyPageRouteSlugBrand: unique symbol;
+export type NonEmptyPageRouteSlug = string & {
+    readonly [nonEmptyPageRouteSlugBrand]: "NonEmptyPageRouteSlug";
 };
-type BaseBlockManifestField = {
-    id: string;
+export type PageRouteSlug = Readonly<{
+    kind: "homepage";
+}> | Readonly<{
+    kind: "slug";
+    value: NonEmptyPageRouteSlug;
+}>;
+export type RouteMetadataManifestContext = Readonly<{
+    kind: "page";
+    routeSlug: PageRouteSlug;
+}> | Readonly<{
+    kind: "content";
+    typeKey?: string | null;
+}>;
+export type RouteMetadataPresentation = Readonly<{
+    kind: "page-homepage";
+    manifest: RouteMetadataManifest;
+    routeSlug: Extract<PageRouteSlug, {
+        kind: "homepage";
+    }>;
+}> | Readonly<{
+    kind: "page-routable";
+    manifest: RouteMetadataManifest;
+    routeSlug: Extract<PageRouteSlug, {
+        kind: "slug";
+    }>;
+}> | Readonly<{
+    kind: "content";
+    manifest: RouteMetadataManifest;
+    typeKey: string | null;
+}>;
+export type RouteMetadataFieldId = "draftTitle" | "draftSlug" | "draftStatus" | "scheduledPublishAt" | "draftMetaTitle" | "draftMetaDescription" | "ogImageId";
+type RouteMetadataTextField = {
+    id: "draftTitle" | "draftMetaTitle" | "draftMetaDescription" | "ogImageId";
+    type: "text";
     label: string;
     description?: string;
-    visibleRoles?: VisibilityRole[];
-    defaultValue?: unknown;
     required: boolean;
-    ui?: BlockManifestUi;
-};
-type TextBlockManifestField = BaseBlockManifestField & {
-    type: "text";
     multiline: boolean;
-    maxLength?: number;
+    ui?: {
+        showCharCount?: {
+            max: number;
+        };
+    };
 };
-type SlugBlockManifestField = BaseBlockManifestField & {
+type RouteMetadataSlugField = {
+    id: "draftSlug";
     type: "slug";
-    sourceFieldId?: string;
-    statusFieldId?: string;
-    maxLength?: number;
+    label: string;
+    description: string;
+    required: true;
+    sourceFieldId?: "draftTitle";
+    statusFieldId: "draftStatus";
+    maxLength: number;
+    ui: {
+        showSlugPreview: true;
+    };
 };
-type SelectBlockManifestField = BaseBlockManifestField & {
+type RouteMetadataSelectField = {
+    id: "draftStatus";
     type: "select";
+    label: string;
+    description: string;
+    required: true;
+    defaultValue: string;
     options: Array<{
         value: string;
         label: string;
-        description?: string;
-        icon?: string;
     }>;
-    multiple: boolean;
+    multiple: false;
 };
-type DateTimeBlockManifestField = BaseBlockManifestField & {
+type RouteMetadataDatetimeField = {
+    id: "scheduledPublishAt";
     type: "datetime";
-};
-type BlockManifestField = TextBlockManifestField | SlugBlockManifestField | SelectBlockManifestField | DateTimeBlockManifestField;
-type BlockManifestSlot = {
-    id: string;
     label: string;
-    allowedKinds: string[];
-    min: number;
-    max?: number;
-    help?: string;
-    visibleRoles?: VisibilityRole[];
+    description: string;
+    required: false;
+    ui: {
+        visibleWhen: {
+            field: "draftStatus";
+            equals: "scheduled";
+        };
+    };
 };
-type BlockManifest = {
+export type RouteMetadataField = RouteMetadataTextField | RouteMetadataSlugField | RouteMetadataSelectField | RouteMetadataDatetimeField;
+export type RouteMetadataManifest = {
     name: string;
     version: string;
     title: string;
     description: string;
     component: string;
-    fields: BlockManifestField[];
-    slots: BlockManifestSlot[];
+    fields: RouteMetadataField[];
+    slots: [];
 };
-export type RouteMetadataFieldId = "draftTitle" | "draftSlug" | "draftStatus" | "scheduledPublishAt" | "draftMetaTitle" | "draftMetaDescription" | "ogImageId";
-export declare const ROUTE_METADATA_MANIFEST: BlockManifest;
+export declare const ROUTE_METADATA_MANIFEST: RouteMetadataManifest;
 export declare const METADATA_WORKFLOW_FIELDS: {
     readonly title: "draftTitle";
     readonly slug: "draftSlug";
     readonly status: "draftStatus";
     readonly publishAt: "scheduledPublishAt";
 };
+export declare function pageRouteSlugFromEditorValue(value: string | null | undefined): PageRouteSlug;
+export declare function pageRouteSlugToEditorValue(slug: PageRouteSlug): string;
+export declare function pageRouteSlugToStoredValue(slug: PageRouteSlug): string | null;
+export declare function isHomepagePageRouteSlug(slug: PageRouteSlug): boolean;
+export declare function resolvePageRouteSlug(entry: ContentEntrySnapshot, currentSlug?: string | null): PageRouteSlug | null;
 export declare const ROUTE_METADATA_MANAGED_FIELDS_BY_TYPE: {
     readonly event: readonly ["draftTitle", "draftSlug", "draftStatus", "scheduledPublishAt"];
     readonly course: readonly ["draftTitle", "draftSlug", "draftStatus", "scheduledPublishAt"];
@@ -82,13 +118,17 @@ export declare const ROUTE_METADATA_MANAGED_FIELDS_BY_TYPE: {
 export declare function getManagedRouteMetadataFieldIdsForType(typeKey: string | null | undefined): ReadonlyArray<RouteMetadataFieldId>;
 export declare function isRouteMetadataFieldEditableForType(typeKey: string | null | undefined, fieldId: string): boolean;
 export declare function getEditableRouteMetadataFieldIdsForType(typeKey: string | null | undefined): ReadonlyArray<RouteMetadataFieldId>;
-export declare function getRouteMetadataManifestForType(typeKey: string | null | undefined): BlockManifest;
+export declare function getRouteMetadataManifestForType(typeKey: string | null | undefined): RouteMetadataManifest;
+export declare function getRouteMetadataManifestForContext(context: RouteMetadataManifestContext): RouteMetadataManifest;
+export declare function deriveRouteMetadataPresentation(context: RouteMetadataManifestContext, options?: Readonly<{
+    omitTitle?: boolean;
+}>): RouteMetadataPresentation;
 /**
  * Remove the legacy route title editor from a route metadata manifest.
  *
  * Entry titles are now derived from entry data (single source of truth) and the route title is a denormalized copy.
  * We still keep `draftTitle` in the underlying manifest for page creation flows, but we omit it from entry editors.
  */
-export declare function omitRouteTitleFieldFromManifest(manifest: BlockManifest): BlockManifest;
+export declare function omitRouteTitleFieldFromManifest(manifest: RouteMetadataManifest): RouteMetadataManifest;
 export declare function sanitizeSlug(value: string): string;
 export {};

package/dist/_dts/core/src/branded.d.ts

@@ -75,6 +75,8 @@ export type BookingCalendarFeedTokenPublicId = Brand<string, 'BookingCalendarFee
 export type BookingCalendarFeedTokenSecret = Brand<string, 'BookingCalendarFeedTokenSecret'>;
 export type BookingCalendarFeedTokenSecretHash = Brand<string, 'BookingCalendarFeedTokenSecretHash'>;
 export type ContentEntryId = Brand<string, 'ContentEntryId'>;
+export type ContentVersionId = Brand<string, 'ContentVersionId'>;
+export type EntryContentHash = Brand<string, 'EntryContentHash'>;
 export type StripeInvoiceId = Brand<string, 'StripeInvoiceId'>;
 export type NewsletterSubscriberId = Brand<string, 'NewsletterSubscriberId'>;
 export type NavigationMenuId = Brand<string, 'NavigationMenuId'>;
@@ -186,6 +188,8 @@ export declare const unsafeAsBookingCalendarFeedTokenPublicId: (id: string) => B
 export declare const unsafeAsBookingCalendarFeedTokenSecret: (value: string) => BookingCalendarFeedTokenSecret;
 export declare const unsafeAsBookingCalendarFeedTokenSecretHash: (value: string) => BookingCalendarFeedTokenSecretHash;
 export declare const unsafeAsContentEntryId: (id: string) => ContentEntryId;
+export declare const unsafeAsContentVersionId: (id: string) => ContentVersionId;
+export declare const unsafeAsEntryContentHash: (value: string) => EntryContentHash;
 export declare const unsafeAsStripeInvoiceId: (id: string) => StripeInvoiceId;
 export declare const unsafeAsNewsletterSubscriberId: (id: string) => NewsletterSubscriberId;
 export declare const unsafeAsNavigationMenuId: (id: string) => NavigationMenuId;
@@ -229,6 +233,7 @@ export declare const parseProductVariantId: (value: unknown) => Result<ProductVa
 export declare const parseProductCategoryId: (value: unknown) => Result<ProductCategoryId, BrandedIdParseError>;
 export declare const parseMediaAssetId: (value: unknown) => Result<MediaAssetId, BrandedIdParseError>;
 export declare const parseContentEntryId: (value: unknown) => Result<ContentEntryId, BrandedIdParseError>;
+export declare const parseContentVersionId: (value: unknown) => Result<ContentVersionId, BrandedIdParseError>;
 export declare const parseNavigationMenuId: (value: unknown) => Result<NavigationMenuId, BrandedIdParseError>;
 export declare const parseNavigationItemId: (value: unknown) => Result<NavigationItemId, BrandedIdParseError>;
 export declare const parsePassId: (value: unknown) => Result<PassId, BrandedIdParseError>;

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

@@ -41,5 +41,6 @@ export * from "./email-format";
 export * from "./slug";
 export * from "./string";
 export * from "./uuid";
+export * from "./stable-json";
 export { disabledSelection, enabledSelection, plannerNoChange, plannerPatch, plannerUpdate, resolvePlanningDateInput, resolvePlanningNow, resolvePlanningNowDate, systemPlanningClock, } from "./planner";
 export type { DisabledSelection, EnabledSelection, OptionalSelection, PlannerNoChange, PlannerPatch, PlannerUpdate, PlanningClock, PlanningDateInput, PlanningTimeOptions, } from "./planner";

package/dist/_dts/core/src/stable-json.d.ts

@@ -0,0 +1 @@
+export declare function stableJsonStringify(value: unknown): string;

package/dist/_dts/editor/src/EditorProvider.d.ts

@@ -0,0 +1,26 @@
+import React, { type ReactNode } from 'react';
+export type DrawerFocusTarget = {
+    blockId: string | null;
+    fieldPath?: string | null;
+    itemIndex?: number | null;
+};
+export type DraftSyncState = 'baseline' | 'pending' | 'failed';
+interface EditorContextType {
+    isEditingMode: boolean;
+    toggleEditingMode: () => void;
+    setEditingMode: (value: boolean) => void;
+    editingElement: string | null;
+    setEditingElement: (elementId: string | null) => void;
+    currentBlockId?: string;
+    setCurrentBlock: (id: string | undefined) => void;
+    drawerFocus: DrawerFocusTarget | null;
+    setDrawerFocus: (target: DrawerFocusTarget | null) => void;
+    clearDrawerFocus: () => void;
+}
+export declare const useEditor: () => EditorContextType;
+interface EditorProviderProps {
+    children: ReactNode;
+    initialEditingMode?: boolean;
+}
+export declare const EditorProvider: React.FC<EditorProviderProps>;
+export {};

package/dist/_dts/editor/src/chrome/EditorChrome.d.ts

@@ -0,0 +1,26 @@
+import { type ReactNode } from 'react';
+import { type EditorHistoryBarControls, type EditorStatusBarToolbar, type StatusBarMenuItem } from './EditorStatusBar';
+type EditorChromeProps = {
+    toolbarOverrides?: Partial<EditorStatusBarToolbar>;
+    onPublish?: () => void | Promise<void>;
+    onDiscard?: () => void | Promise<void>;
+    publishMenuItems?: StatusBarMenuItem[];
+    actionsSlot?: ReactNode;
+    messageOverride?: string | null;
+    messageVariant?: 'default' | 'manual-save';
+    actionButtonSize?: 'sm' | 'default' | 'lg';
+    showStatusBar?: boolean;
+    showToggle?: boolean;
+    /** Override kebab menu items; pass [] to hide menu entirely. */
+    menuItems?: StatusBarMenuItem[];
+    /** Add kebab menu items that only appear on mobile. */
+    mobileMenuItems?: StatusBarMenuItem[];
+    status?: 'idle' | 'saving' | 'success' | 'error';
+    lastSavedAt?: string | null;
+    draftSyncState?: 'baseline' | 'pending' | 'failed';
+    hasFailedSaves?: boolean;
+    onRetryFailedSaves?: () => void | Promise<void>;
+    historyControls?: EditorHistoryBarControls;
+};
+export declare function EditorChrome({ toolbarOverrides, onPublish, onDiscard, publishMenuItems, actionsSlot, messageOverride, messageVariant, actionButtonSize, showStatusBar, showToggle, menuItems: menuItemsOverride, mobileMenuItems, status, lastSavedAt, draftSyncState, hasFailedSaves, onRetryFailedSaves, historyControls, }: EditorChromeProps): import("react/jsx-runtime").JSX.Element;
+export {};

package/dist/_dts/editor/src/chrome/EditorStatusBar.d.ts

@@ -0,0 +1,45 @@
+import { type ReactElement, type ReactNode } from "react";
+import type { DraftSyncState } from "../EditorProvider";
+export type DraftWorkflowStatus = "idle" | "saving" | "success" | "error";
+export type EditorStatusBarToolbar = {
+    publishLabel?: string;
+    hasUnpublishedChanges?: boolean;
+    disablePublish?: boolean;
+    disableDiscard?: boolean;
+    currentStatus?: string | null;
+    publishedMessage?: string | null;
+};
+export type EditorHistoryBarControls = {
+    canUndo: boolean;
+    canRedo: boolean;
+    onUndo: () => void;
+    onRedo: () => void;
+};
+export type StatusBarMenuItem = {
+    label: string;
+    onClick: () => void;
+    variant?: "default" | "destructive";
+};
+export type EditorStatusBarProps = {
+    status: DraftWorkflowStatus;
+    lastSavedAt: string | null;
+    toolbar?: EditorStatusBarToolbar;
+    draftSyncState?: DraftSyncState;
+    onPublish?: () => void | Promise<void>;
+    onDiscard?: () => void | Promise<void>;
+    publishMenuItems?: StatusBarMenuItem[];
+    actionsSlot?: ReactNode;
+    toggleSlot?: ReactNode;
+    messageOverride?: string | null;
+    messageVariant?: "default" | "manual-save";
+    actionButtonSize?: "sm" | "default" | "lg";
+    hasFailedSaves?: boolean;
+    onRetryFailedSaves?: () => void | Promise<void>;
+    historyControls?: EditorHistoryBarControls;
+    secondaryMessage?: string | null;
+    /** Menu items for the kebab menu */
+    menuItems?: StatusBarMenuItem[];
+    /** Menu items that only appear in the mobile kebab menu. */
+    mobileMenuItems?: StatusBarMenuItem[];
+};
+export declare function EditorStatusBar({ status, lastSavedAt, toolbar, draftSyncState, onPublish, publishMenuItems, actionsSlot, toggleSlot, messageOverride, messageVariant, actionButtonSize, hasFailedSaves, onRetryFailedSaves, historyControls, secondaryMessage, menuItems, mobileMenuItems, }: EditorStatusBarProps): ReactElement;

package/dist/_dts/editor/src/chrome/statusBarPresentation.d.ts

@@ -0,0 +1,25 @@
+import type { ReactNode } from 'react';
+import type { DraftSyncState } from '../EditorProvider';
+import type { DraftWorkflowStatus, EditorStatusBarProps, EditorStatusBarToolbar, StatusBarMenuItem } from './EditorStatusBar';
+export declare function getLatestSavedAt(values: readonly (string | null)[]): string | null;
+export type EditorStatusBarPresentationInput = Readonly<{
+    status: DraftWorkflowStatus;
+    lastSavedAt: string | null;
+    toolbar: EditorStatusBarToolbar;
+    draftSyncState: DraftSyncState;
+    hasFailedSaves: boolean;
+    errorMessage?: string | null;
+    unfinishedSummary: string | null;
+    canUndo: boolean;
+    canRedo: boolean;
+    onUndo: () => void;
+    onRedo: () => void;
+    onPublish?: () => Promise<void>;
+    onDiscard?: () => Promise<void>;
+    publishMenuItems?: StatusBarMenuItem[];
+    actionsSlot?: ReactNode;
+    menuItems?: StatusBarMenuItem[];
+    messageVariant: 'default' | 'manual-save';
+    actionButtonSize: 'sm' | 'default' | 'lg';
+}>;
+export declare function buildEditorStatusBarPresentationProps({ status, lastSavedAt, toolbar, draftSyncState, hasFailedSaves, errorMessage, unfinishedSummary, canUndo, canRedo, onUndo, onRedo, onPublish, onDiscard, publishMenuItems, actionsSlot, menuItems, messageVariant, actionButtonSize, }: EditorStatusBarPresentationInput): EditorStatusBarProps;

package/dist/_dts/editor/src/components/EditingToggle.d.ts

@@ -0,0 +1,9 @@
+import React from 'react';
+type EditingToggleProps = {
+    placement?: 'floating' | 'toolbar';
+};
+/**
+ * Toggle button for switching between edit and preview modes.
+ */
+export declare const EditingToggle: React.FC<EditingToggleProps>;
+export {};

package/dist/_dts/editor/src/hooks/useEditableElement.d.ts

@@ -0,0 +1,18 @@
+import { type KeyboardEvent } from 'react';
+export interface UseEditableElementOptions {
+    id: string;
+    value: string;
+    onChange: (value: string) => void;
+    onStartEdit?: () => void;
+    onEndEdit?: () => void;
+}
+export declare function useEditableElement({ id, onChange, onStartEdit, onEndEdit, }: UseEditableElementOptions): {
+    isEditingMode: boolean;
+    isEditing: boolean;
+    isHovered: boolean;
+    setIsHovered: import("react").Dispatch<import("react").SetStateAction<boolean>>;
+    editRef: import("react").RefObject<HTMLElement | null>;
+    handleStartEdit: () => void;
+    handleEndEdit: (newValue?: string) => void;
+    handleKeyDown: (e: KeyboardEvent) => void;
+};

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

@@ -0,0 +1,29 @@
+export { EditorChrome } from './chrome/EditorChrome';
+export { EditorStatusBar } from './chrome/EditorStatusBar';
+export { buildEditorStatusBarPresentationProps, getLatestSavedAt, } from './chrome/statusBarPresentation';
+export type { DraftWorkflowStatus, EditorHistoryBarControls, EditorStatusBarProps, EditorStatusBarToolbar, StatusBarMenuItem, } from './chrome/EditorStatusBar';
+export type { EditorStatusBarPresentationInput } from './chrome/statusBarPresentation';
+export { EditingToggle } from './components/EditingToggle';
+export { EditorProvider, useEditor } from './EditorProvider';
+export type { DraftSyncState, DrawerFocusTarget } from './EditorProvider';
+export { useEditableElement } from './hooks/useEditableElement';
+export type { UseEditableElementOptions } from './hooks/useEditableElement';
+export { InlineTextEditor } from './inline/InlineTextEditor';
+export { EditorPrimitivesProvider } from './primitives/EditorPrimitivesProvider';
+export type { InlineFieldAdapter } from './primitives/InlineFieldContext';
+export { deriveChannelId } from './primitives/helpers';
+export { richTextConfigs } from './primitives/rich-text/config';
+export type { RichTextEditorConfig, ToolbarButtonConfig, } from './primitives/rich-text/config';
+export { RichTextToolbar } from './primitives/rich-text/RichTextToolbar';
+export { RichTextEditorSurface } from './primitives/rich-text/RichTextEditorSurface';
+export type { RichTextRoutableItem } from './primitives/rich-text/toolbar/linkPopoverUtils';
+export { useRichTextEditor } from './primitives/rich-text/useRichTextEditor';
+export { buildRichTextImageAttrs, getRichTextImagePositionFromTarget, getSelectedRichTextImagePosition, insertOrReplaceRichTextImage, } from './primitives/rich-text/imageActions';
+export type { PickedRichTextImage } from './primitives/rich-text/imageActions';
+export { EMPTY_DOC, isDocEmpty, normaliseDoc, } from './primitives/rich-text/utils';
+export { formatUnsupportedRichTextSummary, hasUnsupportedRichTextContent, sanitizeRichTextContentForSchema, } from './primitives/rich-text/sanitize';
+export type { RichTextContentWarnings } from './primitives/rich-text/sanitize';
+export { EditorContent } from '@tiptap/react';
+export { EditorSaveProvider, useSaveField } from './primitives/SaveContext';
+export { createOptimisticTokenStore, OptimisticTokenStore, } from './utils/optimisticTokens';
+export type { OptimisticToken, OptimisticTokenSnapshot, } from './utils/optimisticTokens';

package/dist/_dts/editor/src/inline/InlineTextEditor.d.ts

@@ -0,0 +1 @@
+export declare const InlineTextEditor: () => import("react/jsx-runtime").JSX.Element;

package/dist/_dts/editor/src/lib/utils.d.ts

@@ -0,0 +1 @@
+export declare function cn(...values: Array<string | false | null | undefined>): string;

package/dist/_dts/editor/src/primitives/EditorPrimitivesProvider.d.ts

@@ -0,0 +1,20 @@
+import React from 'react';
+import { type InlineFieldAdapter } from './InlineFieldContext';
+type SaveArgs = {
+    path: string;
+    value: unknown;
+};
+type SaveFieldArgs = {
+    blockId: string;
+    path: string;
+    value: unknown;
+};
+type SaveFieldFn = (args: SaveFieldArgs) => Promise<unknown>;
+export declare function EditorPrimitivesProvider({ canEdit, saveField, onSave, inlineFieldAdapter, children, }: {
+    canEdit?: boolean;
+    saveField?: SaveFieldFn;
+    onSave?: (args: SaveArgs) => Promise<void>;
+    inlineFieldAdapter?: InlineFieldAdapter | null;
+    children: React.ReactNode;
+}): import("react/jsx-runtime").JSX.Element;
+export {};

package/dist/_dts/editor/src/primitives/InlineFieldContext.d.ts

@@ -0,0 +1,11 @@
+import { type ReactNode } from 'react';
+export type InlineFieldAdapter = {
+    getValue: (path: string) => unknown;
+    setValue: (path: string, value: unknown) => void;
+    subscribe: (path: string, callback: () => void) => () => void;
+};
+export declare function InlineFieldProvider({ adapter, children, }: {
+    adapter?: InlineFieldAdapter | null;
+    children: ReactNode;
+}): import("react/jsx-runtime").JSX.Element;
+export declare function useInlineFieldAdapter(): InlineFieldAdapter | null;

package/dist/_dts/editor/src/primitives/SaveContext.d.ts

@@ -0,0 +1,12 @@
+import React from 'react';
+type SaveArgs = {
+    path: string;
+    value: unknown;
+};
+type SaveFn = (args: SaveArgs) => Promise<void>;
+export declare function EditorSaveProvider({ save, children }: {
+    save: SaveFn;
+    children: React.ReactNode;
+}): import("react/jsx-runtime").JSX.Element;
+export declare function useSaveField(): SaveFn;
+export {};

package/dist/_dts/editor/src/primitives/helpers.d.ts

@@ -0,0 +1 @@
+export declare function deriveChannelId(path: string | undefined): string | null;

package/dist/_dts/editor/src/primitives/rich-text/RichTextEditorSurface.d.ts

@@ -0,0 +1,26 @@
+import type { ReactNode } from 'react';
+import { type Editor } from '@tiptap/react';
+import type { RichTextEditorConfig } from './config';
+import type { PickedRichTextImage } from './imageActions';
+import type { RichTextRoutableItem } from './toolbar/linkPopoverUtils';
+export type RichTextEditorSurfaceProps = Readonly<{
+    editor: Editor | null;
+    config: RichTextEditorConfig;
+    isEmpty: boolean;
+    className?: string;
+    contentClassName?: string;
+    placeholderClassName?: string;
+    placeholderText?: string;
+    linkItems?: RichTextRoutableItem[];
+    onRequestLinkItems?: () => Promise<RichTextRoutableItem[]>;
+    onPickImage?: () => Promise<PickedRichTextImage | null | undefined>;
+    toolbarTone?: 'light' | 'dark';
+    toolbarAlwaysVisible?: boolean;
+    toolbarPortalToChrome?: boolean;
+    hideToolbar?: boolean;
+    hideContent?: boolean;
+    onClick?: () => void;
+    renderContent?: (content: ReactNode) => ReactNode;
+}>;
+export declare function shouldHandleRichTextActivationKey(container: HTMLElement, target: EventTarget | null): boolean;
+export declare function RichTextEditorSurface({ editor, config, isEmpty, className, contentClassName, placeholderClassName, placeholderText, linkItems, onRequestLinkItems, onPickImage, toolbarTone, toolbarAlwaysVisible, toolbarPortalToChrome, hideToolbar, hideContent, onClick, renderContent, }: RichTextEditorSurfaceProps): import("react/jsx-runtime").JSX.Element;

package/dist/_dts/editor/src/primitives/rich-text/RichTextToolbar.d.ts

@@ -0,0 +1,16 @@
+import type { Editor } from '@tiptap/react';
+import type { ToolbarButtonConfig } from './config';
+import type { PickedRichTextImage } from './imageActions';
+import { type RichTextRoutableItem } from './toolbar/LinkPopover';
+interface RichTextToolbarProps {
+    editor: Editor | null;
+    buttons: ToolbarButtonConfig[];
+    onPickImage?: () => Promise<PickedRichTextImage | null | undefined>;
+    linkItems?: RichTextRoutableItem[];
+    onRequestLinkItems?: () => Promise<RichTextRoutableItem[]>;
+    alwaysVisible?: boolean;
+    tone?: 'light' | 'dark';
+    portalToChrome?: boolean;
+}
+export declare function RichTextToolbar({ editor, buttons, onPickImage, linkItems, onRequestLinkItems, alwaysVisible, tone, portalToChrome, }: RichTextToolbarProps): import("react/jsx-runtime").JSX.Element | null;
+export {};

package/dist/_dts/editor/src/primitives/rich-text/config.d.ts

@@ -0,0 +1,23 @@
+import type { AnyExtension } from '@tiptap/core';
+import type { RichTextVariant } from '../../../../blocks/src/index';
+export type ToolbarButtonConfig = {
+    type: 'blockType';
+} | {
+    type: 'bold';
+} | {
+    type: 'italic';
+} | {
+    type: 'link';
+} | {
+    type: 'bulletList';
+} | {
+    type: 'orderedList';
+} | {
+    type: 'image';
+};
+export type RichTextEditorConfig = {
+    extensions: AnyExtension[];
+    toolbar: ToolbarButtonConfig[];
+    placeholder: string;
+};
+export declare const richTextConfigs: Record<RichTextVariant, RichTextEditorConfig>;

package/dist/_dts/editor/src/primitives/rich-text/extensions/RichTextImage.d.ts

@@ -0,0 +1,2 @@
+import { Node } from '@tiptap/core';
+export declare const RichTextImage: Node<any, any>;

package/dist/_dts/editor/src/primitives/rich-text/extensions/RichTextLink.d.ts

@@ -0,0 +1 @@
+export declare const RichTextLink: import("@tiptap/core").Mark<import("@tiptap/extension-link").LinkOptions, any>;

package/dist/_dts/editor/src/primitives/rich-text/imageActions.d.ts

@@ -0,0 +1,22 @@
+import type { Editor } from '@tiptap/react';
+export type PickedRichTextImage = {
+    identifier: string;
+    src?: string;
+    alt?: string;
+    width?: number;
+    height?: number;
+};
+type RichTextImageAttrs = {
+    identifier: string;
+    alt: string;
+    src?: string;
+    width?: number;
+    height?: number;
+};
+export declare function buildRichTextImageAttrs(picked: PickedRichTextImage): RichTextImageAttrs | null;
+export declare function getSelectedRichTextImagePosition(editor: Editor): number | null;
+export declare function getRichTextImagePositionFromTarget(editor: Editor, target: EventTarget | null): number | null;
+export declare function insertOrReplaceRichTextImage(editor: Editor, picked: PickedRichTextImage, options?: {
+    replaceAtPos?: number | null;
+}): 'inserted' | 'replaced' | null;
+export {};