@simon_he/vue-tui 1.0.1 → 1.1.0

package/dist/core/buffer/buffer.d.ts

@@ -31,11 +31,11 @@ export declare function createGridBuffer(cols: number, rows: number, options?: R
 }>): GridBuffer;
 export declare function clamp(n: number, min: number, max: number): number;
 /**
- * Register a fingerprint function on the buffer. This enables SoA fingerprint
+ * Register or clear a fingerprint function on the buffer. This enables SoA fingerprint
  * pre-computation: cell writes will update fingerprints inline, and the renderer
  * can read them via getRowFingerprints() instead of per-cell hash computation.
  */
-export declare function setFingerprintFn(buffer: GridBuffer, fn: CellFingerprintFn): void;
+export declare function setFingerprintFn(buffer: GridBuffer, fn: CellFingerprintFn | null): void;
 /**
  * Get pre-computed fingerprints for a logical row as a TypedArray slice.
  * Returns null if fingerprinting is not enabled on this buffer.

package/dist/core/buffer/eaw-ranges-unicode-17.d.ts

@@ -0,0 +1,14 @@
+/**
+ * East Asian Width ranges generated from Unicode 17.0.0
+ * Source: https://www.unicode.org/Public/17.0.0/ucd/EastAsianWidth.txt
+ * SHA-256: ea7ce50f3444a050333448dffef1cadd9325af55cbb764b4a2280faf52170a33
+ *
+ * Data derived from Unicode EastAsianWidth.txt.
+ * © Unicode, Inc. See Unicode terms of use: https://www.unicode.org/terms_of_use.html
+ *
+ * DO NOT EDIT MANUALLY - regenerate with: pnpm run unicode:eaw:generate
+ */
+export declare const EAW_UNICODE_VERSION = "17.0.0";
+export declare const EAW_SOURCE_SHA256 = "ea7ce50f3444a050333448dffef1cadd9325af55cbb764b4a2280faf52170a33";
+export declare const fullWidthRanges: Array<[number, number]>;
+export declare const ambiguousWidthRanges: Array<[number, number]>;

package/dist/core/perf/instrumentation-noop.d.ts

@@ -0,0 +1,48 @@
+/**
+ * No-op instrumentation stub for production builds
+ *
+ * This module provides empty implementations of all instrumentation
+ * functions to enable complete tree-shaking in production.
+ */
+export declare const cellInstr: {
+    recordCreateCellCall: () => void;
+    recordCharCellWidthCall: () => void;
+    recordCacheHit: (_arg: any) => void;
+    recordCacheMiss: (_arg: any) => void;
+    recordNewCell: () => void;
+    recordBlankCacheHit: () => void;
+    recordBlankCacheMiss: () => void;
+    recordContinuationCacheHit: () => void;
+    recordContinuationCacheMiss: () => void;
+    recordCacheClear: (_arg: any) => void;
+    registerCacheBucket: (..._args: any[]) => void;
+    updateMaxCacheSize: (..._args: any[]) => void;
+};
+export declare const textInstr: {
+    recordTextCellWidthCall: (..._args: any[]) => void;
+    recordRenderPassCacheHit: () => void;
+    recordRenderPassCacheMiss: () => void;
+    recordTextWidthCacheHit: () => void;
+    recordTextWidthCacheMiss: () => void;
+    recordTextWidthCacheSet: () => void;
+    recordTextWidthCacheEvict: () => void;
+    recordWrapByCellsCall: () => void;
+    recordWrapCacheHit: () => void;
+    recordWrapCacheMiss: () => void;
+    recordWrapCacheClear: () => void;
+    recordWrapCacheSet: () => void;
+    recordWrapWidthBucketMapClear: () => void;
+};
+export declare const graphemeInstr: {
+    recordSegmentedGraphemesCall: () => void;
+    recordSegmentationRequiredInput: () => void;
+    recordIntlSegmenterUsed: () => void;
+    recordFallbackSegmenterUsed: () => void;
+};
+export declare const isInstrumentationEnabled: () => boolean;
+export declare const enableInstrumentation: () => void;
+export declare const disableInstrumentation: () => void;
+export declare const resetMetrics: () => void;
+export declare const getMetrics: () => any;
+export declare const getHeapUsed: () => null;
+export declare const getMetricsWithHeap: () => any;

package/dist/core/perf/instrumentation.d.ts

