@mieweb/ui 0.10.0-dev.3 → 0.10.0-dev.31

package/dist/templates.js

@@ -0,0 +1,11 @@
+export { BenchmarkTableSection, ComparisonSection, CtaSection, FaqSection, FeatureGridSection, HeroSection, LandingPage, LeadFormSection, LinkGroupsSection, LogoCloudSection, MetricListSection, PdfEmbedSection, PricingSection, ProcessStepsSection, RankedListSection, ReportByline, ReportLegend, ReportMethodology, ResourceCardsSection, SplitContentSection, StatsSection, TestimonialSection, TileCartogramSection, VideoSection, defaultLeadFormFields, landingPresets, quartileBuckets, usStateTiles, validateLandingPage } from './chunk-T4JYUICS.js';
+import './chunk-IQ4KQJAO.js';
+export { MetricStatusBadge, SectionHeading, SectionShell, TemplateIcon, defaultMetricStatusLabels, templateIcons } from './chunk-FBCDYTWM.js';
+import './chunk-6NZXWKUE.js';
+import './chunk-3IMM2PM4.js';
+import './chunk-BMSG4NBH.js';
+import './chunk-GVM6DTR5.js';
+import './chunk-TQONQSJO.js';
+import './chunk-PX6F3LHL.js';
+//# sourceMappingURL=templates.js.map
+//# sourceMappingURL=templates.js.map

package/dist/templates.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":[],"names":[],"mappings":"","file":"templates.js"}

package/dist/types-Cx1FHLq2.d.cts

