jsmdcui 0.9.0 → 0.11.1

package/src/plugins/js-bridge.js

@@ -1622,6 +1622,11 @@ function _makeBufAPI(buffer) {
     get Type()     { return buffer.Type; },
     get Settings() { return buffer.Settings; },
     get Modified() { return buffer.modified; },
+    get MdcuiModuleSource() {
+      return global.MDCUI_MAIN && buffer._useBundledMdcuiModules
+        ? "embedded"
+        : "external";
+    },
 
     Line:      (n) => buffer.Line(n),
     LinesNum:  ()  => buffer.LinesNum(),

package/tests/cat-markdown.test.js

@@ -78,3 +78,62 @@ test("--edit overrides the .md mdcui default with utf8", async () => {
     await rm(dir, { recursive: true, force: true });
   }
 });
+
+test("--mdcui and --tui are equivalent to -encoding mdcui", async () => {
+  const dir = await mkdtemp(join(tmpdir(), "jsmdcui-cat-mdcui-"));
+  const markdownPath = join(dir, "sample.md");
+  await writeFile(markdownPath, "# Heading\n\n- one\n- two\n");
+
+  try {
+    const flag = Bun.spawnSync([bunBin, tui, "-cat", "--mdcui", markdownPath], {
+      cwd: dir,
+      stdout: "pipe",
+      stderr: "pipe",
+    });
+    const encoding = Bun.spawnSync([bunBin, tui, "-cat", "-encoding", "mdcui", markdownPath], {
+      cwd: dir,
+      stdout: "pipe",
+      stderr: "pipe",
+    });
+    const tuiFlag = Bun.spawnSync([bunBin, tui, "-cat", "--tui", markdownPath], {
+      cwd: dir,
+      stdout: "pipe",
+      stderr: "pipe",
+    });
+
+    expect(flag.exitCode).toBe(0);
+    expect(encoding.exitCode).toBe(0);
+    expect(tuiFlag.exitCode).toBe(0);
+    expect(flag.stdout.toString()).toBe(encoding.stdout.toString());
+    expect(tuiFlag.stdout.toString()).toBe(encoding.stdout.toString());
+  } finally {
+    await rm(dir, { recursive: true, force: true });
+  }
+});
+
+test("-filetype forces syntax highlighting independently of the filename", async () => {
+  const dir = await mkdtemp(join(tmpdir(), "jsmdcui-cat-filetype-"));
+  const textPath = join(dir, "sample.txt");
+  await writeFile(textPath, "const answer = 42;\n");
+
+  try {
+    const automatic = Bun.spawnSync([bunBin, tui, "-cat", textPath], {
+      cwd: dir,
+      stdout: "pipe",
+      stderr: "pipe",
+    });
+    const javascript = Bun.spawnSync([bunBin, tui, "-cat", "-filetype", "javascript", textPath], {
+      cwd: dir,
+      stdout: "pipe",
+      stderr: "pipe",
+    });
+
+    expect(automatic.exitCode).toBe(0);
+    expect(javascript.exitCode).toBe(0);
+    expect(automatic.stdout.toString()).not.toContain("\x1b[");
+    expect(javascript.stdout.toString()).toContain("\x1b[");
+    expect(Bun.stripANSI(javascript.stdout.toString()).trimEnd()).toBe("const answer = 42;");
+  } finally {
+    await rm(dir, { recursive: true, force: true });
+  }
+});

package/tests/compiled-runtime.test.js

@@ -1,8 +1,75 @@
 import { expect, test } from "bun:test";
-import { isCompiledBinary as isSingleExeCompiled } from "../single-exe/compiled.js";
+import {
+  isCompiledBinary as isSingleExeCompiled,
+  stringifyNonPrimitiveDefineValues,
+} from "../single-exe/compiled.js";
 
 test("single-exe recognizes Bun compiled virtual paths", () => {
   expect(isSingleExeCompiled(["bun", "/$bunfs/root/app.js"])).toBe(true);
   expect(isSingleExeCompiled(["bun", "B:/~BUN/root/app.js"])).toBe(true);
   expect(isSingleExeCompiled(["bun", "/project/src/index.js"])).toBe(false);
 });
