@riverbankcms/sdk 0.62.2 → 0.64.0

package/dist/_dts/block-form/src/blockDraftSaveability.d.ts

@@ -0,0 +1,70 @@
+import { type BlockManifest } from '@riverbankcms/blocks';
+import type { EditorSyncState } from '@riverbankcms/core';
+import type { z } from 'zod';
+type ManifestValidationIssue = z.core.$ZodIssue;
+export type BlockDraftValidationIssue = Readonly<{
+    code: ManifestValidationIssue['code'];
+    path: (string | number)[];
+    fieldPath: string;
+    message: string;
+}>;
+export type BlockManifestValidationMode = 'draft' | 'strict';
+export type BlockDraftSaveability = Readonly<{
+    kind: 'pristine';
+    issues: readonly BlockDraftValidationIssue[];
+}> | Readonly<{
+    kind: 'incomplete';
+    issues: readonly BlockDraftValidationIssue[];
+}> | Readonly<{
+    kind: 'saveable';
+    issues: readonly [];
+}> | Readonly<{
+    kind: 'save_failed';
+    issues: readonly BlockDraftValidationIssue[];
+    error: string;
+}>;
+export declare const unfinishedBlockCopy: {
+    readonly title: "Fix this block to save it";
+    readonly description: "Some fields need a quick check. Your changes are safe here for now.";
+};
+export declare const recoveryConflictCopy: {
+    readonly reviewActionLabel: "Review affected blocks";
+    readonly discardActionLabel: "Discard browser recovery";
+    readonly blockNoticeTitle: "We couldn’t restore unfinished edits here automatically";
+    readonly blockNoticeDescription: "The saved version changed before we could put them back.";
+    readonly pageNoticeDescription: "The saved page changed, so we couldn’t restore them automatically.";
+};
+export declare const unfinishedBlocksSummaryCopy: {
+    readonly singular: "1 block still needs attention";
+    readonly plural: (count: number) => string;
+};
+export declare const publishBlockedCopy: {
+    readonly singleInvalidBlock: (blockLabel: string) => string;
+    readonly multipleInvalidBlocks: (count: number) => string;
+};
+export declare function formatRecoveryConflictTitle(count: number): string;
+export declare function formatRecoveryConflictSummary(count: number): string | null;
+export declare function formatUnfinishedBlocksSummary(count: number): string | null;
+export declare function formatPublishBlockedMessage(input: Readonly<{
+    type: 'single-invalid-block';
+    blockLabel: string;
+} | {
+    type: 'multiple-invalid-blocks';
+    count: number;
+}>): string;
+export declare function deriveBlockDraftSaveability(input: {
+    syncState: EditorSyncState;
+    issues: readonly BlockDraftValidationIssue[];
+    hasMeaningfulEdit: boolean;
+    showAllValidation: boolean;
+}): BlockDraftSaveability;
+export declare function shouldShowBlockFieldValidation(input: {
+    fieldPath: string;
+    touchedPaths: ReadonlySet<string>;
+    showAllValidation: boolean;
+}): boolean;
+export declare function validateBlockManifestValues(manifest: BlockManifest, values: Record<string, unknown>): BlockDraftValidationIssue[];
+export declare function validateBlockManifestIssues(manifest: BlockManifest, values: Record<string, unknown>, mode: BlockManifestValidationMode): ManifestValidationIssue[];
+export declare function validateBlockManifest(manifest: BlockManifest, values: Record<string, unknown>, mode: BlockManifestValidationMode): BlockDraftValidationIssue[];
+export declare function normalizeManifestIssueMessage(issue: ManifestValidationIssue): string;
+export {};

package/dist/_dts/block-form/src/client/blockDraftSaveability.d.ts

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

package/dist/_dts/block-form/src/client/index.d.ts

