@tempots/beatui 0.16.0 → 0.18.0

package/dist/types/components/json-schema/widgets/utils.d.ts

@@ -0,0 +1,45 @@
+import { JSONSchema } from '../schema-context';
+/**
+ * Unified x:ui configuration types
+ */
+export type XUIString = string;
+export interface XUIObject {
+    /** Widget type - takes precedence over format */
+    widget?: string;
+    /** Format type - fallback if widget not specified */
+    format?: string;
+    /** Widget-specific options */
+    [key: string]: unknown;
+}
+export type XUIConfig = XUIString | XUIObject;
+/**
+ * Resolved widget information with precedence applied
+ */
+export interface ResolvedWidget {
+    /** The effective widget type */
+    widget: string;
+    /** Source of the widget selection for debugging */
+    source: 'explicit-widget' | 'explicit-format' | 'schema-format' | 'schema-media' | 'constraints' | 'heuristics' | 'type-fallback';
+    /** Additional options from x:ui object */
+    options?: Record<string, unknown>;
+}
+/**
+ * Extract x:ui configuration from schema definition
+ */
+export declare function getXUIConfig(definition: JSONSchema): XUIConfig | undefined;
+/**
+ * Resolve effective widget with precedence rules:
+ * 1. Explicit x:ui.widget
+ * 2. Explicit x:ui.format (or x:ui as string)
+ * 3. Schema format property
+ * 4. Schema contentMediaType/contentEncoding
+ * 5. Schema constraints (enum, const, min/max, etc.)
+ * 6. Heuristics (property names, length bounds)
+ * 7. Type fallback
+ */
+export declare function resolveWidget(definition: JSONSchema, propertyName?: string): ResolvedWidget | undefined;
+/**
+ * Legacy function for backward compatibility
+ * @deprecated Use resolveWidget instead
+ */
+export declare function getUIFormat(definition: JSONSchema): string | undefined;

package/dist/types/components/json-schema/widgets/widget-composition.d.ts