@@ -0,0 +1,548 @@
+import * as React from 'react';
+
+/** A caller-owned media resource. Provider embeds can also use `renderMedia`. */
+interface MediaFeedMedia {
+    kind: 'image' | 'video' | 'audio' | 'youtube';
+    src: string;
+    poster?: string;
+    alt?: string;
+}
+interface MediaFeedAuthor {
+    name: string;
+    avatar?: string;
+}
+/** An explicit Play gesture, separate from item selection and automatic playback. */
+interface MediaFeedPlaybackRequest {
+    itemId: string;
+    /** Use a fresh token for each gesture, including repeated Play on the same item. */
+    requestId: string | number;
+}
+/** Custom players must stop playback whenever `active` is false. */
+interface MediaFeedRenderContext<T> {
+    item: T;
+    active: boolean;
+    autoPlay: boolean;
+    muted: boolean;
+    loop: boolean;
+    /** A pending manual Play token for this active item. Handle each token once. */
+    playbackRequestId?: string | number;
+}
+/** Every string authored by the feed can be localized by its host. */
+interface MediaFeedLabels {
+    feed: string;
+    loading: string;
+    empty: string;
+    error: string;
+    retry: string;
+    fullscreen: string;
+    close: string;
+    previous: string;
+    next: string;
+    play: string;
+    pause: string;
+    blockedAutoplay: string;
+    mediaError: string;
+    openSource: string;
+    youtubeNotice: string;
+    item: (position: number, total: number) => string;
+    position: (position: number, total: number) => string;
+}
+/** Keys match the feed's `data-slot` attributes. */
+interface MediaFeedClassNames {
+    root?: string;
+    viewport?: string;
+    item?: string;
+    media?: string;
+    details?: string;
+    author?: string;
+    title?: string;
+    caption?: string;
+    actions?: string;
+    status?: string;
+    controls?: string;
+    fullscreen?: string;
+}
+interface MediaFeedProps<T> extends Omit<React.HTMLAttributes<HTMLDivElement>, 'children' | 'onError'> {
+    /** Records in presentation order. The feed never fetches or mutates them. */
+    items: readonly T[];
+    /** A stable, unique ID for each record. */
+    getId: (item: T) => string;
+    getMedia: (item: T) => MediaFeedMedia;
+    getTitle?: (item: T) => string;
+    getCaption?: (item: T) => React.ReactNode;
+    getAuthor?: (item: T) => MediaFeedAuthor;
+    /** Host-owned actions, such as reactions or opening a conversation. */
+    renderActions?: (item: T) => React.ReactNode;
+    /** Replace the built-in player, respecting its active playback boundary. */
+    renderMedia?: (media: MediaFeedMedia, context: MediaFeedRenderContext<T>) => React.ReactNode;
+    /** Controlled selection. Changes scroll the selected record into view. */
+    activeItemId?: string;
+    /** Initial selection for an uncontrolled feed. */
+    defaultActiveItemId?: string;
+    /** Fires for user navigation and visibility changes, with the original item. */
+    onActiveItemChange?: (item: T) => void;
+    /**
+     * Attempt explicit playback once the requested item is selected and visible.
+     * This bypasses reduced-motion/autoplay suppression for that gesture only;
+     * it does not change selection. Browsers can still require another gesture.
+     */
+    playbackRequest?: MediaFeedPlaybackRequest;
+    loading?: boolean;
+    error?: string | null;
+    onRetry?: () => void | Promise<void>;
+    /** Attempt visible playback unless reduced motion is preferred; a gesture may be required. */
+    autoPlay?: boolean;
+    /** Native playback begins muted by default. Native controls can unmute it. */
+    muted?: boolean;
+    loop?: boolean;
+    labels?: Partial<MediaFeedLabels>;
+    classNames?: MediaFeedClassNames;
+}
+
+/**
+ * AI Component Types
+ *
+ * Type definitions for AI-related components including MCP (Model Context Protocol)
+ * interactions, tool calls, and chat messages.
+ */
+
+/**
+ * Status of an MCP tool invocation
+ */
+type MCPToolStatus = 'pending' | 'running' | 'success' | 'error' | 'cancelled';
+/**
+ * MCP Tool parameter definition
+ */
+interface MCPToolParameter {
+    name: string;
+    type: string;
+    value: unknown;
+    description?: string;
+}
+/**
+ * MCP Tool invocation
+ */
+interface MCPToolCall {
+    /** Unique identifier for this tool call */
+    id: string;
+    /** Name of the tool being invoked */
+    toolName: string;
+    /** Human-readable description of what the tool does */
+    description?: string;
+    /** Parameters passed to the tool */
+    parameters: MCPToolParameter[];
+    /** Current status of the tool execution */
+    status: MCPToolStatus;
+    /** Timestamp when tool was invoked */
+    startedAt: Date | string;
+    /** Timestamp when tool completed */
+    completedAt?: Date | string;
+    /** Duration in milliseconds */
+    duration?: number;
+    /** Result data if successful */
+    result?: MCPToolResult;
+    /** Error message if failed */
+    error?: string;
+}
+/**
+ * Result from an MCP tool execution
+ */
+interface MCPToolResult {
+    /** Type of result data */
+    type: 'text' | 'json' | 'link' | 'resource' | 'error';
+    /** The result data */
+    data: unknown;
+    /** Human-readable summary of the result */
+    summary?: string;
+    /** Link to a resource (for link type) */
+    link?: MCPResourceLink;
+    /** Resources created or modified */
+    resources?: MCPResource[];
+}
+/**
+ * Link to a resource
+ */
+interface MCPResourceLink {
+    /** URL or path to the resource */
+    href: string;
+    /** Display text for the link */
+    label: string;
+    /** Type of resource */
+    type?: 'patient' | 'document' | 'appointment' | 'order' | 'provider' | 'external' | 'internal';
+    /** Icon name or component */
+    icon?: string;
+}
+/**
+ * MCP Resource definition
+ */
+interface MCPResource {
+    /** Unique identifier */
+    id: string;
+    /** Resource type (e.g., 'patient', 'appointment', 'document') */
+    type: string;
+    /** Display name */
+    name: string;
+    /** URL to access the resource */
+    uri?: string;
+    /** Brief description */
+    description?: string;
+    /** Additional metadata */
+    metadata?: Record<string, unknown>;
+}
+/**
+ * Role of the message sender
+ */
+type AIMessageRole = 'user' | 'assistant' | 'system' | 'tool';
+/**
+ * Status of an AI message
+ */
+type AIMessageStatus = 'pending' | 'streaming' | 'complete' | 'error';
+/**
+ * Content block within a message
+ */
+interface AIMessageContent {
+    /** Type of content */
+    type: 'text' | 'tool_use' | 'tool_result' | 'thinking' | 'code' | 'image' | 'file' | 'audio' | 'video';
+    /** Text content (also used as the label for `audio` and `video` blocks) */
+    text?: string;
+    /** Tool call reference */
+    toolCall?: MCPToolCall;
+    /** Language for code blocks */
+    language?: string;
+    /** Whether this content is collapsed by default */
+    collapsed?: boolean;
+    /** Image source URL (for `image` blocks) */
+    imageUrl?: string;
+    /** Alt text / file name (for `image` and `file` blocks) */
+    name?: string;
+    /** File size in bytes (for `file` blocks) */
+    fileSize?: number;
+    /** MIME type (for `file`, `audio`, and `video` blocks) */
+    mimeType?: string;
+    /** Download/open URL (for `file` blocks) */
+    fileUrl?: string;
+    /** Source URL for `audio` blocks */
+    audioUrl?: string;
+    /** Source URL for `video` blocks */
+    videoUrl?: string;
+    /** Duration in seconds for `audio` blocks */
+    duration?: number;
+}
+/**
+ * AI Chat Message
+ */
+interface AIMessage {
+    /** Unique identifier */
+    id: string;
+    /** Role of sender */
+    role: AIMessageRole;
+    /** Message content blocks */
+    content: AIMessageContent[];
+    /** Timestamp */
+    timestamp: Date | string;
+    /** Current status */
+    status: AIMessageStatus;
+    /** Model used (for assistant messages) */
+    model?: string;
+    /** Token usage info */
+    usage?: {
+        promptTokens?: number;
+        completionTokens?: number;
+        totalTokens?: number;
+    };
+    /** Custom metadata */
+    metadata?: Record<string, unknown>;
+}
+/** Context passed to a custom text content renderer. */
+interface AITextRenderContext {
+    /** id of the parent message (useful as a render cache key) */
+    messageId: string;
+    /** true while the message is still streaming */
+    streaming: boolean;
+    /** role of the parent message */
+    role: AIMessage['role'];
+}
+/**
+ * Render-prop for customizing `text` content blocks. Host is responsible
+ * for sanitizing untrusted input.
+ */
+type AIRenderTextContent = (text: string, ctx: AITextRenderContext) => React.ReactNode;
+
+/**
+ * SuperChat Types
+ *
+ * A multi-participant chat model that generalizes the AI module's
+ * `user`/`assistant` roles and the standalone `chat-component`'s
+ * `external`/`internal`/`system` roles into a single **participant** concept,
+ * plus the pluggable Markdown render pipeline contracts.
+ *
+ * See `MAINTAINERS.md` (Mission → Decisions 2 & 3) for the design rationale.
+ */
+
+/** What kind of actor a participant is. */
+type ParticipantKind = 'human' | 'agent' | 'system';
+/** Presence/activity status for a participant. */
+type ParticipantStatus = 'online' | 'offline' | 'busy' | 'typing';
+/**
+ * A single actor in a conversation. Any mix of multiple agents and multiple
+ * humans can participate in one conversation.
+ */
+interface Participant {
+    /** Stable unique id, referenced by `SuperChatMessage.participantId`. */
+    id: string;
+    /** Whether this is a human, an AI agent, or the system. */
+    kind: ParticipantKind;
+    /** Display name. */
+    name: string;
+    /** Optional avatar image URL. */
+    avatar?: string;
+    /**
+     * Optional accent color (any CSS color) used as a visual cue so concurrent /
+     * interleaved replies from multiple agents stay legible.
+     */
+    color?: string;
+    /** Optional sub-label, e.g. "Triage agent" or "Front desk". */
+    role?: string;
+    /** Optional presence indicator. */
+    status?: ParticipantStatus;
+}
+/** Channel a message arrived/was sent on (healthcare-messaging compatible). */
+type SuperChatChannel = 'portal' | 'sms' | 'voicemail' | 'auto' | (string & {});
+/**
+ * Format used when a message's copy action is triggered without picking an
+ * explicit variant (Ctrl/Cmd-click on the footer copy button).
+ * - `'rich'` (default): writes rich text (`text/html`) *and* Markdown
+ *   (`text/plain`) in one clipboard write — the paste target decides.
+ * - `'markdown'`: writes the Markdown source as plain text.
+ * - `'plain'`: writes the rendered plain text.
+ *
+ * All formats stay reachable per message via the copy menus.
+ */
+type SuperChatCopyFormat = 'rich' | 'markdown' | 'plain';
+/** Reference attachment carried by a `ref` thread item. */
+interface SuperChatRef {
+    /** Kind of referenced entity. */
+    refType: 'doc' | 'rx' | 'appt' | (string & {});
+    /** Id of the referenced entity. */
+    refId: string;
+    /** Display title for the reference. */
+    title: string;
+}
+/** Kind of thread item. */
+type SuperChatItemType = 'message' | 'ref' | 'system';
+/** Persisted media belonging to a message; ids are unique within that message. */
+interface SuperChatMediaAttachment extends MediaFeedMedia {
+    /** Stable attachment id assigned by the host when the media is persisted. */
+    id: string;
+    /** Optional display title, independent of the source filename. */
+    title?: string;
+    /** Optional plain-text caption; defaults to the source message text. */
+    caption?: string;
+}
+/** A conversation media item retains the original message and author identity. */
+interface SuperChatMediaItem {
+    /** Collision-safe identity derived from conversation, message and attachment ids. */
+    id: string;
+    conversationId: string;
+    message: SuperChatMessage;
+    attachment: SuperChatMediaAttachment;
+    participant?: Participant;
+}
+type SuperChatView = 'thread' | 'media';
+/** Feed behavior and extension slots; conversation data/accessors are fixed. */
+type SuperChatMediaFeedProps = Omit<MediaFeedProps<SuperChatMediaItem>, 'items' | 'getId' | 'getMedia' | 'getTitle' | 'getCaption' | 'getAuthor'>;
+/** Labels introduced by the conversation's media view. */
+interface SuperChatMediaLabels {
+    backToConversation: string;
+    openMedia: string;
+    playMedia: string;
+    unknownAuthor: string;
+}
+/**
+ * A single thread item. Preserves the `chat-component` thread-item shape
+ * (`senderId`/`sender_name`/`channel`/`time`/`text`) while adding a
+ * `participantId` (Decision 2) and optional rich `content` blocks reused from
+ * the AI module.
+ */
+interface SuperChatMessage {
+    /** Unique identifier. */
+    id: string;
+    /** Item type. Defaults to `'message'`. */
+    type?: SuperChatItemType;
+    /** Participant who authored the item. */
+    participantId: string;
+    /** Plain-text body (rendered through the Markdown pipeline). */
+    text?: string;
+    /**
+     * Optional rich content blocks (text / tool_use / tool_result / thinking /
+     * code), reused from the AI module for tool-call visualization etc.
+     */
+    content?: AIMessageContent[];
+    /** Explicit persisted image/video/audio/YouTube attachments for thread and feed views. */
+    media?: SuperChatMediaAttachment[];
+    /** Timestamp; the thread is append-only and ordered by `time`. */
+    time: Date | string;
+    /**
+     * Timestamp of the most recent edit, if the message has been edited. When
+     * set, surfaces an "(edited)" indicator next to the message time.
+     */
+    editedAt?: Date | string;
+    /** Delivery/generation status. */
+    status?: AIMessageStatus;
+    /** Channel the item belongs to. */
+    channel?: SuperChatChannel;
+    /** Reference payload when `type === 'ref'`. */
+    ref?: SuperChatRef;
+    /** Participant ids addressed via `@`-mention. */
+    mentions?: string[];
+    /** Custom metadata. */
+    metadata?: Record<string, unknown>;
+    /** @deprecated use `participantId`. */
+    senderId?: string;
+    /** @deprecated derive from the participant. */
+    sender_name?: string;
+}
+/**
+ * A file (typically an image) the local user pasted or attached in the
+ * composer, surfaced to the host via the send callback so it can be embedded,
+ * uploaded, or otherwise added to the conversation.
+ */
+interface ComposerAttachment {
+    /** Stable id for the attachment (unique within a single draft). */
+    id: string;
+    /** File name, derived from the pasted file or a generated fallback. */
+    name: string;
+    /** MIME type, e.g. `image/png`. */
+    type: string;
+    /** Base64 `data:` URL of the file contents. */
+    dataUrl: string;
+}
+/**
+ * Categories of files the composer can accept. Developers pick which kinds are
+ * allowed via `acceptedFileTypes`; each maps to an `<input accept>` token and a
+ * MIME matcher used to filter pastes and file-picker selections.
+ * - `image` → `image/*`
+ * - `video` → `video/*`
+ * - `audio` → `audio/*`
+ * - `pdf` → `application/pdf`
+ */
+type AttachmentKind = 'image' | 'video' | 'audio' | 'pdf';
+/** A conversation: participants + an ordered thread. */
+interface SuperChatConversation {
+    /** Unique identifier. */
+    id: string;
+    /** Display title. */
+    title: string;
+    /** Optional external reference id (e.g. patient/chart id). */
+    reference_id?: string;
+    /** Whether the conversation is currently open. */
+    open?: boolean;
+    /** Unread message count. */
+    unread?: number;
+    /** Timestamp of the last activity (used for sidebar ordering). */
+    lastActivity?: Date | string;
+    /** Everyone taking part in this conversation. */
+    participants: Participant[];
+    /** Ordered thread items. */
+    thread: SuperChatMessage[];
+}
+/** Builds an href for a reference item (e.g. doc/rx/appt deep link). */
+type SuperChatLinkBuilder = (ref: SuperChatRef) => string | undefined;
+/**
+ * A unified remark/rehype plugin entry. Kept dependency-light here (the public
+ * type surface stays zero-dep); the composer casts to the concrete
+ * `react-markdown` `PluggableList` type.
+ */
+type SuperChatPluggable = unknown;
+type SuperChatPluggableList = SuperChatPluggable[];
+/**
+ * A render plugin contributes remark/rehype plugins, custom node components,
+ * and/or GenUI widgets to the Markdown pipeline. Plugins are composed into a
+ * single `renderTextContent` implementation.
+ */
+interface SuperChatRenderPlugin {
+    /** Unique plugin name. */
+    name: string;
+    /** remark plugins to add (operate on the Markdown AST). */
+    remarkPlugins?: SuperChatPluggableList;
+    /** rehype plugins to add (operate on the HTML AST). */
+    rehypePlugins?: SuperChatPluggableList;
+    /** Custom React components keyed by node/tag name. */
+    components?: Record<string, React.ComponentType<Record<string, unknown>>>;
+    /** Named interactive widgets for fenced ```genui blocks. */
+    widgets?: GenUIRegistry;
+    /**
+     * Optional contribution to the `rehype-sanitize` allow-list schema, merged by
+     * the composer so token classNames / KaTeX markup survive sanitization.
+     */
+    sanitizeSchema?: Record<string, unknown>;
+}
+/** When to prefetch a GenUI widget's code/data. */
+type GenUIPrefetchPolicy = 'eager' | 'visible' | 'idle';
+/**
+ * Minimal subset of the Standard Schema (https://standardschema.dev) interface,
+ * implemented by zod v4 and others, used to validate untrusted widget payloads.
+ */
+interface StandardSchemaV1<Output = unknown, Input = Output> {
+    readonly '~standard': {
+        readonly version: 1;
+        readonly vendor: string;
+        readonly validate: (value: unknown) => {
+            readonly value: Output;
+        } | {
+            readonly issues: ReadonlyArray<{
+                readonly message: string;
+            }>;
+        } | Promise<{
+            readonly value: Output;
+        } | {
+            readonly issues: ReadonlyArray<{
+                readonly message: string;
+            }>;
+        }>;
+        readonly types?: {
+            readonly input: Input;
+            readonly output: Output;
+        };
+    };
+}
+/** Props passed to a host-registered GenUI widget. */
+interface GenUIWidgetProps<T = unknown> {
+    /** Payload, validated against the entry's `schema` when provided. */
+    data: T;
+    /** Render-time metadata. */
+    meta: {
+        name: string;
+        version?: number;
+        messageId: string;
+        streaming: boolean;
+    };
+}
+/** A single registry entry: lazy code + optional schema/prefetch policy. */
+interface GenUIWidgetEntry<T = unknown> {
+    /** Lazy chunk — keeps the widget out of the base bundle. */
+    component: () => Promise<{
+        default: React.ComponentType<GenUIWidgetProps<T>>;
+    }>;
+    /** Optional runtime validation of the untrusted payload. */
+    schema?: StandardSchemaV1<T>;
+    /** Default policy if the wire payload omits one. */
+    prefetch?: GenUIPrefetchPolicy;
+    /** Optional data prefetch, distinct from loading the component code. */
+    prefetchData?: (data: T) => Promise<unknown>;
+}
+/** Map of widget base-name → entry. Versions are resolved explicitly. */
+type GenUIRegistry = Record<string, GenUIWidgetEntry>;
+/** Parsed body of a fenced ```genui block. */
+interface GenUIBlockPayload {
+    /** Widget base name (resolved against the registry). */
+    widget: string;
+    /** Explicit version selector. */
+    version?: number;
+    /** Wire-level prefetch hint (registry policy overrides this). */
+    prefetch?: GenUIPrefetchPolicy;
+    /** Arbitrary widget props. */
+    props?: unknown;
+}
+
+export type { AIRenderTextContent as A, ComposerAttachment as C, GenUIBlockPayload as G, MCPResourceLink as M, Participant as P, SuperChatConversation as S, SuperChatView as a, SuperChatMediaFeedProps as b, SuperChatMediaLabels as c, SuperChatRenderPlugin as d, AttachmentKind as e, SuperChatLinkBuilder as f, SuperChatCopyFormat as g, SuperChatRef as h, SuperChatMediaItem as i, AIMessageContent as j, AIMessageStatus as k, AITextRenderContext as l, GenUIPrefetchPolicy as m, GenUIRegistry as n, GenUIWidgetEntry as o, GenUIWidgetProps as p, ParticipantKind as q, ParticipantStatus as r, StandardSchemaV1 as s, SuperChatChannel as t, SuperChatItemType as u, SuperChatMediaAttachment as v, SuperChatMessage as w, SuperChatPluggable as x, SuperChatPluggableList as y };