@@ -0,0 +1,30 @@
+export { FormRenderer } from '../FormRenderer';
+export type { FormRendererProps } from '../FormRenderer';
+export { ManifestForm } from '../manifest/ManifestForm';
+export type { ManifestFormProps } from '../manifest/ManifestForm';
+export type { FieldWidgetComponent, FieldWidgetProps } from '../fields/props';
+export { useField, useArrayField } from '../backend/hooks';
+export { createRHFBackend, createStoreBackend, useBackendWatch } from '../backend/types';
+export type { FormBackend, FieldError, FieldState, SetValueOptions } from '../backend/types';
+export type { ManifestAdapterOptions, ManifestAdapterResult, ManifestFormSource, ManifestSchemaOptions, ManifestValidationResult, } from '../manifest/manifestFormAdapter';
+export { createManifestValidation } from '../manifest/manifestFormAdapter';
+export { formatPublishBlockedMessage, formatRecoveryConflictSummary, formatRecoveryConflictTitle, deriveBlockDraftSaveability, formatUnfinishedBlocksSummary, normalizeManifestIssueMessage, recoveryConflictCopy, shouldShowBlockFieldValidation, unfinishedBlockCopy, validateBlockManifest, validateBlockManifestIssues, validateBlockManifestValues, } from './blockDraftSaveability';
+export type { BlockDraftSaveability, BlockDraftValidationIssue, BlockManifestValidationMode, } from './blockDraftSaveability';
+export type { BaseFieldConfig, FieldConfig, TextFieldConfig, NumberFieldConfig, RichTextFieldConfig, MediaFieldConfig, BooleanFieldConfig, DateFieldConfig, TimeFieldConfig, DateTimeFieldConfig, SlugFieldConfig, UrlFieldConfig, LinkFieldConfig, SelectFieldConfig, ReferenceFieldConfig, GroupFieldConfig, RepeaterFieldConfig, ButtonFieldConfig, ContentTypeSelectFieldConfig, EntryPickerFieldConfig, } from '../fields/types';
+export { createManifestFormAdapter } from '../manifest/manifestFormAdapter';
+export { PaletteProvider, usePalette } from '../palette/PaletteContext';
+export { SdkConfigProvider, useSdkConfig, useBlockFieldOptions } from '../sdk-config';
+export type { SdkConfig, SdkConfigProviderProps, SdkThemePalette, SdkSectionBackground, SdkSectionOptions, SdkSiteStyleConfig, SdkFieldSelectOption, SdkBlockFieldConfig, SdkBlockFieldOptionsMap, SdkBlockFieldExtensionsMap, } from '../sdk-config';
+export { BlockContextProvider, useBlockContext } from '../context';
+export type { BlockContextValue, BlockContextProviderProps } from '../context';
+export { DisplayLabelResolverProvider, useDisplayLabelResolvers } from '../context';
+export type { DisplayLabelResolver, DisplayLabelResolverMap, ResolverCallContext } from '../context';
+export { FieldPreviewResolverProvider, useFieldPreviewResolvers } from '../context';
+export type { FieldPreviewResolver, FieldPreviewResolverMap, FieldPreviewResolverCallContext } from '../context';
+export { ImageResolveContextProvider, useImageResolveContextOptional } from '../context';
+export { mergeManifestWithSdkOptions } from '../manifest/mergeManifestWithSdkOptions';
+export { FieldFrame, FieldFrameMessage } from '../widgets/FieldFrame';
+export type { FieldFrameProps, FieldFrameRenderProps, FieldFrameMessageProps } from '../widgets/FieldFrame';
+export { SelectField } from '../widgets/SelectField';
+export { BackgroundColorField } from '../widgets/BackgroundColorWidget';
+export { BackgroundGradientField } from '../widgets/BackgroundGradientWidget';

package/dist/_dts/block-form/src/context/BlockContext.d.ts

@@ -0,0 +1,29 @@
+import React from 'react';
+/**
+ * Block context value
+ *
+ * Provides information about the current block being edited.
+ * Used by widgets like SdkSelectField to look up SDK-provided field options.
+ */
+export interface BlockContextValue {
+    /** The block kind (e.g., 'block.embed', 'custom.hero') */
+    blockKind: string;
+}
+export interface BlockContextProviderProps {
+    blockKind: string;
+    children: React.ReactNode;
+}
+/**
+ * BlockContextProvider
+ *
+ * Provides block information to child widgets.
+ * Typically used by FormRenderer when editing a block.
+ */
+export declare function BlockContextProvider({ blockKind, children }: BlockContextProviderProps): import("react/jsx-runtime").JSX.Element;
+/**
+ * useBlockContext
+ *
+ * Hook to access the current block context.
+ * Returns null when not within a BlockContextProvider.
+ */
+export declare function useBlockContext(): BlockContextValue | null;

package/dist/_dts/block-form/src/context/DisplayLabelResolverContext.d.ts

