@opentui/core 0.2.15 → 0.3.0

package/testing.js

@@ -2,13 +2,8 @@
 import {
   ANSI,
   CliRenderer,
-  TreeSitterClient,
-  calculateRenderGeometry,
-  resolveRenderLib
-} from "./index-3fq5hq97.js";
-
-// src/testing/test-renderer.ts
-import { Readable, Writable } from "stream";
+  TreeSitterClient
+} from "./index-081xws23.js";
 
 // src/testing/mock-keys.ts
 import { Buffer as Buffer2 } from "buffer";
@@ -455,14 +450,14 @@ function createMockMouse(renderer) {
   };
 }
 
-// src/testing/test-renderer.ts
-var decoder = new TextDecoder;
+// src/testing/test-streams.ts
+import { Readable, Writable } from "stream";
 
 class TestWriteStream extends Writable {
   isTTY = true;
   columns;
   rows;
-  constructor(columns, rows) {
+  constructor(columns = 80, rows = 24) {
     super();
     this.columns = columns;
     this.rows = rows;
@@ -474,6 +469,115 @@ class TestWriteStream extends Writable {
     return 24;
   }
 }
+function createTestStdin() {
+  return new Readable({ read() {} });
+}
+function createTestStdout(columns = 80, rows = 24) {
+  return new TestWriteStream(columns, rows);
+}
+
+// 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));
+    }
+  });
+}
 async function createTestRenderer(options) {
   const useKittyKeyboard = options.kittyKeyboard ? { events: true } : options.useKittyKeyboard;
   const renderer = await setupTestRenderer({
@@ -484,24 +588,108 @@ 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
   });
   const mockMouse = createMockMouse(renderer);
   const renderOnce = async () => {
+    const feed = renderer._feed;
+    if (feed?.isBackpressured()) {
+      await feed.idle();
+    }
     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();
@@ -519,31 +707,14 @@ async function createTestRenderer(options) {
   };
 }
 async function setupTestRenderer(config) {
-  const stdin = config.stdin || new Readable({ read() {} });
+  const stdin = config.stdin || createTestStdin();
   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 screenMode = config.screenMode ?? "alternate-screen";
-  const footerHeight = config.footerHeight ?? 12;
-  const geometry = calculateRenderGeometry(screenMode, width, height, footerHeight);
-  const ziglib = resolveRenderLib();
-  const rendererPtr = ziglib.createRenderer(geometry.renderWidth, geometry.renderHeight, {
-    testing: true,
-    remote: config.remote ?? false
+  const stdout = config.stdout || createTestStdout(width, height);
+  return new CliRenderer(stdin, stdout, width, height, {
+    ...config,
+    bufferedOutput: config.bufferedOutput ?? "memory"
   });
-  if (!rendererPtr) {
-    throw new Error("Failed to create test renderer");
-  }
-  if (config.useThread === undefined) {
-    config.useThread = true;
-  }
-  if (process.platform === "linux") {
-    config.useThread = false;
-  }
-  ziglib.setUseThread(rendererPtr, config.useThread);
-  const renderer = new CliRenderer(ziglib, rendererPtr, stdin, stdout, width, height, config);
-  process.off("SIGWINCH", renderer["sigwinchHandler"]);
-  return renderer;
 }
 // src/testing/mock-tree-sitter-client.ts
 class MockTreeSitterClient extends TreeSitterClient {
@@ -615,7 +786,8 @@ function createTerminalCapabilities(overrides = {}) {
     osc52: false,
     notifications: false,
     explicit_cursor_positioning: false,
-    in_tmux: false,
+    remote: false,
+    multiplexer: "none",
     ...overrides,
     terminal: {
       name: "",
@@ -644,6 +816,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;
@@ -651,10 +911,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 || {};
@@ -668,21 +932,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];
@@ -730,8 +987,9 @@ export {
   TestRecorder,
   MouseButtons,
   MockTreeSitterClient,
+  ManualClock,
   KeyCodes
 };
 
-//# debugId=E4ECC3F7B130440664756E2164756E21
+//# debugId=0BAC903EE185632E64756E2164756E21
 //# sourceMappingURL=testing.js.map