jsmdcui 0.3.0 → 0.5.0

package/src/plugins/js-bridge.js

@@ -685,11 +685,178 @@ function _deleteSel(buf, pane) {
   buf.ensureCursor?.();
 }
 
+// ── mdcui block selector ────────────────────────────────────────────────────
+
+function _parseBlockIdentity(input, { selector = false } = {}) {
+  const text = String(input ?? "").trim();
+  const match = text.match(/^([A-Za-z_][\w:-]*)?(?:#([A-Za-z_][\w:-]*))?((?:\.[A-Za-z_][\w:-]*)*)$/);
+  if (!match || (!match[1] && !match[2] && !match[3])) return null;
+  if (!selector && !match[1]) return null;
+  return {
+    tag: match[1] || null,
+    id: match[2] || null,
+    classes: match[3] ? match[3].slice(1).split(".") : [],
+  };
+}
+
+function _blockHeader(line) {
+  const text = String(line ?? "");
+  const framed = text.match(/^(\s*)(┌─|╭─|\+-)\s*(\S+)\s*$/);
+  if (framed) {
+    const identity = _parseBlockIdentity(framed[3]);
+    return identity
+      ? { kind: "framed", indent: framed[1], bodyMarker: framed[2] === "+-" ? "|" : "│", ...identity }
+      : null;
+  }
+
+  const fenced = text.match(/^(\s*)(`{3,})\s*(\S+)\s*$/);
+  if (fenced) {
+    const identity = _parseBlockIdentity(fenced[3]);
+    return identity
+      ? { kind: "fenced", indent: fenced[1], fenceLength: fenced[2].length, ...identity }
+      : null;
+  }
+
+  return null;
+}
+
+function _matchesBlock(header, selector) {
+  if (selector.tag && header.tag !== selector.tag) return false;
+  if (selector.id && header.id !== selector.id) return false;
+  return selector.classes.every((name) => header.classes.includes(name));
+}
+
+function _findBlock(lines, selector) {
+  for (let start = 0; start < lines.length; start++) {
+    const header = _blockHeader(lines[start]);
+    if (!header || !_matchesBlock(header, selector)) continue;
+
+    for (let y = start + 1; y < lines.length; y++) {
+      const line = String(lines[y] ?? "");
+      const rest = line.startsWith(header.indent)
+        ? line.slice(header.indent.length)
+        : line;
+
+      if (header.kind === "fenced") {
+        const closing = rest.match(/^(`{3,})\s*$/);
+        if (closing && closing[1].length >= header.fenceLength)
+          return { start, end: y, header };
+        continue;
+      }
+
+      if (/^(?:└─|╰─|\+-)\s*$/.test(rest))
+        return { start, end: y, header };
+    }
+    return { start, end: lines.length, header };
+  }
+  return null;
+}
+
+function _blockValue(lines, selector) {
+  const block = _findBlock(lines, selector);
+  if (!block) return undefined;
+  const value = [];
+  for (let y = block.start + 1; y < block.end; y++) {
+    const line = String(lines[y] ?? "");
+    const rest = line.startsWith(block.header.indent)
+      ? line.slice(block.header.indent.length)
+      : line;
+    if (block.header.kind === "fenced") value.push(rest);
+    else {
+      const body = rest.match(/^(?:│|\|)(?: ?)(.*)$/);
+      value.push(body ? body[1] : rest);
+    }
+  }
+  return value.join("\n");
+}
+
+function _spliceBufferLines(buffer, start, deleteCount, replacement) {
+  const oldCursor = buffer.cursor ? { ...buffer.cursor } : null;
+  buffer.lines.splice(start, deleteCount, ...replacement);
+
+  if (Array.isArray(buffer._ansiStyleLines)) {
+    const template = buffer._ansiStyleLines[start] ?? null;
+    buffer._ansiStyleLines.splice(
+      start,
+      deleteCount,
+      ...replacement.map(() => template),
+    );
+  }
+
+  if (typeof buffer._mdcuiAnsiText === "string") {
+    const ansiLines = buffer._mdcuiAnsiText.split("\n");
+    ansiLines.splice(start, deleteCount, ...replacement);
+    buffer._mdcuiAnsiText = ansiLines.join("\n");
+  }
+
+  buffer.invalidateHighlightFrom?.(start, { force: replacement.length !== deleteCount });
+  if (oldCursor) {
+    const oldEnd = start + deleteCount;
+    if (oldCursor.y >= oldEnd) {
+      buffer.cursor.y = oldCursor.y + replacement.length - deleteCount;
+    } else if (oldCursor.y >= start) {
+      const relativeY = Math.min(oldCursor.y - start, Math.max(0, replacement.length - 1));
+      buffer.cursor.y = start + relativeY;
+    }
+  }
+  buffer.modified = true;
+  buffer.ensureCursor?.();
+}
+
+function _setBlockValue(buffer, selector, value) {
+  const lines = buffer.lines;
+  const block = _findBlock(lines, selector);
+  if (!block) return false;
+
+  const values = String(value ?? "").replace(/\r\n?/g, "\n").split("\n");
+  const contentStart = block.start + 1;
+  const capacity = Math.max(0, block.end - contentStart);
+
+  if (block.header.kind === "fenced") {
+    const replacement = values.map((line) => block.header.indent + line);
+    _spliceBufferLines(buffer, contentStart, capacity, replacement);
+    return true;
+  }
+
+  const rowPrefix = block.header.indent + block.header.bodyMarker + " ";
+  const replacement = values.map((line) => rowPrefix + line);
+  _spliceBufferLines(buffer, contentStart, capacity, replacement);
+  return true;
+}
+
+export function createTuiSelector(getBuffer) {
+  return function $(selector) {
+    const parsedSelector = _parseBlockIdentity(selector, { selector: true });
+    const selection = {
+      val(...args) {
+        try {
+          if (!parsedSelector) return args.length > 0 ? selection : "";
+          const buffer = getBuffer?.();
+          if (!buffer) return args.length > 0 ? selection : "";
+          const lines = Array.isArray(buffer.lines)
+            ? buffer.lines
+            : String(buffer).replace(/\r\n?/g, "\n").split("\n");
+          if (args.length > 0) {
+            if (Array.isArray(buffer.lines))
+              _setBlockValue(buffer, parsedSelector, args[0]);
+            return selection;
+          }
+          return _blockValue(lines, parsedSelector) ?? "";
+        } catch {
+          return args.length > 0 ? selection : "";
+        }
+      },
+    };
+    return selection;
+  };
+}
+
 // ── micro global object ───────────────────────────────────────────────────────
 
 export function buildMicroGlobal(jsManager) {
   const getApp = () => jsManager._app;
   const getCtx = () => jsManager._ctx;
+  const $ = createTuiSelector(() => getApp()?.buffer);
 
   // Converts cmd args to a safe command string for handleCommand
   function buildCmdString(name, args) {
@@ -921,6 +1088,7 @@ export function buildMicroGlobal(jsManager) {
   };
 
   globalThis.micro = micro;
+  globalThis.$ = $;
   return micro;
 }
 

package/testapp.md

@@ -9,6 +9,20 @@
 - [Print process.argv](javascript:pav())
 - [Calculator🧮計算機](javascript:calc())
   * Use cos sin PI directly
+- [Show ↓ text](javascript:alert($('text').val()))
+
+```text
+Text edit. TUI: Click ↙ to inc lines ↖ to dec
+可編輯文字框 TUI：按↙擴充行數 ↖減少行數
+```
+## Question 問題
+- What is 1+2+3+4+..+..+∞
+
+```text#ans
+-1/12
+```
+- [Submit 提交](javascript:checkAns())
+
 ## Task list
 - [X] task1
 - [ ] task2
@@ -43,6 +57,15 @@ export async function calc()
     
   );
 }
