@xincli/opentui-core 0.4.6

package/src/tests/renderer.tracker.test.ts

@@ -0,0 +1,202 @@
+import { test, expect, beforeEach, afterEach } from "bun:test"
+import { createCliRenderer } from "../renderer.js"
+import { createTestStdin, createTestStdout } from "../testing/test-streams.js"
+
+let originalStdinPaused: boolean
+let pauseCalled = false
+let originalPause: typeof process.stdin.pause
+let destroyFns: Array<() => void> = []
+
+beforeEach(() => {
+  pauseCalled = false
+  originalStdinPaused = process.stdin.isPaused()
+  originalPause = process.stdin.pause.bind(process.stdin)
+  process.stdin.pause = () => {
+    pauseCalled = true
+    return originalPause()
+  }
+})
+
+afterEach(() => {
+  for (const destroy of destroyFns.splice(0)) {
+    destroy()
+  }
+
+  process.stdin.pause = originalPause
+  if (!originalStdinPaused) {
+    process.stdin.resume()
+  }
+})
+
+test("second renderer sharing process.stdin is rejected", async () => {
+  const first = await createCliRenderer({
+    stdin: process.stdin,
+    stdout: createTestStdout(),
+    bufferedOutput: "memory",
+  })
+  destroyFns.push(() => first.destroy())
+
+  await expect(
+    createCliRenderer({
+      stdin: process.stdin,
+      stdout: createTestStdout(),
+      bufferedOutput: "memory",
+    }),
+  ).rejects.toThrow("stdin is already used by another CliRenderer")
+})
+
+test("second renderer sharing stdout is rejected", async () => {
+  const stdout = createTestStdout()
+  const first = await createCliRenderer({
+    stdin: createTestStdin(),
+    stdout,
+    bufferedOutput: "memory",
+  })
+  destroyFns.push(() => first.destroy())
+
+  await expect(
+    createCliRenderer({
+      stdin: createTestStdin(),
+      stdout,
+      bufferedOutput: "memory",
+    }),
+  ).rejects.toThrow("stdout is already used by another CliRenderer")
+})
+
+test("destroy releases streams for reuse", async () => {
+  const stdin = createTestStdin()
+  const stdout = createTestStdout()
+  const first = await createCliRenderer({
+    stdin,
+    stdout,
+    bufferedOutput: "memory",
+  })
+
+  first.destroy()
+
+  const second = await createCliRenderer({
+    stdin,
+    stdout,
+    bufferedOutput: "memory",
+  })
+  destroyFns.push(() => second.destroy())
+
+  expect(second.stdin).toBe(stdin)
+})
+
+test("failed input setup releases streams for reuse", async () => {
+  const stdin = createTestStdin()
+  const stdout = createTestStdout()
+  let failRawMode = true
+
+  stdin.setRawMode = (enabled) => {
+    if (enabled && failRawMode) {
+      throw new Error("raw mode failed")
+    }
+    return stdin
+  }
+
+  await expect(
+    createCliRenderer({
+      stdin,
+      stdout,
+      bufferedOutput: "memory",
+    }),
+  ).rejects.toThrow("raw mode failed")
+
+  failRawMode = false
+
+  const renderer = await createCliRenderer({
+    stdin,
+    stdout,
+    bufferedOutput: "memory",
+  })
+  destroyFns.push(() => renderer.destroy())
+
+  expect(renderer.stdin).toBe(stdin)
+})
+
+test("renderers using separate stream objects can coexist", async () => {
+  const first = await createCliRenderer({
+    stdin: createTestStdin(),
+    stdout: createTestStdout(),
+    bufferedOutput: "memory",
+  })
+  destroyFns.push(() => first.destroy())
+
+  const second = await createCliRenderer({
+    stdin: createTestStdin(),
+    stdout: createTestStdout(),
+    bufferedOutput: "memory",
+  })
+  destroyFns.push(() => second.destroy())
+
+  expect(second.isDestroyed).toBe(false)
+})
+
+test("renderer using process.stdin pauses it on destroy", async () => {
+  const renderer = await createCliRenderer({
+    stdin: process.stdin,
+    stdout: createTestStdout(),
+    bufferedOutput: "memory",
+  })
+
+  pauseCalled = false
+  renderer.destroy()
+
+  expect(pauseCalled).toBe(true)
+})
+
+test("renderer with custom stdin does not pause process.stdin on destroy", async () => {
+  const renderer = await createCliRenderer({
+    stdin: createTestStdin(),
+    stdout: createTestStdout(),
+    bufferedOutput: "memory",
+  })
+
+  pauseCalled = false
+  renderer.destroy()
+
+  expect(pauseCalled).toBe(false)
+})
+
+test("destroying process stdin owner pauses it while a custom renderer remains", async () => {
+  const processRenderer = await createCliRenderer({
+    stdin: process.stdin,
+    stdout: createTestStdout(),
+    bufferedOutput: "memory",
+  })
+  destroyFns.push(() => processRenderer.destroy())
+  const customRenderer = await createCliRenderer({
+    stdin: createTestStdin(),
+    stdout: createTestStdout(),
+    bufferedOutput: "memory",
+  })
+  destroyFns.push(() => customRenderer.destroy())
+
+  pauseCalled = false
+  processRenderer.destroy()
+
+  expect(pauseCalled).toBe(true)
+})
+
+test("destroying final custom renderer does not pause process stdin again", async () => {
+  const processRenderer = await createCliRenderer({
+    stdin: process.stdin,
+    stdout: createTestStdout(),
+    bufferedOutput: "memory",
+  })
+  destroyFns.push(() => processRenderer.destroy())
+  const customRenderer = await createCliRenderer({
+    stdin: createTestStdin(),
+    stdout: createTestStdout(),
+    bufferedOutput: "memory",
+  })
+  destroyFns.push(() => customRenderer.destroy())
+
+  processRenderer.destroy()
+  pauseCalled = false
+  customRenderer.destroy()
+
+  expect(pauseCalled).toBe(false)
+})