@@ -0,0 +1,144 @@
+import type { Renderable } from '@tempots/dom';
+import type { Controller } from '../../form';
+import type { SchemaContext, JSONSchemaDefinition } from '../schema-context';
+import type { WidgetFactory } from './widget-customization';
+/**
+ * Widget composition configuration
+ */
+export interface WidgetComposition {
+    /** Layout type for composition */
+    layout: 'horizontal' | 'vertical' | 'grid' | 'tabs' | 'accordion' | 'custom';
+    /** Widgets to compose */
+    widgets: ComposedWidget[];
+    /** Layout-specific options */
+    layoutOptions?: {
+        /** Grid columns (for grid layout) */
+        columns?: number;
+        /** Gap between widgets */
+        gap?: string;
+        /** Alignment */
+        align?: 'start' | 'center' | 'end' | 'stretch';
+        /** Custom CSS classes */
+        className?: string;
+    };
+    /** Conditional composition rules */
+    conditions?: CompositionCondition[];
+}
+/**
+ * Individual widget in a composition
+ */
+export interface ComposedWidget {
+    /** Widget type/name */
+    type: string;
+    /** Widget-specific configuration */
+    config?: Record<string, unknown>;
+    /** Widget label/title */
+    label?: string;
+    /** Widget description */
+    description?: string;
+    /** Conditional visibility */
+    condition?: string | ((value: unknown, formData: unknown) => boolean);
+    /** Layout constraints */
+    layout?: {
+        /** Grid column span */
+        colSpan?: number;
+        /** Grid row span */
+        rowSpan?: number;
+        /** Flex grow factor */
+        grow?: number;
+        /** Flex shrink factor */
+        shrink?: number;
+        /** Minimum width */
+        minWidth?: string;
+        /** Maximum width */
+        maxWidth?: string;
+    };
+    /** Custom styling */
+    style?: Record<string, string>;
+    /** Custom CSS classes */
+    className?: string;
+}
+/**
+ * Composition condition for dynamic widget selection
+ */
+export interface CompositionCondition {
+    /** Condition to evaluate */
+    condition: string | ((value: unknown, formData: unknown) => boolean);
+    /** Composition to use when condition is true */
+    then: WidgetComposition;
+    /** Composition to use when condition is false */
+    else?: WidgetComposition;
+}
+/**
+ * Widget composition renderer
+ */
+export declare class WidgetComposer {
+    private widgetFactories;
+    /**
+     * Register a widget factory for composition
+     */
+    registerWidget(name: string, factory: WidgetFactory): void;
+    /**
+     * Unregister a widget factory
+     */
+    unregisterWidget(name: string): void;
+    /**
+     * Render a composed widget
+     */
+    renderComposition(composition: WidgetComposition, controller: Controller<unknown>, ctx: SchemaContext): Renderable;
+    /**
+     * Evaluate composition conditions
+     */
+    private evaluateConditions;
+    /**
+     * Evaluate widget visibility condition
+     */
+    private evaluateWidgetCondition;
+    /**
+     * Evaluate a condition
+     */
+    private evaluateCondition;
+    /**
+     * Render an individual widget
+     */
+    private renderWidget;
+    /**
+     * Wrap widget with layout constraints and styling
+     */
+    private wrapWidget;
+    /**
+     * Apply layout to rendered widgets
+     */
+    private applyLayout;
+}
+/**
+ * Global widget composer instance
+ */
+export declare const globalWidgetComposer: WidgetComposer;
+/**
+ * Extract widget composition from schema x:ui
+ */
+export declare function getWidgetComposition(schema: JSONSchemaDefinition): WidgetComposition | undefined;
+/**
+ * Helper to create a simple horizontal composition
+ */
+export declare function createHorizontalComposition(widgets: Array<{
+    type: string;
+    config?: Record<string, unknown>;
+    label?: string;
+}>, options?: {
+    gap?: string;
+    align?: 'start' | 'center' | 'end' | 'stretch';
+}): WidgetComposition;
+/**
+ * Helper to create a simple grid composition
+ */
+export declare function createGridComposition(widgets: Array<{
+    type: string;
+    config?: Record<string, unknown>;
+    label?: string;
+    colSpan?: number;
+    rowSpan?: number;
+}>, columns: number, options?: {
+    gap?: string;
+}): WidgetComposition;

package/dist/types/components/json-schema/widgets/widget-customization.d.ts

