buninu-linux 0.2.0

package/initramfs/buninu/apps/jsmdcui/src/buffer/buffer.js

@@ -0,0 +1,126 @@
+import { basename } from "node:path";
+import { Loc } from "./loc.js";
+
+export const BTDefault = { Kind: 0, Scratch: false, Readonly: false };
+export const BTHelp = { Kind: 1, Scratch: true, Readonly: true };
+export const BTLog = { Kind: 2, Scratch: true, Readonly: true };
+export const BTScratch = { Kind: 3, Scratch: true, Readonly: false };
+export const BTRaw = { Kind: 4, Scratch: true, Readonly: false };
+export const BTInfo = { Kind: 5, Scratch: true, Readonly: true };
+
+export class BufferCore {
+  constructor({ text = "", path = "", type = BTDefault, settings = {} } = {}) {
+    this.Path = path;
+    this.AbsPath = path;
+    this.Name = path ? basename(path) : "No name";
+    this.Type = type;
+    this.Settings = { filetype: "unknown", tabstospaces: false, tabsize: 4, ...settings };
+    this.lines = normalizeText(text).split("\n");
+    if (this.lines.length === 0) this.lines = [""];
+    this.Messages = [];
+    this.diffBase = "";
+    this.modified = false;
+  }
+
+  Line(n) {
+    return this.lines[n] ?? "";
+  }
+
+  LineBytes(n) {
+    return new TextEncoder().encode(this.Line(n));
+  }
+
+  LinesNum() {
+    return this.lines.length;
+  }
+
+  Size() {
+    return new TextEncoder().encode(this.Bytes()).byteLength;
+  }
+
+  Bytes() {
+    return this.lines.join("\n");
+  }
+
+  FileType() {
+    return this.Settings.filetype ?? "unknown";
+  }
+
+  SetOption(option, value) {
+    this.Settings[option] = parseOption(value);
+  }
+
+  DoSetOptionNative(option, value) {
+    this.Settings[option] = value;
+  }
+
+  Insert(loc, text) {
+    const pos = normalizeLoc(loc);
+    const line = this.Line(pos.Y);
+    const before = line.slice(0, pos.X);
+    const after = line.slice(pos.X);
+    const parts = normalizeText(text).split("\n");
+    if (parts.length === 1) {
+      this.lines[pos.Y] = before + parts[0] + after;
+    } else {
+      const replacement = [before + parts[0], ...parts.slice(1, -1), parts.at(-1) + after];
+      this.lines.splice(pos.Y, 1, ...replacement);
+    }
+    this.modified = true;
+  }
+
+  Replace(start, end, text) {
+    const s = normalizeLoc(start);
+    const e = normalizeLoc(end);
+    if (s.Y === e.Y) {
+      const line = this.Line(s.Y);
+      this.lines[s.Y] = line.slice(0, s.X) + text + line.slice(e.X);
+    } else {
+      const first = this.Line(s.Y).slice(0, s.X);
+      const last = this.Line(e.Y).slice(e.X);
+      const parts = normalizeText(text).split("\n");
+      const replacement = parts.length === 1 ? [first + parts[0] + last] : [first + parts[0], ...parts.slice(1, -1), parts.at(-1) + last];
+      this.lines.splice(s.Y, e.Y - s.Y + 1, ...replacement);
+    }
+    this.modified = true;
+  }
+
+  SetDiffBase(text) {
+    this.diffBase = String(text);
+  }
+
+  AddMessage(message) {
+    this.Messages.push(message);
+  }
+
+  ClearMessages(owner) {
+    this.Messages = this.Messages.filter((message) => message.Owner !== owner);
+  }
+
+  ClearAllMessages() {
+    this.Messages = [];
+  }
+}
+
+export function byteOffset(pos, buffer) {
+  const loc = normalizeLoc(pos);
+  let offset = 0;
+  for (let y = 0; y < loc.Y; y++) offset += buffer.Line(y).length + 1;
+  return offset + buffer.Line(loc.Y).slice(0, loc.X).length;
+}
+
+function normalizeLoc(value) {
+  if (value instanceof Loc) return value;
+  return new Loc(value?.X ?? value?.x ?? 0, value?.Y ?? value?.y ?? 0);
+}
+
+function normalizeText(text) {
+  return String(text).replace(/\r\n/g, "\n").replace(/\r/g, "\n");
+}
+
+function parseOption(value) {
+  if (value === "on" || value === "true") return true;
+  if (value === "off" || value === "false") return false;
+  if (/^-?\d+(\.\d+)?$/.test(String(value))) return Number(value);
+  return value;
+}