package/src/tests/renderer.useMouse.test.ts

@@ -0,0 +1,83 @@
+import { test, expect, describe } from "bun:test"
+import { BoxRenderable } from "../renderables/Box.js"
+import { createTestRenderer } from "../testing/test-renderer.js"
+
+// NOTE: These tests are not running the mouse activation sequences,
+// only verifying that the configuration is applied correctly.
+// Tests avoid actually outputting to the terminal during test runs,
+// to not mess up the terminal state.
+// What actually gets written can be tested properly when
+// https://github.com/anomalyco/opentui/pull/238 is merged.
+describe("useMouse configuration", () => {
+  test("useMouse: true sets renderer.useMouse to true", async () => {
+    const { renderer } = await createTestRenderer({
+      useMouse: true,
+      exitOnCtrlC: false,
+    })
+
+    expect(renderer.useMouse).toBe(true)
+    renderer.destroy()
+  })
+
+  test("useMouse: false disables mouse tracking", async () => {
+    const { renderer } = await createTestRenderer({
+      useMouse: false,
+      exitOnCtrlC: false,
+    })
+
+    expect(renderer.useMouse).toBe(false)
+    renderer.destroy()
+  })
+
+  test("toggling useMouse property updates renderer state", async () => {
+    const { renderer } = await createTestRenderer({
+      useMouse: false,
+      exitOnCtrlC: false,
+    })
+
+    expect(renderer.useMouse).toBe(false)
+
+    renderer.useMouse = true
+    expect(renderer.useMouse).toBe(true)
+
+    renderer.useMouse = false
+    expect(renderer.useMouse).toBe(false)
+
+    renderer.destroy()
+  })
+
+  test("re-enabling useMouse rebuilds hit grid on the next scheduled frame", async () => {
+    const { renderer, flush } = await createTestRenderer({
+      width: 10,
+      height: 5,
+      useMouse: false,
+      exitOnCtrlC: false,
+    })
+
+    const box = new BoxRenderable(renderer, { id: "mouse-target", width: 3, height: 2 })
+    renderer.root.add(box)
+    await flush()
+
+    expect(renderer.hitTest(0, 0)).toBe(0)
+
+    renderer.useMouse = true
+    await flush()
+
+    expect(renderer.hitTest(0, 0)).toBe(box.num)
+    renderer.destroy()
+  })
+
+  test("destroy disables mouse tracking", async () => {
+    const { renderer } = await createTestRenderer({
+      useMouse: true,
+      exitOnCtrlC: false,
+      screenMode: "main-screen",
+    })
+
+    expect(renderer.useMouse).toBe(true)
+
+    renderer.destroy()
+
+    expect(renderer.useMouse).toBe(false)
+  })
+})

package/src/tests/runtime-plugin-node-modules-cycle.fixture.ts