@@ -0,0 +1,33 @@
+import React from 'react';
+import type { FieldConfig } from '../fields/types';
+/**
+ * Context passed to a display label resolver, providing access to sibling field values.
+ */
+export type ResolverCallContext = {
+    getSiblingValue: (fieldId: string) => unknown;
+};
+/**
+ * A function that resolves a stored field value to a human-readable display label.
+ *
+ * Returns null if the value can't be resolved (caller falls back to raw value).
+ */
+export type DisplayLabelResolver = (value: unknown, fieldConfig: FieldConfig, context: ResolverCallContext) => Promise<string | null>;
+/**
+ * Map of field type to display label resolver.
+ * Only field types that need async resolution register here.
+ */
+export type DisplayLabelResolverMap = Partial<Record<FieldConfig['type'], DisplayLabelResolver>>;
+/**
+ * Provides display label resolvers to descendant components.
+ * Repeater items use these resolvers to show human-readable labels
+ * instead of raw stored values (e.g. entry titles instead of slugs).
+ */
+export declare function DisplayLabelResolverProvider({ resolvers, children, }: {
+    resolvers: DisplayLabelResolverMap;
+    children: React.ReactNode;
+}): import("react/jsx-runtime").JSX.Element;
+/**
+ * Access the display label resolver map.
+ * Returns an empty map when no provider is present (resolvers are optional).
+ */
+export declare function useDisplayLabelResolvers(): DisplayLabelResolverMap;

package/dist/_dts/block-form/src/context/FieldPreviewResolverContext.d.ts

@@ -0,0 +1,30 @@
+import React from 'react';
+import type { FieldConfig } from '../fields/types';
+/**
+ * Context passed to a field preview resolver, providing access to sibling field values.
+ */
+export type FieldPreviewResolverCallContext = {
+    getSiblingValue: (fieldId: string) => unknown;
+};
+/**
+ * Resolve a stored field value to a preview value consumable by UI widgets.
+ *
+ * For repeater thumbnails, resolvers can return media-like objects
+ * (e.g. `{ type: 'image', src: '...' }`) for field types that do not store media directly.
+ */
+export type FieldPreviewResolver = (value: unknown, fieldConfig: FieldConfig, context: FieldPreviewResolverCallContext) => Promise<unknown | null>;
+/**
+ * Map of field type to preview resolver.
+ */
+export type FieldPreviewResolverMap = Partial<Record<FieldConfig['type'], FieldPreviewResolver>>;
+/**
+ * Provides field preview resolvers to descendant components.
+ */
+export declare function FieldPreviewResolverProvider({ resolvers, children, }: {
+    resolvers: FieldPreviewResolverMap;
+    children: React.ReactNode;
+}): import("react/jsx-runtime").JSX.Element;
+/**
+ * Access the field preview resolver map.
+ */
+export declare function useFieldPreviewResolvers(): FieldPreviewResolverMap;

package/dist/_dts/block-form/src/context/ImageResolveContext.d.ts

@@ -0,0 +1 @@
+export { ImageResolveContextProvider, useImageResolveContextOptional, } from '@riverbankcms/blocks/client';

package/dist/_dts/block-form/src/context/index.d.ts

@@ -0,0 +1,4 @@
+export { BlockContextProvider, useBlockContext, type BlockContextValue, type BlockContextProviderProps, } from './BlockContext';
+export { DisplayLabelResolverProvider, useDisplayLabelResolvers, type DisplayLabelResolver, type DisplayLabelResolverMap, type ResolverCallContext, } from './DisplayLabelResolverContext';
+export { FieldPreviewResolverProvider, useFieldPreviewResolvers, type FieldPreviewResolver, type FieldPreviewResolverMap, type FieldPreviewResolverCallContext, } from './FieldPreviewResolverContext';
+export { ImageResolveContextProvider, useImageResolveContextOptional, } from './ImageResolveContext';

package/dist/_dts/block-form/src/fields/props.d.ts

