jsmdcui 0.10.1 → 0.11.2

package/tests/demo.test.js

@@ -1,10 +1,12 @@
 import { expect, test } from "bun:test";
-import { mkdtemp, readFile, rm, writeFile } from "node:fs/promises";
+import { mkdir, mkdtemp, readFile, rm, writeFile } from "node:fs/promises";
 import { tmpdir } from "node:os";
 import { join } from "node:path";
 import { readMarkdownInput } from "../runmd.mjs";
 
 const tui = join(import.meta.dir, "..", "tui");
+const indexEntry = join(import.meta.dir, "..", "src", "index.js");
+const demosDirectory = join(import.meta.dir, "..", "demos");
 const bunBin = Bun.which("bun") || process.argv0;
 
 test("--help describes the non-overwriting demo behavior", () => {
@@ -40,6 +42,139 @@ test("--demo-list lists root and automatically discovered demos", () => {
   expect(output).toContain("--demo-imgtool     --demo-image-processor");
 });
 
+test("--version lists every MDCUI build define", () => {
+  const result = Bun.spawnSync([bunBin, tui, "--version"], {
+    stdout: "pipe",
+    stderr: "pipe",
+  });
+
+  expect(result.exitCode).toBe(0);
+  const output = result.stdout.toString();
+  expect(output).toContain("MDCUI_DEFAULT_EDIT:");
+  expect(output).toContain("MDCUI_DEFAULT_DEMO:");
+  expect(output).toContain("MDCUI_DEFAULT_DEMO_WUI:");
+  expect(output).toContain("MDCUI_OVERWRITE_DEMO:");
+  expect(output).toContain("global.MDCUI_MAIN:");
+  expect(output).toContain("global.MDCUI_MAIN_BASE:");
+
+  const presenceResult = Bun.spawnSync(
+    [
+      bunBin,
+      "--define",
+      "MDCUI_DEFAULT_DEMO_WUI=0",
+      indexEntry,
+      "--version",
+    ],
+    {
+      stdout: "pipe",
+      stderr: "pipe",
+    },
+  );
+  expect(presenceResult.exitCode).toBe(0);
+  expect(presenceResult.stdout.toString()).toContain(
+    "MDCUI_DEFAULT_DEMO_WUI: enabled",
+  );
+});
+
+test("--demo names allow Chinese but reject whitespace", () => {
+  const unicodeResult = Bun.spawnSync(
+    [bunBin, tui, "--demo-不存在的程式", "-cat", "-encoding", "utf8"],
+    {
+      stdout: "pipe",
+      stderr: "pipe",
+    },
+  );
+  expect(unicodeResult.exitCode).toBe(2);
+  expect(unicodeResult.stderr.toString()).toContain(
+    "Unknown demo --demo-不存在的程式",
+  );
+  expect(unicodeResult.stderr.toString()).not.toContain("Invalid demo option");
+
+  const whitespaceResult = Bun.spawnSync(
+    [bunBin, tui, "--demo-中文 程式", "-cat", "-encoding", "utf8"],
+    {
+      stdout: "pipe",
+      stderr: "pipe",
+    },
+  );
+  expect(whitespaceResult.exitCode).toBe(2);
+  expect(whitespaceResult.stderr.toString()).toContain("Invalid demo option");
+  expect(whitespaceResult.stderr.toString()).toContain(
+    "whitespace is not allowed",
+  );
+});
+
+test("Unicode MDCUI_MAIN overwrite starts the embedded WUI server", async () => {
+  const directory = await mkdtemp(join(tmpdir(), "jsmdcui-main-unicode-"));
+  const sourceDirectory = join(directory, "source");
+  const workDirectory = join(directory, "work");
+  const demoName = `中文工具-${crypto.randomUUID()}`;
+  const markdownName = `${demoName}.md`;
+  const sourcePath = join(sourceDirectory, markdownName);
+  const workPath = join(workDirectory, markdownName);
+  const bundledDemoPath = join(demosDirectory, markdownName);
+  const preloadPath = join(directory, "mock-serve.mjs");
+  const markdown = `# 中文工具
+
+\`\`\`js front
+export async function run() {
+  return await rpc.answer();
+}
+\`\`\`
+
+\`\`\`js back
+import { helper } from "./helper.js";
+export function answer() {
+  return helper();
+}
+\`\`\`
+`;
+
+  try {
+    await mkdir(sourceDirectory);
+    await mkdir(workDirectory);
+    await writeFile(sourcePath, markdown);
+    await writeFile(
+      join(sourceDirectory, "helper.js"),
+      'export function helper() { return "ok"; }\n',
+    );
+    await writeFile(workPath, "# stale file with a different byte length\n");
+    await writeFile(
+      preloadPath,
+      `Bun.serve = () => ({ port: 34567, stop() {} });\n`,
+    );
+
+    const result = Bun.spawnSync(
+      [
+        bunBin,
+        "--preload",
+        preloadPath,
+        "--define",
+        `global.MDCUI_MAIN=${JSON.stringify(sourcePath)}`,
+        indexEntry,
+        "--wui",
+        `--demo-${demoName}`,
+        "--overwrite-demo",
+      ],
+      {
+        cwd: workDirectory,
+        stdout: "pipe",
+        stderr: "pipe",
+      },
+    );
+
+    expect(result.exitCode).toBe(0);
+    expect(await readFile(workPath, "utf8")).toBe(markdown);
+    const stderr = Bun.stripANSI(result.stderr.toString());
+    expect(stderr).toContain("[mdcui] Starting embedded WUI server:");
+    expect(stderr).toContain(sourcePath);
+    expect(stderr).not.toContain("Cannot find module");
+  } finally {
+    await rm(bundledDemoPath, { force: true });
+    await rm(directory, { recursive: true, force: true });
+  }
+});
+
 test("--export-cdp-maze writes and overwrites the bundled solver", async () => {
   const dir = await mkdtemp(join(tmpdir(), "jsmdcui-export-cdp-maze-"));
   const outputPath = join(dir, "cdp-maze.js");

package/tests/js-plugin-prompts.test.js

@@ -44,3 +44,33 @@ test("micro prompt APIs delegate and return synchronously", () => {
     else globalThis.$ = previousSelector;
   }
 });
+
+test("current buffer exposes its actual MDCUI module source", () => {
+  const previousMicro = globalThis.micro;
+  const previousSelector = globalThis.$;
+  const previousMain = global.MDCUI_MAIN;
+  const buffer = {
+    path: "/tmp/app.md",
+    _useBundledMdcuiModules: true,
+  };
+  const app = { buffer };
+
+  try {
+    global.MDCUI_MAIN = "/build/app.md";
+    const micro = buildMicroGlobal({ _app: app, _ctx: null, on() {} });
+
+    expect(micro.CurPane().Buf.MdcuiModuleSource).toBe("embedded");
+    buffer._useBundledMdcuiModules = false;
+    expect(micro.CurPane().Buf.MdcuiModuleSource).toBe("external");
+    delete global.MDCUI_MAIN;
+    buffer._useBundledMdcuiModules = true;
+    expect(micro.CurPane().Buf.MdcuiModuleSource).toBe("external");
+  } finally {
+    if (previousMain === undefined) delete global.MDCUI_MAIN;
+    else global.MDCUI_MAIN = previousMain;
+    if (previousMicro === undefined) delete globalThis.micro;
+    else globalThis.micro = previousMicro;
+    if (previousSelector === undefined) delete globalThis.$;
+    else globalThis.$ = previousSelector;
+  }
+});

package/tests/wui-responsive-images.test.js

@@ -1,8 +1,8 @@
 import { afterEach, expect, test } from "bun:test";
-import { mkdtempSync, rmSync } from "node:fs";
+import { mkdtempSync, readFileSync, rmSync } from "node:fs";
 import { tmpdir } from "node:os";
 import { join } from "node:path";
-import { createWui } from "../runmd.mjs";
+import { createWui, extractJs } from "../runmd.mjs";
 
 const temporaryDirectories = [];
 
@@ -33,3 +33,22 @@ test("createWui injects the image rule into an existing document head", async ()
   expect(html.indexOf("max-width: 100%")).toBeLessThan(html.indexOf("</head>"));
   expect(html.match(/document\.md\.front\.js/g)).toHaveLength(1);
 });
+
+test("bundling mode creates a browser-only front entry", async () => {
+  const directory = mkdtempSync(join(tmpdir(), "jsmdcui-wui-bundling-"));
+  temporaryDirectories.push(directory);
+  const markdownPath = join(directory, "bundle.md");
+  const source = "```js front\nexport function pav() { return rpc }\n```";
+  const markdown = await extractJs(source, markdownPath, { bundling: true });
+  const html = await createWui(markdown, markdownPath, { bundling: true });
+  const frontSource = readFileSync(`${markdownPath}.tmpfs.js`, "utf8");
+  const installerSource = readFileSync(`${markdownPath}.tmpfi.js`, "utf8");
+
+  expect(frontSource).toContain("const rpc = wuiRpcClient");
+  expect(frontSource).not.toContain("globalThis.process");
+  expect(frontSource).not.toContain('import("./bundle.md.front.js")');
+  expect(installerSource).toContain('import * as frontMod from "./bundle.md.tmpfs.js"');
+  expect(installerSource).toContain("Object.assign(window, frontMod)");
+  expect(html).toContain('src="./bundle.md.tmpfi.js"');
+  expect(html).not.toContain("bundle.md.front.js");
+});

package/tests/wui.test.js

@@ -4,6 +4,9 @@ import { tmpdir } from "node:os";
 import { join } from "node:path";
 import { readMarkdownInput, writeRuntimeFiles } from "../runmd.mjs";
 
+const indexEntry = join(import.meta.dir, "..", "src", "index.js");
+const bunBin = Bun.which("bun") || process.argv0;
+
 test("WUI writes the bundled testapp.md when it is missing", async () => {
   const dir = await mkdtemp(join(tmpdir(), "jsmdcui-wui-"));
   const mdpath = join(dir, "testapp.md");
@@ -43,3 +46,31 @@ test("generated WUI server falls back to a system port when 3000 is occupied", a
     await rm(dir, { recursive: true, force: true });
   }
 });
+
+test("WUI reports an external server before starting it", async () => {
+  const dir = await mkdtemp(join(tmpdir(), "jsmdcui-wui-source-report-"));
+  const mdpath = join(dir, "external.md");
+  const preloadPath = join(dir, "mock-serve.mjs");
+  try {
+    await writeFile(mdpath, "# External WUI\n");
+    await writeFile(
+      preloadPath,
+      `Bun.serve = () => ({ port: 34567, stop() {} });\n`,
+    );
+    const result = Bun.spawnSync(
+      [bunBin, "--preload", preloadPath, indexEntry, "--wui", mdpath],
+      {
+        cwd: dir,
+        stdout: "pipe",
+        stderr: "pipe",
+      },
+    );
+
+    expect(result.exitCode).toBe(0);
+    const stderr = Bun.stripANSI(result.stderr.toString());
+    expect(stderr).toContain("[mdcui] Starting external WUI server:");
+    expect(stderr).toContain(`${mdpath}-server.js`);
+  } finally {
+    await rm(dir, { recursive: true, force: true });
+  }
+});