@@ -0,0 +1,76 @@
+import { mkdirSync, mkdtempSync, rmSync, writeFileSync } from "node:fs"
+import { tmpdir } from "node:os"
+import { join } from "node:path"
+import { plugin as registerPlugin } from "bun"
+import { createRuntimePlugin } from "../runtime-plugin.js"
+
+const tempRoot = mkdtempSync(join(tmpdir(), "core-runtime-plugin-node-modules-cycle-fixture-"))
+const packageADir = join(tempRoot, "external", "node_modules", "runtime-plugin-cycle-a")
+const packageBDir = join(tempRoot, "external", "node_modules", "runtime-plugin-cycle-b")
+const packageAEntryPath = join(packageADir, "index.js")
+
+mkdirSync(packageADir, { recursive: true })
+mkdirSync(packageBDir, { recursive: true })
+
+writeFileSync(
+  join(packageADir, "package.json"),
+  JSON.stringify({
+    name: "runtime-plugin-cycle-a",
+    private: true,
+    type: "module",
+    exports: "./index.js",
+  }),
+)
+
+writeFileSync(
+  join(packageBDir, "package.json"),
+  JSON.stringify({
+    name: "runtime-plugin-cycle-b",
+    private: true,
+    type: "module",
+    exports: "./index.js",
+  }),
+)
+
+writeFileSync(
+  packageAEntryPath,
+  [
+    'import { marker } from "fixture-runtime"',
+    'import { getMarkerB } from "runtime-plugin-cycle-b"',
+    "export function getMarkerABase() {",
+    "  return `aBase=${marker}`",
+    "}",
+    "export function getMarkerA() {",
+    "  return `a=${marker};${getMarkerB()}`",
+    "}",
+  ].join("\n"),
+)
+
+writeFileSync(
+  join(packageBDir, "index.js"),
+  [
+    'import { marker } from "fixture-runtime"',
+    'import { getMarkerABase } from "runtime-plugin-cycle-a"',
+    "export function getMarkerB() {",
+    "  return `b=${marker};${getMarkerABase()}`",
+    "}",
+  ].join("\n"),
+)
+
+registerPlugin.clearAll()
+
+registerPlugin(
+  createRuntimePlugin({
+    additional: {
+      "fixture-runtime": { marker: "resolved-from-node-modules-cycle" },
+    },
+  }),
+)
+
+try {
+  const externalModule = (await import(`${packageAEntryPath}?reload=1`)) as { getMarkerA: () => string }
+  console.log(externalModule.getMarkerA())
+} finally {
+  registerPlugin.clearAll()
+  rmSync(tempRoot, { recursive: true, force: true })
+}

package/src/tests/runtime-plugin-node-modules-import-like-string.fixture.ts

@@ -0,0 +1,48 @@
+import { mkdirSync, mkdtempSync, rmSync, writeFileSync } from "node:fs"
+import { tmpdir } from "node:os"
+import { join } from "node:path"
+import { plugin as registerPlugin } from "bun"
+import { createRuntimePlugin } from "../runtime-plugin.js"
+
+const tempRoot = mkdtempSync(join(tmpdir(), "core-runtime-plugin-node-modules-import-like-string-fixture-"))
+const externalPackageDir = join(tempRoot, "external", "node_modules", "runtime-plugin-import-like-string-fixture")
+const externalPackageEntryPath = join(externalPackageDir, "index.js")
+
+mkdirSync(externalPackageDir, { recursive: true })
+
+writeFileSync(
+  join(externalPackageDir, "package.json"),
+  JSON.stringify({
+    name: "runtime-plugin-import-like-string-fixture",
+    private: true,
+    type: "module",
+    exports: "./index.js",
+  }),
+)
+
+writeFileSync(
+  externalPackageEntryPath,
+  [
+    'import { marker } from "fixture-runtime"',
+    'const fileContent = `import type { FiletypeParserOptions } from "./types.js"`',
+    'export const externalMarker = `${marker}:${fileContent.includes("./types.js")}`',
+  ].join("\n"),
+)
+
+registerPlugin.clearAll()
+
+registerPlugin(
+  createRuntimePlugin({
+    additional: {
+      "fixture-runtime": { marker: "resolved-with-import-like-string" },
+    },
+  }),
+)
+
+try {
+  const externalModule = (await import(externalPackageEntryPath)) as { externalMarker: string }
+  console.log(`marker=${externalModule.externalMarker}`)
+} finally {
+  registerPlugin.clearAll()
+  rmSync(tempRoot, { recursive: true, force: true })
+}

package/src/tests/runtime-plugin-node-modules-mjs.fixture.ts