@@ -0,0 +1,48 @@
+/**
+ * Widget Props Types
+ *
+ * Runtime props for field widgets - combines field config with runtime context
+ */
+import type { ComponentType, ReactNode } from 'react';
+import type { FormBackend } from '../backend/types';
+import type { FieldConfig } from './types';
+/**
+ * Function for rendering child fields (used by container widgets like GroupField/RepeaterField)
+ */
+export type RenderChildField = (childConfig: FieldConfig, childPath: string) => ReactNode;
+/**
+ * Props for field widget components
+ *
+ * @template TValue - The type of value this field manages
+ * @template TConfig - The specific field config type (e.g., TextFieldConfig, GroupFieldConfig)
+ */
+export interface FieldWidgetProps<TValue = unknown, TConfig extends FieldConfig = FieldConfig> {
+    /** Runtime path to this field (e.g., 'title', 'items.0.name') */
+    path: string;
+    /** Form backend for reading/writing values */
+    backend: FormBackend;
+    /** Field configuration (pure definition) */
+    config: TConfig;
+    /** Function to render child fields (required for container widgets like group/repeater) */
+    renderChild?: RenderChildField;
+}
+/**
+ * Type for field widget components
+ *
+ * Widgets are strongly typed with specific config types (TextFieldConfig, etc.) for
+ * type safety within their implementation. At the registry boundary, type assertions
+ * are used to store them in a homogeneous collection (see registry/widgets.ts).
+ *
+ * This is safe because:
+ * 1. The field.type discriminant ensures the correct widget is selected
+ * 2. Each widget receives its expected config subtype at runtime
+ * 3. The type system prevents accessing properties that don't exist on BaseFieldConfig
+ */
+export type FieldWidgetComponent<TValue = unknown, TConfig extends FieldConfig = FieldConfig> = ComponentType<FieldWidgetProps<TValue, TConfig>>;
+/**
+ * Widget registry - maps field type strings to their components
+ *
+ * This is a heterogeneous collection where each widget has different type parameters,
+ * stored with a common base type for lookup. See registry/widgets.ts for implementation.
+ */
+export type WidgetRegistry = Record<string, FieldWidgetComponent>;

package/dist/_dts/block-form/src/fields/types.d.ts

