@jitl/opentui-core 0.1.97 → 0.2.15

package/testing.js

@@ -3,10 +3,11 @@ import {
   ANSI,
   CliRenderer,
   TreeSitterClient,
+  calculateRenderGeometry,
   resolveRenderLib
-} from "./index-rhfjv9c1.js";
-import"./index-cbvybypy.js";
-import"./index-re3ntm60.js";
+} from "./index-g9agybj3.js";
+import"./index-5zwezmgj.js";
+import"./index-k18nf2r7.js";
 
 // src/testing/test-renderer.ts
 import { Readable, Writable } from "stream";
@@ -458,6 +459,106 @@ function createMockMouse(renderer) {
 
 // src/testing/test-renderer.ts
 var decoder = new TextDecoder;
+var DEFAULT_MAX_PASSES = 20;
+var DEFAULT_MAX_VISUAL_IDLE_FRAMES = 20;
+var DEFAULT_QUIET_FRAMES = 1;
+async function drainImmediateWork() {
+  await Promise.resolve();
+  await new Promise((resolve) => process.nextTick(resolve));
+  await Promise.resolve();
+}
+function normalizePositiveInteger(value, fallback) {
+  if (typeof value !== "number" || !Number.isFinite(value) || value <= 0) {
+    return fallback;
+  }
+  return Math.floor(value);
+}
+function createWaitError(renderer, message, frame) {
+  const stats = renderer.getStats();
+  const scheduler = renderer.getSchedulerState();
+  const details = [
+    message,
+    `frameId: ${renderer.frameId}`,
+    `nativeFrameCount: ${stats.nativeFrameCount}`,
+    `cellsUpdated: ${stats.cellsUpdated}`,
+    `isRunning: ${scheduler.isRunning}`,
+    `isRendering: ${scheduler.isRendering}`,
+    `hasScheduledRender: ${scheduler.hasScheduledRender}`
+  ];
+  if (frame !== undefined) {
+    details.push(`lastFrame:
+${frame}`);
+  }
+  return new Error(details.join(`
+`));
+}
+
+class TestExternalOutputRecorder {
+  commits = [];
+  constructor(renderer) {
+    renderer.on("external_output" /* EXTERNAL_OUTPUT */, this.record);
+    renderer.once("destroy" /* DESTROY */, () => {
+      renderer.off("external_output" /* EXTERNAL_OUTPUT */, this.record);
+    });
+  }
+  record = (event) => {
+    const raw = decoder.decode(event.snapshot.getRealCharBytes(false));
+    const rows = Array.from({ length: event.snapshot.height }, (_, index) => raw.slice(index * event.snapshot.width, (index + 1) * event.snapshot.width).trimEnd());
+    this.commits.push({
+      text: rows.join(`
+`),
+      rows,
+      width: event.snapshot.width,
+      height: event.snapshot.height,
+      rowColumns: event.rowColumns,
+      startOnNewLine: event.startOnNewLine,
+      trailingNewline: event.trailingNewline
+    });
+  };
+  take() {
+    const commits = this.commits;
+    this.commits = [];
+    return commits;
+  }
+  takeText() {
+    return this.take().flatMap((commit) => commit.rows).join(`
+`);
+  }
+  clear() {
+    this.commits = [];
+  }
+}
+function waitForNextFrameOrIdle(renderer) {
+  const scheduler = renderer.getSchedulerState();
+  if (!scheduler.isRunning && !scheduler.isRendering && !scheduler.hasScheduledRender) {
+    return Promise.resolve(null);
+  }
+  return new Promise((resolve) => {
+    let settled = false;
+    const cleanup = () => {
+      renderer.off("frame" /* FRAME */, onFrame);
+      renderer.off("destroy" /* DESTROY */, onDestroy);
+    };
+    const finish = (event) => {
+      if (settled)
+        return;
+      settled = true;
+      cleanup();
+      resolve(event);
+    };
+    const onFrame = (event) => {
+      finish(event);
+    };
+    const onDestroy = () => {
+      finish(null);
+    };
+    renderer.on("frame" /* FRAME */, onFrame);
+    renderer.once("destroy" /* DESTROY */, onDestroy);
+    if (!scheduler.isRunning) {
+      renderer.idle().then(() => finish(null));
+    }
+  });
+}
 
 class TestWriteStream extends Writable {
   isTTY = true;
@@ -485,6 +586,7 @@ async function createTestRenderer(options) {
     consoleMode: options.consoleMode ?? "disabled",
     externalOutputMode: options.externalOutputMode ?? "passthrough"
   });
+  const externalOutput = new TestExternalOutputRecorder(renderer);
   const mockInput = createMockKeys(renderer, {
     kittyKeyboard: options.kittyKeyboard,
     otherModifiersMode: options.otherModifiersMode
@@ -493,16 +595,95 @@ async function createTestRenderer(options) {
   const renderOnce = async () => {
     await renderer.loop();
   };
+  const captureCharFrame = () => {
+    const currentBuffer = renderer.currentRenderBuffer;
+    const frameBytes = currentBuffer.getRealCharBytes(true);
+    return decoder.decode(frameBytes);
+  };
+  const waitForVisualIdle = async (waitOptions = {}) => {
+    const maxFrames = normalizePositiveInteger(waitOptions.maxFrames, DEFAULT_MAX_VISUAL_IDLE_FRAMES);
+    const quietFrames = normalizePositiveInteger(waitOptions.quietFrames, DEFAULT_QUIET_FRAMES);
+    let consecutiveQuietFrames = 0;
+    for (let frame = 0;frame < maxFrames; frame++) {
+      await drainImmediateWork();
+      const scheduler2 = renderer.getSchedulerState();
+      if (!scheduler2.isRunning && !scheduler2.isRendering && !scheduler2.hasScheduledRender) {
+        return;
+      }
+      const event = await waitForNextFrameOrIdle(renderer);
+      if (!event) {
+        return;
+      }
+      if (renderer.getNativeStats().cellsUpdated === 0) {
+        consecutiveQuietFrames++;
+        if (consecutiveQuietFrames >= quietFrames) {
+          return;
+        }
+      } else {
+        consecutiveQuietFrames = 0;
+      }
+    }
+    await drainImmediateWork();
+    const scheduler = renderer.getSchedulerState();
+    if (!scheduler.isRunning && !scheduler.isRendering && !scheduler.hasScheduledRender) {
+      return;
+    }
+    throw createWaitError(renderer, `Timed out waiting for visual idle after ${maxFrames} frames`);
+  };
+  const flush = async (flushOptions = {}) => {
+    await waitForVisualIdle({ maxFrames: normalizePositiveInteger(flushOptions.maxPasses, DEFAULT_MAX_PASSES) });
+  };
+  const waitFor = async (predicate, waitOptions = {}) => {
+    const maxPasses = normalizePositiveInteger(waitOptions.maxPasses, DEFAULT_MAX_PASSES);
+    for (let pass = 0;pass <= maxPasses; pass++) {
+      await drainImmediateWork();
+      if (await predicate()) {
+        return;
+      }
+      if (pass === maxPasses) {
+        break;
+      }
+      const scheduler = renderer.getSchedulerState();
+      if (!scheduler.isRunning && !scheduler.isRendering && !scheduler.hasScheduledRender) {
+        break;
+      }
+      await waitForNextFrameOrIdle(renderer);
+    }
+    throw createWaitError(renderer, `Timed out waiting for predicate after ${maxPasses} passes`);
+  };
+  const waitForFrame = async (predicate, waitOptions = {}) => {
+    const maxPasses = normalizePositiveInteger(waitOptions.maxPasses, DEFAULT_MAX_PASSES);
+    let frame = captureCharFrame();
+    for (let pass = 0;pass <= maxPasses; pass++) {
+      await drainImmediateWork();
+      frame = captureCharFrame();
+      if (await predicate(frame)) {
+        return frame;
+      }
+      if (pass === maxPasses) {
+        break;
+      }
+      const scheduler = renderer.getSchedulerState();
+      if (!scheduler.isRunning && !scheduler.isRendering && !scheduler.hasScheduledRender) {
+        break;
+      }
+      await waitForNextFrameOrIdle(renderer);
+    }
+    frame = captureCharFrame();
+    throw createWaitError(renderer, `Timed out waiting for frame predicate after ${maxPasses} passes`, frame);
+  };
   return {
     renderer,
     mockInput,
     mockMouse,
     renderOnce,
-    captureCharFrame: () => {
-      const currentBuffer = renderer.currentRenderBuffer;
-      const frameBytes = currentBuffer.getRealCharBytes(true);
-      return decoder.decode(frameBytes);
-    },
+    flush,
+    waitFor,
+    waitForFrame,
+    waitForVisualIdle,
+    externalOutput,
+    getNativeStats: () => renderer.getNativeStats(),
+    captureCharFrame,
     captureSpans: () => {
       const currentBuffer = renderer.currentRenderBuffer;
       const lines = currentBuffer.getSpanLines();
@@ -524,9 +705,11 @@ async function setupTestRenderer(config) {
   const width = config.width || config.stdout?.columns || process.stdout.columns || 80;
   const height = config.height || config.stdout?.rows || process.stdout.rows || 24;
   const stdout = config.stdout || new TestWriteStream(width, height);
-  const renderHeight = config.screenMode === "split-footer" ? config.footerHeight ?? 12 : height;
+  const screenMode = config.screenMode ?? "alternate-screen";
+  const footerHeight = config.footerHeight ?? 12;
+  const geometry = calculateRenderGeometry(screenMode, width, height, footerHeight);
   const ziglib = resolveRenderLib();
-  const rendererPtr = ziglib.createRenderer(width, renderHeight, {
+  const rendererPtr = ziglib.createRenderer(geometry.renderWidth, geometry.renderHeight, {
     testing: true,
     remote: config.remote ?? false
   });
@@ -594,6 +777,41 @@ class MockTreeSitterClient extends TreeSitterClient {
     return this._highlightPromises.length > 0;
   }
 }
+// src/testing/terminal-capabilities.ts
+function createTerminalCapabilities(overrides = {}) {
+  return {
+    kitty_keyboard: false,
+    kitty_graphics: false,
+    rgb: false,
+    ansi256: false,
+    unicode: "unicode",
+    sgr_pixels: false,
+    color_scheme_updates: false,
+    explicit_width: false,
+    scaled_text: false,
+    sixel: false,
+    focus_tracking: false,
+    sync: false,
+    bracketed_paste: false,
+    hyperlinks: false,
+    osc52: false,
+    notifications: false,
+    explicit_cursor_positioning: false,
+    in_tmux: false,
+    ...overrides,
+    terminal: {
+      name: "",
+      version: "",
+      from_xtversion: false,
+      ...overrides.terminal
+    }
+  };
+}
+function setRendererCapabilities(renderer, overrides = {}) {
+  const capabilities = createTerminalCapabilities(overrides);
+  renderer._capabilities = capabilities;
+  return capabilities;
+}
 // src/testing/spy.ts
 function createSpy() {
   const calls = [];
@@ -608,6 +826,94 @@ function createSpy() {
   spy.reset = () => calls.length = 0;
   return spy;
 }
+// src/testing/manual-clock.ts
+function compareTimers(left, right) {
+  if (left.fireAt !== right.fireAt) {
+    return left.fireAt - right.fireAt;
+  }
+  return left.order - right.order;
+}
+
+class ManualClock {
+  time = 0;
+  nextId = 1;
+  nextOrder = 0;
+  timers = new Map;
+  now() {
+    return this.time;
+  }
+  setTime(time) {
+    const targetTime = Math.floor(time);
+    if (targetTime >= this.time) {
+      this.advance(targetTime - this.time);
+      return;
+    }
+    this.time = targetTime;
+  }
+  setTimeout(fn, delayMs) {
+    return this.schedule(fn, delayMs, false);
+  }
+  clearTimeout(handle) {
+    this.timers.delete(Number(handle));
+  }
+  setInterval(fn, delayMs) {
+    return this.schedule(fn, delayMs, true);
+  }
+  clearInterval(handle) {
+    this.clearTimeout(handle);
+  }
+  advance(delayMs) {
+    const targetTime = this.time + Math.max(0, Math.floor(delayMs));
+    while (true) {
+      const nextTimer = this.peekNextTimer();
+      if (!nextTimer || nextTimer.fireAt > targetTime) {
+        break;
+      }
+      this.timers.delete(nextTimer.id);
+      this.time = nextTimer.fireAt;
+      nextTimer.fn();
+      if (nextTimer.repeat && !this.timers.has(nextTimer.id)) {
+        this.timers.set(nextTimer.id, {
+          ...nextTimer,
+          fireAt: this.time + nextTimer.delayMs,
+          order: this.nextOrder++
+        });
+      }
+    }
+    this.time = targetTime;
+  }
+  runAll() {
+    while (true) {
+      const nextTimer = this.peekNextTimer();
+      if (!nextTimer) {
+        return;
+      }
+      this.advance(nextTimer.fireAt - this.time);
+    }
+  }
+  schedule(fn, delayMs, repeat) {
+    const id = this.nextId++;
+    const normalizedDelay = Math.max(0, Math.floor(delayMs));
+    this.timers.set(id, {
+      id,
+      fireAt: this.time + normalizedDelay,
+      order: this.nextOrder++,
+      delayMs: normalizedDelay,
+      repeat,
+      fn
+    });
+    return id;
+  }
+  peekNextTimer() {
+    let nextTimer = null;
+    for (const timer of this.timers.values()) {
+      if (!nextTimer || compareTimers(timer, nextTimer) < 0) {
+        nextTimer = timer;
+      }
+    }
+    return nextTimer;
+  }
+}
 // src/testing/test-recorder.ts
 class TestRecorder {
   renderer;
@@ -615,10 +921,14 @@ class TestRecorder {
   recording = false;
   frameNumber = 0;
   startTime = 0;
-  originalRenderNative;
   decoder = new TextDecoder;
   recordBuffers;
   now;
+  onFrame = () => {
+    if (!this.recording)
+      return;
+    this.captureFrame();
+  };
   constructor(renderer, options) {
     this.renderer = renderer;
     this.recordBuffers = options?.recordBuffers || {};
@@ -632,21 +942,14 @@ class TestRecorder {
     this.frames = [];
     this.frameNumber = 0;
     this.startTime = this.now();
-    this.originalRenderNative = this.renderer["renderNative"].bind(this.renderer);
-    this.renderer["renderNative"] = () => {
-      this.originalRenderNative();
-      this.captureFrame();
-    };
+    this.renderer.on("frame" /* FRAME */, this.onFrame);
   }
   stop() {
     if (!this.recording) {
       return;
     }
     this.recording = false;
-    if (this.originalRenderNative) {
-      this.renderer["renderNative"] = this.originalRenderNative;
-      this.originalRenderNative = undefined;
-    }
+    this.renderer.off("frame" /* FRAME */, this.onFrame);
   }
   get recordedFrames() {
     return [...this.frames];
@@ -671,10 +974,10 @@ class TestRecorder {
       const buffers = currentBuffer.buffers;
       recordedFrame.buffers = {};
       if (this.recordBuffers.fg) {
-        recordedFrame.buffers.fg = new Float32Array(buffers.fg);
+        recordedFrame.buffers.fg = new Uint16Array(buffers.fg);
       }
       if (this.recordBuffers.bg) {
-        recordedFrame.buffers.bg = new Float32Array(buffers.bg);
+        recordedFrame.buffers.bg = new Uint16Array(buffers.bg);
       }
       if (this.recordBuffers.attributes) {
         recordedFrame.buffers.attributes = new Uint8Array(buffers.attributes);
@@ -684,16 +987,19 @@ class TestRecorder {
   }
 }
 export {
+  setRendererCapabilities,
   pasteBytes,
   createTestRenderer,
+  createTerminalCapabilities,
   createSpy,
   createMockMouse,
   createMockKeys,
   TestRecorder,
   MouseButtons,
   MockTreeSitterClient,
+  ManualClock,
   KeyCodes
 };
 
-//# debugId=5F2319EEEBCB872F64756E2164756E21
+//# debugId=11276D484C35A4DF64756E2164756E21
 //# sourceMappingURL=testing.js.map