package/initramfs/buninu/apps/jsmdcui/src/buffer/fixed3-codec.js

@@ -0,0 +1,140 @@
+const HEX = Array.from({ length: 256 }, (_, i) =>
+  i.toString(16).padStart(2, "0"),
+);
+const ENCODE_TABLE = new Uint8Array(256 * 3);
+const DECODE_HEX = new Int16Array(128);
+
+DECODE_HEX.fill(-1);
+
+for (let i = 0; i < 10; i++) {
+  DECODE_HEX[0x30 + i] = i;
+}
+for (let i = 0; i < 6; i++) {
+  DECODE_HEX[0x41 + i] = 10 + i;
+  DECODE_HEX[0x61 + i] = 10 + i;
+}
+
+for (let byte = 0; byte < 256; byte++) {
+  const offset = byte * 3;
+
+  if (byte >= 0x20 && byte <= 0x7e) {
+    ENCODE_TABLE[offset] = byte;
+    ENCODE_TABLE[offset + 1] = 0x2e;
+    ENCODE_TABLE[offset + 2] = 0x2e;
+  } else {
+    ENCODE_TABLE[offset] = 0x5c;
+    ENCODE_TABLE[offset + 1] = HEX[byte].charCodeAt(0);
+    ENCODE_TABLE[offset + 2] = HEX[byte].charCodeAt(1);
+  }
+}
+
+export class Fixed3DecodeError extends SyntaxError {
+  constructor(message, position) {
+    super(`${message} at text offset ${position}`);
+    this.name = "Fixed3DecodeError";
+    this.position = position;
+    this.byteOffset = Math.floor(position / 3);
+  }
+}
+
+export function encodeBinary(input) {
+  return encodeBinaryToBuffer(input).toString("latin1");
+}
+
+export function encodeBinaryToBuffer(input) {
+  const bytes = input instanceof Uint8Array ? input : Buffer.from(input);
+  const out = Buffer.allocUnsafe(bytes.byteLength * 3);
+  let j = 0;
+
+  for (let i = 0; i < bytes.byteLength; i++) {
+    const offset = bytes[i] * 3;
+    out[j++] = ENCODE_TABLE[offset];
+    out[j++] = ENCODE_TABLE[offset + 1];
+    out[j++] = ENCODE_TABLE[offset + 2];
+  }
+
+  return out;
+}
+
+export function decodeBinary(text) {
+  if (typeof text !== "string") {
+    throw new TypeError("decodeBinary() expects a string");
+  }
+
+  return decodeBinaryBytes(Buffer.from(text, "latin1"));
+}
+
+export function decodeBinaryBytes(input) {
+  const bytes = input instanceof Uint8Array ? input : Buffer.from(input);
+  const out = Buffer.allocUnsafe(Math.floor(bytes.byteLength / 3));
+  let j = 0;
+
+  for (let i = 0; i < bytes.byteLength; i += 3) {
+    const a = bytes[i];
+    const b = bytes[i + 1];
+    const c = bytes[i + 2];
+
+    if (b === 0x2e && c === 0x2e) {
+      out[j++] = a;
+    } else {
+      out[j++] = (DECODE_HEX[b] << 4) | DECODE_HEX[c];
+    }
+  }
+
+  return out;
+}
+
+export function decodeBinaryStrict(text) {
+  if (typeof text !== "string") {
+    throw new TypeError("decodeBinary() expects a string");
+  }
+
+  if (text.length % 3 !== 0) {
+    throw new Fixed3DecodeError("input length is not a multiple of 3", text.length);
+  }
+
+  const out = Buffer.allocUnsafe(text.length / 3);
+  let j = 0;
+
+  for (let i = 0; i < text.length; i += 3) {
+    const a = text.charCodeAt(i);
+    const b = text.charCodeAt(i + 1);
+    const c = text.charCodeAt(i + 2);
+
+    if (b === 0x2e && c === 0x2e) {
+      if (a < 0x20 || a > 0x7e) {
+        throw new Fixed3DecodeError("printable cell has non-printable byte", i);
+      }
+      out[j++] = a;
+      continue;
+    }
+
+    if (a !== 0x5c) {
+      throw new Fixed3DecodeError("escaped cell must start with backslash", i);
+    }
+
+    const hi = b < 128 ? DECODE_HEX[b] : -1;
+    const lo = c < 128 ? DECODE_HEX[c] : -1;
+    if (hi < 0 || lo < 0) {
+      throw new Fixed3DecodeError("escaped cell must contain two hex digits", i);
+    }
+
+    const byte = (hi << 4) | lo;
+    if (byte >= 0x20 && byte <= 0x7e) {
+      throw new Fixed3DecodeError("printable byte must use c.. form", i);
+    }
+
+    out[j++] = byte;
+  }
+
+  return out;
+}
+
+export default {
+  encodeBinary,
+  encodeBinaryToBuffer,
+  decodeBinary,
+  decodeBinaryBytes,
+  decodeBinaryStrict,
+  Fixed3DecodeError,
+};

