jsmdcui 0.3.0

package/src/shell/shell.js

@@ -0,0 +1,70 @@
+import { run } from "../platform/commands.js";
+
+export function shellSplit(input) {
+  const args = [];
+  let current = "";
+  let quote = null;
+  let escaped = false;
+  let started = false;
+
+  for (const ch of String(input)) {
+    if (escaped) {
+      if (ch === 'n') current += '\n';
+      else if (ch === 't') current += '\t';
+      else if (ch === 'r') current += '\r';
+      else current += ch;
+      escaped = false;
+      started = true;
+      continue;
+    }
+    if (ch === "\\" && quote !== "'") {
+      escaped = true;
+      started = true;
+      continue;
+    }
+    if (quote) {
+      if (ch === quote) { quote = null; }
+      else { current += ch; }
+      continue;
+    }
+    if (ch === "'" || ch === '"') {
+      quote = ch;
+      started = true;
+      continue;
+    }
+    if (/\s/.test(ch)) {
+      if (started) {
+        args.push(current);
+        current = "";
+        started = false;
+      }
+      continue;
+    }
+    current += ch;
+    started = true;
+  }
+
+  if (escaped) current += "\\";
+  if (quote) throw new Error(`Unclosed ${quote} quote`);
+  if (started) args.push(current);
+  return args;
+}
+
+export async function execCommand(name, args = []) {
+  const result = await run([name, ...args.map(String)], { allowFailure: true });
+  const output = result.stdout + result.stderr;
+  return [output, result.ok ? null : `${name} exited with ${result.code}`];
+}
+
+export async function runCommand(input) {
+  const args = shellSplit(input);
+  if (args.length === 0) return ["", "No arguments"];
+  return execCommand(args[0], args.slice(1));
+}
+
+export function runBackgroundShell(input) {
+  return async () => {
+    const [output, error] = await runCommand(input);
+    return error ? `${error}: ${output}` : output;
+  };
+}

package/testapp.md

