markstream-vue2 0.0.26 → 0.0.28

package/dist/types/utils/performance-monitor.d.ts

@@ -0,0 +1,121 @@
+/**
+ * Performance monitoring utility for KaTeX rendering
+ * Helps determine if Worker is beneficial in production
+ */
+interface RenderMetrics {
+    type: 'worker' | 'direct' | 'cache-hit';
+    duration: number;
+    formulaLength: number;
+    timestamp: number;
+    success: boolean;
+    error?: string;
+}
+declare class PerformanceMonitor {
+    private metrics;
+    private enabled;
+    private maxMetrics;
+    enable(): void;
+    disable(): void;
+    recordRender(metrics: RenderMetrics): void;
+    getStats(): {
+        totalRenders: number;
+        cacheHitRate: number;
+        averageWorkerTime: number;
+        averageDirectTime: number;
+        averageCacheHitTime: number;
+        workerSavings: number;
+        recommendation: string;
+        cacheHits?: undefined;
+        workerCalls?: undefined;
+        directCalls?: undefined;
+    } | {
+        totalRenders: number;
+        cacheHits: number;
+        cacheHitRate: string;
+        workerCalls: number;
+        directCalls: number;
+        averageWorkerTime: string;
+        averageDirectTime: string;
+        averageCacheHitTime: string;
+        workerSavings: string;
+        recommendation: string;
+    };
+    printReport(): {
+        totalRenders: number;
+        cacheHitRate: number;
+        averageWorkerTime: number;
+        averageDirectTime: number;
+        averageCacheHitTime: number;
+        workerSavings: number;
+        recommendation: string;
+        cacheHits?: undefined;
+        workerCalls?: undefined;
+        directCalls?: undefined;
+    } | {
+        totalRenders: number;
+        cacheHits: number;
+        cacheHitRate: string;
+        workerCalls: number;
+        directCalls: number;
+        averageWorkerTime: string;
+        averageDirectTime: string;
+        averageCacheHitTime: string;
+        workerSavings: string;
+        recommendation: string;
+    };
+    reset(): void;
+    exportMetrics(): {
+        metrics: RenderMetrics[];
+        stats: {
+            totalRenders: number;
+            cacheHitRate: number;
+            averageWorkerTime: number;
+            averageDirectTime: number;
+            averageCacheHitTime: number;
+            workerSavings: number;
+            recommendation: string;
+            cacheHits?: undefined;
+            workerCalls?: undefined;
+            directCalls?: undefined;
+        } | {
+            totalRenders: number;
+            cacheHits: number;
+            cacheHitRate: string;
+            workerCalls: number;
+            directCalls: number;
+            averageWorkerTime: string;
+            averageDirectTime: string;
+            averageCacheHitTime: string;
+            workerSavings: string;
+            recommendation: string;
+        };
+        timestamp: number;
+    };
+}
+export declare const perfMonitor: PerformanceMonitor;
+export declare function enablePerfMonitoring(): void;
+export declare function disablePerfMonitoring(): void;
+export declare function getPerfReport(): {
+    totalRenders: number;
+    cacheHitRate: number;
+    averageWorkerTime: number;
+    averageDirectTime: number;
+    averageCacheHitTime: number;
+    workerSavings: number;
+    recommendation: string;
+    cacheHits?: undefined;
+    workerCalls?: undefined;
+    directCalls?: undefined;
+} | {
+    totalRenders: number;
+    cacheHits: number;
+    cacheHitRate: string;
+    workerCalls: number;
+    directCalls: number;
+    averageWorkerTime: string;
+    averageDirectTime: string;
+    averageCacheHitTime: string;
+    workerSavings: string;
+    recommendation: string;
+};
+export {};

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

@@ -0,0 +1,2 @@
+export declare function safeRaf(cb: FrameRequestCallback): any;
+export declare function safeCancelRaf(id: number | null): void;

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

