@simon_he/vue-tui 0.0.8 → 1.0.0

package/dist/observability/cli-latency-node.d.ts

@@ -0,0 +1,3 @@
+import type { CliLatencyProfiler } from "./cli-latency-types.js";
+export declare function defaultCliLatencyLogPath(): string;
+export declare function getCliLatencyProfiler(): CliLatencyProfiler | null;

package/dist/observability/cli-latency-types.d.ts

@@ -0,0 +1,41 @@
+export type CliLatencyStageEvent = Readonly<Record<string, unknown>> & {
+    type?: unknown;
+    key?: unknown;
+    code?: unknown;
+};
+export type CliLatencyProfiler = Readonly<{
+    enabled: true;
+    recordRawInput: (info?: Readonly<{
+        bytes?: number;
+    }>) => void;
+    recordStdinDispatch: (event: CliLatencyStageEvent, info?: Readonly<{
+        parser?: string | null;
+    }>) => void;
+    recordEventDispatchStart: (event: CliLatencyStageEvent) => void;
+    recordEventDispatchEnd: (event: CliLatencyStageEvent, info: Readonly<{
+        defaultPrevented: boolean;
+    }>) => void;
+    recordSchedulerInvalidate: (info?: Readonly<{
+        priority?: string | null;
+        plane?: string | null;
+    }>) => void;
+    recordFlushStart: (info?: Readonly<{
+        sync?: boolean;
+        activePlanes?: readonly string[] | null;
+    }>) => void;
+    recordFlushEnd: () => void;
+    recordCommit: (info?: Readonly<{
+        sync?: boolean;
+        dirtyRows?: readonly number[] | null;
+        planes?: readonly string[] | null;
+    }>) => void;
+    recordStdoutQueued: (delayMs: number) => void;
+    recordStdoutRenderStart: () => void;
+    recordStdoutNoOutput: () => void;
+    recordStdoutWrite: (info: Readonly<{
+        durationMs: number;
+        bytes: number;
+        mode: string;
+    }>) => void;
+    markOperation: (operation: string) => void;
+}>;

package/dist/observability/cli-latency.d.ts

@@ -0,0 +1,3 @@
+import type { CliLatencyProfiler } from "./cli-latency-types.js";
+export type { CliLatencyProfiler } from "./cli-latency-types.js";
+export declare function getCliLatencyProfiler(): CliLatencyProfiler | null;

package/dist/observability/frame-perf-store.d.ts

@@ -0,0 +1,18 @@
+import type { Ref } from "vue";
+import type { FramePerfSample } from "./frame-perf.js";
+import type { ComponentPerf, TuiPerfEvent, TuiPerfSink } from "./perf-sink.js";
+export type FramePerfStore = Readonly<{
+    enabled: Ref<boolean>;
+    acquire: (reason?: string) => () => void;
+    push: (sample: FramePerfSample) => void;
+    recordComponent: (sample: ComponentPerf) => void;
+    recordEvent: (event: TuiPerfEvent) => void;
+    addSink: (sink: TuiPerfSink) => () => void;
+    latest: () => FramePerfSample | null;
+    list: () => FramePerfSample[];
+    clear: () => void;
+}>;
+export declare function createFramePerfStore(limit?: number, opts?: Readonly<{
+    enabled?: boolean;
+    sink?: TuiPerfSink | readonly TuiPerfSink[] | null;
+}>): FramePerfStore;

package/dist/observability/frame-perf.d.ts

@@ -0,0 +1,40 @@
+export type FramePerfReason = "scroll" | "input" | "stream" | "resize" | "data" | "selection" | "manual" | "unknown";
+export type FramePerfRowBucketFallback = Readonly<{
+    plane: string;
+    reason: "dirty-ratio" | "candidate-ratio";
+    dirtyRows: number;
+    planeNodes: number;
+    candidates?: number;
+}>;
+export type FramePerfMailboxFailure = Readonly<{
+    id: string;
+    queued: number;
+    dropped: number;
+}>;
+export type FramePerfSample = Readonly<{
+    frameId: number;
+    reason: FramePerfReason;
+    startedAt: number;
+    durationMs: number;
+    renderManagerMs: number;
+    commitMs: number;
+    domFlushMs?: number;
+    stdoutFlushMs?: number;
+    dirtyRows: number | null;
+    activePlanes: readonly string[] | null;
+    scannedNodes: number;
+    paintedNodes: number;
+    rowBucketFallbacks?: readonly FramePerfRowBucketFallback[];
+    coalescedInvalidates: number;
+    frameTaskCount: number;
+    coalescedFrameTasks: number;
+    frameTaskQueueDepthBeforeRun: number;
+    frameTaskQueueDepthAfterRun: number;
+    remainingFrameTasks: number;
+    droppedUpdates: number;
+    mailboxFailure?: FramePerfMailboxFailure;
+    queueDepth: number;
+    liveReasons?: readonly string[];
+}>;
+export declare function framePerfNow(): number;
+export declare function mergeFramePerfReason(prev: FramePerfReason | undefined, next: FramePerfReason | undefined): FramePerfReason;