+
+export function checkAns()
+{
+  if($('#ans').val().trim()=='-1/12')
+    $('#ans').val('答對🥳Right!');
+  else
+    $('#ans').val('答錯😫Wrong!');
+}
+
 ```
 
 

package/tests/backup.test.js

@@ -130,4 +130,29 @@ describe("backup lifecycle", () => {
     expect(await writeBackup(buf, root, buf.AbsPath, { force: true })).toBe(true);
     expect(existsSync(determineBackupPath(backupDir, buf.AbsPath).name)).toBe(true);
   });
+
+  test("mdcui buffers never write, recover, or remove backups", async () => {
+    const root = await tempDir();
+    const backupDir = join(root, "backups");
+    await mkdir(backupDir);
+    const buf = buffer("/tmp/file.md", "rendered markdown");
+    buf.Settings.backupdir = backupDir;
+    buf.encoding = "mdcui";
+    buf.Settings.encoding = "mdcui";
+    const target = determineBackupPath(backupDir, buf.AbsPath);
+
+    expect(await writeBackup(buf, root)).toBe(false);
+    expect(await writeBackup(buf, root, buf.AbsPath, { force: true })).toBe(false);
+    expect(existsSync(target.name)).toBe(false);
+
+    await writeFile(target.name, "utf8 editor recovery");
+    let prompted = false;
+    expect(await applyBackup(buf, root, async () => { prompted = true; return "recover"; }))
+      .toEqual({ recovered: false, abort: false });
+    expect(prompted).toBe(false);
+    expect(buf.lines).toEqual(["rendered markdown"]);
+
+    removeBackup(buf, root);
+    expect(existsSync(target.name)).toBe(true);
+  });
 });

package/tests/cat-markdown.test.js

@@ -0,0 +1,79 @@
+import { expect, test } from "bun:test";
+import { mkdtemp, rm, writeFile } from "node:fs/promises";
+import { existsSync } from "node:fs";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+
+const tui = join(import.meta.dir, "..", "tui");
+
+test("cat renders .md files once with the implicit mdcui encoding", async () => {
+  const dir = await mkdtemp(join(tmpdir(), "jsmdcui-cat-"));
+  const markdownPath = join(dir, "sample.md");
+  await writeFile(markdownPath, "# Heading\n\n- one\n- two\n");
+
+  try {
+    const implicit = Bun.spawnSync([tui, "-cat", markdownPath], {
+      cwd: dir,
+      stdout: "pipe",
+      stderr: "pipe",
+    });
+    const explicit = Bun.spawnSync([tui, "-cat", "-encoding", "mdcui", markdownPath], {
+      cwd: dir,
+      stdout: "pipe",
+      stderr: "pipe",
+    });
+
+    expect(implicit.exitCode).toBe(0);
+    expect(explicit.exitCode).toBe(0);
+    expect(implicit.stdout.toString()).toBe(explicit.stdout.toString());
+  } finally {
+    await rm(dir, { recursive: true, force: true });
+  }
+});
+
+test("an explicit utf8 encoding overrides the .md mdcui default", async () => {
+  const dir = await mkdtemp(join(tmpdir(), "jsmdcui-cat-utf8-"));
+  const markdownPath = join(dir, "sample.md");
+  await writeFile(markdownPath, "# Heading\n\n```js front\nalert('kept')\n```\n");
+
+  try {
+    const result = Bun.spawnSync([tui, "-cat", "-encoding", "utf8", markdownPath], {
+      cwd: dir,
+      stdout: "pipe",
+      stderr: "pipe",
+    });
+
+    expect(result.exitCode).toBe(0);
+    expect(Bun.stripANSI(result.stdout.toString())).toContain("alert('kept')");
+    expect(existsSync(markdownPath + ".front.js")).toBe(false);
+    expect(existsSync(markdownPath + ".html")).toBe(false);
+  } finally {
+    await rm(dir, { recursive: true, force: true });
+  }
+});
+
+test("--edit overrides the .md mdcui default with utf8", async () => {
+  const dir = await mkdtemp(join(tmpdir(), "jsmdcui-cat-edit-"));
+  const markdownPath = join(dir, "sample.md");
+  await writeFile(markdownPath, "# Heading\n\n```js front\nalert('editable')\n```\n");
+
+  try {
+    const edit = Bun.spawnSync([tui, "-cat", "--edit", markdownPath], {
+      cwd: dir,
+      stdout: "pipe",
+      stderr: "pipe",
+    });
+    const utf8 = Bun.spawnSync([tui, "-cat", "-encoding", "utf8", markdownPath], {
+      cwd: dir,
+      stdout: "pipe",
+      stderr: "pipe",
+    });
+
+    expect(edit.exitCode).toBe(0);
+    expect(edit.stdout.toString()).toBe(utf8.stdout.toString());
+    expect(Bun.stripANSI(edit.stdout.toString())).toContain("alert('editable')");
+    expect(existsSync(markdownPath + ".front.js")).toBe(false);
+  } finally {
+    await rm(dir, { recursive: true, force: true });
+  }
+});

package/tests/config-settings.test.js

@@ -0,0 +1,52 @@
+import { afterEach, expect, test } from "bun:test";
+import { mkdtemp, readFile, rm, writeFile } from "node:fs/promises";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+import { Config } from "../src/config/config.js";
+
+const tempDirs = [];
+
+afterEach(async () => {
+  await Promise.all(tempDirs.splice(0).map((path) => rm(path, { recursive: true, force: true })));
+});
+
+async function loadConfig(settings) {
+  const configDir = await mkdtemp(join(tmpdir(), "jsmdcui-config-"));
+  tempDirs.push(configDir);
+  await writeFile(join(configDir, "settings.json"), JSON.stringify(settings), "utf8");
+  return await new Config({ configDir }).init();
+}
+
+test("Config.init discards top-level encoding from settings.json in memory", async () => {
+  const config = await loadConfig({
+    encoding: "big5",
+    ruler: false,
+    "ft:markdown": { encoding: "big5", tabsize: 2 },
+  });
+
+  expect(config.getGlobalOption("encoding")).toBe("utf-8");
+  expect(config.parsedSettings).not.toHaveProperty("encoding");
+  expect(config.parsedSettings["ft:markdown"].encoding).toBe("big5");
+});
+
+test("Config.saveSettings removes the top-level encoding discarded during init", async () => {
+  const config = await loadConfig({
+    encoding: "big5",
+    ruler: false,
+    "ft:markdown": { encoding: "big5", tabsize: 2 },
+  });
+
+  await config.saveSettings();
+  const saved = JSON.parse(await readFile(join(config.configDir, "settings.json"), "utf8"));
+  expect(saved).toEqual({ ruler: false, "ft:markdown": { encoding: "big5", tabsize: 2 } });
+});
+
+test("CLI encoding applies to the current invocation but saveSettings never persists it", async () => {
+  const config = await loadConfig({ ruler: false });
+  config.applyCliSettings(new Map([["encoding", "big5"]]));
+
+  expect(config.getGlobalOption("encoding")).toBe("big5");
+  await config.saveSettings();
+  const saved = JSON.parse(await readFile(join(config.configDir, "settings.json"), "utf8"));
+  expect(saved).toEqual({ ruler: false });
+});

package/tests/demo.test.js

@@ -0,0 +1,24 @@
+import { expect, test } from "bun:test";
+import { mkdtemp, readFile, rm } from "node:fs/promises";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+
+const tui = join(import.meta.dir, "..", "tui");
+
+test("--demo writes bundled testapp.md to cwd before opening it", async () => {
+  const dir = await mkdtemp(join(tmpdir(), "jsmdcui-demo-"));
+  try {
+    const result = Bun.spawnSync([tui, "--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("# jsmdcui");
+    expect(Bun.stripANSI(result.stdout.toString())).toContain("jsmdcui");
+  } finally {
+    await rm(dir, { recursive: true, force: true });
+  }
+});