@fairyhunter13/opentui-core 0.1.112 → 0.1.114

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

@@ -0,0 +1,47 @@
+import { test, expect, describe } from "bun:test"
+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()
+  })
+})

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-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 })
+}

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

@@ -0,0 +1,85 @@
+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-scoped-package-bare-rewrite-fixture-"))
+const externalPluginDir = join(tempRoot, "external-plugin")
+const externalNodeModulesDir = join(externalPluginDir, "node_modules")
+const hostRuntimeDependencyDir = join(externalNodeModulesDir, "host-runtime-dependency")
+const scopedPackageDir = join(externalNodeModulesDir, "@runtime-plugin", "scoped-fixture")
+const externalPluginEntryPath = join(externalPluginDir, "index.ts")
+
+mkdirSync(hostRuntimeDependencyDir, { recursive: true })
+mkdirSync(scopedPackageDir, { recursive: true })
+
+writeFileSync(
+  join(hostRuntimeDependencyDir, "package.json"),
+  JSON.stringify({
+    name: "host-runtime-dependency",
+    private: true,
+    type: "module",
+    exports: "./index.js",
+  }),
+)
+
+writeFileSync(
+  join(hostRuntimeDependencyDir, "index.js"),
+  'export const marker = "resolved-from-scoped-package-parent"\n',
+)
+
+writeFileSync(
+  join(scopedPackageDir, "package.json"),
+  JSON.stringify({
+    name: "@runtime-plugin/scoped-fixture",
+    private: true,
+    type: "module",
+    exports: "./index.js",
+  }),
+)
+
+writeFileSync(
+  join(scopedPackageDir, "index.js"),
+  [
+    'import { marker as runtimeMarker } from "fixture-runtime"',
+    'import { helperMarker } from "./helper.js"',
+    "export const marker = `${runtimeMarker}:${helperMarker}`",
+  ].join("\n"),
+)
+
+writeFileSync(
+  join(scopedPackageDir, "helper.js"),
+  ['import { marker } from "host-runtime-dependency"', "export const helperMarker = marker"].join("\n"),
+)
+
+writeFileSync(
+  externalPluginEntryPath,
+  [
+    'import { marker as entryMarker } from "fixture-entry-runtime"',
+    'import { marker as scopedMarker } from "@runtime-plugin/scoped-fixture"',
+    "console.log(`entry=${entryMarker};scoped=${scopedMarker}`)",
+    "export const noop = 1",
+  ].join("\n"),
+)
+
+registerPlugin.clearAll()
+
+registerPlugin(
+  createRuntimePlugin({
+    additional: {
+      "fixture-entry-runtime": { marker: "entry-runtime-marker" },
+      "fixture-runtime": { marker: "scoped-runtime-marker" },
+    },
+    rewrite: {
+      nodeModulesBareSpecifiers: true,
+    },
+  }),
+)
+
+try {
+  await import(`${externalPluginEntryPath}?reload=1`)
+} finally {
+  registerPlugin.clearAll()
+  rmSync(tempRoot, { recursive: true, force: true })
+}

package/src/tests/runtime-plugin-path-alias.fixture.ts

@@ -0,0 +1,43 @@
+import { mkdtempSync, realpathSync, rmSync, symlinkSync, unlinkSync, writeFileSync } from "node:fs"
+import { tmpdir } from "node:os"
+import { dirname, join } from "node:path"
+import { plugin as registerPlugin } from "bun"
+import { createRuntimePlugin } from "../runtime-plugin.js"
+
+const realRoot = mkdtempSync(join(tmpdir(), "core-runtime-plugin-path-alias-fixture-"))
+const aliasRoot = join(dirname(realRoot), `core-runtime-plugin-path-alias-link-${Math.random().toString(36).slice(2)}`)
+const realEntryPath = join(realRoot, "external.ts")
+const aliasEntryPath = join(aliasRoot, "external.ts")
+
+writeFileSync(
+  realEntryPath,
+  ['import { marker } from "@opentui/core"', "export const externalMarker = marker"].join("\n"),
+)
+
+symlinkSync(realRoot, aliasRoot, process.platform === "win32" ? "junction" : "dir")
+
+registerPlugin.clearAll()
+
+registerPlugin(
+  createRuntimePlugin({
+    core: {
+      marker: "resolved-from-path-alias",
+    },
+  }),
+)
+
+try {
+  const aliasPathCanonicalized = aliasEntryPath !== realpathSync(aliasEntryPath)
+  const externalModule = (await import(aliasEntryPath)) as { externalMarker: string }
+  console.log(`aliasPathCanonicalized=${aliasPathCanonicalized};marker=${externalModule.externalMarker}`)
+} finally {
+  registerPlugin.clearAll()
+
+  try {
+    unlinkSync(aliasRoot)
+  } catch {
+    rmSync(aliasRoot, { recursive: true, force: true })
+  }
+
+  rmSync(realRoot, { recursive: true, force: true })
+}

package/src/tests/runtime-plugin-resolve-roots.fixture.ts