@@ -0,0 +1,55 @@
+# jsmdcui
+# hello
+- world
+- 你好 世界 😅
+- Bun JavaScript
+- [example](https://example.com)
+- [Hello! Click Me](javascript:alert('world'))
+- [myfunc 請按我](javascript:myfunc())
+- [Print process.argv](javascript:pav())
+- [Calculator🧮計算機](javascript:calc())
+  * Use cos sin PI directly
+## Task list
+- [X] task1
+- [ ] task2
+
+```js front
+export async function myfunc()
+{
+  let yn=confirm('😃 Are you happy? 你開心嗎？')
+  alert(
+    yn ? 'Great 太棒了':
+         'Sorry to hear that. 很遺憾聽到你這麼說'
+  );
+}
+
+export async function pav()
+{
+  let r=await rpc.getArgv();
+  alert(r)
+}
+
+export async function calc()
+{
+  let s = prompt('Enter an expression 輸入運算式：')
+  const AsyncFunction = Object.getPrototypeOf(async function () {}).constructor;
+  const result = await new AsyncFunction('rpc',...Object.getOwnPropertyNames(Math),
+    `return await (${s});` 
+  )(rpc,...Object.getOwnPropertyNames(Math).map(i=>Math[i]))
+  alert(
+  
+    'Result 結果：'+
+    result
+    
+  );
+}
+```
+
+
+```js back
+
+export function getArgv()
+{
+  return process.argv ;
+}
+```

package/tests/backup.test.js

@@ -0,0 +1,133 @@
+import { afterEach, describe, expect, test } from "bun:test";
+import { mkdtemp, mkdir, readFile, rm, writeFile } from "node:fs/promises";
+import { existsSync } from "node:fs";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+import { createHash } from "node:crypto";
+import {
+  BACKUP_SUFFIX,
+  applyBackup,
+  determineBackupPath,
+  removeBackup,
+  writeBackup,
+} from "../src/buffer/backup.js";
+
+const cleanup = [];
+
+afterEach(async () => {
+  await Promise.all(cleanup.splice(0).map((path) => rm(path, { recursive: true, force: true })));
+});
+
+async function tempDir() {
+  const path = await mkdtemp(join(tmpdir(), "bunmicro-backup-"));
+  cleanup.push(path);
+  return path;
+}
+
+function buffer(path, text = "changed") {
+  return {
+    path,
+    AbsPath: path,
+    type: "default",
+    lines: text.split("\n"),
+    Settings: { backup: true, backupdir: "", permbackup: false },
+    _savedSerial: 0,
+    setModified(value) { this.modified = Boolean(value); },
+  };
+}
+
+describe("go-micro compatible backup paths", () => {
+  test("uses Go url.QueryEscape-compatible names", async () => {
+    const dir = await tempDir();
+    const result = determineBackupPath(dir, "/tmp/a b%~!'()*.txt");
+    expect(result).toEqual({
+      name: join(dir, "%2Ftmp%2Fa+b%25~%21%27%28%29%2A.txt"),
+      resolveName: null,
+    });
+  });
+
+  test("prefers an existing legacy name", async () => {
+    const dir = await tempDir();
+    const legacy = join(dir, "%tmp%legacy.txt");
+    await writeFile(legacy, "legacy");
+    expect(determineBackupPath(dir, "/tmp/legacy.txt").name).toBe(legacy);
+  });
+
+  test("uses Go's full MD5 hash and .path sidecar for long names", async () => {
+    const dir = await tempDir();
+    const path = "/" + "x".repeat(300);
+    const hash = createHash("md5").update(path).digest("hex");
+    expect(determineBackupPath(dir, path)).toEqual({
+      name: join(dir, hash),
+      resolveName: join(dir, hash + ".path"),
+    });
+  });
+});
+
+describe("backup lifecycle", () => {
+  test("writes atomically using the Go backup suffix", async () => {
+    const root = await tempDir();
+    const backupDir = join(root, "backups");
+    const buf = buffer("/tmp/file.txt", "one\ntwo");
+    buf.Settings.backupdir = backupDir;
+    const target = determineBackupPath(backupDir, buf.AbsPath);
+
+    expect(await writeBackup(buf, root)).toBe(true);
+    expect(await readFile(target.name, "utf8")).toBe("one\ntwo");
+    expect(existsSync(target.name + BACKUP_SUFFIX)).toBe(false);
+  });
+
+  test("recover keeps the backup and marks a distinct dirty baseline", async () => {
+    const root = await tempDir();
+    const backupDir = join(root, "backups");
+    await mkdir(backupDir);
+    const buf = buffer("/tmp/file.txt", "disk");
+    buf.Settings.backupdir = backupDir;
+    const target = determineBackupPath(backupDir, buf.AbsPath);
+    await writeFile(target.name, "recovered");
+
+    expect(await applyBackup(buf, root, async () => "recover")).toEqual({ recovered: true, abort: false });
+    expect(buf.lines).toEqual(["recovered"]);
+    expect(buf.modified).toBe(true);
+    expect(buf._savedSerial).toBe(-1);
+    expect(existsSync(target.name)).toBe(true);
+  });
+
+  test("ignore removes the backup", async () => {
+    const root = await tempDir();
+    const backupDir = join(root, "backups");
+    await mkdir(backupDir);
+    const buf = buffer("/tmp/file.txt");
+    buf.Settings.backupdir = backupDir;
+    const target = determineBackupPath(backupDir, buf.AbsPath);
+    await writeFile(target.name, "ignored");
+
+    expect(await applyBackup(buf, root, async () => "ignore")).toEqual({ recovered: false, abort: false });
+    expect(existsSync(target.name)).toBe(false);
+  });
+
+  test("permanent backups survive removal", async () => {
+    const root = await tempDir();
+    const backupDir = join(root, "backups");
+    const buf = buffer("/tmp/file.txt");
+    buf.Settings.backupdir = backupDir;
+    buf.Settings.permbackup = true;
+    await writeBackup(buf, root);
+    const target = determineBackupPath(backupDir, buf.AbsPath);
+
+    removeBackup(buf, root);
+    expect(existsSync(target.name)).toBe(true);
+  });
+
+  test("forced safe-write backups work when periodic backups are disabled", async () => {
+    const root = await tempDir();
+    const backupDir = join(root, "backups");
+    const buf = buffer("/tmp/file.txt");
+    buf.Settings.backupdir = backupDir;
+    buf.Settings.backup = false;
+
+    expect(await writeBackup(buf, root)).toBe(false);
+    expect(await writeBackup(buf, root, buf.AbsPath, { force: true })).toBe(true);
+    expect(existsSync(determineBackupPath(backupDir, buf.AbsPath).name)).toBe(true);
+  });
+});

package/tests/cmphex3b64.js

@@ -0,0 +1,95 @@
+import { randomBytes } from "node:crypto";
+import {
+  decodeBinaryStrict,
+  encodeBinary,
+} from "../src/buffer/fixed3-codec.js";
+
+const SIZES = [1024, 64 * 1024, 1024 * 1024];
+const ITERATIONS = {
+  1024: 20_000,
+  [64 * 1024]: 2_000,
+  [1024 * 1024]: 200,
+};
+
+function makeRandom(size) {
+  return randomBytes(size);
+}
+
+function makeAscii(size) {
+  const buf = Buffer.allocUnsafe(size);
+  for (let i = 0; i < size; i++) {
+    buf[i] = 0x20 + (i % 95);
+  }
+  return buf;
+}
+
+function mbps(bytes, ns) {
+  return (bytes / (1024 * 1024)) / (Number(ns) / 1e9);
+}
+
+function bench(name, fn, iters, payloadSize) {
+  const warmup = Math.min(200, Math.max(20, Math.floor(iters / 20)));
+  for (let i = 0; i < warmup; i++) fn();
+
+  const start = process.hrtime.bigint();
+  let sink = 0;
+  for (let i = 0; i < iters; i++) {
+    sink ^= fn();
+  }
+  const elapsed = process.hrtime.bigint() - start;
+
+  return {
+    name,
+    iters,
+    ms: Number(elapsed) / 1e6,
+    mbps: mbps(payloadSize * iters, elapsed),
+    sink,
+  };
+}
+
+function runCase(label, input) {
+  const fixedEncoded = encodeBinary(input);
+  const base64Encoded = input.toString("base64");
+
+  if (!decodeBinaryStrict(fixedEncoded).equals(input)) {
+    throw new Error(`hex3 roundtrip failed for ${label}`);
+  }
+  if (!Buffer.from(base64Encoded, "base64").equals(input)) {
+    throw new Error(`base64 roundtrip failed for ${label}`);
+  }
+
+  const iters = ITERATIONS[input.length] ?? Math.max(50, Math.floor(100 * 1024 * 1024 / input.length));
+
+  const results = [
+    bench(
+      "hex3 encode+decode",
+      () => {
+        const encoded = encodeBinary(input);
+        return decodeBinaryStrict(encoded).length;
+      },
+      iters,
+      input.length,
+    ),
+    bench(
+      "base64 encode+decode",
+      () => {
+        const encoded = input.toString("base64");
+        return Buffer.from(encoded, "base64").length;
+      },
+      iters,
+      input.length,
+    ),
+  ];
+
+  console.log(`\n${label} (${input.length.toLocaleString()} bytes, ${iters.toLocaleString()} iterations)`);
+  for (const r of results) {
+    console.log(
+      `${r.name.padEnd(22)} ${r.ms.toFixed(1).padStart(10)} ms  ${r.mbps.toFixed(1).padStart(8)} MiB/s  sink=${r.sink}`,
+    );
+  }
+}
+
+for (const size of SIZES) {
+  runCase("random", makeRandom(size));
+  runCase("ascii", makeAscii(size));
+}