@simon_he/vue-tui 1.1.3 → 1.1.5

package/dist/vue/components/TMermaidText.d.ts

@@ -522,10 +522,10 @@ export declare const TMermaidText: import("vue").DefineComponent<import("vue").E
     }>;
     readonly final: boolean;
     readonly streaming: boolean;
+    readonly ascii: boolean;
     readonly paddingX: number;
     readonly paddingY: number;
     readonly boxBorderPadding: number;
-    readonly ascii: boolean;
     readonly isTransientError: TMermaidTransientErrorClassifier;
     readonly shouldRenderSource: TMermaidRenderEligibility;
     readonly incompleteText: string;
@@ -880,10 +880,10 @@ export declare const TMermaid: import("vue").DefineComponent<import("vue").Extra
     }>;
     readonly final: boolean;
     readonly streaming: boolean;
+    readonly ascii: boolean;
     readonly paddingX: number;
     readonly paddingY: number;
     readonly boxBorderPadding: number;
-    readonly ascii: boolean;
     readonly isTransientError: TMermaidTransientErrorClassifier;
     readonly shouldRenderSource: TMermaidRenderEligibility;
     readonly incompleteText: string;

package/dist/vue/components/TVirtualMarkdown.d.ts

@@ -88,6 +88,34 @@ export declare const TVirtualMarkdown: import("vue").DefineComponent<import("vue
         type: BooleanConstructor;
         default: boolean;
     };