@@ -0,0 +1,223 @@
+/**
+ * Field Configuration Types
+ *
+ * Pure field definitions independent of how they're created (manifest, manual, etc.)
+ * These types describe what a field IS, not where it came from.
+ *
+ * FieldConfig types are structurally compatible with FieldDefinition from @riverbankcms/blocks,
+ * allowing manifest fields to be passed through with minimal transformation.
+ */
+import type { FieldDefinition } from '@riverbankcms/blocks';
+import type { ZodTypeAny } from 'zod';
+import type { TabGroupFieldConfig } from '../widgets/TabGroupField/types';
+import type { PresetOrCustomFieldConfig } from '../widgets/PresetOrCustomField/types';
+/**
+ * Base configuration for all field types
+ */
+export interface BaseFieldConfig {
+    /** Unique identifier for this field */
+    id: string;
+    /** Field type discriminator */
+    type: string;
+    /** Human-readable label */
+    label: string;
+    /** Optional description/help text */
+    description?: string;
+    /** Whether this field is required (defaults to false if not specified) */
+    required?: boolean;
+    /** Default value for this field */
+    defaultValue?: unknown;
+    /** UI-specific configuration - uses same type as FieldDefinition for compatibility */
+    ui?: FieldDefinition['ui'];
+}
+/**
+ * Text field configuration
+ */
+export interface TextFieldConfig extends BaseFieldConfig {
+    type: 'text';
+    multiline?: boolean;
+    maxLength?: number;
+}
+/**
+ * Number field configuration
+ */
+export interface NumberFieldConfig extends BaseFieldConfig {
+    type: 'number';
+    min?: number;
+    max?: number;
+    step?: number;
+}
+/**
+ * Rich text field configuration
+ */
+export interface RichTextFieldConfig extends BaseFieldConfig {
+    type: 'richText';
+}
+/**
+ * Media field configuration
+ */
+export interface MediaFieldConfig extends BaseFieldConfig {
+    type: 'media';
+    mediaKinds?: ('image' | 'video' | 'audio' | 'document' | 'spreadsheet' | 'archive')[];
+    aspectRatio?: string;
+}
+/**
+ * Boolean field configuration
+ */
+export interface BooleanFieldConfig extends BaseFieldConfig {
+    type: 'boolean';
+}
+/**
+ * Date field configuration
+ */
+export interface DateFieldConfig extends BaseFieldConfig {
+    type: 'date';
+}
+/**
+ * Time field configuration
+ */
+export interface TimeFieldConfig extends BaseFieldConfig {
+    type: 'time';
+}
+/**
+ * DateTime field configuration
+ */
+export interface DateTimeFieldConfig extends BaseFieldConfig {
+    type: 'datetime';
+}
+/**
+ * Slug field configuration
+ */
+export interface SlugFieldConfig extends BaseFieldConfig {
+    type: 'slug';
+    sourceFieldId?: string;
+    statusFieldId?: string;
+    maxLength?: number;
+}
+/**
+ * URL field configuration
+ */
+export interface UrlFieldConfig extends BaseFieldConfig {
+    type: 'url';
+    allowRelative?: boolean;
+}
+/**
+ * Link field configuration
+ */
+export interface LinkFieldConfig extends BaseFieldConfig {
+    type: 'link';
+}
+/**
+ * Select field configuration
+ */
+export interface SelectFieldConfig extends BaseFieldConfig {
+    type: 'select';
+    options: Array<{
+        value: string;
+        label: string;
+    }>;
+    multiple?: boolean;
+}
+/**
+ * Reference field configuration
+ */
+export interface ReferenceFieldConfig extends BaseFieldConfig {
+    type: 'reference';
+    referenceKind: string;
+    allowManualEntry?: boolean;
+}
+/**
+ * Group field configuration (nested object)
+ */
+export interface GroupFieldConfig extends BaseFieldConfig {
+    type: 'group';
+    fields: FieldConfig[];
+    /** Optional nested schema shape for compatibility with manifest FieldDefinition */
+    schema?: {
+        fields?: FieldConfig[];
+    };
+}
+/**
+ * Modal field configuration (nested object shown in a dialog)
+ *
+ * Modal fields are structurally similar to group fields, but store children under
+ * `schema.fields` in the block manifest.
+ */
+export interface ModalFieldConfig extends BaseFieldConfig {
+    type: 'modal';
+    schema: {
+        fields: FieldConfig[];
+    };
+}
+/**
+ * Repeater field configuration (array)
+ */
+export type RepeaterFieldConfig = BaseFieldConfig & ({
+    /**
+     * Optional custom validation schema for the entire repeater field.
+     * Useful for complex constraints that aren't expressible via field-level config.
+     */
+    validation?: ZodTypeAny;
+} & ({
+    type: 'repeater';
+    itemLabel?: string;
+    itemLabelSource?: string;
+    minItems?: number;
+    maxItems?: number;
+    polymorphic?: false;
+    fields: FieldConfig[];
+    /** Optional nested schema shape for compatibility with manifest FieldDefinition */
+    schema?: {
+        fields?: FieldConfig[];
+    };
+    itemTypes?: never;
+    allowConversion?: boolean;
+} | {
+    type: 'repeater';
+    itemLabel?: string;
+    itemLabelSource?: string;
+    minItems?: number;
+    maxItems?: number;
+    polymorphic: true;
+    fields?: never;
+    /** Polymorphic repeaters do not use schema.fields */
+    schema?: never;
+    itemTypes: Record<string, {
+        label: string;
+        icon?: string;
+        fields: FieldConfig[];
+    }>;
+    allowConversion?: boolean;
+}));
+/**
+ * Button field configuration
+ */
+export interface ButtonFieldConfig extends BaseFieldConfig {
+    type: 'button';
+    allowedSizes?: Array<'sm' | 'md' | 'lg' | 'xl'>;
+    defaultSize?: 'sm' | 'md' | 'lg' | 'xl';
+}
+/**
+ * Content type select field configuration
+ */
+export interface ContentTypeSelectFieldConfig extends BaseFieldConfig {
+    type: 'contentTypeSelect';
+    /** Filter: all, routable (hasPages=true), nonRoutable (hasPages=false) */
+    filter?: 'all' | 'routable' | 'nonRoutable';
+}
+/**
+ * Entry picker field configuration
+ */
+export interface EntryPickerFieldConfig extends BaseFieldConfig {
+    type: 'entryPicker';
+    /** Fixed content type to filter entries by (no sibling contentType field required) */
+    fixedContentType?: string;
+    /** Field ID that contains the content type to filter entries by */
+    contentTypeField?: string;
+    /** What value should be stored when an entry is selected */
+    valueFrom?: 'id' | 'identifier' | 'slug';
+}
+/**
+ * Union of all field configuration types
+ */
+export type FieldConfig = TextFieldConfig | NumberFieldConfig | RichTextFieldConfig | MediaFieldConfig | BooleanFieldConfig | DateFieldConfig | TimeFieldConfig | DateTimeFieldConfig | SlugFieldConfig | UrlFieldConfig | LinkFieldConfig | SelectFieldConfig | ReferenceFieldConfig | GroupFieldConfig | ModalFieldConfig | RepeaterFieldConfig | ButtonFieldConfig | TabGroupFieldConfig | PresetOrCustomFieldConfig | ContentTypeSelectFieldConfig | EntryPickerFieldConfig;