package/dist/observability/perf-sink.d.ts

@@ -0,0 +1,56 @@
+import type { FramePerfSample } from "./frame-perf.js";
+export type FramePerf = FramePerfSample;
+export type ComponentPerf = Readonly<{
+    name: string;
+    id?: string;
+    phase: "source-read" | "measure" | "layout" | "render" | "cache-hit" | "cache-miss" | "scroll" | "parse";
+    durationMs: number;
+    visibleStart?: number;
+    visibleEnd?: number;
+    overscanStart?: number;
+    overscanEnd?: number;
+    itemCount?: number;
+    renderedCount?: number;
+    cacheHit?: number;
+    cacheMiss?: number;
+    width?: number;
+    version?: string | number;
+    reason?: string;
+}>;
+export type TuiPerfEvent = Readonly<{
+    type: string;
+    ts?: number;
+    component?: string;
+    id?: string;
+    data?: Record<string, unknown>;
+}>;
+export type TuiPerfSink = Readonly<{
+    onFramePerf: (sample: FramePerfSample) => void;
+    onComponentPerf?: (sample: ComponentPerf) => void;
+    onEvent?: (event: TuiPerfEvent) => void;
+    dispose?: () => void;
+}>;
+export type TuiPerfJsonlWriter = Readonly<{
+    appendFileSync?: (path: string, data: string) => void;
+}>;
+export type CreateJsonlPerfSinkOptions = Readonly<{
+    file?: string;
+    fileWriter?: TuiPerfJsonlWriter | null;
+    write?: (line: string) => void;
+    sampleRate?: number;
+    includeComponents?: boolean;
+    includeEvents?: boolean;
+}>;
+export type InstallTuiPerfOptions = Readonly<{
+    enabled?: boolean;
+    sink?: TuiPerfSink | null;
+    debugOverlay?: boolean;
+}>;
+type InstalledTuiPerf = Readonly<{
+    enabled: boolean;
+    sink: TuiPerfSink | null;
+}>;
+export declare function createJsonlPerfSink(options?: CreateJsonlPerfSinkOptions): TuiPerfSink;
+export declare function installTuiPerf(options?: InstallTuiPerfOptions): () => void;
+export declare function getInstalledTuiPerf(): InstalledTuiPerf;
+export {};

package/dist/observability/trace.d.ts

@@ -0,0 +1,40 @@
+import type { Ref } from "vue";
+import type { TerminalRenderPlanes } from "../core/render-plane.js";
+import type { TerminalEventRecord } from "../events/recording.js";
+import type { DomRendererSyncFlushDecision } from "../renderer/dom/dom-renderer.js";
+export type TraceRecord = Readonly<{
+    type: "event";
+    at: number;
+    event: TerminalEventRecord;
+}> | Readonly<{
+    type: "focus";
+    at: number;
+    prev: string | null;
+    next: string | null;
+}> | Readonly<{
+    type: "commit";
+    at: number;
+    dirtyRows: readonly number[] | null;
+    planes: TerminalRenderPlanes | null;
+    sync?: boolean;
+    rendererSyncFlush?: DomRendererSyncFlushDecision | null;
+    focusedId: string | null;
+}> | Readonly<{
+    type: "selection-copy";
+    at: number;
+    rows: number;
+    chars: number;
+    ok: boolean;
+    error?: string;
+}>;
+export type TraceStore = Readonly<{
+    enabled: Ref<boolean>;
+    records: TraceRecord[];
+    push: (record: TraceRecord) => void;
+    clear: () => void;
+    snapshot: () => TraceRecord[];
+}>;
+export declare function createTraceStore(opts?: Readonly<{
+    enabled?: boolean;
+    max?: number;
+}>): TraceStore;

