@tuidom/core 0.9.0 → 0.10.0

package/dist/common/displayLine.js

@@ -1,5 +1,5 @@
+import { segmentGraphemes } from "./segmentGraphemes.js";
 import { getCharDisplayWidth, getGraphemeDisplayWidth } from "./unicodeWidth.js";
-const segmenter = new Intl.Segmenter("en", { granularity: "grapheme" });
 const DEFAULT_TAB_SIZE = 4;
 /**
  * Maps a raw document string to an array of grapheme slots with correct
@@ -34,7 +34,7 @@ export class DisplayLine {
         // отброшенной графемы (сегменты непрерывны, поэтому это ровно граница).
         let scannedLength = raw.length;
         let truncated = false;
-        for (const { segment, index } of segmenter.segment(raw)) {
+        for (const { segment, index } of segmentGraphemes(raw)) {
             if (index >= stopAfter) {
                 truncated = true;
                 scannedLength = index;

package/dist/common/measureTextWidth.js

@@ -1,5 +1,5 @@
+import { segmentGraphemes } from "./segmentGraphemes.js";
 import { getCharDisplayWidth, getGraphemeDisplayWidth } from "./unicodeWidth.js";
-const segmenter = new Intl.Segmenter("en", { granularity: "grapheme" });
 const DEFAULT_TAB_SIZE = 4;
 /**
  * Display width of `raw` in terminal columns.
@@ -23,7 +23,7 @@ const DEFAULT_TAB_SIZE = 4;
  */
 export function measureTextWidth(raw, tabSize = DEFAULT_TAB_SIZE, stopAfter = Infinity) {
     let column = 0;
-    for (const { segment, index } of segmenter.segment(raw)) {
+    for (const { segment, index } of segmentGraphemes(raw)) {
         if (index >= stopAfter)
             break;
         if (segment === "\t") {

package/dist/common/segmentGraphemes.d.ts

@@ -0,0 +1,24 @@
+/** One grapheme cluster of a string — the shape of `Intl.SegmentData` callers use. */
+export interface GraphemeSegment {
+    /** The grapheme cluster. */
+    readonly segment: string;
+    /** Its start offset in the source string (code units). */
+    readonly index: number;
+}
+/**
+ * Grapheme segmentation of `raw`, lazy as `Intl.Segmenter.segment`: a caller
+ * that stops early never touches the tail.
+ *
+ * Text where every code unit is a grapheme of its own (ASCII, Latin, Cyrillic,
+ * Greek, punctuation, box drawing, symbols, icon PUA) is split by code units
+ * without ICU — the same answer, but without loading ICU's break iterator,
+ * which costs a first frame ~15 ms. From the first code unit outside that set
+ * the rest of the string goes to `Intl.Segmenter`. VS Code does the same with
+ * its `isBasicASCII` fast paths and its own grapheme break table.
+ *
+ * The segmenter is created on first need, not at module load: a native `Intl`
+ * object held by a module-level binding cannot be serialized into a V8 startup
+ * snapshot, and hosts build one from the whole engine graph
+ * (`npm run check:snapshot`).
+ */
+export declare function segmentGraphemes(raw: string): Iterable<GraphemeSegment>;

package/dist/common/segmentGraphemes.js

@@ -0,0 +1,87 @@
+let segmenter = null;
+/**
+ * BMP code points that are always a grapheme of their own next to each other:
+ * inclusive `[from, to]`, ascending. Beyond the Latin-1 + Latin Extended
+ * prefix checked inline in {@link isStandalone}.
+ *
+ * Every code point here has the UAX #29 Grapheme_Cluster_Break value `Other`
+ * or `Control` (CR and LF excluded). Between two such code points there is
+ * always a break: GB4/GB5 for `Control`, GB999 for `Other`, and the rules that
+ * could keep two of them together (GB9c, GB11, GB12/13) need an `Extend`,
+ * `ZWJ` or regional indicator right before the break. The exhaustive test in
+ * `segmentGraphemes.test.ts` checks every code point here against ICU.
+ */
+const STANDALONE_RANGES = [
+    [0x0370, 0x0482], // Greek, Cyrillic up to the combining titlo
+    [0x048a, 0x052f], // Cyrillic, Cyrillic Supplement
+    [0x2010, 0x2027], // dashes, quotes, bullets, ellipsis
+    [0x2030, 0x205e], // per mille, primes, punctuation
+    [0x2070, 0x20cf], // super/subscripts, currency
+    [0x2100, 0x23ff], // letterlike, number forms, arrows, math, technical
+    [0x2400, 0x27bf], // control pictures, box drawing, blocks, shapes, symbols, dingbats
+    [0x27c0, 0x2bff], // math, arrows, braille, symbols
+    [0xe000, 0xf8ff], // Private Use Area — icon fonts
+];
+/**
+ * `true` when code unit `c` always forms a grapheme of its own next to another
+ * such code unit: everything below U+0300 except CR and LF, plus
+ * {@link STANDALONE_RANGES}.
+ */
+function isStandalone(c) {
+    if (c < 0x0300)
+        return c !== 0x0a && c !== 0x0d;
+    for (const [from, to] of STANDALONE_RANGES) {
+        if (c < from)
+            return false;
+        if (c <= to)
+            return true;
+    }
+    return false;
+}
+function segmentWithIcu(raw) {
+    segmenter ??= new Intl.Segmenter("en", { granularity: "grapheme" });
+    return segmenter.segment(raw);
+}
+function* segmentFrom(raw) {
+    let i = 0;
+    let standalone = raw.length > 0 && isStandalone(raw.charCodeAt(0));
+    while (i < raw.length) {
+        const nextStandalone = i + 1 >= raw.length || isStandalone(raw.charCodeAt(i + 1));
+        // Break before `i` is certain (start of string, or two standalone code
+        // units); the cluster at `i` is one code unit only if its right
+        // neighbour is standalone too.
+        if (!standalone || !nextStandalone)
+            break;
+        yield { segment: raw[i], index: i };
+        i++;
+        standalone = nextStandalone;
+    }
+    if (i >= raw.length)
+        return;
+    // The rest goes to ICU from a certain break: no rule looks back across a
+    // break between two standalone code units, so the tail segments as it
+    // would inside the whole string.
+    const tail = i === 0 ? raw : raw.slice(i);
+    for (const { segment, index } of segmentWithIcu(tail)) {
+        yield { segment, index: index + i };
+    }
+}
+/**
+ * Grapheme segmentation of `raw`, lazy as `Intl.Segmenter.segment`: a caller
+ * that stops early never touches the tail.
+ *
+ * Text where every code unit is a grapheme of its own (ASCII, Latin, Cyrillic,
+ * Greek, punctuation, box drawing, symbols, icon PUA) is split by code units
+ * without ICU — the same answer, but without loading ICU's break iterator,
+ * which costs a first frame ~15 ms. From the first code unit outside that set
+ * the rest of the string goes to `Intl.Segmenter`. VS Code does the same with
+ * its `isBasicASCII` fast paths and its own grapheme break table.
+ *
+ * The segmenter is created on first need, not at module load: a native `Intl`
+ * object held by a module-level binding cannot be serialized into a V8 startup
+ * snapshot, and hosts build one from the whole engine graph
+ * (`npm run check:snapshot`).
+ */
+export function segmentGraphemes(raw) {
+    return segmentFrom(raw);
+}

package/dist/dom/tuiApplication.d.ts

@@ -3,6 +3,23 @@ import { TerminalScreen } from "../rendering/terminalScreen.js";
 import { FocusManager } from "./events/focusManager.js";
 import { MouseEventDispatcher } from "./events/mouseEventDispatcher.js";
 import { type TUIElement } from "./tuiElement.js";
+/**
+ * Сколько занял кадр по фазам {@link TuiApplication.renderFrame}, мс. Для
+ * профилирования хостом (трасса старта, бенчи): кадр — layout → стили →
+ * damage-обход → отрисовка повреждённых областей → flush в бэкенд (diff +
+ * запись в терминал).
+ */
+export interface IFrameTimings {
+    /** Номер кадра — {@link TuiApplication.frameCount} после этого кадра. */
+    readonly frame: number;
+    /** Начало кадра, `performance.now()`. */
+    readonly start: number;
+    readonly layout: number;
+    readonly style: number;
+    readonly damage: number;
+    readonly paint: number;
+    readonly flush: number;
+}
 export declare class TuiApplication {
     backend: ITerminalBackend;
     root: TUIElement | null;
@@ -17,6 +34,11 @@ export declare class TuiApplication {
      * кадре, а не молчаливым «не показывается / не кликается».
      */
     validateTreeAfterRender: boolean;
+    /**
+     * Наблюдатель фаз кадра: зовётся после каждого кадра с таймингами
+     * {@link IFrameTimings}. Пока он null, кадр не читает часы вовсе.
+     */
+    onFrameTimings: ((timings: IFrameTimings) => void) | null;
     private frameCounter;
     private pinnedKeypressTarget;
     private needsFullRepaint;

package/dist/dom/tuiApplication.js

@@ -23,6 +23,11 @@ export class TuiApplication {
      * кадре, а не молчаливым «не показывается / не кликается».
      */
     validateTreeAfterRender = false;
+    /**
+     * Наблюдатель фаз кадра: зовётся после каждого кадра с таймингами
+     * {@link IFrameTimings}. Пока он null, кадр не читает часы вовсе.
+     */
+    onFrameTimings = null;
     // Монотонный счётчик отрисованных кадров. Инкремент на каждый renderFrame —
     // инспектор ждёт «рендер устоялся» (frameCount не менялся + нет
     // запланированного рендера), не завися от sleep. См. inspector/idleWaiter.
@@ -47,6 +52,8 @@ export class TuiApplication {
     renderFrame() {
         if (this.root) {
             this.frameCounter++;
+            const observer = this.onFrameTimings;
+            const start = observer === null ? 0 : performance.now();
             // Root at (0, 0) — top-left of screen. globalPosition производный
             // (localPosition корня без родителя), выставлять его не нужно.
             this.root.localPosition = new Offset(0, 0);
@@ -54,7 +61,9 @@ export class TuiApplication {
             // validateTree не зависят от damage); стили гейтятся внутри.
             const constraints = BoxConstraints.tight(this.screen.size);
             this.root.layout(constraints);
+            const layoutEnd = observer === null ? 0 : performance.now();
             this.root.performStyleResolution(ROOT_STYLE_CONTEXT);
+            const styleEnd = observer === null ? 0 : performance.now();
             // Damage-обход — всегда: и собирает области, и актуализирует
             // lastPaintedRect/флаги (даже когда кадр будет полным).
             const damage = new DamageList();
@@ -62,6 +71,7 @@ export class TuiApplication {
                 damage.add(detached);
             }
             this.root.collectDamage(damage, new Point(0, 0));
+            const damageEnd = observer === null ? 0 : performance.now();
             const screenBounds = new Rect(new Point(0, 0), this.screen.size);
             let rects;
             if (this.needsFullRepaint) {
@@ -91,8 +101,21 @@ export class TuiApplication {
                 }
                 this.root.render(new RenderContext(this.screen, new Offset(0, 0), rect));
             }
+            const paintEnd = observer === null ? 0 : performance.now();
             // Всегда: пустой damage — пустой diff, ноль байт в терминал.
             this.screen.flush(this.backend);
+            if (observer !== null) {
+                const flushEnd = performance.now();
+                observer({
+                    frame: this.frameCounter,
+                    start,
+                    layout: layoutEnd - start,
+                    style: styleEnd - layoutEnd,
+                    damage: damageEnd - styleEnd,
+                    paint: paintEnd - damageEnd,
+                    flush: flushEnd - paintEnd,
+                });
+            }
             if (this.validateTreeAfterRender) {
                 assertValidTree(this.root);
             }

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "@tuidom/core",
-    "version": "0.9.0",
+    "version": "0.10.0",
     "type": "module",
     "description": "Experimental terminal UI DOM — core: element tree, flex layout, grid rendering, input parsing. API is unstable.",
     "license": "MIT",