+    mathImages: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+    mathCellWidthPx: {
+        type: NumberConstructor;
+        default: undefined;
+    };
+    mathCellHeightPx: {
+        type: NumberConstructor;
+        default: undefined;
+    };
+    mathScale: {
+        type: NumberConstructor;
+        default: undefined;
+    };
+    mathColor: {
+        type: StringConstructor;
+        default: undefined;
+    };
+    mathMaxWidthCells: {
+        type: NumberConstructor;
+        default: undefined;
+    };
+    mathBaselineRatio: {
+        type: NumberConstructor;
+        default: undefined;
+    };
     imageActions: {
         type: BooleanConstructor;
         default: boolean;
@@ -200,6 +228,34 @@ export declare const TVirtualMarkdown: import("vue").DefineComponent<import("vue
         type: BooleanConstructor;
         default: boolean;
     };
+    mathImages: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+    mathCellWidthPx: {
+        type: NumberConstructor;
+        default: undefined;
+    };
+    mathCellHeightPx: {
+        type: NumberConstructor;
+        default: undefined;
+    };
+    mathScale: {
+        type: NumberConstructor;
+        default: undefined;
+    };
+    mathColor: {
+        type: StringConstructor;
+        default: undefined;
+    };
+    mathMaxWidthCells: {
+        type: NumberConstructor;
+        default: undefined;
+    };
+    mathBaselineRatio: {
+        type: NumberConstructor;
+        default: undefined;
+    };
     imageActions: {
         type: BooleanConstructor;
         default: boolean;
@@ -227,6 +283,8 @@ export declare const TVirtualMarkdown: import("vue").DefineComponent<import("vue
             source: string;
             raw: string;
             rendered: boolean;
+            pendingImage?: boolean;
+            mode?: "inline" | "display";
         }>;
         rect: Readonly<{
             x: number;
@@ -241,9 +299,11 @@ export declare const TVirtualMarkdown: import("vue").DefineComponent<import("vue
     }>) => any) | undefined;
     onImageAction?: ((_payload: Readonly<{
         image: Readonly<{
-            kind: "image";
-            src: string;
+            kind: "image" | "math";
+            src?: string;
             alt?: string;
+            tex?: string;
+            raw?: string;
             mime?: string;
             base64?: string;
             originalBase64?: string;
@@ -309,6 +369,7 @@ export declare const TVirtualMarkdown: import("vue").DefineComponent<import("vue
         codeBlock: Partial<Style>;
         thematicBreak: Partial<Style>;
         html: Partial<Style>;
+        math: Partial<Style>;
     }>>;
     blocks: readonly TuiMarkdownBlock[];
     imageRenderer: TuiMarkdownImageResolver;
@@ -317,6 +378,13 @@ export declare const TVirtualMarkdown: import("vue").DefineComponent<import("vue
     imageMinHeight: number;
     imageMaxHeight: number;
     imagePreserveAspectRatio: boolean;
+    mathImages: boolean;
+    mathCellWidthPx: number;
+    mathCellHeightPx: number;
+    mathScale: number;
+    mathColor: string;
+    mathMaxWidthCells: number;
+    mathBaselineRatio: number;
     imageActions: boolean;
     mathActions: boolean;
     linkActions: boolean;

package/dist/vue/markdown/ast.d.ts

@@ -1,6 +1,11 @@
+import { type TuiMarkdownMathImageOptions } from "./math-image.js";
 import { type TuiMarkdownTheme } from "./theme.js";
 import type { TuiMarkdownBlock, TuiMarkdownImageResolver, TuiMarkdownImageSize, TuiMarkdownNode } from "./types.js";
+export type TuiMarkdownMathOptions = Readonly<{
+    enabled?: boolean;
+} & TuiMarkdownMathImageOptions>;
 export declare function markdownAstToBlocks(nodes: readonly TuiMarkdownNode[], theme: TuiMarkdownTheme, options?: Readonly<{
     imageResolver?: TuiMarkdownImageResolver;
     imageSize?: TuiMarkdownImageSize;
+    math?: TuiMarkdownMathOptions;
 }>): readonly TuiMarkdownBlock[];

package/dist/vue/markdown/document.d.ts

@@ -1,4 +1,5 @@
 import type { TuiMarkdownImageResolver, TuiMarkdownImageSize } from "./types.js";
+import { type TuiMarkdownMathOptions } from "./ast.js";
 import { type TuiMarkdownParser } from "./parser.js";
 import { type TuiMarkdownThemeOverrides } from "./theme.js";
 import type { TuiMarkdownBlock, TuiMarkdownNode, TuiMarkdownVisualRow } from "./types.js";
@@ -12,6 +13,7 @@ export declare function buildMarkdownBlocks(content: string, parser: TuiMarkdown
     theme?: TuiMarkdownThemeOverrides;
     imageResolver?: TuiMarkdownImageResolver;
     imageSize?: TuiMarkdownImageSize;
+    math?: TuiMarkdownMathOptions;
 }>): Readonly<{
     nodes: readonly TuiMarkdownNode[];
     blocks: readonly TuiMarkdownBlock[];
@@ -22,4 +24,5 @@ export declare function buildMarkdownVisualRows(content: string, width: number,
     widthProvider?: WidthProvider;
     imageResolver?: TuiMarkdownImageResolver;
     imageSize?: TuiMarkdownImageSize;
+    math?: TuiMarkdownMathOptions;
 }>): readonly TuiMarkdownVisualRow[];

package/dist/vue/markdown/math-image.d.ts

@@ -0,0 +1,68 @@
+import type { TuiMarkdownVisualRow } from "./types.js";
+export type TuiMarkdownMathMode = "inline" | "display";
+export type TuiMarkdownMathImageCells = Readonly<{
+    base64: string;
+    widthCells: number;
+    heightCells: number;
+}>;
+export type TuiMarkdownMathImageOptions = Readonly<{
+    cellWidthPx?: number;
+    cellHeightPx?: number;
+    scale?: number;
+    color?: string;
+    maxWidthCells?: number;
+    /**
+     * Vertical position of the text baseline inside a terminal cell, as a
+     * fraction of the cell height (0 = top, 1 = bottom). Inline formula images
+     * are padded so their baseline lands here. Defaults to 0.78.
+     */
+    baselineRatio?: number;
+}>;
+export type TuiMarkdownMathRasterizer = (tex: string, mode: TuiMarkdownMathMode, options: Required<TuiMarkdownMathImageOptions>) => Promise<TuiMarkdownMathImageCells | null>;
+type RequiredMathImageOptions = Required<TuiMarkdownMathImageOptions>;
+export declare function resolveMarkdownMathColor(fg: unknown): string | undefined;
+export declare function normalizeMathImageOptions(options?: TuiMarkdownMathImageOptions): RequiredMathImageOptions;
+/**
+ * Install a custom TeX -> PNG rasterizer (e.g. consumers that already have a
+ * katex/mathjax pipeline). Passing `null` restores the built-in lazy loader.
+ */
+export declare function setMarkdownMathRasterizer(rasterizer: TuiMarkdownMathRasterizer | null): void;
+export declare function subscribeMarkdownMathImage(listener: () => void): () => void;
+/**
+ * True when a rasterizer is confirmed available (a custom one was installed or
+ * the built-in MathJax+resvg stack finished loading). Components should gate
+ * image production on this so they never spend time rasterizing formulas while
+ * the math engine is still loading or missing.
+ */
+export declare function isMarkdownMathImageRendererReady(): boolean;
+/**
+ * Ensure the math image rasterizer is loaded (or resolved as unavailable).
+ * Resolves `true` once a rasterizer is usable. Safe to call repeatedly; the
+ * underlying load is shared and its outcome is cached.
+ */
+export declare function loadMarkdownMathImageRenderer(): Promise<boolean>;
+/** Synchronous cache lookup used by the markdown AST/layout phase. */
+export declare function getCachedMarkdownMathImage(tex: string, mode: TuiMarkdownMathMode, options?: TuiMarkdownMathImageOptions): TuiMarkdownMathImageCells | null;
+/**
+ * Drop all cached rasterized formulas (PNG + failed lookups). Useful for long
+ * running processes that change cell metrics, and for tests.
+ */
+export declare function clearMarkdownMathImageCache(): void;
+/**
+ * Resolve a TeX formula to a PNG base64 + cell size. Cached per
+ * (tex, mode, cell metrics, color). In-flight requests are deduped. When a new
+ * image finishes, `subscribeMarkdownMathImage` listeners are notified so
+ * components can rebuild/re-paint with the real size.
+ */
+export declare function getMarkdownMathImage(tex: string, mode: TuiMarkdownMathMode, options?: TuiMarkdownMathImageOptions): Promise<TuiMarkdownMathImageCells | null>;
+/**
+ * Kick off rasterization for every math graphic segment in the given row range
+ * that does not have a cached PNG yet. Safe to call after every row rebuild;
+ * in-flight and cached requests are deduped inside getMarkdownMathImage. Pass a
+ * viewport to avoid rasterizing off-screen formulas (e.g. virtualized views).
+ */
+export declare function enqueueMarkdownMathImages(rows: readonly TuiMarkdownVisualRow[], options?: TuiMarkdownMathImageOptions, viewport?: Readonly<{
+    firstRow: number;
+    lastRow: number;
+}>): void;
+export {};

package/dist/vue/markdown/theme.d.ts

@@ -11,6 +11,7 @@ export type TuiMarkdownTheme = Readonly<{
     codeBlock: Style;
     thematicBreak: Style;
     html: Style;
+    math: Style;
 }>;
 export type TuiMarkdownThemeOverrides = Readonly<Partial<{
     heading: readonly Partial<Style>[];
@@ -24,6 +25,7 @@ export type TuiMarkdownThemeOverrides = Readonly<Partial<{
     codeBlock: Partial<Style>;
     thematicBreak: Partial<Style>;
     html: Partial<Style>;
+    math: Partial<Style>;
 }>>;
 export declare const DEFAULT_TUI_MARKDOWN_THEME: Readonly<{
     heading: readonly [Readonly<{
@@ -181,6 +183,16 @@ export declare const DEFAULT_TUI_MARKDOWN_THEME: Readonly<{
         inverse?: boolean;
         href?: string;
     }>;
+    math: Readonly<{
+        fg?: string;
+        bg?: string;
+        bold?: boolean;
+        dim?: boolean;
+        italic?: boolean;
+        underline?: boolean;
+        inverse?: boolean;
+        href?: string;
+    }>;
 }>;
 export declare function markdownThemeSignature(overrides?: TuiMarkdownThemeOverrides): string;
 export declare function resolveTuiMarkdownTheme(overrides?: TuiMarkdownThemeOverrides): TuiMarkdownTheme;

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

@@ -13,9 +13,11 @@ export type TuiMarkdownImageSize = Readonly<{
     preserveAspectRatio?: boolean;
 }>;
 export type TuiMarkdownGraphicSegment = Readonly<{
-    kind: "image";
-    src: string;
+    kind: "image" | "math";
+    src?: string;
     alt?: string;
+    tex?: string;
+    raw?: string;
     mime?: string;
     base64?: string;
     originalBase64?: string;
@@ -63,6 +65,14 @@ export type TuiMarkdownMathSegment = Readonly<{
     source: string;
     raw: string;
     rendered: boolean;
+    /**
+     * Set on the boxed fallback of block-level math / raw inline math: the
+     * formula still needs to be rasterized once the graphics/raster stack is
+     * available. `mode` tells the rasterizer whether to render inline (fits one
+     * line, baseline-aligned) or display style.
+     */
+    pendingImage?: boolean;
+    mode?: "inline" | "display";
 }>;
 export type TuiMarkdownMathActionPayload = Readonly<{
     math: TuiMarkdownMathSegment;