package/dist/observability/tui-profiler.d.ts

@@ -0,0 +1,33 @@
+import type { TerminalRenderPlane, TerminalRenderPlanes } from "../core/render-plane.js";
+type NowFn = () => number;
+type TuiProfilerFileWriter = Readonly<{
+    appendFileSync?: (path: string, data: string) => void;
+}>;
+export type CreateTuiProfilerOptions = Readonly<{
+    fileWriter?: TuiProfilerFileWriter;
+    defaultLogDest?: "stdout" | "file" | "both";
+    defaultLogPath?: string;
+}>;
+export declare function setTuiProfilerFileWriter(writer: TuiProfilerFileWriter | null): void;
+export type TuiProfiler = Readonly<{
+    now: NowFn;
+    recordInvalidate: (info?: {
+        plane?: TerminalRenderPlane | null;
+    }) => void;
+    recordRender: (info: {
+        durationMs: number;
+        rows: number;
+        nodes: number;
+        fullRepaint: boolean;
+        sorted: boolean;
+        activePlanes?: TerminalRenderPlanes | null;
+    }) => void;
+    recordWrite: (info: {
+        durationMs: number;
+        bytes: number;
+        mode: "stream" | "sync" | "chunked";
+    }) => void;
+    dispose: () => void;
+}>;
+export declare function createTuiProfiler(name: string, options?: CreateTuiProfilerOptions): TuiProfiler | null;
+export {};

package/dist/observability.cjs