@@ -0,0 +1,120 @@
+import type { Renderable } from '@tempots/dom';
+import type { Controller } from '../../form';
+import type { SchemaContext, JSONSchema } from '../schema-context';
+import { type ResolvedWidget } from './utils';
+/**
+ * Widget factory function signature
+ */
+export type WidgetFactory<T = unknown> = (props: {
+    controller: Controller<T>;
+    ctx: SchemaContext;
+    options?: Record<string, unknown>;
+}) => Renderable;
+/**
+ * Widget registration entry
+ */
+export interface WidgetRegistration<T = unknown> {
+    /** Widget factory function */
+    factory: WidgetFactory<T>;
+    /** Widget display name */
+    displayName: string;
+    /** Widget description */
+    description?: string;
+    /** Supported JSON Schema types */
+    supportedTypes?: string[];
+    /** Default configuration */
+    defaultConfig?: Record<string, unknown>;
+    /** Configuration schema for the widget */
+    configSchema?: JSONSchema;
+    /** Widget priority (higher = preferred when multiple widgets match) */
+    priority?: number;
+    /** Whether this widget can be used as a fallback */
+    canFallback?: boolean;
+}
+/**
+ * Widget customization configuration from x:ui
+ */
+export interface WidgetCustomization {
+    /** Custom widget type override */
+    widget?: string;
+    /** Widget-specific configuration */
+    config?: Record<string, unknown>;
+    /** Custom CSS classes */
+    className?: string;
+    /** Custom styles */
+    style?: Record<string, string>;
+    /** Custom attributes */
+    attributes?: Record<string, string>;
+    /** Widget wrapper configuration */
+    wrapper?: {
+        tag?: string;
+        className?: string;
+        style?: Record<string, string>;
+        attributes?: Record<string, string>;
+    };
+    /** Conditional widget selection */
+    conditional?: {
+        condition: string | ((value: unknown, formData: unknown) => boolean);
+        then?: WidgetCustomization;
+        else?: WidgetCustomization;
+    };
+}
+/**
+ * Widget registry for managing custom widgets
+ */
+export declare class WidgetRegistry {
+    private widgets;
+    private typeMapping;
+    /**
+     * Register a custom widget
+     */
+    register<T = unknown>(name: string, registration: WidgetRegistration<T>): void;
+    /**
+     * Unregister a widget
+     */
+    unregister(name: string): void;
+    /**
+     * Get a registered widget
+     */
+    get(name: string): WidgetRegistration<unknown> | undefined;
+    /**
+     * Get all registered widgets
+     */
+    getAll(): Map<string, WidgetRegistration<unknown>>;
+    /**
+     * Get widgets that support a specific JSON Schema type
+     */
+    getForType(type: string): WidgetRegistration<unknown>[];
+    /**
+     * Find the best widget for a schema context
+     */
+    findBestWidget(ctx: SchemaContext): {
+        name: string;
+        registration: WidgetRegistration<unknown>;
+        resolved: ResolvedWidget;
+    } | null;
+}
+/**
+ * Global widget registry instance
+ */
+export declare const globalWidgetRegistry: WidgetRegistry;
+/**
+ * Extract widget customization from schema x:ui
+ */
+export declare function getWidgetCustomization(schema: JSONSchema): WidgetCustomization | undefined;
+/**
+ * Apply widget customization to a rendered widget
+ */
+export declare function applyWidgetCustomization(widget: Renderable, customization: WidgetCustomization, value?: unknown, formData?: unknown): Renderable;
+/**
+ * Create a customized widget factory
+ */
+export declare function createCustomizedWidget<T = unknown>(baseFactory: WidgetFactory<T>, customization: WidgetCustomization): WidgetFactory<T>;
+/**
+ * Register built-in enhanced widgets
+ */
+export declare function registerEnhancedWidgets(registry?: WidgetRegistry): void;
+/**
+ * Helper to register a simple widget
+ */
+export declare function registerWidget<T = unknown>(name: string, factory: WidgetFactory<T>, options?: Partial<WidgetRegistration<T>>, registry?: WidgetRegistry): void;

package/dist/types/components/layout/index.d.ts

@@ -2,6 +2,7 @@ export * from './app-shell';
 export * from './card';
 export * from './center';
 export * from './collapse';
+export * from './nine-slice-scroll-view';
 export * from './group';
 export * from './scrollable-panel';
 export * from './sink';

package/dist/types/components/layout/nine-slice-scroll-view.d.ts

@@ -0,0 +1,21 @@
+import { TNode, Value } from '@tempots/dom';
+export type AnchorMode = 'container-edge' | 'body-end' | 'body-bottom' | 'body-end-bottom';
+export type NineSliceScrollViewOptions = {
+    body: TNode;
+    contentWidth: Value<bigint>;
+    contentHeight: Value<bigint>;
+    header?: TNode;
+    headerHeight?: Value<number>;
+    topStart?: TNode;
+    topEnd?: TNode;
+    footer?: TNode;
+    footerHeight?: Value<number>;
+    bottomStart?: TNode;
+    bottomEnd?: TNode;
+    sidebarStart?: TNode;
+    sidebarStartWidth?: Value<number>;
+    sidebarEnd?: TNode;
+    sidebarEndWidth?: Value<number>;
+    anchorMode?: Value<AnchorMode>;
+};
+export declare function NineSliceScrollView({ body, contentWidth, contentHeight, header, headerHeight, topStart, topEnd, footer, footerHeight, bottomStart, bottomEnd, sidebarStart, sidebarStartWidth, sidebarEnd, sidebarEndWidth, anchorMode, }: NineSliceScrollViewOptions): import("@tempots/dom").Renderable;