@@ -0,0 +1,8 @@
+export declare function getVue2MinorVersion(version: unknown): number;
+export declare function isLegacyVue26Version(version: unknown): boolean;
+export declare function resolveVueVersion(input: any): string;
+export declare function isLegacyVue26Vm(input: any): boolean;
+type VueListener = (...args: unknown[]) => unknown;
+type VueListenerValue = VueListener | VueListener[];
+export declare function resolveVueListeners(input: any): Record<string, VueListenerValue>;
+export {};

package/dist/types/workers/katexCdnWorker.d.ts

@@ -0,0 +1,52 @@
+export type KaTeXCDNWorkerMode = 'classic' | 'module';
+export interface KaTeXCDNWorkerOptions {
+    /**
+     * Where to load KaTeX from inside the worker.
+     * - classic mode: UMD build (used via importScripts)
+     * - module mode: ESM build (used via dynamic import(url))
+     */
+    katexUrl: string;
+    /**
+     * Optional mhchem plugin URL to load in the worker (recommended).
+     * - classic mode: UMD build (importScripts)
+     * - module mode: ESM build (dynamic import(url))
+     */
+    mhchemUrl?: string;
+    /**
+     * - classic: widest compatibility, uses importScripts()
+     * - module: requires { type: 'module' } workers, uses import(url)
+     */
+    mode?: KaTeXCDNWorkerMode;
+    /**
+     * If set, worker prints verbose logs.
+     */
+    debug?: boolean;
+    /**
+     * Worker constructor options (name/type/credentials).
+     * Note: for module mode you should pass { type: 'module' }.
+     */
+    workerOptions?: WorkerOptions;
+    /**
+     * KaTeX render options used in the worker.
+     * Keep this minimal and stable for caching and predictable output.
+     */
+    renderOptions?: {
+        throwOnError?: boolean;
+        output?: string;
+        strict?: string;
+    };
+}
+export interface KaTeXCDNWorkerHandle {
+    worker: Worker | null;
+    /**
+     * Revoke the generated Blob URL. Call this when you no longer need the worker.
+     * This does not terminate the worker automatically.
+     */
+    dispose: () => void;
+    /**
+     * The generated worker source code (useful for debugging/tests).
+     */
+    source: string;
+}
+export declare function buildKaTeXCDNWorkerSource(options: KaTeXCDNWorkerOptions): string;
+export declare function createKaTeXWorkerFromCDN(options: KaTeXCDNWorkerOptions): KaTeXCDNWorkerHandle;

package/dist/types/workers/katexWorkerClient.d.ts

@@ -0,0 +1,48 @@
+/**
+ * Allow user to inject a Worker instance, e.g. from Vite ?worker import.
+ */
+export declare function setKaTeXWorker(w: Worker): void;
+/**
+ * Remove the current worker instance (for cleanup or SSR).
+ */
+export declare function clearKaTeXWorker(): void;
+export declare function setKaTeXWorkerDebug(enabled: boolean): void;
+export declare function renderKaTeXInWorker(content: string, displayMode?: boolean, timeout?: number, signal?: AbortSignal): Promise<string>;
+export declare function setKaTeXCache(content: string, displayMode: boolean, html: string): void;
+/**
+ * Utilities for clients to inspect/adjust worker load behavior
+ */
+export declare function getKaTeXWorkerLoad(): {
+    inFlight: number;
+    max: number;
+};
+export declare function setKaTeXWorkerMaxConcurrency(n: number): void;
+export declare const WORKER_BUSY_CODE = "WORKER_BUSY";
+export declare function isKaTeXWorkerBusy(): boolean;
+export declare function waitForKaTeXWorkerSlot(timeout?: number, signal?: AbortSignal): Promise<void>;
+export interface BackpressureOptions {
+    timeout?: number;
+    waitTimeout?: number;
+    backoffMs?: number;
+    maxRetries?: number;
+    signal?: AbortSignal;
+}
+declare const defaultBackpressure: {
+    timeout: number;
+    waitTimeout: number;
+    backoffMs: number;
+    maxRetries: number;
+};
+export declare function setKaTeXBackpressureDefaults(opts: Partial<typeof defaultBackpressure>): void;
+export declare function getKaTeXBackpressureDefaults(): {
+    timeout: number;
+    waitTimeout: number;
+    backoffMs: number;
+    maxRetries: number;
+};
+/**
+ * Convenience wrapper: when worker reports busy, wait for a slot and retry.
+ * Does not implement fallback-to-main-thread; leave that to the caller.
+ */
+export declare function renderKaTeXWithBackpressure(content: string, displayMode?: boolean, opts?: BackpressureOptions): Promise<string>;
+export {};

