markstream-vue2 0.0.26 → 0.0.28

package/dist/types/types/component-props.d.ts

@@ -0,0 +1,210 @@
+import { CodeBlockNode } from 'stream-markdown-parser';
+export interface CodeBlockMonacoThemeObject {
+    name: string;
+    base?: string;
+    inherit?: boolean;
+    colors?: Record<string, string>;
+    rules?: Array<Record<string, unknown>>;
+    [key: string]: unknown;
+}
+export type CodeBlockMonacoTheme = string | CodeBlockMonacoThemeObject;
+export type CodeBlockMonacoLanguage = string | ((...args: any[]) => unknown);
+export interface CodeBlockDiffHideUnchangedRegionsOptions {
+    enabled?: boolean;
+    contextLineCount?: number;
+    minimumLineCount?: number;
+    revealLineCount?: number;
+}
+export type CodeBlockDiffHideUnchangedRegions = boolean | CodeBlockDiffHideUnchangedRegionsOptions;
+export type CodeBlockDiffLineStyle = 'background' | 'bar';
+export type CodeBlockDiffAppearance = 'auto' | 'light' | 'dark';
+export type CodeBlockDiffUnchangedRegionStyle = 'line-info' | 'line-info-basic' | 'metadata' | 'simple';
+export type CodeBlockDiffHunkActionKind = 'revert' | 'stage';
+export type CodeBlockDiffHunkSide = 'upper' | 'lower';
+export interface CodeBlockDiffHunkActionContext {
+    action: CodeBlockDiffHunkActionKind;
+    side: CodeBlockDiffHunkSide;
+    lineChange: unknown;
+    originalModel: unknown;
+    modifiedModel: unknown;
+}
+export interface CodeBlockMonacoOptions {
+    MAX_HEIGHT?: number | string;
+    fontSize?: number;
+    lineHeight?: number;
+    fontFamily?: string;
+    tabSize?: number;
+    readOnly?: boolean;
+    wordWrap?: 'off' | 'on' | 'wordWrapColumn' | 'bounded' | string;
+    wrappingIndent?: 'none' | 'same' | 'indent' | 'deepIndent' | string;
+    theme?: string;
+    themes?: CodeBlockMonacoTheme[];
+    languages?: CodeBlockMonacoLanguage[];
+    renderSideBySide?: boolean;
+    enableSplitViewResizing?: boolean;
+    ignoreTrimWhitespace?: boolean;
+    maxComputationTime?: number;
+    diffAlgorithm?: string;
+    renderIndicators?: boolean;
+    originalEditable?: boolean;
+    revealDebounceMs?: number;
+    revealStrategy?: 'bottom' | 'centerIfOutside' | 'center';
+    revealBatchOnIdleMs?: number;
+    updateThrottleMs?: number;
+    diffUpdateThrottleMs?: number;
+    diffAutoScroll?: boolean;
+    diffHideUnchangedRegions?: CodeBlockDiffHideUnchangedRegions;
+    diffLineStyle?: CodeBlockDiffLineStyle;
+    diffAppearance?: CodeBlockDiffAppearance;
+    diffUnchangedRegionStyle?: CodeBlockDiffUnchangedRegionStyle;
+    diffHunkActionsOnHover?: boolean;
+    diffHunkHoverHideDelayMs?: number;
+    onDiffHunkAction?: (context: CodeBlockDiffHunkActionContext) => void | boolean | Promise<void | boolean>;
+    scrollbar?: Record<string, any>;
+    [key: string]: any;
+}
+export interface CodeBlockNodeProps {
+    node: CodeBlockNode;
+    isDark?: boolean;
+    loading?: boolean;
+    stream?: boolean;
+    darkTheme?: CodeBlockMonacoTheme;
+    lightTheme?: CodeBlockMonacoTheme;
+    isShowPreview?: boolean;
+    monacoOptions?: CodeBlockMonacoOptions;
+    enableFontSizeControl?: boolean;
+    minWidth?: string | number;
+    maxWidth?: string | number;
+    themes?: CodeBlockMonacoTheme[];
+    showHeader?: boolean;
+    showCopyButton?: boolean;
+    showExpandButton?: boolean;
+    showPreviewButton?: boolean;
+    showCollapseButton?: boolean;
+    showFontSizeButtons?: boolean;
+    showTooltips?: boolean;
+    customId?: string;
+}
+export 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;
+}
+export interface LinkNodeProps {
+    node: {
+        type: 'link';
+        href: string;
+        title: string | null;
+        text: string;
+        attrs?: [string, 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;
+}
+export interface PreCodeNodeProps {
+    node: CodeBlockNode;
+}
+export interface MermaidBlockNodeProps {
+    node: CodeBlockNode;
+    maxHeight?: string | null;
+    loading?: boolean;
+    isDark?: boolean;
+    workerTimeoutMs?: number;
+    parseTimeoutMs?: number;
+    renderTimeoutMs?: number;
+    fullRenderTimeoutMs?: number;
+    renderDebounceMs?: number;
+    contentStableDelayMs?: number;
+    previewPollDelayMs?: number;
+    previewPollMaxDelayMs?: number;
+    previewPollMaxAttempts?: number;
+    showHeader?: boolean;
+    showModeToggle?: boolean;
+    showCopyButton?: boolean;
+    showExportButton?: boolean;
+    showFullscreenButton?: boolean;
+    showCollapseButton?: boolean;
+    showZoomControls?: boolean;
+    enableWheelZoom?: boolean;
+    isStrict?: boolean;
+    showTooltips?: boolean;
+    onRenderError?: (error: unknown, code: string, container: HTMLElement) => boolean | void;
+}
+export interface MermaidBlockEvent<TPayload = any> {
+    payload?: TPayload;
+    defaultPrevented: boolean;
+    preventDefault: () => void;
+    svgElement?: SVGElement | null;
+    svgString?: string | null;
+}
+export interface D2BlockNodeProps {
+    node: CodeBlockNode;
+    maxHeight?: string | null;
+    loading?: boolean;
+    isDark?: boolean;
+    progressiveRender?: boolean;
+    progressiveIntervalMs?: number;
+    themeId?: number | null;
+    darkThemeId?: number | null;
+    showHeader?: boolean;
+    showModeToggle?: boolean;
+    showCopyButton?: boolean;
+    showExportButton?: boolean;
+    showCollapseButton?: boolean;
+}
+export interface MathBlockNodeProps {
+    node: {
+        type: 'math_block';
+        content: string;
+        raw: string;
+        loading?: boolean;
+    };
+    indexKey?: number | string;
+}
+export interface MathInlineNodeProps {
+    node: {
+        type: 'math_inline';
+        content: string;
+        raw: string;
+        loading?: boolean;
+        markup?: string;
+    };
+    indexKey?: number | string;
+}
+export interface InfographicBlockNodeProps {
+    node: CodeBlockNode;
+    maxHeight?: string | null;
+    loading?: boolean;
+    isDark?: boolean;
+    showHeader?: boolean;
+    showModeToggle?: boolean;
+    showCopyButton?: boolean;
+    showCollapseButton?: boolean;
+    showExportButton?: boolean;
+    showFullscreenButton?: boolean;
+    showZoomControls?: boolean;
+}

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

@@ -0,0 +1,271 @@
+import { Component } from 'vue-demi';
+export interface BaseNode {
+    type: string;
+    raw: string;
+    loading?: boolean;
+    code?: string;
+    diff?: boolean;
+}
+/**
+ * A catch‑all node type for user extensions.
+ * Must still satisfy the renderer contract (`type` + `raw`), but may carry
+ * arbitrary extra fields.
+ */
+export type UnknownNode = BaseNode & Record<string, unknown>;
+export interface TextNode extends BaseNode {
+    type: 'text';
+    content: string;
+    center?: boolean;
+}
+export interface HeadingNode extends BaseNode {
+    type: 'heading';
+    level: number;
+    text: string;
+    attrs?: Record<string, string | boolean>;
+    children: ParsedNode[];
+}
+export interface ParagraphNode extends BaseNode {
+    type: 'paragraph';
+    children: ParsedNode[];
+    maybeCheckbox?: boolean;
+}
+export interface ListNode extends BaseNode {
+    type: 'list';
+    ordered: boolean;
+    start?: number;
+    items: ListItemNode[];
+}
+export interface ListItemNode extends BaseNode {
+    type: 'list_item';
+    children: ParsedNode[];
+}
+export interface CodeBlockNode extends BaseNode {
+    type: 'code_block';
+    language: string;
+    code: string;
+    startLine?: number;
+    endLine?: number;
+    loading?: boolean;
+    diff?: boolean;
+    originalCode?: string;
+    updatedCode?: string;
+    raw: string;
+}
+export interface InlineCodeNode extends BaseNode {
+    type: 'inline_code';
+    code: string;
+}
+export interface LinkNode extends BaseNode {
+    type: 'link';
+    href: string;
+    title: string | null;
+    text: string;
+    children: ParsedNode[];
+}
+export interface ImageNode extends BaseNode {
+    type: 'image';
+    src: string;
+    alt: string;
+    title: string | null;
+}
+export interface HtmlInlineNode extends BaseNode {
+    type: 'html_inline';
+    tag?: string;
+    content: string;
+    children: ParsedNode[];
+    autoClosed?: boolean;
+}
+export type CustomComponentAttrs = [string, string][] | Record<string, string | boolean> | Array<{
+    name: string;
+    value: string | boolean;
+}> | null;
+export interface CustomComponentNode extends BaseNode {
+    type: string;
+    tag: string;
+    content: string;
+    attrs?: CustomComponentAttrs;
+    children?: ParsedNode[];
+    autoClosed?: boolean;
+}
+export interface ThematicBreakNode extends BaseNode {
+    type: 'thematic_break';
+}
+export interface MermaidBlockNode {
+    node: {
+        type: 'code_block';
+        language: string;
+        code: string;
+        loading?: boolean;
+    };
+}
+export type MarkdownRender = {
+    content: string;
+    nodes?: undefined;
+} | {
+    content?: undefined;
+    nodes: BaseNode[];
+};
+export interface BlockquoteNode extends BaseNode {
+    type: 'blockquote';
+    children: ParsedNode[];
+}
+export interface TableNode extends BaseNode {
+    type: 'table';
+    header: TableRowNode;
+    rows: TableRowNode[];
+}
+export interface TableRowNode extends BaseNode {
+    type: 'table_row';
+    cells: TableCellNode[];
+}
+export interface TableCellNode extends BaseNode {
+    type: 'table_cell';
+    header: boolean;
+    children: ParsedNode[];
+}
+export interface DefinitionListNode extends BaseNode {
+    type: 'definition_list';
+    items: DefinitionItemNode[];
+}
+export interface DefinitionItemNode extends BaseNode {
+    type: 'definition_item';
+    term: ParsedNode[];
+    definition: ParsedNode[];
+}
+export interface FootnoteNode extends BaseNode {
+    type: 'footnote';
+    id: string;
+    children: ParsedNode[];
+}
+export interface FootnoteReferenceNode extends BaseNode {
+    type: 'footnote_reference';
+    id: string;
+}
+export interface AdmonitionNode extends BaseNode {
+    type: 'admonition';
+    kind: string;
+    title: string;
+    children: ParsedNode[];
+}
+export interface StrongNode extends BaseNode {
+    type: 'strong';
+    children: ParsedNode[];
+}
+export interface EmphasisNode extends BaseNode {
+    type: 'emphasis';
+    children: ParsedNode[];
+}
+export interface StrikethroughNode extends BaseNode {
+    type: 'strikethrough';
+    children: ParsedNode[];
+}
+export interface HighlightNode extends BaseNode {
+    type: 'highlight';
+    children: ParsedNode[];
+}
+export interface InsertNode extends BaseNode {
+    type: 'insert';
+    children: ParsedNode[];
+}
+export interface SubscriptNode extends BaseNode {
+    type: 'subscript';
+    children: ParsedNode[];
+}
+export interface SuperscriptNode extends BaseNode {
+    type: 'superscript';
+    children: ParsedNode[];
+}
+export interface CheckboxNode extends BaseNode {
+    type: 'checkbox';
+    checked: boolean;
+}
+export interface CheckboxInputNode extends BaseNode {
+    type: 'checkbox_input';
+    checked: boolean;
+}
+export interface EmojiNode extends BaseNode {
+    type: 'emoji';
+    name: string;
+    markup: string;
+}
+export interface HardBreakNode extends BaseNode {
+    type: 'hardbreak';
+}
+export interface MathInlineNode extends BaseNode {
+    type: 'math_inline';
+    content: string;
+    markup?: string;
+}
+export interface MathBlockNode extends BaseNode {
+    type: 'math_block';
+    content: string;
+    markup?: string;
+}
+export interface ReferenceNode extends BaseNode {
+    type: 'reference';
+    id: string;
+}
+export interface MarkdownToken {
+    type: string;
+    tag?: string;
+    content?: string;
+    info?: string;
+    loading?: boolean;
+    children?: MarkdownToken[];
+    attrs?: [string, string][];
+    markup?: string;
+    meta?: any;
+    map?: [number, number];
+    raw?: string;
+}
+export type ParsedNode = TextNode | HeadingNode | ParagraphNode | ListNode | ListItemNode | CodeBlockNode | InlineCodeNode | LinkNode | ImageNode | HtmlInlineNode | CustomComponentNode | ThematicBreakNode | BlockquoteNode | TableNode | TableRowNode | TableCellNode | StrongNode | EmphasisNode | StrikethroughNode | HighlightNode | InsertNode | SubscriptNode | SuperscriptNode | CheckboxNode | CheckboxInputNode | EmojiNode | DefinitionListNode | DefinitionItemNode | FootnoteNode | FootnoteReferenceNode | AdmonitionNode | HardBreakNode | MathInlineNode | MathBlockNode | ReferenceNode | UnknownNode;
+export interface CustomComponents {
+    text?: Component;
+    paragraph?: Component;
+    heading?: Component;
+    code_block?: Component;
+    list?: Component;
+    list_item?: Component;
+    blockquote?: Component;
+    table?: Component;
+    definition_list?: Component;
+    footnote?: Component;
+    footnote_reference?: Component;
+    footnote_anchor?: Component;
+    admonition?: Component;
+    hardbreak?: Component;
+    link?: Component;
+    image?: Component;
+    thematic_break?: Component;
+    math_inline?: Component;
+    math_block?: Component;
+    strong?: Component;
+    emphasis?: Component;
+    strikethrough?: Component;
+    highlight?: Component;
+    insert?: Component;
+    subscript?: Component;
+    superscript?: Component;
+    emoji?: Component;
+    checkbox?: Component;
+    inline_code?: Component;
+    html_inline?: Component;
+    html_block?: Component;
+    reference?: Component;
+    mermaid?: Component;
+    infographic?: Component;
+    d2?: Component;
+    vmr_container?: Component;
+    [key: string]: Component | undefined;
+}
+export type TransformTokensHook = (tokens: MarkdownToken[]) => MarkdownToken[];
+export interface ParseOptions {
+    preTransformTokens?: TransformTokensHook;
+    postTransformTokens?: TransformTokensHook;
+    /**
+     * Custom HTML-like tag names that should be emitted as custom nodes
+     * instead of `html_inline` when encountered (e.g. ['thinking']).
+     */
+    customHtmlTags?: readonly string[];
+}
+export type PostTransformNodesHook = (nodes: ParsedNode[]) => ParsedNode[];

package/dist/types/utils/htmlRenderer.d.ts

@@ -0,0 +1,43 @@
+import { Component } from 'vue-demi';
+export interface HtmlToken {
+    type: 'text' | 'tag_open' | 'tag_close' | 'self_closing';
+    tagName?: string;
+    attrs?: Record<string, string>;
+    content?: string;
+}
+type CreateElementLike = (tag: any, attrs?: Record<string, any>, children?: any[] | undefined) => any;
+/**
+ * Check if a tag name is a custom Vue component
+ */
+export declare function isCustomComponent(tagName: string, customComponents: Record<string, Component>): boolean;
+/**
+ * Sanitize attributes to remove XSS-prone event handlers
+ */
+export declare function sanitizeAttrs(attrs: Record<string, string>): Record<string, string>;
+/**
+ * Convert attribute value to appropriate type
+ */
+export declare function convertPropValue(value: string, key: string): any;
+/**
+ * Convert all attribute values to appropriate types
+ */
+export declare function convertAttrsToProps(attrs: Record<string, string>): Record<string, any>;
+/**
+ * Simple HTML tokenizer
+ * Note: This is a basic implementation. For production use with complex HTML,
+ * consider using a proper HTML parser library like htmlparser2.
+ */
+export declare function tokenizeHtml(html: string): HtmlToken[];
+/**
+ * Build VNode tree from tokens
+ */
+export declare function buildVNodeTree(tokens: HtmlToken[], customComponents: Record<string, Component>, createElement?: CreateElementLike): any[];
+/**
+ * Check if HTML content contains custom components
+ */
+export declare function hasCustomComponents(content: string, customComponents: Record<string, Component>): boolean;
+/**
+ * Parse HTML content to VNodes
+ */
+export declare function parseHtmlToVNodes(content: string, customComponents: Record<string, Component>, createElement?: CreateElementLike): any[] | null;
+export {};

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

@@ -0,0 +1,5 @@
+export * from '../components/CodeBlockNode/monaco';
+export * from './languageIcon';
+export * from './nestedHtml';
+export * from './nestedNodes';
+export * from 'stream-markdown-parser';

package/dist/types/utils/katex-threshold.d.ts

@@ -0,0 +1,20 @@
+/**
+ * Recommend when to use Worker based on formula count and complexity.
+ *
+ * N_threshold ≈ floor(B / (R × (1 - H)))
+ * - B: main-thread budget (ms), e.g. 50ms or a stricter 16.7ms
+ * - R: avg render time per unique formula (ms)
+ * - H: cache hit rate (0~1)
+ */
+export interface ThresholdInput {
+    R: number;
+    H?: number;
+    B?: number;
+}
+export declare function recommendWorkerThreshold({ R, H, B }: ThresholdInput): number;
+export declare function estimateRByFormula(sample: string): 'simple' | 'medium' | 'complex';
+export declare function defaultRByClass(cls: 'simple' | 'medium' | 'complex'): number;
+export declare function recommendNForSamples(formulas: string[], opts?: {
+    H?: number;
+    B?: number;
+}): number;

package/dist/types/utils/languageIcon.d.ts

@@ -0,0 +1,8 @@
+export type LanguageIconResolver = (lang: string) => string | undefined | null;
+export declare const languageIconsRevision: import('vue-demi').Ref<number>;
+export declare function setLanguageIconResolver(resolver?: LanguageIconResolver | null): void;
+export declare function normalizeLanguageIdentifier(lang?: string | null): string;
+export declare function resolveMonacoLanguageId(lang?: string | null): string;
+export declare function preloadExtendedLanguageIcons(): Promise<void>;
+export declare function getLanguageIcon(lang: string): string;
+export declare const languageMap: Record<string, string>;

package/dist/types/utils/languageIconExtended.d.ts

@@ -0,0 +1 @@
+export declare const EXTENDED_LANGUAGE_ICON_MAP: Record<string, string>;

package/dist/types/utils/mathRenderCache.d.ts

@@ -0,0 +1,7 @@
+interface CachedMathRender {
+    html: string;
+}
+export declare function getCachedMathRender(key: string | null | undefined): CachedMathRender;
+export declare function setCachedMathRender(key: string | null | undefined, html: string): void;
+export declare function clearCachedMathRender(key?: string | null): void;
+export {};

package/dist/types/utils/nestedHtml.d.ts

@@ -0,0 +1,19 @@
+import { BaseNode, ParsedNode } from 'stream-markdown-parser';
+export type NestedRenderableNode = (ParsedNode | BaseNode) & Record<string, unknown>;
+type NestedClassValue = string | readonly string[] | null | undefined;
+export interface NestedMarkdownHtmlOptions {
+    cacheKey?: string;
+    customHtmlTags?: readonly string[];
+    allowHtml?: boolean;
+    customNodeTag?: string;
+    customNodeClass?: NestedClassValue | ((node: NestedRenderableNode) => NestedClassValue);
+}
+export interface NestedMarkdownHtmlInput {
+    node?: NestedRenderableNode | null;
+    nodes?: readonly NestedRenderableNode[] | null;
+    content?: string | null;
+}
+export declare function renderNestedMarkdownToHtml(input: NestedMarkdownHtmlInput, options?: NestedMarkdownHtmlOptions): string;
+export declare function renderMarkdownNodesToHtml(nodes: readonly NestedRenderableNode[] | null | undefined, options?: NestedMarkdownHtmlOptions): string;
+export declare function renderMarkdownNodeToHtml(node: NestedRenderableNode | null | undefined, options?: NestedMarkdownHtmlOptions): string;
+export {};

package/dist/types/utils/nestedNodes.d.ts

@@ -0,0 +1,14 @@
+import { BaseNode, MarkdownIt, ParseOptions } from 'stream-markdown-parser';
+export interface NestedMarkdownNodesInput {
+    node?: (BaseNode & Record<string, any>) | null;
+    nodes?: readonly BaseNode[] | null;
+    content?: string | null;
+}
+export interface NestedMarkdownNodesOptions {
+    cacheKey?: string;
+    final?: boolean;
+    parseOptions?: ParseOptions;
+    customHtmlTags?: readonly string[];
+    customMarkdownIt?: (markdown: MarkdownIt) => MarkdownIt;
+}
+export declare function parseNestedMarkdownToNodes(input: NestedMarkdownNodesInput, options?: NestedMarkdownNodesOptions): BaseNode[];

package/dist/types/utils/nodeComponents.d.ts

@@ -0,0 +1,20 @@
+import { CustomComponents } from '../types';
+export declare const customComponentsRevision: import('vue-demi').ShallowRef<any>;
+export declare function setCustomComponents(id: string, mapping: Partial<CustomComponents>): void;
+export declare function setCustomComponents(mapping: Partial<CustomComponents>): void;
+/**
+ * Retrieve custom components for a given scope id.
+ * If no id is provided, returns the legacy/global mapping (if any).
+ */
+export declare function getCustomNodeComponents(customId?: string): Partial<CustomComponents>;
+/**
+ * Remove a scoped custom components mapping.
+ * Use this to clean up mappings for dynamic or temporary renderers.
+ */
+export declare function removeCustomComponents(id: string): void;
+/**
+ * Clear the legacy/global custom components mapping.
+ * Use this when you want to remove the single-argument mapping set by
+ * `setCustomComponents(mapping)`.
+ */
+export declare function clearGlobalCustomComponents(): void;