package/dist/types/components/layout/scrollable-panel.d.ts

@@ -5,4 +5,4 @@ export type ScrollablePanelOptions = {
     body: TNode;
     shadowOnScroll?: Value<boolean>;
 };
-export declare function ScrollablePanel({ header, footer, body, shadowOnScroll, }: ScrollablePanelOptions): import("@tempots/dom").Renderable;
+export declare function ScrollablePanel({ header, footer, body, shadowOnScroll }: ScrollablePanelOptions, ...children: TNode[]): import("@tempots/dom").Renderable;

package/dist/types/components/milkdown/milkdown-input.d.ts

@@ -0,0 +1,15 @@
+import { TNode, Value } from '@tempots/dom';
+import type { InputOptions } from '../form/input/input-options';
+import { Merge } from '@tempots/std';
+export type ListenerManager = {
+    markdownUpdated: (fn: (ctx: unknown, markdown: string, prevMarkdown: string) => unknown) => unknown;
+    focus: (fn: () => unknown) => unknown;
+    blur: (fn: () => unknown) => unknown;
+};
+export type MilkdownInputOptions = Merge<InputOptions<string>, {
+    readOnly?: Value<boolean>;
+    featureConfigs?: Record<string, unknown> | undefined;
+    features?: Record<string, boolean> | undefined;
+    cssInjection?: 'link' | 'none';
+}>;
+export declare const MilkdownInput: (options: MilkdownInputOptions) => TNode;

package/dist/types/components/milkdown/milkdown-url.d.ts

@@ -0,0 +1,2 @@
+declare const cssHref: string;
+export default cssHref;

package/dist/types/components/misc/index.d.ts

@@ -1 +1,4 @@
 export * from './expando';
+export * from './style-portal';
+export * from './link-portal';
+export * from './notice';

package/dist/types/components/misc/link-portal.d.ts

@@ -0,0 +1,11 @@
+import { Renderable, Value } from '@tempots/dom';
+export type LinkPortalOptions = {
+    id?: Value<string>;
+    href: Value<string>;
+    rel?: Value<string>;
+};
+/**
+ * Injects a <link rel="stylesheet"> tag with the provided href into <head> via Portal.
+ * Keeps styling SSR/SSG-friendly while leveraging browser caching of CSS assets.
+ */
+export declare const LinkPortal: ({ id, href, rel }: LinkPortalOptions) => Renderable;

package/dist/types/components/misc/notice.d.ts

@@ -0,0 +1,15 @@
+import { TNode, Value, Renderable } from '@tempots/dom';
+export type NoticeVariant = 'info' | 'success' | 'warning' | 'error';
+export type NoticeTone = 'subtle' | 'prominent';
+export type NoticeRole = 'status' | 'alert';
+export type NoticeOptions = {
+    variant?: Value<NoticeVariant>;
+    tone?: Value<NoticeTone>;
+    role?: Value<NoticeRole | undefined>;
+    title?: Value<string | undefined>;
+    icon?: Value<string | false | undefined>;
+    closable?: Value<boolean>;
+    onDismiss?: () => void;
+    class?: Value<string>;
+};
+export declare function Notice({ variant, tone, role, title, icon, closable, onDismiss, class: cls, }: NoticeOptions, ...children: TNode[]): Renderable;

package/dist/types/components/misc/style-portal.d.ts

@@ -0,0 +1,10 @@
+import { Renderable, Value } from '@tempots/dom';
+export type StylePortalOptions = {
+    id?: Value<string>;
+    css: Value<string>;
+};
+/**
+ * Injects a <style> tag with the provided CSS into <head> via Portal.
+ * Ensures declarative, SSR/SSG-friendly styling without imperative DOM APIs.
+ */
+export declare const StylePortal: ({ id, css }: StylePortalOptions) => Renderable;