@@ -0,0 +1,43 @@
+import { mkdirSync, mkdtempSync, rmSync, writeFileSync } from "node:fs"
+import { tmpdir } from "node:os"
+import { join } from "node:path"
+import { plugin as registerPlugin } from "bun"
+import { createRuntimePlugin } from "../runtime-plugin.js"
+
+const tempRoot = mkdtempSync(join(tmpdir(), "core-runtime-plugin-node-modules-mjs-fixture-"))
+const externalPackageDir = join(tempRoot, "external", "node_modules", "runtime-plugin-node-modules-mjs-fixture")
+const externalPackageEntryPath = join(externalPackageDir, "index.mjs")
+
+mkdirSync(externalPackageDir, { recursive: true })
+
+writeFileSync(
+  join(externalPackageDir, "package.json"),
+  JSON.stringify({
+    name: "runtime-plugin-node-modules-mjs-fixture",
+    private: true,
+    exports: "./index.mjs",
+  }),
+)
+
+writeFileSync(
+  externalPackageEntryPath,
+  ['import { marker } from "fixture-runtime"', "export const externalMarker = marker"].join("\n"),
+)
+
+registerPlugin.clearAll()
+
+registerPlugin(
+  createRuntimePlugin({
+    additional: {
+      "fixture-runtime": { marker: "resolved-from-node-modules-mjs" },
+    },
+  }),
+)
+
+try {
+  const externalModule = (await import(`${externalPackageEntryPath}?reload=1`)) as { externalMarker: string }
+  console.log(`marker=${externalModule.externalMarker}`)
+} finally {
+  registerPlugin.clearAll()
+  rmSync(tempRoot, { recursive: true, force: true })
+}

package/src/tests/runtime-plugin-node-modules-no-bare-rewrite.fixture.ts

@@ -0,0 +1,67 @@
+import { mkdirSync, mkdtempSync, rmSync, writeFileSync } from "node:fs"
+import { tmpdir } from "node:os"
+import { join } from "node:path"
+import { plugin as registerPlugin } from "bun"
+import { createRuntimePlugin } from "../runtime-plugin.js"
+
+const tempRoot = mkdtempSync(join(tmpdir(), "core-runtime-plugin-node-modules-no-bare-rewrite-fixture-"))
+const hostRuntimeDir = join(tempRoot, "host-runtime")
+const hostRuntimePath = join(hostRuntimeDir, "index.ts")
+const hostRuntimeDependencyDir = join(hostRuntimeDir, "node_modules", "node-modules-bare-dependency")
+const isolatedPackageDir = join(tempRoot, "isolated", "node_modules", "runtime-plugin-no-bare-fixture")
+const isolatedPackagePath = join(isolatedPackageDir, "index.js")
+
+mkdirSync(hostRuntimeDependencyDir, { recursive: true })
+mkdirSync(isolatedPackageDir, { recursive: true })
+
+writeFileSync(
+  join(hostRuntimeDependencyDir, "package.json"),
+  JSON.stringify({
+    name: "node-modules-bare-dependency",
+    private: true,
+    type: "module",
+    exports: "./index.js",
+  }),
+)
+
+writeFileSync(join(hostRuntimeDependencyDir, "index.js"), 'export const marker = "resolved-from-host-runtime-parent"\n')
+
+writeFileSync(
+  hostRuntimePath,
+  ['import { marker } from "@opentui/core"', "export const hostRuntimeMarker = marker"].join("\n"),
+)
+
+writeFileSync(
+  isolatedPackagePath,
+  [
+    'import { marker as coreMarker } from "@opentui/core"',
+    'import { marker as dependencyMarker } from "node-modules-bare-dependency"',
+    "export const marker = `${coreMarker}:${dependencyMarker}`",
+  ].join("\n"),
+)
+
+registerPlugin.clearAll()
+
+registerPlugin(
+  createRuntimePlugin({
+    core: {
+      marker: "core-runtime-marker",
+    },
+  }),
+)
+
+try {
+  await import(hostRuntimePath)
+
+  try {
+    await import(isolatedPackagePath)
+    console.log("errorContainsMissingBareDependency=false")
+  } catch (error) {
+    const message = error instanceof Error ? error.message : String(error)
+    const containsMissingBareDependency = message.includes("node-modules-bare-dependency")
+    console.log(`errorContainsMissingBareDependency=${containsMissingBareDependency}`)
+  }
+} finally {
+  registerPlugin.clearAll()
+  rmSync(tempRoot, { recursive: true, force: true })
+}

package/src/tests/runtime-plugin-node-modules-package-type-cache.fixture.ts