package/initramfs/buninu/apps/jsmdcui/src/buffer/loc.js

@@ -0,0 +1,38 @@
+export class Loc {
+  constructor(x = 0, y = 0) {
+    this.X = x;
+    this.Y = y;
+    this.x = x;
+    this.y = y;
+  }
+
+  lessThan(other) {
+    return this.Y < other.Y || (this.Y === other.Y && this.X < other.X);
+  }
+
+  greaterThan(other) {
+    return this.Y > other.Y || (this.Y === other.Y && this.X > other.X);
+  }
+
+  greaterEqual(other) {
+    return this.greaterThan(other) || (this.X === other.X && this.Y === other.Y);
+  }
+
+  lessEqual(other) {
+    return this.lessThan(other) || (this.X === other.X && this.Y === other.Y);
+  }
+
+  clamp(start, end) {
+    if (this.greaterEqual(end)) return end;
+    if (this.lessThan(start)) return start;
+    return this;
+  }
+
+  toJSON() {
+    return { X: this.X, Y: this.Y };
+  }
+}
+
+export function loc(x = 0, y = 0) {
+  return new Loc(x, y);
+}

package/initramfs/buninu/apps/jsmdcui/src/buffer/message.js

@@ -0,0 +1,29 @@
+import { Loc } from "./loc.js";
+
+export const MTInfo = 0;
+export const MTWarning = 1;
+export const MTError = 2;
+
+export class BufferMessage {
+  constructor(owner, msg, start, end, kind) {
+    this.Owner = owner;
+    this.Msg = msg;
+    this.Start = start;
+    this.End = end;
+    this.Kind = kind;
+  }
+}
+
+export function newMessage(owner, msg, start, end, kind) {
+  return new BufferMessage(owner, msg, normalizeLoc(start), normalizeLoc(end), kind);
+}
+
+export function newMessageAtLine(owner, msg, line, kind) {
+  const pos = new Loc(-1, Number(line) - 1);
+  return newMessage(owner, msg, pos, pos, kind);
+}
+
+function normalizeLoc(value) {
+  if (value instanceof Loc) return value;
+  return new Loc(value?.X ?? value?.x ?? 0, value?.Y ?? value?.y ?? 0);
+}