@@ -0,0 +1,221 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/observability.ts
+var observability_exports = {};
+__export(observability_exports, {
+  createFramePerfStore: () => createFramePerfStore,
+  createJsonlPerfSink: () => createJsonlPerfSink,
+  createTraceStore: () => createTraceStore,
+  framePerfNow: () => framePerfNow,
+  installTuiPerf: () => installTuiPerf
+});
+module.exports = __toCommonJS(observability_exports);
+
+// src/observability/frame-perf.ts
+function framePerfNow() {
+  const p = globalThis.performance;
+  if (p && typeof p.now === "function")
+    return p.now();
+  return Date.now();
+}
+
+// src/observability/frame-perf-store.ts
+var import_vue = require("vue");
+
+// src/observability/perf-sink.ts
+var installedTuiPerf = { enabled: false, sink: null };
+function shouldSample(rate) {
+  if (rate <= 0)
+    return false;
+  if (rate >= 1)
+    return true;
+  return Math.random() < rate;
+}
+function normalizeSampleRate(value) {
+  const n = Number(value);
+  if (!Number.isFinite(n))
+    return 1;
+  return Math.max(0, Math.min(1, n));
+}
+function createJsonlPerfSink(options = {}) {
+  const sampleRate = normalizeSampleRate(options.sampleRate);
+  const includeComponents = options.includeComponents ?? true;
+  const includeEvents = options.includeEvents ?? false;
+  function emit(value) {
+    const line = JSON.stringify(value);
+    if (options.file && options.fileWriter?.appendFileSync) {
+      options.fileWriter.appendFileSync(options.file, `${line}
+`);
+    }
+    options.write?.(line);
+  }
+  return {
+    onFramePerf(sample) {
+      if (!shouldSample(sampleRate))
+        return;
+      emit({ type: "frame", ...sample });
+    },
+    onComponentPerf(sample) {
+      if (!includeComponents || !shouldSample(sampleRate))
+        return;
+      emit({ type: "component", ...sample });
+    },
+    onEvent(event) {
+      if (!includeEvents || !shouldSample(sampleRate))
+        return;
+      emit({
+        type: "event",
+        eventType: event.type,
+        ts: event.ts ?? Date.now(),
+        component: event.component,
+        id: event.id,
+        data: event.data
+      });
+    }
+  };
+}
+function installTuiPerf(options = {}) {
+  const previous = installedTuiPerf;
+  const previousDebugPerf = globalThis.__VT_DEBUG_PERF__;
+  const current = {
+    enabled: options.enabled ?? Boolean(options.sink),
+    sink: options.sink ?? null
+  };
+  installedTuiPerf = current;
+  if (options.debugOverlay != null) {
+    globalThis.__VT_DEBUG_PERF__ = Boolean(options.debugOverlay);
+  }
+  return () => {
+    current.sink?.dispose?.();
+    if (installedTuiPerf === current)
+      installedTuiPerf = previous;
+    if (previousDebugPerf === void 0)
+      delete globalThis.__VT_DEBUG_PERF__;
+    else
+      globalThis.__VT_DEBUG_PERF__ = previousDebugPerf;
+  };
+}
+function getInstalledTuiPerf() {
+  return installedTuiPerf;
+}
+
+// src/observability/frame-perf-store.ts
+function createFramePerfStore(limit = 120, opts) {
+  const max = Math.max(1, Math.floor(limit));
+  const installed = getInstalledTuiPerf();
+  const manualEnabled = (0, import_vue.ref)(Boolean(opts?.enabled ?? installed.enabled));
+  const leaseCount = (0, import_vue.ref)(0);
+  const enabled = (0, import_vue.computed)({
+    get: () => manualEnabled.value || leaseCount.value > 0,
+    set: (next) => {
+      manualEnabled.value = Boolean(next);
+    }
+  });
+  const samples = [];
+  const sinks = [];
+  if (installed.sink)
+    sinks.push(installed.sink);
+  const configuredSink = opts?.sink;
+  if (Array.isArray(configuredSink))
+    sinks.push(...configuredSink);
+  else if (configuredSink)
+    sinks.push(configuredSink);
+  function emitToSinks(fn) {
+    for (const sink of sinks) {
+      try {
+        fn(sink);
+      } catch {
+      }
+    }
+  }
+  function acquire(_reason) {
+    leaseCount.value++;
+    let released = false;
+    return () => {
+      if (released)
+        return;
+      released = true;
+      leaseCount.value = Math.max(0, leaseCount.value - 1);
+    };
+  }
+  function push(sample) {
+    if (!enabled.value)
+      return;
+    samples.push(sample);
+    if (samples.length > max)
+      samples.splice(0, samples.length - max);
+    emitToSinks((sink) => sink.onFramePerf(sample));
+  }
+  function recordComponent(sample) {
+    if (!enabled.value)
+      return;
+    emitToSinks((sink) => sink.onComponentPerf?.(sample));
+  }
+  function recordEvent(event) {
+    if (!enabled.value)
+      return;
+    emitToSinks((sink) => sink.onEvent?.(event));
+  }
+  function addSink(sink) {
+    sinks.push(sink);
+    let disposed = false;
+    return () => {
+      if (disposed)
+        return;
+      disposed = true;
+      const index = sinks.indexOf(sink);
+      if (index >= 0)
+        sinks.splice(index, 1);
+      sink.dispose?.();
+    };
+  }
+  function latest() {
+    return samples.length > 0 ? samples[samples.length - 1] : null;
+  }
+  function list() {
+    return samples.slice();
+  }
+  function clear() {
+    samples.length = 0;
+  }
+  return { enabled, acquire, push, recordComponent, recordEvent, addSink, latest, list, clear };
+}
+
+// src/observability/trace.ts
+var import_vue2 = require("vue");
+function createTraceStore(opts) {
+  const enabled = (0, import_vue2.ref)(Boolean(opts?.enabled));
+  const records = (0, import_vue2.shallowReactive)([]);
+  const max = Math.max(10, Math.floor(opts?.max ?? 400));
+  function push(record) {
+    if (!enabled.value)
+      return;
+    records.push(record);
+    if (records.length > max)
+      records.splice(0, records.length - max);
+  }
+  function clear() {
+    records.splice(0, records.length);
+  }
+  function snapshot() {
+    return records.slice();
+  }
+  return { enabled, records, push, clear, snapshot };
+}

package/dist/observability.d.cts

@@ -0,0 +1,8 @@
+export type { FramePerfReason, FramePerfRowBucketFallback, FramePerfSample, } from "./observability/frame-perf.js";
+export { framePerfNow } from "./observability/frame-perf.js";
+export type { FramePerfStore } from "./observability/frame-perf-store.js";
+export { createFramePerfStore } from "./observability/frame-perf-store.js";
+export type { ComponentPerf, CreateJsonlPerfSinkOptions, FramePerf, InstallTuiPerfOptions, TuiPerfEvent, TuiPerfSink, } from "./observability/perf-sink.js";
+export { createJsonlPerfSink, installTuiPerf } from "./observability/perf-sink.js";
+export type { TraceRecord, TraceStore } from "./observability/trace.js";
+export { createTraceStore } from "./observability/trace.js";

package/dist/observability.d.ts