package/dist/types/workers/mermaidCdnWorker.d.ts

@@ -0,0 +1,35 @@
+export type MermaidCDNWorkerMode = 'classic' | 'module';
+export interface MermaidCDNWorkerOptions {
+    /**
+     * Where to load mermaid from inside the worker.
+     * - classic mode: non-module build (used via importScripts)
+     * - module mode: ESM build (used via dynamic import(url))
+     */
+    mermaidUrl: string;
+    /**
+     * - classic: widest compatibility, uses importScripts()
+     * - module: requires { type: 'module' } workers, uses import(url)
+     */
+    mode?: MermaidCDNWorkerMode;
+    /**
+     * If set, worker prints verbose logs.
+     */
+    debug?: boolean;
+    /**
+     * Worker constructor options (name/type/credentials).
+     * Note: for module mode you should pass { type: 'module' }.
+     */
+    workerOptions?: WorkerOptions;
+    /**
+     * Mermaid initialize options used in the worker.
+     * This worker is used for parsing only; keep options minimal.
+     */
+    initializeOptions?: Record<string, any>;
+}
+export interface MermaidCDNWorkerHandle {
+    worker: Worker | null;
+    dispose: () => void;
+    source: string;
+}
+export declare function buildMermaidCDNWorkerSource(options: MermaidCDNWorkerOptions): string;
+export declare function createMermaidWorkerFromCDN(options: MermaidCDNWorkerOptions): MermaidCDNWorkerHandle;

package/dist/types/workers/mermaidParser.worker.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/types/workers/mermaidWorkerClient.d.ts

@@ -0,0 +1,21 @@
+type Theme = 'light' | 'dark';
+export declare function setMermaidWorkerClientDebug(enabled: boolean): void;
+export declare function setMermaidWorkerMaxConcurrency(n: number): void;
+export declare function getMermaidWorkerLoad(): {
+    inFlight: number;
+    max: number;
+};
+export declare const MERMAID_WORKER_BUSY_CODE = "WORKER_BUSY";
+export declare const MERMAID_DISABLED_CODE = "MERMAID_DISABLED";
+/**
+ * Allow user to inject a Worker instance, e.g. from Vite ?worker import.
+ */
+export declare function setMermaidWorker(w: Worker): void;
+/**
+ * Remove the current worker instance (for cleanup or SSR).
+ */
+export declare function clearMermaidWorker(): void;
+export declare function canParseOffthread(code: string, theme: Theme, timeout?: number): Promise<boolean>;
+export declare function findPrefixOffthread(code: string, theme: Theme, timeout?: number): Promise<string>;
+export declare function terminateWorker(): void;
+export {};

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "markstream-vue2",
   "type": "module",
-  "version": "0.0.26",
+  "version": "0.0.28",
   "description": "Vue 2 Markdown renderer optimized for large documents with progressive Mermaid rendering, streaming diff code blocks, and fast real-time preview. Perfect for documentation sites, AI chat interfaces, and content management systems.",
   "author": "Simon He",
   "license": "MIT",
@@ -122,7 +122,7 @@
   "dependencies": {
     "@floating-ui/dom": "^1.7.6",
     "vue-demi": "^0.14.10",
-    "stream-markdown-parser": "0.0.74"
+    "stream-markdown-parser": "0.0.76"
   },
   "devDependencies": {
     "@vitejs/plugin-vue2": "^2.3.4",