package/dist/_dts/block-form/src/index.d.ts

@@ -0,0 +1,22 @@
+export * from './client/index';
+export { formatPublishBlockedMessage, formatRecoveryConflictSummary, formatRecoveryConflictTitle, formatUnfinishedBlocksSummary, recoveryConflictCopy, unfinishedBlockCopy, } from './blockDraftSaveability';
+export { WIDGET_NAMES, type WidgetName } from './widgets';
+export { WidgetField, WidgetFieldMessage } from './widgets';
+export type { WidgetFieldProps, WidgetFieldMessageProps } from './widgets';
+export { SelectWidget } from './widgets';
+export type { SelectWidgetProps, SelectWidgetOption } from './widgets';
+export { ToggleWidget } from './widgets';
+export type { ToggleWidgetProps } from './widgets';
+export { TextInputWidget } from './widgets';
+export type { TextInputWidgetProps } from './widgets';
+export { BackgroundColorWidget } from './widgets';
+export type { BackgroundColorWidgetProps, BackgroundColorMode } from './widgets';
+export { BackgroundGradientWidget } from './widgets';
+export type { BackgroundGradientWidgetProps } from './widgets';
+export { BoxStyleWidget } from './widgets';
+export { DatePickerPopover, parseDateValue, type DateParseResult, type DatePickerPopoverProps, } from './widgets';
+export { FieldSettingsModal } from './widgets';
+export type { FieldSettingsModalProps } from './widgets';
+export { SettingsModal } from './widgets';
+export type { SettingsModalProps, SettingsTab, SettingsTabId } from './widgets';
+export * from './utils/fieldHelpers';

package/dist/_dts/block-form/src/manifest/ManifestForm.d.ts

@@ -0,0 +1,37 @@
+/**
+ * ManifestForm - Thin wrapper around FormRenderer for manifest-based forms
+ *
+ * Responsibilities:
+ * 1. Transform manifest FieldDefinitions → FieldConfigs (via adapter)
+ * 2. Pass transformed fields to generic FormRenderer
+ * 3. Handle manifest-specific options (role visibility, etc.)
+ */
+import type { BlockManifest, VisibilityLevel } from '@riverbankcms/blocks';
+import { type FormRendererProps } from '../FormRenderer';
+import type { FormBackend } from '../backend/types';
+export interface ManifestFormProps {
+    manifest: BlockManifest;
+    className?: string;
+    role?: VisibilityLevel;
+    backend: FormBackend;
+    /** Optional widget overrides - allows replacing widgets at runtime */
+    widgetOverrides?: FormRendererProps['widgetOverrides'];
+    /** Optional block kind for SDK field options lookup (e.g., 'block.embed', 'custom.hero') */
+    blockKind?: string;
+    /** Show inline settings trigger for non-content intents (default: true) */
+    showSettingsTrigger?: boolean;
+}
+/**
+ * ManifestForm - Renders form fields from a block manifest
+ *
+ * This is a thin adapter that:
+ * 1. Converts manifest FieldDefinitions to FieldConfigs (via adapter)
+ * 2. Delegates rendering to FormRenderer
+ *
+ * @example
+ * ```tsx
+ * const backend = createRHFBackend(form)
+ * <ManifestForm manifest={blockManifest} backend={backend} />
+ * ```
+ */
+export declare function ManifestForm({ manifest, className, role, backend, widgetOverrides, blockKind, showSettingsTrigger, }: ManifestFormProps): import("react/jsx-runtime").JSX.Element | null;

package/dist/_dts/block-form/src/manifest/canonicalValidation.d.ts

@@ -0,0 +1,5 @@
+import { type NativeInputValidationProps } from '@riverbankcms/blocks/system/manifest/fieldValidation';
+import type { z } from 'zod';
+import type { FieldConfig } from '../fields/types';
+export declare function buildCanonicalFieldSchema(field: FieldConfig): z.ZodTypeAny;
+export declare function getCanonicalNativeInputProps(field: FieldConfig): NativeInputValidationProps;

package/dist/_dts/block-form/src/manifest/filterSdkTabs.d.ts