package/initramfs/buninu/apps/jsmdcui/src/build-args.js

@@ -0,0 +1,40 @@
+export function expandBuildMdAliases(argv = process.argv) {
+  const buildMdExeIndex = argv.indexOf("--build-md-exe");
+  if (buildMdExeIndex !== -1) {
+    const markdown = argv[buildMdExeIndex + 1];
+    if (!markdown || markdown.startsWith("-")) {
+      throw new Error("Missing Markdown path for --build-md-exe");
+    }
+
+    argv.splice(
+      buildMdExeIndex,
+      2,
+      "--build-exe",
+      "--define",
+      `global.MDCUI_MAIN=${markdown}`,
+    );
+    return true;
+  }
+
+  const buildMdForIndex = argv.indexOf("--build-md-for");
+  if (buildMdForIndex === -1) return false;
+
+  const platform = argv[buildMdForIndex + 1];
+  if (!platform || platform.startsWith("-")) {
+    throw new Error("Missing platform for --build-md-for");
+  }
+  const markdown = argv[buildMdForIndex + 2];
+  if (!markdown || markdown.startsWith("-")) {
+    throw new Error("Missing Markdown path for --build-md-for");
+  }
+
+  argv.splice(
+    buildMdForIndex,
+    3,
+    "--build-for",
+    platform,
+    "--define",
+    `global.MDCUI_MAIN=${markdown}`,
+  );
+  return true;
+}

package/initramfs/buninu/apps/jsmdcui/src/config/clean.js