@@ -0,0 +1,136 @@
+/**
+ * Debug performance instrumentation (Phase 3)
+ *
+ * Collection is disabled by default. Hook functions are called from
+ * production hot paths even when disabled. Disabled-path runtime and
+ * bundle overhead are tracked separately and must not be assumed negligible.
+ *
+ * See issue #119 for validation status.
+ */
+export interface CellCacheMetrics {
+    createCellCalls: number;
+    charCellWidthCallsFromCreateCell: number;
+    newCellCount: number;
+    cellCacheHitWidth1: number;
+    cellCacheHitWidth2: number;
+    cellCacheMissWidth1: number;
+    cellCacheMissWidth2: number;
+    cellCacheClearWidth1: number;
+    cellCacheClearWidth2: number;
+    blankCellCacheHit: number;
+    blankCellCacheMiss: number;
+    continuationCellCacheHit: number;
+    continuationCellCacheMiss: number;
+    maxCacheSizeWidth1: number;
+    maxCacheSizeWidth2: number;
+    registeredBucketCountWidth1: number;
+    registeredBucketCountWidth2: number;
+    registeredBucketSizeP50Width1: number;
+    registeredBucketSizeP95Width1: number;
+    registeredBucketSizeMaxWidth1: number;
+    registeredBucketSizeP50Width2: number;
+    registeredBucketSizeP95Width2: number;
+    registeredBucketSizeMaxWidth2: number;
+    estimatedRegisteredBucketCells: number;
+}
+export interface TextCacheMetrics {
+    textCellWidthCalls: number;
+    textWidthCacheHit: number;
+    textWidthCacheMiss: number;
+    textWidthCacheSet: number;
+    textWidthCacheEvict: number;
+    renderPassTextWidthCacheHit: number;
+    renderPassTextWidthCacheMiss: number;
+    wrapByCellsCalls: number;
+    wrapCacheHit: number;
+    wrapCacheMiss: number;
+    wrapCacheSet: number;
+    wrapCacheClear: number;
+    wrapWidthBucketMapClear: number;
+    maxTextLength: number;
+    totalTextLength: number;
+    asciiFastPathCount: number;
+    nonAsciiOrNoFastPathCount: number;
+}
+export interface GraphemeMetrics {
+    graphemeSegmentationRequiredCalls: number;
+    intlSegmenterUsed: number;
+    fallbackSegmenterUsed: number;
+    segmentationRequiredInputCount: number;
+}
+export interface PerformanceMetrics {
+    cell: CellCacheMetrics;
+    text: TextCacheMetrics;
+    grapheme: GraphemeMetrics;
+    heapUsedBefore?: number;
+    heapUsedAfter?: number;
+    gcCount?: number;
+}
+/**
+ * Enable instrumentation collection
+ */
+export declare function enableInstrumentation(): void;
+/**
+ * Disable instrumentation collection
+ */
+export declare function disableInstrumentation(): void;
+/**
+ * Check if instrumentation is enabled
+ */
+export declare function isInstrumentationEnabled(): boolean;
+/**
+ * Reset all metrics to zero
+ */
+export declare function resetMetrics(): void;
+/**
+ * Get current metrics snapshot
+ */
+export declare function getMetrics(): PerformanceMetrics;
+/**
+ * Get heap used bytes (Node.js or Chrome)
+ */
+export declare function getHeapUsed(): number | null;
+/**
+ * Get metrics with heap information
+ *
+ * Note: heapUsedBefore/After measures GC impact, not workload memory.
+ * To measure workload memory, call getHeapUsed() before/after your workload.
+ */
+export declare function getMetricsWithHeap(): PerformanceMetrics;
+export declare const cellInstr: {
+    recordCreateCellCall(): void;
+    recordCharCellWidthCall(): void;
+    recordNewCell(): void;
+    recordCacheHit(width: 1 | 2): void;
+    recordCacheMiss(width: 1 | 2): void;
+    recordCacheClear(width: 1 | 2): void;
+    recordBlankCacheHit(): void;
+    recordBlankCacheMiss(): void;
+    recordContinuationCacheHit(): void;
+    recordContinuationCacheMiss(): void;
+    updateMaxCacheSize(width: 1 | 2, size: number): void;
+    registerCacheBucket(width: 1 | 2, bucket: Map<string, any>): void;
+    updateBucketCounts(width1Count: number, width2Count: number): void;
+    updateEstimatedRetainedCells(count: number): void;
+};
+export declare const textInstr: {
+    recordTextCellWidthCall(textLength: number, isAscii: boolean): void;
+    recordTextWidthCacheHit(): void;
+    recordTextWidthCacheMiss(): void;
+    recordTextWidthCacheSet(): void;
+    recordTextWidthCacheEvict(): void;
+    recordRenderPassCacheHit(): void;
+    recordRenderPassCacheMiss(): void;
+    recordWrapByCellsCall(): void;
+    recordWrapCacheHit(): void;
+    recordWrapCacheMiss(): void;
+    recordWrapCacheSet(): void;
+    recordWrapCacheClear(): void;
+    recordWrapWidthBucketMapClear(): void;
+};
+export declare const graphemeInstr: {
+    recordSegmentedGraphemesCall(): void;
+    recordIntlSegmenterUsed(): void;
+    recordFallbackSegmenterUsed(): void;
+    recordSegmentationRequiredInput(): void;
+};

package/dist/core/terminal/create-terminal.d.ts

@@ -1,5 +1,6 @@
 import type { TerminalRenderPlane, TerminalRenderPlanes } from "../render-plane.js";
 import type { Cell, Terminal, TerminalOptions } from "../types.js";
+export declare function getRootTerminal(terminal: Terminal): Terminal;
 export declare function getPlaneTerminal(terminal: Terminal, plane: TerminalRenderPlane): Terminal;
 export declare function readTerminalRowForPlanes(terminal: Terminal, y: number, planes?: TerminalRenderPlanes | null): readonly Cell[];
 export declare function resetPlaneRowsForRender(terminal: Terminal, plane: TerminalRenderPlane, dirtyRows: readonly number[] | null): void;

package/dist/core/types.d.ts

@@ -100,8 +100,4 @@ export interface Terminal {
     getRow: (y: number) => readonly Cell[];
     setScrollbackLimit: (limit: number) => void;
     getScrollbackLines: (count?: number) => readonly string[];
-    /** Register fingerprint function for SoA pre-computation on the composite buffer. */
-    setFingerprintFn: (fn: (ch: string, style: Style) => number) => void;
-    /** Get pre-computed fingerprints for a composite buffer row (null if not enabled). */
-    getRowFingerprints: (y: number) => Uint32Array | null;
 }