@@ -0,0 +1,8 @@
+export type { FramePerfReason, FramePerfRowBucketFallback, FramePerfSample, } from "./observability/frame-perf.js";
+export { framePerfNow } from "./observability/frame-perf.js";
+export type { FramePerfStore } from "./observability/frame-perf-store.js";
+export { createFramePerfStore } from "./observability/frame-perf-store.js";
+export type { ComponentPerf, CreateJsonlPerfSinkOptions, FramePerf, InstallTuiPerfOptions, TuiPerfEvent, TuiPerfSink, } from "./observability/perf-sink.js";
+export { createJsonlPerfSink, installTuiPerf } from "./observability/perf-sink.js";
+export type { TraceRecord, TraceStore } from "./observability/trace.js";
+export { createTraceStore } from "./observability/trace.js";

package/dist/observability.js

@@ -0,0 +1,4 @@
+import { createFramePerfStore, createJsonlPerfSink, createTraceStore, installTuiPerf } from "./trace-CjzYeIxN.js";
+import { framePerfNow } from "./frame-perf-C6Xfg85O.js";
+
+export { createFramePerfStore, createJsonlPerfSink, createTraceStore, framePerfNow, installTuiPerf };

package/dist/path-mnSgEpCm.js

@@ -0,0 +1,81 @@
+//#region src/utils/newlines.ts
+function normalizeNewlines(text) {
+	return text.replace(/\r\n/g, "\n").replace(/\r/g, "\n");
+}
+
+//#endregion
+//#region src/utils/path.ts
+function normalizeSeparators(input) {
+	let out = "";
+	for (let i = 0; i < input.length; i++) {
+		const ch = input[i];
+		out += ch === "\\" ? "/" : ch;
+	}
+	return out;
+}
+function isAbsolutePath(path) {
+	const p = normalizeSeparators(path);
+	if (p.startsWith("/")) return true;
+	return /^[A-Z]:\//i.test(p);
+}
+function stripTrailingSlash(path) {
+	const p = normalizeSeparators(path);
+	if (p === "/") return p;
+	let end = p.length;
+	while (end > 0 && p.charCodeAt(end - 1) === 47) end--;
+	return end === p.length ? p : p.slice(0, end);
+}
+function joinPath(base, next) {
+	const a = normalizeSeparators(base);
+	const b = normalizeSeparators(next);
+	if (!a) return b;
+	if (!b) return a;
+	if (a.endsWith("/")) return `${a}${b.startsWith("/") ? b.slice(1) : b}`;
+	return `${a}/${b.startsWith("/") ? b.slice(1) : b}`;
+}
+function dirname(path) {
+	const p = stripTrailingSlash(path);
+	const normalized = normalizeSeparators(p);
+	if (normalized === "/") return "/";
+	const drive = normalized.match(/^([A-Z]:)\//i)?.[1] ?? null;
+	const start = drive ? drive.length + 1 : 0;
+	const idx = normalized.lastIndexOf("/");
+	if (idx < start) return drive ? `${drive}/` : "";
+	const out = normalized.slice(0, idx) || (drive ? `${drive}/` : "/");
+	return out;
+}
+function normalizePath(path) {
+	const raw = normalizeSeparators(path);
+	if (!raw) return "";
+	const drive = raw.match(/^([A-Z]:)(\/|$)/i)?.[1] ?? null;
+	const rest = drive ? raw.slice(drive.length) : raw;
+	const absolute = rest.startsWith("/");
+	const parts = rest.split("/").filter(Boolean);
+	const stack = [];
+	for (const part of parts) {
+		if (part === ".") continue;
+		if (part === "..") {
+			if (stack.length > 0 && stack[stack.length - 1] !== "..") {
+				stack.pop();
+				continue;
+			}
+			if (!absolute) stack.push("..");
+			continue;
+		}
+		stack.push(part);
+	}
+	const prefix = drive ? `${drive}${absolute ? "/" : ""}` : absolute ? "/" : "";
+	const joined = stack.join("/");
+	const out = `${prefix}${joined}`;
+	return out || (absolute ? drive ? `${drive}/` : "/" : "");
+}
+function resolvePath(baseAbs, input) {
+	const b = normalizePath(baseAbs);
+	const i = normalizePath(input);
+	if (!b) return i;
+	if (isAbsolutePath(i)) return i;
+	return normalizePath(joinPath(b, i));
+}
+
+//#endregion
+export { dirname, isAbsolutePath, joinPath, normalizeNewlines, normalizePath, resolvePath, stripTrailingSlash };