package/dist/types/components/monaco/monaco-editor-input.d.ts

@@ -0,0 +1,12 @@
+import { Renderable } from '@tempots/dom';
+import type { InputOptions } from '../form/input/input-options';
+import { Merge } from '@tempots/std';
+import { MonacoEditorSpecificOptions } from '@/monaco/types';
+export type MonacoEditorInputOptions = Merge<InputOptions<string>, MonacoEditorSpecificOptions & {
+    cssInjection?: 'link' | 'none';
+}>;
+/**
+ * MonacoEditorInput mounts a Monaco editor in an InputContainer and wires its value to BeatUI inputs.
+ * Note: This component dynamically imports 'monaco-editor' at runtime and does not include it in the main bundle.
+ */
+export declare const MonacoEditorInput: (options: MonacoEditorInputOptions) => Renderable;

package/dist/types/components/navigation/flyout.d.ts

@@ -1,4 +1,4 @@
-import { TNode, Value } from '@tempots/dom';
+import { Renderable, TNode, Value } from '@tempots/dom';
 import { Placement } from '@tempots/ui';
 export type FlyoutTrigger = 'hover' | 'focus' | 'hover-focus' | 'click' | 'never';
 export type FlyoutTriggerFunction = (show: () => void, hide: () => void) => TNode;
