buninu-linux 0.2.0

package/initramfs/buninu/apps/jsmdcui/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));
+}

package/initramfs/buninu/apps/jsmdcui/tests/compiled-runtime.test.js

@@ -0,0 +1,139 @@
+import { expect, test } from "bun:test";
+import { expandBuildMdAliases } from "../src/build-args.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("--build-md-exe expands before the existing build flow", () => {
+  const argv = [
+    "bun",
+    "src/index.js",
+    "--build-md-exe",
+    "../中文工具.md",
+    "--sourcemap",
+  ];
+  expect(expandBuildMdAliases(argv)).toBe(true);
+  expect(argv).toEqual([
+    "bun",
+    "src/index.js",
+    "--build-exe",
+    "--define",
+    "global.MDCUI_MAIN=../中文工具.md",
+    "--sourcemap",
+  ]);
+  expect(expandBuildMdAliases(argv)).toBe(false);
+});
+
+test("--build-md-exe requires a Markdown path", () => {
+  expect(() => expandBuildMdAliases(["bun", "index.js", "--build-md-exe"]))
+    .toThrow("Missing Markdown path for --build-md-exe");
+  expect(() => expandBuildMdAliases([
+    "bun",
+    "index.js",
+    "--build-md-exe",
+    "--sourcemap",
+  ])).toThrow("Missing Markdown path for --build-md-exe");
+});
+
+test("--build-md-for expands before the existing cross-build flow", () => {
+  const argv = [
+    "bun",
+    "src/index.js",
+    "--build-md-for",
+    "bun-linux-x64",
+    "../中文工具.md",
+    "--sourcemap",
+  ];
+  expect(expandBuildMdAliases(argv)).toBe(true);
+  expect(argv).toEqual([
+    "bun",
+    "src/index.js",
+    "--build-for",
+    "bun-linux-x64",
+    "--define",
+    "global.MDCUI_MAIN=../中文工具.md",
+    "--sourcemap",
+  ]);
+});
+
+test("--build-md-for requires a platform and Markdown path", () => {
+  expect(() => expandBuildMdAliases(["bun", "index.js", "--build-md-for"]))
+    .toThrow("Missing platform for --build-md-for");
+  expect(() => expandBuildMdAliases([
+    "bun",
+    "index.js",
+    "--build-md-for",
+    "bun-linux-x64",
+  ])).toThrow("Missing Markdown path for --build-md-for");
+});
+
+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/initramfs/buninu/apps/jsmdcui/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 });
+});