@xincli/opentui-core 0.4.6

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-configure.fixture.ts

@@ -0,0 +1,31 @@
+import { mkdtempSync, rmSync, writeFileSync } from "node:fs"
+import { tmpdir } from "node:os"
+import { join } from "node:path"
+import { plugin as registerPlugin } from "bun"
+import { ensureRuntimePluginSupport } from "../runtime-plugin-support-configure.js"
+
+const tempRoot = mkdtempSync(join(tmpdir(), "core-runtime-plugin-support-configure-fixture-"))
+const entryPath = join(tempRoot, "entry.ts")
+
+const source = [
+  'import { marker } from "runtime-plugin-support-extra"',
+  "console.log(`extra=${marker}`)",
+  "export const noop = 1",
+].join("\n")
+
+writeFileSync(entryPath, source)
+
+registerPlugin.clearAll()
+
+try {
+  const additional = {
+    "runtime-plugin-support-extra": { marker: "ok" },
+  }
+  const first = ensureRuntimePluginSupport({ additional })
+  const second = ensureRuntimePluginSupport({ additional })
+  console.log(`first=${first};second=${second}`)
+  await import(entryPath)
+} finally {
+  registerPlugin.clearAll()
+  rmSync(tempRoot, { recursive: true, force: true })
+}

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

@@ -0,0 +1,17 @@
+import { plugin as registerPlugin } from "bun"
+import { ensureRuntimePluginSupport } from "../runtime-plugin-support-configure.js"
+
+registerPlugin.clearAll()
+
+try {
+  await import("../runtime-plugin-support.js")
+  ensureRuntimePluginSupport({
+    additional: {
+      "runtime-plugin-support-extra": { marker: "ok" },
+    },
+  })
+} catch (error) {
+  console.log(error instanceof Error ? error.message : String(error))
+} finally {
+  registerPlugin.clearAll()
+}

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,54 @@
+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")
+  })
+
+  it("loads caller-provided runtime modules through the configurable entrypoint", () => {
+    const fixturePath = join(import.meta.dir, "runtime-plugin-support-configure.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("first=true")
+    expect(stdout).toContain("second=false")
+    expect(stdout).toContain("extra=ok")
+  })
+
+  it("throws when modules are added after side-effect installation", () => {
+    const fixturePath = join(import.meta.dir, "runtime-plugin-support-late-addition.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(
+      "OpenTUI Core runtime plugin support is already installed without runtime-plugin-support-extra",
+    )
+    expect(stdout).toContain("@opentui/core/runtime-plugin-support/configure")
+  })
+})

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 "@opentui/core"',
+  'import { createTestRenderer } from "@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 })
+}