+
+test("non-primitive MDCUI_MAIN define values become strings", () => {
+  const split = [
+    "bun",
+    "src/index.js",
+    "--build-exe",
+    "--define",
+    "global.MDCUI_MAIN=../中文=工具.md",
+  ];
+  expect(
+    stringifyNonPrimitiveDefineValues(split, "global.MDCUI_MAIN"),
+  ).toBe(split);
+  expect(split.at(-1)).toBe(
+    'global.MDCUI_MAIN="../中文=工具.md"',
+  );
+
+  const inline = [
+    "--define=global.MDCUI_MAIN=../m.md",
+    "--define",
+    "OTHER=../other.md",
+    "--define",
+    "global.MDCUI_MAIN_BASE=m.md",
+  ];
+  stringifyNonPrimitiveDefineValues(inline, "global.MDCUI_MAIN");
+  expect(inline).toEqual([
+    '--define=global.MDCUI_MAIN="../m.md"',
+    "--define",
+    "OTHER=../other.md",
+    "--define",
+    "global.MDCUI_MAIN_BASE=m.md",
+  ]);
+
+  for (const source of ["", "[]", "{}", "makePath()"]) {
+    const argv = ["--define", `global.MDCUI_MAIN=${source}`];
+    stringifyNonPrimitiveDefineValues(argv, "global.MDCUI_MAIN");
+    expect(argv[1]).toBe(
+      `global.MDCUI_MAIN=${JSON.stringify(source)}`,
+    );
+  }
+});
+
+test("primitive MDCUI_MAIN define values keep their type", () => {
+  const cases = new Map([
+    ['"../m.md"', '"../m.md"'],
+    ["'../m.md'", '"../m.md"'],
+    ["true", "true"],
+    ["false", "false"],
+    ["null", "null"],
+    ["undefined", "undefined"],
+    ["0", "0"],
+    ["-1.5", "-1.5"],
+    ["NaN", "NaN"],
+    ["Infinity", "Infinity"],
+    ["0xff", "0xff"],
+    ["0b10", "0b10"],
+    ["1_000", "1_000"],
+  ]);
+
+  for (const [source, normalized] of cases) {
+    const argv = ["--define", `global.MDCUI_MAIN=${source}`];
+    stringifyNonPrimitiveDefineValues(argv, "global.MDCUI_MAIN");
+    expect(argv[1]).toBe(`global.MDCUI_MAIN=${normalized}`);
+  }
+});

package/tests/demo.test.js

@@ -1,9 +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", () => {
@@ -14,8 +17,8 @@ test("--help describes the non-overwriting demo behavior", () => {
 
   expect(result.exitCode).toBe(0);
   const output = result.stdout.toString();
-  expect(output).toContain("use the existing ./testapp.md without overwriting it");
-  expect(output).toContain("If ./testapp.md is missing, write the bundled demo there first");
+  expect(output).toContain("Execute an existing ./testapp.md");
+  expect(output).toContain("Or write the bundled demo if missing");
   expect(output).toContain("--demo-<filename>");
   expect(output).toContain("demos/<filename>.md");
   expect(output.match(/Open it in the TUI and write 5 generated files beside it/g)?.length).toBe(2);
@@ -39,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");
@@ -97,6 +233,44 @@ test("--demo preserves an existing testapp.md", async () => {
   }
 });
 
+test("--overwrite-demo replaces an existing demo with the bundled copy", async () => {
+  const dir = await mkdtemp(join(tmpdir(), "jsmdcui-demo-overwrite-"));
+  const existing = "# Replace my demo\n";
+  try {
+    await writeFile(join(dir, "testapp.md"), existing);
+    const result = Bun.spawnSync(
+      [bunBin, tui, "--overwrite-demo", "--demo", "-cat", "-encoding", "utf8"],
+      {
+        cwd: dir,
+        stdout: "pipe",
+        stderr: "pipe",
+      },
+    );
+
+    expect(result.exitCode).toBe(0);
+    const written = await readFile(join(dir, "testapp.md"), "utf8");
+    expect(written).toContain("計算機");
+    expect(written).not.toBe(existing);
+    expect(Bun.stripANSI(result.stdout.toString())).toContain("計算機");
+  } finally {
+    await rm(dir, { recursive: true, force: true });
+  }
+});
+
+test("WUI demo loading can overwrite an existing testapp.md", async () => {
+  const dir = await mkdtemp(join(tmpdir(), "jsmdcui-wui-demo-overwrite-"));
+  const demoPath = join(dir, "testapp.md");
+  try {
+    await writeFile(demoPath, "# Replace my WUI demo\n");
+    const source = await readMarkdownInput(demoPath, true);
+
+    expect(source).toContain("計算機");
+    expect(await readFile(demoPath, "utf8")).toBe(source);
+  } finally {
+    await rm(dir, { recursive: true, force: true });
+  }
+});
+
 test("--demo-<filename> automatically loads a matching demos file", async () => {
   const dir = await mkdtemp(join(tmpdir(), "jsmdcui-demo-generic-"));
   try {

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