@@ -0,0 +1,65 @@
+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-resolve-roots-fixture-"))
+const hostModuleDir = join(tempRoot, "host")
+const externalPluginDir = join(tempRoot, "external-plugin")
+const externalNodeModules = join(externalPluginDir, "node_modules")
+const externalDependencyDir = join(externalNodeModules, "runtime-root-dependency")
+const hostModulePath = join(hostModuleDir, "host-runtime.ts")
+const externalPluginEntryPath = join(externalPluginDir, "index.ts")
+
+mkdirSync(hostModuleDir, { recursive: true })
+mkdirSync(externalDependencyDir, { recursive: true })
+
+writeFileSync(
+  join(externalPluginDir, "package.json"),
+  JSON.stringify({
+    name: "runtime-plugin-external-fixture",
+    private: true,
+    type: "module",
+  }),
+)
+
+writeFileSync(
+  join(externalDependencyDir, "package.json"),
+  JSON.stringify({
+    name: "runtime-root-dependency",
+    version: "1.0.0",
+    type: "module",
+    exports: "./index.js",
+  }),
+)
+
+writeFileSync(join(externalDependencyDir, "index.js"), 'export const marker = "resolved-from-external-root"\n')
+
+writeFileSync(
+  hostModulePath,
+  ['import { marker } from "runtime-root-dependency"', "export const hostRuntimeMarker = marker"].join("\n"),
+)
+
+writeFileSync(
+  externalPluginEntryPath,
+  ['import { hostRuntimeMarker } from "fixture-host-runtime"', "export const marker = hostRuntimeMarker"].join("\n"),
+)
+
+registerPlugin.clearAll()
+
+registerPlugin(
+  createRuntimePlugin({
+    additional: {
+      "fixture-host-runtime": async () => (await import(hostModulePath)) as Record<string, unknown>,
+    },
+  }),
+)
+
+try {
+  const externalPlugin = (await import(externalPluginEntryPath)) as { marker: string }
+  console.log(`marker=${externalPlugin.marker}`)
+} finally {
+  registerPlugin.clearAll()
+  rmSync(tempRoot, { recursive: true, force: true })
+}

package/src/tests/runtime-plugin-support.fixture.ts

@@ -0,0 +1,11 @@
+import { plugin as registerPlugin } from "bun"
+
+registerPlugin.clearAll()
+
+try {
+  const runtimePluginSupport = await import("../runtime-plugin-support.js")
+  const alreadyInstalled = runtimePluginSupport.ensureRuntimePluginSupport() === false
+  console.log(`idempotent=${alreadyInstalled}`)
+} finally {
+  registerPlugin.clearAll()
+}

package/src/tests/runtime-plugin-support.test.ts

@@ -0,0 +1,19 @@
+import { describe, expect, it } from "bun:test"
+import { join } from "node:path"
+
+describe("runtime plugin support", () => {
+  it("installs exactly once via drop-in module", () => {
+    const fixturePath = join(import.meta.dir, "runtime-plugin-support.fixture.ts")
+    const result = Bun.spawnSync([process.execPath, fixturePath], {
+      cwd: join(import.meta.dir, "..", ".."),
+      stdout: "pipe",
+      stderr: "pipe",
+      env: process.env,
+    })
+
+    const stdout = result.stdout.toString().trim()
+
+    expect(result.exitCode).toBe(0)
+    expect(stdout).toContain("idempotent=true")
+  })
+})

package/src/tests/runtime-plugin-windows-file-url.fixture.ts

@@ -0,0 +1,30 @@
+import { mkdtempSync, rmSync, writeFileSync } from "node:fs"
+import { tmpdir } from "node:os"
+import { join } from "node:path"
+import { pathToFileURL } from "node:url"
+import { plugin as registerPlugin } from "bun"
+import { createRuntimePlugin } from "../runtime-plugin.js"
+
+const tempRoot = mkdtempSync(join(tmpdir(), "core-runtime-plugin-windows-file-url-fixture-"))
+const entryPath = join(tempRoot, "entry.ts")
+
+writeFileSync(entryPath, ['import { marker } from "@opentui/core"', "export const externalMarker = marker"].join("\n"))
+
+registerPlugin.clearAll()
+
+registerPlugin(
+  createRuntimePlugin({
+    core: {
+      marker: "resolved-from-windows-file-url",
+    },
+  }),
+)
+
+try {
+  const entryUrl = pathToFileURL(entryPath).href
+  const externalModule = (await import(entryUrl)) as { externalMarker: string }
+  console.log(`marker=${externalModule.externalMarker}`)
+} finally {
+  registerPlugin.clearAll()
+  rmSync(tempRoot, { recursive: true, force: true })
+}

package/src/tests/runtime-plugin.fixture.ts

@@ -0,0 +1,40 @@
+import { 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-fixture-"))
+const entryPath = join(tempRoot, "entry.ts")
+
+const source = [
+  'import { marker as coreMarker } from "@fairyhunter13/opentui-core"',
+  'import { createTestRenderer } from "@fairyhunter13/opentui-core/testing"',
+  'import { value as syncValue } from "fixture-sync"',
+  'import { value as asyncValue } from "@fixture/async-module"',
+  "console.log(`core=${coreMarker};coreTesting=${typeof createTestRenderer === 'function'};sync=${syncValue};async=${asyncValue}`)",
+  "export const noop = 1",
+].join("\n")
+
+writeFileSync(entryPath, source)
+
+registerPlugin.clearAll()
+
+registerPlugin(
+  createRuntimePlugin({
+    core: {
+      marker: "core-value",
+    },
+    additional: {
+      "fixture-sync": { value: "sync-value" },
+      "@fixture/async-module": async () => ({ value: "async-value" }),
+    },
+  }),
+)
+
+try {
+  await import(`${entryPath}?reload=1`)
+} finally {
+  registerPlugin.clearAll()
+  rmSync(tempRoot, { recursive: true, force: true })
+}