@@ -0,0 +1,172 @@
+import { existsSync, readdirSync, readFileSync, statSync } from "node:fs";
+import { rm } from "node:fs/promises";
+import { join } from "node:path";
+import { createInterface } from "node:readline/promises";
+import { defaultAllSettings, LOCAL_SETTINGS } from "./defaults.js";
+
+function settingsEqual(a, b) {
+  return JSON.stringify(a) === JSON.stringify(b);
+}
+
+async function createCleanPrompt() {
+  if (process.stdin.isTTY) {
+    const rl = createInterface({ input: process.stdin, output: process.stdout });
+    return {
+      ask: async () => {
+        const text = (await rl.question("Continue [Y/n]: ")).trim();
+        return text.length === 0 || text.toLowerCase().startsWith("y");
+      },
+      close: () => rl.close(),
+    };
+  }
+
+  const answers = (await Bun.stdin.text()).split(/\r?\n/);
+  let index = 0;
+  return {
+    ask: async () => {
+      process.stdout.write("Continue [Y/n]: ");
+      const text = (answers[index++] ?? "").trim();
+      return text.length === 0 || text.toLowerCase().startsWith("y");
+    },
+    close: () => {},
+  };
+}
+
+function cleanDefaultSettings(config) {
+  const defaults = defaultAllSettings();
+  const cleaned = { ...config.parsedSettings };
+  for (const [key, value] of Object.entries(cleaned)) {
+    if (LOCAL_SETTINGS.has(key)) {
+      delete cleaned[key];
+      continue;
+    }
+    if (key in defaults && settingsEqual(config.globalSettings[key], defaults[key]) && settingsEqual(value, defaults[key])) {
+      delete cleaned[key];
+    }
+  }
+  return cleaned;
+}
+
+function findUnusedOptions(settings, pluginNames) {
+  const defaults = defaultAllSettings();
+  const unused = [];
+  for (const key of Object.keys(settings)) {
+    if (key.startsWith("ft:") || key.startsWith("glob:")) continue;
+    if (key in defaults) continue;
+    let valid = false;
+    for (const name of pluginNames) {
+      if (key === name || key.startsWith(`${name}.`)) {
+        valid = true;
+        break;
+      }
+    }
+    if (!valid) unused.push(key);
+  }
+  return unused.sort();
+}
+
+async function writeCleanSettings(config, settings) {
+  const settingsFile = join(config.configDir, "settings.json");
+  await Bun.write(settingsFile, JSON.stringify(settings, null, "    ") + "\n");
+}
+
+function invalidBunBufferStateFile(path, name) {
+  if (name !== "history.json" && name !== "cursor_state.json") return false;
+  try {
+    const parsed = JSON.parse(readFileSync(path, "utf8"));
+    return !parsed || typeof parsed !== "object" || Array.isArray(parsed);
+  } catch {
+    return true;
+  }
+}
+
+export async function cleanConfig(config, plugins) {
+  const prompt = await createCleanPrompt();
+  try {
+    console.log("Cleaning your configuration directory at", config.configDir);
+    console.log(`Please consider backing up ${config.configDir} before continuing`);
+
+    if (!(await prompt.ask())) {
+      console.log("Stopping early");
+      return;
+    }
+
+    console.log("Cleaning default settings");
+    let cleanedSettings = cleanDefaultSettings(config);
+    try {
+      await writeCleanSettings(config, cleanedSettings);
+    } catch (err) {
+      console.log(`Error writing settings.json file: ${err.message}`);
+    }
+
+    const pluginNames = new Set(plugins.list().map((plugin) => plugin.name));
+    const unusedOptions = findUnusedOptions(cleanedSettings, pluginNames);
+    if (unusedOptions.length > 0) {
+      const settingsFile = join(config.configDir, "settings.json");
+      console.log("The following options are unused:");
+      for (const option of unusedOptions) console.log(`${option} (value: ${JSON.stringify(cleanedSettings[option])})`);
+      console.log(`These options will be removed from ${settingsFile}`);
+
+      if (await prompt.ask()) {
+        for (const option of unusedOptions) delete cleanedSettings[option];
+        try {
+          await writeCleanSettings(config, cleanedSettings);
+          console.log("Removed unused options");
+          console.log("\n");
+        } catch (err) {
+          console.log(`Error overwriting settings.json file: ${err.message}`);
+        }
+      }
+    }
+
+    const buffersPath = join(config.configDir, "buffers");
+    if (existsSync(buffersPath)) {
+      const badFiles = [];
+      for (const entry of readdirSync(buffersPath, { withFileTypes: true })) {
+        if (!entry.isFile()) continue;
+        const path = join(buffersPath, entry.name);
+        if (invalidBunBufferStateFile(path, entry.name)) badFiles.push(path);
+      }
+      if (badFiles.length > 0) {
+        console.log(`Detected ${badFiles.length} files with an invalid format in ${buffersPath}`);
+        console.log("These files store cursor and undo history.");
+        console.log(`Removing badly formatted files in ${buffersPath}`);
+
+        if (await prompt.ask()) {
+          let removed = 0;
+          for (const file of badFiles) {
+            try {
+              await rm(file);
+              removed++;
+            } catch (err) {
+              console.log(err.message);
+            }
+          }
+          if (removed === 0) console.log("Failed to remove files");
+          else console.log(`Removed ${removed} badly formatted files`);
+          console.log("\n");
+        }
+      }
+    }
+
+    const oldPluginsDir = join(config.configDir, "plugins");
+    if (existsSync(oldPluginsDir) && statSync(oldPluginsDir).isDirectory()) {
+      console.log(`Found directory ${oldPluginsDir}`);
+      console.log(`Plugins should now be stored in ${join(config.configDir, "plug")}`);
+      console.log(`Removing ${oldPluginsDir}`);
+
+      if (await prompt.ask()) {
+        try {
+          await rm(oldPluginsDir, { recursive: true, force: true });
+        } catch (err) {
+          console.log(err.message);
+        }
+      }
+      console.log("\n");
+    }
+
+    console.log("Done cleaning");
+  } finally {
+    prompt.close();
+  }
+}

package/initramfs/buninu/apps/jsmdcui/src/config/colorscheme.js