@@ -0,0 +1,44 @@
+/**
+ * SDK Tab Filtering
+ *
+ * Pure function for filtering tab group tabs based on SDK section options.
+ * This is used by TabGroupField to respect SDK site configuration.
+ */
+import type { SdkSectionOptions } from '../sdk-config';
+/**
+ * Tab definition with optional SDK section option.
+ * This is a minimal interface that matches what TabGroupField receives.
+ */
+export interface FilterableTab {
+    id: string;
+    sdkSectionOption?: 'backgroundColor' | 'backgroundGradient' | 'backgroundImage';
+}
+export declare function isSdkSectionOptionEnabled(sdkSectionOption: FilterableTab['sdkSectionOption'] | undefined, isSdkSite: boolean, sectionOptions: SdkSectionOptions | null): boolean;
+/**
+ * Filters tabs based on SDK section options.
+ *
+ * This pure function handles the filtering logic that was previously embedded
+ * in TabGroupField. It's designed to be testable and reusable.
+ *
+ * ## Filtering Rules
+ *
+ * - If not an SDK site or no sectionOptions exist, all tabs are returned
+ * - Tabs without `sdkSectionOption` are always visible
+ * - Tabs with `sdkSectionOption` are visible unless explicitly disabled
+ * - A disabled option is when `sectionOptions[key] === false`
+ *
+ * @param tabs - Array of tabs to filter
+ * @param isSdkSite - Whether this is an SDK-configured site
+ * @param sectionOptions - SDK section options (may be null)
+ * @returns Filtered array of visible tabs
+ *
+ * @example
+ * ```typescript
+ * const visibleTabs = filterTabsBySdkOptions(
+ *   config.tabs,
+ *   isSdkSite,
+ *   sectionOptions
+ * )
+ * ```
+ */
+export declare function filterTabsBySdkOptions<T extends FilterableTab>(tabs: T[], isSdkSite: boolean, sectionOptions: SdkSectionOptions | null): T[];

package/dist/_dts/block-form/src/manifest/manifestFormAdapter.d.ts

@@ -0,0 +1,61 @@
+/**
+ * Manifest Form Adapter
+ *
+ * Transforms BlockManifest field definitions into FieldConfigs for form rendering.
+ * Handles role-based visibility filtering and structure normalization.
+ *
+ * This adapter is intentionally minimal - it only does what's truly manifest-specific:
+ * 1. Filter fields by role visibility
+ * 2. Flatten nested structure (schema.fields → fields)
+ *
+ * Everything else (validation, defaults, UI) is handled by the generic form system.
+ */
+import type { VisibilityLevel, BlockManifest } from '@riverbankcms/blocks';
+import type { ZodType } from 'zod';
+import type { FieldConfig } from '../fields/types';
+export interface ManifestAdapterOptions {
+    role?: VisibilityLevel;
+}
+export interface ManifestAdapterResult {
+    fields: FieldConfig[];
+    schema: ZodType<Record<string, unknown>, Record<string, unknown>>;
+}
+/**
+ * Union type for manifest form sources
+ * Can be either a BlockManifest or null
+ */
+export type ManifestFormSource = BlockManifest | null;
+/**
+ * Options for manifest validation schema creation
+ */
+export interface ManifestSchemaOptions {
+    role?: VisibilityLevel;
+    widgets?: unknown;
+}
+/**
+ * Result of createManifestValidation
+ */
+export interface ManifestValidationResult {
+    schema: ZodType<Record<string, unknown>, Record<string, unknown>>;
+    fields: FieldConfig[];
+}
+/**
+ * Transform a BlockManifest into form fields and validation schema
+ */
+export declare function createManifestFormAdapter(manifest: BlockManifest, options?: ManifestAdapterOptions): ManifestAdapterResult;
+/**
+ * Create validation schema from a block manifest
+ *
+ * This is a convenience wrapper around createManifestFormAdapter for RHF validation.
+ * Use this when you need a Zod schema for form validation (e.g., with zodResolver).
+ *
+ * @example
+ * ```tsx
+ * const validation = createManifestValidation(manifest, { role: 'author' })
+ * const form = useForm({
+ *   resolver: zodResolver(validation.schema),
+ *   defaultValues: ...
+ * })
+ * ```
+ */
+export declare function createManifestValidation(manifest: BlockManifest, options?: ManifestSchemaOptions): ManifestValidationResult;