@@ -41,4 +41,4 @@ export interface FlyoutOptions {
  *
  * Uses @tempo-ts/ui PopOver for positioning.
  */
-export declare function Flyout(options: FlyoutOptions): TNode;
+export declare function Flyout(options: FlyoutOptions): Renderable;

package/dist/types/components/navigation/index.d.ts

@@ -3,3 +3,4 @@ export * from './link';
 export * from './menu';
 export * from './sidebar/index';
 export * from './tabs';
+export * from './toolbar';

package/dist/types/components/navigation/menu.d.ts

@@ -1,6 +1,6 @@
-import { TNode, Value } from '@tempots/dom';
+import { TNode, Value, Renderable } from '@tempots/dom';
 import { Placement } from '@tempots/ui';
-import { FlyoutTrigger } from './flyout';
+import { FlyoutTrigger, FlyoutTriggerFunction } from './flyout';
 export type MenuTrigger = FlyoutTrigger;
 export interface MenuOptions {
     /** The menu items to display */
@@ -15,8 +15,8 @@ export interface MenuOptions {
     mainAxisOffset?: Value<number>;
     /** Offset in pixels from the cross axis */
     crossAxisOffset?: Value<number>;
-    /** How to show the menu */
-    showOn?: Value<MenuTrigger>;
+    /** How to show the menu (accepts Flyout trigger or a custom trigger function) */
+    showOn?: Value<MenuTrigger> | FlyoutTriggerFunction;
     /** Whether the menu can be closed with Escape key */
     closable?: Value<boolean>;
     /** Callback when menu is closed */
@@ -72,7 +72,7 @@ export interface MenuSeparatorOptions {
  * )
  * ```
  */
-export declare function Menu(options: MenuOptions): TNode;
+export declare function Menu(options: MenuOptions): Renderable;
 /**
  * MenuItem component for individual menu items.
  *
@@ -86,7 +86,7 @@ export declare function Menu(options: MenuOptions): TNode;
  * })
  * ```
  */
-export declare function MenuItem(options: MenuItemOptions): TNode;
+export declare function MenuItem(options: MenuItemOptions): Renderable;
 /**
  * MenuSeparator component for visual grouping of menu items.
  * Creates a visual divider between groups of menu items.
@@ -103,4 +103,4 @@ export declare function MenuItem(options: MenuItemOptions): TNode;
  * })
  * ```
  */
-export declare function MenuSeparator(options?: MenuSeparatorOptions): TNode;
+export declare function MenuSeparator(options?: MenuSeparatorOptions): Renderable;

package/dist/types/components/navigation/toolbar/index.d.ts

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

package/dist/types/components/navigation/toolbar/toolbar.d.ts

@@ -0,0 +1,17 @@
+import { TNode, Value } from '@tempots/dom';
+import { ButtonOptions } from '@/components/button/button';
+export interface ToolbarOptions {
+    ariaLabel?: Value<string>;
+}
+export declare function Toolbar(...children: TNode[]): import("@tempots/dom").Renderable;
+export interface ToolbarButtonOptions extends ButtonOptions {
+    iconOnly?: Value<boolean>;
+    ariaLabel?: Value<string>;
+}
+export declare function ToolbarButton(options: ButtonOptions, ...children: TNode[]): import("@tempots/dom").Renderable;
+export interface ToolbarGroupOptions {
+    ariaLabel?: Value<string>;
+}
+export declare function ToolbarGroup(...children: TNode[]): import("@tempots/dom").Renderable;
+export declare function ToolbarDivider(): import("@tempots/dom").Renderable;
+export declare function ToolbarSpacer(): import("@tempots/dom").Renderable;

package/dist/types/components/overlay/drawer.d.ts

@@ -1,4 +1,4 @@
-import { TNode, Value } from '@tempots/dom';
+import { TNode, Renderable, Value } from '@tempots/dom';
 import { OverlayEffect } from '../theme/types';
 export interface DrawerOptions {
     /** Size of the drawer */
@@ -26,4 +26,4 @@ export interface DrawerOptions {
  * Drawer component that provides a slide-out panel anchored to any side
  * Built on top of the overlay component
  */
-export declare function Drawer(fn: (open: (options: DrawerOptions) => void, close: () => void) => TNode): TNode;
+export declare function Drawer(fn: (open: (options: DrawerOptions) => void, close: () => void) => TNode): Renderable;

package/dist/types/components/overlay/modal.d.ts

@@ -1,4 +1,4 @@
-import { TNode, Value } from '@tempots/dom';
+import { TNode, Value, Renderable } from '@tempots/dom';
 import { OverlayEffect } from '../theme';
 export interface ModalOptions {
     /** Size of the modal */
@@ -28,7 +28,7 @@ export interface ModalContentOptions {
  * Modal component that provides a structured dialog with optional header, body, and footer
  * Built on top of the overlay component
  */
-export declare function Modal(options: ModalOptions, fn: (open: (content: ModalContentOptions) => void, close: () => void) => TNode): TNode;
+export declare function Modal(options: ModalOptions, fn: (open: (content: ModalContentOptions) => void, close: () => void) => TNode): Renderable;
 /**
  * Convenience function to create a confirmation modal
  */
@@ -37,4 +37,4 @@ export declare function ConfirmModal(options: ModalOptions & {
     cancelText?: Value<string>;
     onConfirm?: () => void;
     onCancel?: () => void;
-}, fn: (open: (message: TNode) => void, close: () => void) => TNode): TNode;
+}, fn: (open: (message: TNode) => void, close: () => void) => TNode): Renderable;

package/dist/types/components/overlay/tooltip.d.ts

@@ -1,4 +1,4 @@
-import { TNode, Value } from '@tempots/dom';
+import { TNode, Value, Renderable } from '@tempots/dom';
 import { Placement } from '@tempots/ui';
 import { FlyoutTrigger } from '../navigation/flyout';
 export type TooltipTrigger = FlyoutTrigger;
@@ -34,4 +34,4 @@ export interface TooltipOptions {
  * )
  * ```
  */
-export declare function Tooltip(options: TooltipOptions): TNode;
+export declare function Tooltip(options: TooltipOptions): Renderable;

package/dist/types/i18n/translate.d.ts

@@ -1,18 +1,4 @@
-import { Signal, Value } from '@tempots/dom';
-/**
- * Utility type that wraps each element of a tuple in a Value<T>.
- * Used to convert function parameters to reactive values.
- */
-type WrapInValue<T extends unknown[]> = {
-    [K in keyof T]: Value<T[K]>;
-};
-/**
- * Transforms a messages object into a computed version where each message function
- * returns a reactive Signal instead of a direct value.
- */
-export type ReactiveMessages<M extends object> = {
-    [K in keyof M]: M[K] extends (...args: infer Args) => infer R ? (...args: WrapInValue<Args>) => Signal<R> : never;
-};
+import { Signal } from '@tempots/dom';
 /**
  * Creates a reactive translation system that dynamically loads locale-specific messages.
  *
@@ -77,6 +63,5 @@ export declare function makeMessages<M extends object>({ locale, defaultLocale,
     /** Clean up all resources and event listeners */
     dispose: () => void;
     /** Translation functions that return reactive signals */
-    t: ReactiveMessages<M>;
+    t: import("@tempots/dom").Prop<M>;
 };
-export {};

package/dist/types/index.d.ts

@@ -1,6 +1,5 @@
 export { Use } from '@tempots/dom';
 export * from './beatui-i18n';
-export * from './components/auth';
 export * from './components/beatui';
 export * from './components/button';
 export * from './components/content';
@@ -16,3 +15,4 @@ export * from './components/typography';
 export * from './i18n';
 export * from './tokens';
 export * from './utils';
+export * from './temporal';

package/dist/types/json-schema/index.d.ts

@@ -0,0 +1 @@
+export * from '../components/json-schema';

package/dist/types/markdown/extensions.d.ts

@@ -0,0 +1,8 @@
+import type { Options as MicromarkOptions } from 'micromark';
+export type MarkdownFeatures = {
+    gfm?: boolean;
+};
+export declare function resolveExtensions(features?: MarkdownFeatures): Promise<{
+    extensions: MicromarkOptions['extensions'];
+    htmlExtensions: MicromarkOptions['htmlExtensions'];
+}>;

package/dist/types/markdown/index.d.ts

@@ -0,0 +1,17 @@
+import { TNode, Value, Renderable } from '@tempots/dom';
+export type MarkdownOptions = {
+    content: Value<string>;
+    /** Escape HTML by default for safety. Set true to allow raw HTML passthrough. */
+    allowHtml?: Value<boolean>;
+    features?: Value<{
+        gfm?: boolean;
+    }>;
+    cssInjection?: 'link' | 'none';
+};
+/**
+ * Markdown component: renders Markdown to HTML using micromark.
+ * - Escapes HTML by default (allowHtml: false)
+ * - Applies bu-prose utilities for typography and a small component CSS (bc-markdown)
+ * - Ships as separate subpath bundle (@tempots/beatui/markdown)
+ */
+export declare function Markdown(options: MarkdownOptions, ...children: TNode[]): Renderable;

package/dist/types/markdown/styles-url.d.ts

@@ -0,0 +1,2 @@
+declare const cssHref: string;
+export default cssHref;

package/dist/types/markdown/styles.d.ts

@@ -0,0 +1,2 @@
+declare const _default: string;
+export default _default;

package/dist/types/milkdown/index.d.ts

@@ -0,0 +1 @@
+export * from '../components/milkdown/milkdown-input';

package/dist/types/milkdown/styles.d.ts

@@ -0,0 +1,2 @@
+declare const _default: string;
+export default _default;

package/dist/types/monaco/index.d.ts

@@ -0,0 +1,3 @@
+export * from '../components/monaco/monaco-editor-input';
+export * from './types';
+export { configureMonacoEnvironment } from './lazy-loader';

package/dist/types/monaco/lazy-loader.d.ts

@@ -0,0 +1,5 @@
+import type * as MonacoTypes from 'monaco-editor';
+export declare function loadMonacoCore(): Promise<typeof MonacoTypes>;
+export declare function loadLanguageFeatures(language: string): Promise<void>;
+export declare function loadMonacoWithLanguage(language: string): Promise<typeof MonacoTypes>;
+export declare function configureMonacoEnvironment(getWorkerFn?: (workerId: string, label: string) => Worker): void;