@@ -0,0 +1,99 @@
+export const DEFAULT_STYLE = {
+  fg: "default",
+  bg: "default",
+  bold: false,
+  italic: false,
+  reverse: false,
+  underline: false,
+};
+
+const COLOR_LINK = /color-link\s+(\S*)\s+"(.*)"/;
+const INCLUDE = /include\s+"(.*)"/;
+
+export class Colorscheme {
+  constructor(runtime) {
+    this.runtime = runtime;
+    this.styles = new Map();
+    this.defaultStyle = { ...DEFAULT_STYLE };
+  }
+
+  async load(name = "default", parsed = new Set()) {
+    const file = this.runtime.find(0, name);
+    if (!file) throw new Error(`${name} is not a valid colorscheme`);
+    parsed.add(name);
+    const parsedStyles = await this.parse(name, await file.text(), parsed);
+    this.styles = parsedStyles;
+    return this;
+  }
+
+  async parse(name, text, parsed = new Set()) {
+    const styles = new Map();
+    for (const rawLine of String(text).split("\n")) {
+      const line = rawLine.trim();
+      if (!line || line.startsWith("#")) continue;
+
+      const include = line.match(INCLUDE);
+      if (include) {
+        const includeName = include[1];
+        if (!parsed.has(includeName)) {
+          const file = this.runtime.find(0, includeName);
+          if (!file) throw new Error(`${includeName} is not a valid colorscheme`);
+          parsed.add(includeName);
+          const includedStyles = await this.parse(includeName, await file.text(), parsed);
+          for (const [key, value] of includedStyles) styles.set(key, value);
+        }
+        continue;
+      }
+
+      const match = line.match(COLOR_LINK);
+      if (!match) throw new Error(`Color-link statement is not valid: ${rawLine}`);
+      const style = stringToStyle(match[2], this.defaultStyle);
+      styles.set(match[1], style);
+      if (match[1] === "default") this.defaultStyle = style;
+    }
+    if (styles.has("default")) this.defaultStyle = styles.get("default");
+    return styles;
+  }
+
+  get(group) {
+    if (!group) return this.defaultStyle;
+    const parts = String(group).split(".");
+    let style = this.styles.get(group);
+    if (parts.length > 1) {
+      let cur = "";
+      for (const part of parts) {
+        cur = cur ? `${cur}.${part}` : part;
+        if (this.styles.has(cur)) style = this.styles.get(cur);
+      }
+    }
+    return style ?? stringToStyle(group, this.defaultStyle);
+  }
+}
+
+export function stringToStyle(input, base = DEFAULT_STYLE) {
+  const text = String(input);
+  const colorPart = text.split(/\s+/).at(-1) ?? "";
+  const [fgRaw = "default", bgRaw = "default"] = colorPart.split(",");
+  return {
+    fg: stringToColor(fgRaw.trim(), base.fg),
+    bg: stringToColor(bgRaw.trim(), base.bg),
+    bold: base.bold || text.includes("bold"),
+    italic: base.italic || text.includes("italic"),
+    reverse: base.reverse || text.includes("reverse"),
+    underline: base.underline || text.includes("underline"),
+  };
+}
+
+export function stringToColor(value, fallback = "default") {
+  const color = String(value || "default").trim();
+  if (color === "default" || color === "") return fallback;
+  if (/^\d+$/.test(color)) return Number(color);
+  if (/^#[0-9a-fA-F]{6}$/.test(color)) return color;
+  const names = new Set([
+    "black", "red", "green", "yellow", "blue", "magenta", "cyan", "white",
+    "brightblack", "brightred", "brightgreen", "brightyellow", "brightblue",
+    "brightmagenta", "brightcyan", "brightwhite", "lightblack", "lightred",
+    "lightgreen", "lightyellow", "lightblue", "lightmagenta", "lightcyan", "lightwhite",
+  ]);
+  return names.has(color) ? color : fallback;
+}