markstream-react 0.0.14 → 0.0.16

package/dist/index.d.ts

@@ -0,0 +1,585 @@
+import * as react_jsx_runtime from 'react/jsx-runtime';
+import { BaseNode, ParseOptions, MarkdownIt, ParsedNode } from 'stream-markdown-parser';
+import React, { ComponentType } from 'react';
+
+interface NodeRendererProps {
+    content?: string;
+    nodes?: BaseNode[];
+    /**
+     * Whether the input stream is complete (end-of-stream). When true, the parser
+     * can stop emitting streaming "loading" nodes for unfinished constructs.
+     */
+    final?: boolean;
+    parseOptions?: ParseOptions;
+    customMarkdownIt?: (md: MarkdownIt) => MarkdownIt;
+    /** Log parse/render timing stats (dev only). */
+    debugPerformance?: boolean;
+    /**
+     * Custom HTML-like tags that should be emitted as custom nodes (e.g. ['thinking']).
+     * Forwarded to `getMarkdown()` and merged into parseOptions.
+     */
+    customHtmlTags?: readonly string[];
+    viewportPriority?: boolean;
+    codeBlockStream?: boolean;
+    codeBlockDarkTheme?: any;
+    codeBlockLightTheme?: any;
+    codeBlockMonacoOptions?: Record<string, any>;
+    renderCodeBlocksAsPre?: boolean;
+    codeBlockMinWidth?: string | number;
+    codeBlockMaxWidth?: string | number;
+    codeBlockProps?: Record<string, any>;
+    themes?: string[];
+    isDark?: boolean;
+    customId?: string;
+    indexKey?: number | string;
+    typewriter?: boolean;
+    batchRendering?: boolean;
+    initialRenderBatchSize?: number;
+    renderBatchSize?: number;
+    renderBatchDelay?: number;
+    renderBatchBudgetMs?: number;
+    renderBatchIdleTimeoutMs?: number;
+    deferNodesUntilVisible?: boolean;
+    maxLiveNodes?: number;
+    liveNodeBuffer?: number;
+    onCopy?: (code: string) => void;
+    onHandleArtifactClick?: (payload: any) => void;
+    onClick?: (event: React.MouseEvent<HTMLDivElement>) => void;
+    onMouseOver?: (event: React.MouseEvent<HTMLElement>) => void;
+    onMouseOut?: (event: React.MouseEvent<HTMLElement>) => void;
+}
+interface RenderContext {
+    customId?: string;
+    isDark?: boolean;
+    indexKey?: string;
+    typewriter?: boolean;
+    codeBlockProps?: Record<string, any>;
+    codeBlockStream?: boolean;
+    renderCodeBlocksAsPre?: boolean;
+    codeBlockThemes?: {
+        themes?: string[];
+        darkTheme?: any;
+        lightTheme?: any;
+        monacoOptions?: Record<string, any>;
+        minWidth?: string | number;
+        maxWidth?: string | number;
+    };
+    events: {
+        onCopy?: (code: string) => void;
+        onHandleArtifactClick?: (payload: any) => void;
+    };
+}
+type RenderNodeFn = (node: ParsedNode, key: React.Key, ctx: RenderContext) => React.ReactNode;
+
+interface NodeComponentProps<TNode = unknown> {
+    node: TNode;
+    ctx?: RenderContext;
+    renderNode?: RenderNodeFn;
+    indexKey?: React.Key;
+    customId?: string;
+    isDark?: boolean;
+    typewriter?: boolean;
+    children?: React.ReactNode;
+}
+
+declare function AdmonitionNode(props: NodeComponentProps<{
+    type: 'admonition';
+    kind?: string;
+    title?: string;
+    children?: ParsedNode[];
+    collapsible?: boolean;
+    open?: boolean;
+}>): react_jsx_runtime.JSX.Element;
+
+declare function BlockquoteNode(props: NodeComponentProps<{
+    type: 'blockquote';
+    children?: ParsedNode[];
+}>): react_jsx_runtime.JSX.Element;
+
+declare function CheckboxNode(props: NodeComponentProps<{
+    type: 'checkbox' | 'checkbox_input';
+    checked?: boolean;
+}>): react_jsx_runtime.JSX.Element;
+
+interface CodeBlockNodeProps {
+    node: {
+        type: 'code_block';
+        language: string;
+        code: string;
+        raw: string;
+        diff?: boolean;
+        originalCode?: string;
+        updatedCode?: string;
+    };
+    isDark?: boolean;
+    loading?: boolean;
+    stream?: boolean;
+    darkTheme?: any;
+    lightTheme?: any;
+    isShowPreview?: boolean;
+    monacoOptions?: {
+        [k: string]: any;
+    };
+    enableFontSizeControl?: boolean;
+    minWidth?: string | number;
+    maxWidth?: string | number;
+    themes?: any[];
+    showHeader?: boolean;
+    showCopyButton?: boolean;
+    showExpandButton?: boolean;
+    showPreviewButton?: boolean;
+    showFontSizeButtons?: boolean;
+    customId?: string;
+}
+interface ImageNodeProps {
+    node: {
+        type: 'image';
+        src: string;
+        alt: string;
+        title: string | null;
+        raw: string;
+        loading?: boolean;
+    };
+    fallbackSrc?: string;
+    showCaption?: boolean;
+    lazy?: boolean;
+    svgMinHeight?: string;
+    usePlaceholder?: boolean;
+}
+interface LinkNodeProps {
+    node: {
+        type: 'link';
+        href: string;
+        title: string | null;
+        text: string;
+        children: {
+            type: string;
+            raw: string;
+        }[];
+        raw: string;
+        loading?: boolean;
+    };
+    indexKey: number | string;
+    customId?: string;
+    showTooltip?: boolean;
+    color?: string;
+    underlineHeight?: number;
+    underlineBottom?: number | string;
+    animationDuration?: number;
+    animationOpacity?: number;
+    animationTiming?: string;
+    animationIteration?: string | number;
+}
+interface PreCodeNodeProps {
+    node: any;
+}
+interface MermaidBlockNodeProps {
+    node: any;
+    maxHeight?: string | null;
+    loading?: boolean;
+    isDark?: boolean;
+    workerTimeoutMs?: number;
+    parseTimeoutMs?: number;
+    renderTimeoutMs?: number;
+    fullRenderTimeoutMs?: number;
+    showHeader?: boolean;
+    showModeToggle?: boolean;
+    showCopyButton?: boolean;
+    showExportButton?: boolean;
+    showFullscreenButton?: boolean;
+    showCollapseButton?: boolean;
+    showZoomControls?: boolean;
+    enableWheelZoom?: boolean;
+    isStrict?: boolean;
+}
+interface MermaidBlockEvent<TPayload = any> {
+    payload?: TPayload;
+    defaultPrevented: boolean;
+    preventDefault: () => void;
+    svgElement?: SVGElement | null;
+    svgString?: string | null;
+}
+interface MathBlockNodeProps {
+    node: {
+        type: 'math_block';
+        content: string;
+        raw: string;
+        loading?: boolean;
+    };
+}
+interface MathInlineNodeProps {
+    node: {
+        type: 'math_inline';
+        content: string;
+        raw: string;
+        loading?: boolean;
+        markup?: string;
+    };
+}
+interface InfographicBlockNodeProps {
+    node: any;
+    maxHeight?: string | null;
+    loading?: boolean;
+    isDark?: boolean;
+    showHeader?: boolean;
+    showModeToggle?: boolean;
+    showCopyButton?: boolean;
+    showExportButton?: boolean;
+    showFullscreenButton?: boolean;
+    showCollapseButton?: boolean;
+    showZoomControls?: boolean;
+}
+
+interface CodeBlockPreviewPayload {
+    node: CodeBlockNodeProps['node'];
+    artifactType: 'text/html' | 'image/svg+xml';
+    artifactTitle: string;
+    id: string;
+}
+interface CodeBlockNodeReactEvents {
+    onCopy?: (code: string) => void;
+    onPreviewCode?: (payload: CodeBlockPreviewPayload) => void;
+}
+declare function CodeBlockNode(rawProps: CodeBlockNodeProps & CodeBlockNodeReactEvents): react_jsx_runtime.JSX.Element;
+
+interface HtmlPreviewFrameProps {
+    code: string;
+    isDark?: boolean;
+    onClose?: () => void;
+    title?: string;
+}
+declare function HtmlPreviewFrame(props: HtmlPreviewFrameProps): React.ReactPortal;
+
+declare function DefinitionListNode(props: NodeComponentProps<{
+    type: 'definition_list';
+    items?: any[];
+}>): react_jsx_runtime.JSX.Element;
+
+declare function EmojiNode(props: NodeComponentProps<{
+    type: 'emoji';
+    name: string;
+    markup?: string;
+}>): react_jsx_runtime.JSX.Element;
+
+declare function EmphasisNode(props: NodeComponentProps<{
+    type: 'emphasis';
+}>): react_jsx_runtime.JSX.Element;
+
+declare function FootnoteAnchorNode(props: NodeComponentProps<{
+    type: 'footnote_anchor';
+    id: string;
+}>): react_jsx_runtime.JSX.Element;
+
+declare function FootnoteNode(props: NodeComponentProps<{
+    type: 'footnote';
+    id: string;
+    children?: ParsedNode[];
+}>): react_jsx_runtime.JSX.Element;
+
+declare function FootnoteReferenceNode(props: NodeComponentProps<{
+    type: 'footnote_reference';
+    id: string;
+}>): react_jsx_runtime.JSX.Element;
+
+declare function HardBreakNode(_props: NodeComponentProps<{
+    type: 'hardbreak';
+}>): react_jsx_runtime.JSX.Element;
+
+declare function HeadingNode(props: NodeComponentProps<{
+    type: 'heading';
+    level?: number;
+    children?: ParsedNode[];
+    attrs?: Record<string, string | boolean>;
+}>): react_jsx_runtime.JSX.Element;
+
+declare function HighlightNode(props: NodeComponentProps<{
+    type: 'highlight';
+}>): react_jsx_runtime.JSX.Element;
+
+declare function HtmlBlockNode(props: NodeComponentProps<{
+    type: 'html_block';
+    content: string;
+    attrs?: [string, string | null][] | null;
+    loading?: boolean;
+}> & {
+    customComponents?: Record<string, React.ComponentType<any>>;
+    placeholder?: React.ReactNode;
+}): react_jsx_runtime.JSX.Element;
+
+declare function HtmlInlineNode(props: NodeComponentProps<{
+    type: 'html_inline';
+    content: string;
+    loading?: boolean;
+    autoClosed?: boolean;
+}>): react_jsx_runtime.JSX.Element;
+
+interface ImageNodeReactEvents {
+    onLoad?: (src: string) => void;
+    onError?: (src: string) => void;
+    onClick?: (payload: [event: React.MouseEvent<HTMLImageElement>, src: string]) => void;
+}
+declare function ImageNode(rawProps: ImageNodeProps & ImageNodeReactEvents): react_jsx_runtime.JSX.Element;
+
+interface InfographicBlockNodeReactEvents {
+    onCopy?: (code: string) => void;
+    onExport?: (event: MermaidBlockEvent<{
+        type: 'export';
+    }>) => void;
+    onOpenModal?: (event: MermaidBlockEvent<{
+        type: 'open-modal';
+    }>) => void;
+    onToggleMode?: (target: 'preview' | 'source', event: MermaidBlockEvent<{
+        type: 'toggle-mode';
+        target: 'preview' | 'source';
+    }>) => void;
+}
+declare function InfographicBlockNode(rawProps: InfographicBlockNodeProps & InfographicBlockNodeReactEvents): react_jsx_runtime.JSX.Element;
+
+declare function InlineCodeNode(props: NodeComponentProps<{
+    type: 'inline_code';
+    code: string;
+}>): react_jsx_runtime.JSX.Element;
+
+declare function InsertNode(props: NodeComponentProps<{
+    type: 'insert';
+}>): react_jsx_runtime.JSX.Element;
+
+interface LinkNodeStyleProps {
+    showTooltip?: boolean;
+    color?: string;
+    underlineHeight?: number;
+    underlineBottom?: number | string;
+    animationDuration?: number;
+    animationOpacity?: number;
+    animationTiming?: string;
+    animationIteration?: string | number;
+}
+declare function LinkNode(props: NodeComponentProps<{
+    type: 'link';
+    href: string;
+    title: string | null;
+    text: string;
+    children?: ParsedNode[];
+    loading?: boolean;
+}> & LinkNodeStyleProps): react_jsx_runtime.JSX.Element;
+
+interface ListItemNodeData {
+    type: 'list_item';
+    children?: ParsedNode[];
+    raw?: string;
+}
+interface ListItemNodeProps extends NodeComponentProps<ListItemNodeData> {
+    value?: number;
+}
+declare function ListItemNode(props: ListItemNodeProps): react_jsx_runtime.JSX.Element;
+
+declare function ListNode(props: NodeComponentProps<{
+    type: 'list';
+    ordered?: boolean;
+    start?: number;
+    items?: any[];
+}>): react_jsx_runtime.JSX.Element;
+
+interface MarkdownCodeBlockNodeProps {
+    node: {
+        type: 'code_block';
+        language: string;
+        code: string;
+        raw: string;
+        diff?: boolean;
+        originalCode?: string;
+        updatedCode?: string;
+    };
+    loading?: boolean;
+    stream?: boolean;
+    darkTheme?: string;
+    lightTheme?: string;
+    isDark?: boolean;
+    isShowPreview?: boolean;
+    enableFontSizeControl?: boolean;
+    minWidth?: string | number;
+    maxWidth?: string | number;
+    themes?: string[];
+    showHeader?: boolean;
+    showCopyButton?: boolean;
+    showExpandButton?: boolean;
+    showPreviewButton?: boolean;
+    showFontSizeButtons?: boolean;
+    onCopy?: (code: string) => void;
+    onPreviewCode?: (payload: {
+        type: string;
+        content: string;
+        title: string;
+    }) => void;
+}
+declare function MarkdownCodeBlockNode(rawProps: MarkdownCodeBlockNodeProps): react_jsx_runtime.JSX.Element;
+
+declare function MathBlockNode({ node }: MathBlockNodeProps): react_jsx_runtime.JSX.Element;
+
+declare function MathInlineNode({ node }: MathInlineNodeProps): react_jsx_runtime.JSX.Element;
+
+interface MermaidBlockNodeReactEvents {
+    onCopy?: (code: string) => void;
+    onExport?: (event: MermaidBlockEvent<{
+        type: 'export';
+    }>) => void;
+    onOpenModal?: (event: MermaidBlockEvent<{
+        type: 'open-modal';
+    }>) => void;
+    onToggleMode?: (target: 'preview' | 'source', event: MermaidBlockEvent<{
+        type: 'toggle-mode';
+        target: 'preview' | 'source';
+    }>) => void;
+}
+declare function MermaidBlockNode(rawProps: MermaidBlockNodeProps & MermaidBlockNodeReactEvents): react_jsx_runtime.JSX.Element;
+
+declare const NodeRenderer: React.FC<NodeRendererProps>;
+
+declare function FallbackComponent(props: NodeComponentProps<{
+    type: string;
+}>): react_jsx_runtime.JSX.Element;
+
+declare function ParagraphNode(props: NodeComponentProps<{
+    type: 'paragraph';
+    children?: ParsedNode[];
+}>): react_jsx_runtime.JSX.Element;
+
+declare function PreCodeNode({ node }: PreCodeNodeProps): react_jsx_runtime.JSX.Element;
+
+interface ReferenceNodeHandlers {
+    onClick?: (event: React.MouseEvent, id: string, messageId?: string, threadId?: string) => void;
+    onMouseEnter?: (event: React.MouseEvent, id: string, messageId?: string, threadId?: string) => void;
+    onMouseLeave?: (event: React.MouseEvent, id: string, messageId?: string, threadId?: string) => void;
+}
+declare function ReferenceNode(props: NodeComponentProps<{
+    type: 'reference';
+    id: string;
+}> & {
+    messageId?: string;
+    threadId?: string;
+} & ReferenceNodeHandlers): react_jsx_runtime.JSX.Element;
+
+declare function StrikethroughNode(props: NodeComponentProps<{
+    type: 'strikethrough';
+}>): react_jsx_runtime.JSX.Element;
+
+declare function StrongNode(props: NodeComponentProps<{
+    type: 'strong';
+}>): react_jsx_runtime.JSX.Element;
+
+declare function SubscriptNode(props: NodeComponentProps<{
+    type: 'subscript';
+}>): react_jsx_runtime.JSX.Element;
+
+declare function SuperscriptNode(props: NodeComponentProps<{
+    type: 'superscript';
+}>): react_jsx_runtime.JSX.Element;
+
+declare function TableNode(props: NodeComponentProps<{
+    type: 'table';
+    header?: any;
+    rows?: any[];
+    loading?: boolean;
+}>): react_jsx_runtime.JSX.Element;
+
+declare function TextNode(props: NodeComponentProps<{
+    type: 'text';
+    content: string;
+    center?: boolean;
+}>): react_jsx_runtime.JSX.Element;
+
+declare function ThematicBreakNode(): react_jsx_runtime.JSX.Element;
+
+type TooltipPlacement = 'top' | 'bottom' | 'left' | 'right';
+interface TooltipProps {
+    visible: boolean;
+    anchorEl: HTMLElement | null;
+    content: string;
+    placement?: TooltipPlacement;
+    offset?: number;
+    originX?: number | null;
+    originY?: number | null;
+    id?: string | null;
+    isDark?: boolean | null;
+}
+declare function Tooltip(props: TooltipProps): React.ReactPortal;
+
+declare function VmrContainerNode(props: NodeComponentProps<{
+    type: 'vmr_container';
+    name: string;
+    attrs?: Record<string, string> | [string, string | null][] | null;
+    children?: ParsedNode[];
+}>): react_jsx_runtime.JSX.Element;
+
+type CustomComponentMap = Record<string, ComponentType<any>>;
+declare function setCustomComponents(id: string, mapping: CustomComponentMap): void;
+declare function setCustomComponents(mapping: CustomComponentMap): void;
+declare function getCustomNodeComponents(customId?: string): CustomComponentMap;
+declare function removeCustomComponents(id: string): void;
+declare function clearGlobalCustomComponents(): void;
+
+declare const defaultMap: Record<string, string>;
+/**
+ * Replace the entire default translation map.
+ * Consumers can call this to provide their own fallback translations (e.g. Chinese).
+ */
+declare function setDefaultI18nMap(map: Record<keyof typeof defaultMap, string>): void;
+declare function useSafeI18n(): {
+    t: (key: string) => string;
+};
+
+declare function renderNode(node: ParsedNode, key: React.Key, ctx: RenderContext): react_jsx_runtime.JSX.Element;
+
+type LanguageIconResolver = (lang: string) => string | undefined | null;
+declare function setLanguageIconResolver(resolver?: LanguageIconResolver | null): void;
+declare function normalizeLanguageIdentifier(lang?: string | null): string;
+declare function resolveMonacoLanguageId(lang?: string | null): string;
+declare function getLanguageIcon(lang: string): string;
+declare const languageMap: Record<string, string>;
+
+declare function setKaTeXWorker(w: Worker): void;
+declare function clearKaTeXWorker(): void;
+declare function setKaTeXWorkerDebug(enabled: boolean): void;
+declare const WORKER_BUSY_CODE = "WORKER_BUSY";
+declare function renderKaTeXInWorker(content: string, displayMode?: boolean, timeout?: number, signal?: AbortSignal): Promise<string>;
+declare function setKaTeXCache(content: string, displayMode: boolean, html: string): void;
+declare function clearKaTeXCache(): void;
+declare function setKaTeXConcurrencyLimit(limit: number): void;
+declare function waitForKaTeXWorkerSlot(timeout?: number, signal?: AbortSignal): Promise<void>;
+interface BackpressureOptions {
+    timeout?: number;
+    waitTimeout?: number;
+    backoffMs?: number;
+    maxRetries?: number;
+    signal?: AbortSignal;
+}
+declare const defaultBackpressure: {
+    timeout: number;
+    waitTimeout: number;
+    backoffMs: number;
+    maxRetries: number;
+};
+declare function setKaTeXBackpressureDefaults(opts: Partial<typeof defaultBackpressure>): void;
+declare function getKaTeXBackpressureDefaults(): {
+    timeout: number;
+    waitTimeout: number;
+    backoffMs: number;
+    maxRetries: number;
+};
+declare function renderKaTeXWithBackpressure(content: string, displayMode?: boolean, opts?: BackpressureOptions): Promise<string>;
+
+type Theme = 'light' | 'dark';
+declare function setMermaidWorkerClientDebug(enabled: boolean): void;
+declare function setMermaidWorkerMaxConcurrency(n: number): void;
+declare function getMermaidWorkerLoad(): {
+    inFlight: number;
+    max: number;
+};
+declare const MERMAID_WORKER_BUSY_CODE = "WORKER_BUSY";
+declare function setMermaidWorker(w: Worker): void;
+declare function clearMermaidWorker(): void;
+declare function canParseOffthread(code: string, theme: Theme, timeout?: number): Promise<boolean>;
+declare function findPrefixOffthread(code: string, theme: Theme, timeout?: number): Promise<string>;
+declare function terminateWorker(): void;
+
+export { AdmonitionNode, BackpressureOptions, BlockquoteNode, CheckboxNode, CodeBlockNode, CodeBlockNodeProps, DefinitionListNode, EmojiNode, EmphasisNode, FallbackComponent, FootnoteAnchorNode, FootnoteNode, FootnoteReferenceNode, HardBreakNode, HeadingNode, HighlightNode, HtmlBlockNode, HtmlInlineNode, HtmlPreviewFrame, ImageNode, ImageNodeProps, InfographicBlockNode, InfographicBlockNodeProps, InlineCodeNode, InsertNode, LanguageIconResolver, LinkNode, LinkNodeProps, ListItemNode, ListNode, MERMAID_WORKER_BUSY_CODE, MarkdownCodeBlockNode, MathBlockNode, MathBlockNodeProps, MathInlineNode, MathInlineNodeProps, MermaidBlockEvent, MermaidBlockNode, MermaidBlockNodeProps, NodeComponentProps, NodeRenderer, NodeRendererProps, ParagraphNode, PreCodeNode, PreCodeNodeProps, CodeBlockNode as ReactCodeBlockNode, ReferenceNode, StrikethroughNode, StrongNode, SubscriptNode, SuperscriptNode, TableNode, TextNode, ThematicBreakNode, Tooltip, VmrContainerNode, WORKER_BUSY_CODE, canParseOffthread, clearGlobalCustomComponents, clearKaTeXCache, clearKaTeXWorker, clearMermaidWorker, findPrefixOffthread, getCustomNodeComponents, getKaTeXBackpressureDefaults, getLanguageIcon, getMermaidWorkerLoad, languageMap, normalizeLanguageIdentifier, removeCustomComponents, renderKaTeXInWorker, renderKaTeXWithBackpressure, renderNode, resolveMonacoLanguageId, setCustomComponents, setDefaultI18nMap, setKaTeXBackpressureDefaults, setKaTeXCache, setKaTeXConcurrencyLimit, setKaTeXWorker, setKaTeXWorkerDebug, setLanguageIconResolver, setMermaidWorker, setMermaidWorkerClientDebug, setMermaidWorkerMaxConcurrency, terminateWorker, useSafeI18n, waitForKaTeXWorkerSlot };