@@ -0,0 +1,72 @@
+import { mkdirSync, mkdtempSync, rmSync, writeFileSync } from "node:fs"
+import { tmpdir } from "node:os"
+import { join } from "node:path"
+import { plugin as registerPlugin } from "bun"
+import { createRuntimePlugin } from "../runtime-plugin.js"
+
+const tempRoot = mkdtempSync(join(tmpdir(), "core-runtime-plugin-node-modules-package-type-cache-fixture-"))
+const externalNodeModulesDir = join(tempRoot, "external", "node_modules")
+const childPackageDir = join(externalNodeModulesDir, "runtime-plugin-package-type-cache-child")
+const childPackageEntryPath = join(childPackageDir, "index.js")
+const parentPackageDir = join(externalNodeModulesDir, "runtime-plugin-package-type-cache-parent")
+const parentPackageEntryPath = join(parentPackageDir, "index.js")
+
+const writeChildPackage = (mode: "commonjs" | "module"): void => {
+  writeFileSync(
+    join(childPackageDir, "package.json"),
+    JSON.stringify({
+      name: "runtime-plugin-package-type-cache-child",
+      private: true,
+      ...(mode === "module" ? { type: "module", exports: "./index.js" } : { main: "./index.js" }),
+    }),
+  )
+
+  writeFileSync(
+    childPackageEntryPath,
+    mode === "module"
+      ? ['import { marker } from "fixture-runtime"', "export const childMarker = marker"].join("\n")
+      : 'module.exports.childMarker = "primed-as-commonjs"\n',
+  )
+}
+
+mkdirSync(childPackageDir, { recursive: true })
+mkdirSync(parentPackageDir, { recursive: true })
+
+writeChildPackage("commonjs")
+
+writeFileSync(
+  join(parentPackageDir, "package.json"),
+  JSON.stringify({
+    name: "runtime-plugin-package-type-cache-parent",
+    private: true,
+    type: "module",
+    exports: "./index.js",
+  }),
+)
+
+writeFileSync(parentPackageEntryPath, 'export { childMarker } from "runtime-plugin-package-type-cache-child"\n')
+
+registerPlugin.clearAll()
+
+registerPlugin(createRuntimePlugin())
+
+try {
+  await import(`${childPackageEntryPath}?phase=commonjs`)
+
+  registerPlugin.clearAll()
+  writeChildPackage("module")
+
+  registerPlugin(
+    createRuntimePlugin({
+      additional: {
+        "fixture-runtime": { marker: "resolved-after-package-type-change" },
+      },
+    }),
+  )
+
+  const parentModule = (await import(`${parentPackageEntryPath}?phase=module`)) as { childMarker: string }
+  console.log(`marker=${parentModule.childMarker}`)
+} finally {
+  registerPlugin.clearAll()
+  rmSync(tempRoot, { recursive: true, force: true })
+}

package/src/tests/runtime-plugin-node-modules-runtime-specifier.fixture.ts

@@ -0,0 +1,44 @@
+import { mkdirSync, mkdtempSync, rmSync, writeFileSync } from "node:fs"
+import { tmpdir } from "node:os"
+import { join } from "node:path"
+import { plugin as registerPlugin } from "bun"
+import { createRuntimePlugin } from "../runtime-plugin.js"
+
+const tempRoot = mkdtempSync(join(tmpdir(), "core-runtime-plugin-node-modules-runtime-specifier-fixture-"))
+const externalPackageDir = join(tempRoot, "external", "node_modules", "runtime-plugin-node-modules-fixture")
+const externalPackageEntryPath = join(externalPackageDir, "index.js")
+
+mkdirSync(externalPackageDir, { recursive: true })
+
+writeFileSync(
+  join(externalPackageDir, "package.json"),
+  JSON.stringify({
+    name: "runtime-plugin-node-modules-fixture",
+    private: true,
+    type: "module",
+    exports: "./index.js",
+  }),
+)
+
+writeFileSync(
+  externalPackageEntryPath,
+  ['import { marker } from "@opentui/core"', "export const externalMarker = marker"].join("\n"),
+)
+
+registerPlugin.clearAll()
+
+registerPlugin(
+  createRuntimePlugin({
+    core: {
+      marker: "resolved-from-node-modules-runtime-specifier",
+    },
+  }),
+)
+
+try {
+  const externalModule = (await import(externalPackageEntryPath)) as { externalMarker: string }
+  console.log(`marker=${externalModule.externalMarker}`)
+} finally {
+  registerPlugin.clearAll()
+  rmSync(tempRoot, { recursive: true, force: true })
+}