buninu-linux 0.2.0

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

@@ -0,0 +1,125 @@
+import { existsSync } from "node:fs";
+import { mkdir, readFile } from "node:fs/promises";
+import { homedir } from "node:os";
+import { join } from "node:path";
+//import { Glob } from "bun";
+import { defaultAllSettings, OPTION_CHOICES, LOCAL_SETTINGS } from "./defaults.js";
+import { isHex3Encoding, isMdcuiEncoding } from "../runtime/encodings.js";
+
+export class Config {
+  constructor({ configDir = "" } = {}) {
+    this.configDir = configDir || defaultConfigDir();
+    this.globalSettings = defaultAllSettings();
+    this.volatileSettings = new Set();
+    this.modifiedSettings = new Set();
+    this.parsedSettings = {};
+  }
+
+  async init() {
+    await mkdir(this.configDir, { recursive: true });
+    await this.readSettings();
+    return this;
+  }
+
+  async readSettings() {
+    const path = join(this.configDir, "settings.json");
+    if (!existsSync(path)) return;
+    const text = await readFile(path, "utf8");
+    if (text.trimStart().startsWith("null") || text.trim() === "") return;
+    this.parsedSettings = Bun.JSON5.parse(text);
+    // jsmdcui chooses the input encoding per invocation/buffer. A persisted
+    // global encoding must neither affect startup nor survive the next save.
+    delete this.parsedSettings.encoding;
+    this.applyParsedSettings(this.parsedSettings);
+  }
+
+  applyCliSettings(settings) {
+    for (const [key, raw] of settings) {
+      if (!(key in this.globalSettings)) continue;
+      this.setGlobalOptionNative(key, parseSetting(raw), { volatile: true });
+    }
+  }
+
+  applyParsedSettings(parsed) {
+    for (const [key, value] of Object.entries(parsed)) {
+      if (key.startsWith("ft:")) continue;
+      if (key.startsWith("glob:")) {
+        //new Glob(key.slice(5));
+        continue;
+      }
+      if (!(key in this.globalSettings)) continue;
+      this.setGlobalOptionNative(key, normalizeSetting(key, value), { modified: false });
+    }
+  }
+
+  registerCommonOption(plugin, option, value) {
+    this.registerGlobalOption(`${plugin}.${option}`, value);
+  }
+
+  registerGlobalOption(option, value) {
+    if (!(option in this.globalSettings)) this.globalSettings[option] = value;
+    if (Object.hasOwn(this.parsedSettings, option)) {
+      this.setGlobalOptionNative(option, normalizeSetting(option, this.parsedSettings[option]), { modified: false });
+    }
+  }
+
+  getGlobalOption(option) {
+    return this.globalSettings[option];
+  }
+
+  setGlobalOptionNative(option, value, { volatile = false, modified = true } = {}) {
+    if (!(option in this.globalSettings)) throw new Error(`Invalid option: ${option}`);
+    validateOption(option, value);
+    this.globalSettings[option] = value;
+    if (volatile) this.volatileSettings.add(option);
+    if (modified) this.modifiedSettings.add(option);
+  }
+
+  async saveSettings() {
+    const path = join(this.configDir, "settings.json");
+    const out = { ...this.parsedSettings };
+    for (const key of this.modifiedSettings) {
+      if (!this.volatileSettings.has(key) && !LOCAL_SETTINGS.has(key)) out[key] = this.globalSettings[key];
+    }
+    // Remove any local-only settings that may have leaked into parsedSettings previously.
+    for (const key of LOCAL_SETTINGS) delete out[key];
+    await Bun.write(path, JSON.stringify(out, null, "    ") + "\n");
+    this.parsedSettings = { ...out };
+  }
+}
+
+export function defaultConfigDir() {
+  if (process.env.MICRO_CONFIG_HOME) return process.env.MICRO_CONFIG_HOME;
+  const xdg = process.env.XDG_CONFIG_HOME || join(homedir(), ".config");
+  return join(xdg, "micro");
+}
+
+export function parseSetting(value) {
+  if (value === "true" || value === "on") return true;
+  if (value === "false" || value === "off") return false;
+  if (/^-?\d+(\.\d+)?$/.test(value)) return Number(value);
+  return value;
+}
+
+function normalizeSetting(key, value) {
+  if (key === "autosave" && typeof value === "boolean") return value ? 8 : 0;
+  return value;
+}
+
+function validateOption(option, value) {
+  if (option === "encoding") {
+    const encoding = String(value || "utf-8");
+    if (isMdcuiEncoding(encoding)) return;
+    if (isHex3Encoding(encoding)) return;
+    try { new TextDecoder(encoding); }
+    catch { throw new Error(`Invalid encoding: ${value}`); }
+  }
+  const choices = OPTION_CHOICES[option];
+  if (choices && !choices.includes(value)) {
+    throw new Error(`Invalid value for ${option}: ${value}`);
+  }
+  if (["autosave", "colorcolumn", "detectlimit", "pageoverlap", "scrollmargin", "scrollspeed"].includes(option) && Number(value) < 0) {
+    throw new Error(`${option} must be non-negative`);
+  }
+  if (option === "tabsize" && Number(value) <= 0) throw new Error("tabsize must be positive");
+}

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

@@ -0,0 +1,109 @@
+export const DEFAULT_COMMON_SETTINGS = {
+  autoindent: true,
+  autosu: false,
+  backup: true,
+  backupdir: "",
+  basename: false,
+  colorcolumn: 0,
+  cursorline: true,
+  detectlimit: 100,
+  diffgutter: false,
+  encoding: "utf-8",
+  eofnewline: true,
+  fastdirty: false,
+  fileformat: defaultFileFormat(),
+  filetype: "unknown",
+  hlsearch: false,
+  hltaberrors: false,
+  hltrailingws: false,
+  ignorecase: true,
+  incsearch: true,
+  indentchar: " ",
+  keepautoindent: false,
+  matchbrace: true,
+  matchbraceleft: true,
+  matchbracestyle: "underline",
+  mkparents: false,
+  pageoverlap: 2,
+  permbackup: false,
+  readonly: false,
+  relativeruler: false,
+  reload: "prompt",
+  rmtrailingws: false,
+  ruler: true,
+  savecursor: false,
+  saveundo: false,
+  scrollbar: false,
+  scrollmargin: 3,
+  scrollspeed: 2,
+  showchars: "",
+  smartpaste: true,
+  softwrap: true,
+  splitbottom: true,
+  splitright: true,
+  statusformatl: "$(filename) $(modified)$(overwrite)($(line),$(col)) $(status.paste)| ft:$(opt:filetype) | $(opt:fileformat) | $(opt:encoding)",
+  statusformatr: "$(bind:ToggleKeyMenu): bindings, $(bind:ToggleHelp): help",
+  statusline: true,
+  syntax: true,
+  tabmovement: false,
+  tabsize: 4,
+  tabstospaces: false,
+  truecolor: "auto",
+  useprimary: true,
+  wordwrap: false,
+};
+
+export const DEFAULT_GLOBAL_ONLY_SETTINGS = {
+  autosave: 0,
+  clipboard: "external",
+  colorscheme: "default",
+  cursorshape: "block",
+  savehistory: true,
+  divchars: "|-",
+  divreverse: true,
+  fakecursor: process.platform === "win32",
+  helpsplit: "hsplit",
+  infobar: true,
+  keymenu: false,
+  lockbindings: false,
+  mouse: true,
+  multiopen: "tab",
+  parsecursor: false,
+  paste: false,
+  pluginchannels: ["https://raw.githubusercontent.com/micro-editor/plugin-channel/master/channel.json"],
+  pluginrepos: [],
+  savehistory: true,
+  scrollbarchar: "|",
+  sucmd: "sudo",
+  tabhighlight: false,
+  tabreverse: true,
+  xterm: false,
+};
+
+export const OPTION_CHOICES = {
+  clipboard: ["internal", "external", "terminal"],
+  cursorshape: [
+    "default",
+    "block", "blinking-block",
+    "underline", "blinking-underline",
+    "bar", "blinking-bar",
+  ],
+  fileformat: ["unix", "dos"],
+  helpsplit: ["hsplit", "vsplit"],
+  matchbracestyle: ["underline", "highlight"],
+  multiopen: ["tab", "hsplit", "vsplit"],
+  reload: ["prompt", "auto", "disabled"],
+  truecolor: ["auto", "on", "off"],
+};
+
+// Settings that are buffer-local only and must never be written to the global config file.
+// Mirrors Go micro's config.LocalSettings.
+export const LOCAL_SETTINGS = new Set(["readonly", "filetype", "fileformat", "encoding"]);
+
+export function defaultAllSettings() {
+  return { ...DEFAULT_COMMON_SETTINGS, ...DEFAULT_GLOBAL_ONLY_SETTINGS };
+}
+
+function defaultFileFormat() {
+  return process.platform === "win32" ? "dos" : "unix";
+}

package/initramfs/buninu/apps/jsmdcui/src/cui/fence-events.mjs

@@ -0,0 +1,144 @@
+import { parseMdcuiIdentity } from "./identity.mjs";
+
+function parseIdentity(value) {
+  return parseMdcuiIdentity(value);
+}
+
+function parseEventAttributes(text) {
+  const events = new Map();
+  let offset = 0;
+  while (offset < text.length) {
+    while (/\s/.test(text[offset] ?? "")) offset++;
+    if (offset >= text.length || text[offset] !== "@") break;
+    offset++;
+    const nameStart = offset;
+    while (/[A-Za-z0-9_.:-]/.test(text[offset] ?? "")) offset++;
+    const name = text.slice(nameStart, offset);
+    while (/\s/.test(text[offset] ?? "")) offset++;
+    if (!name || text[offset] !== "=") break;
+    offset++;
+    while (/\s/.test(text[offset] ?? "")) offset++;
+    if (text[offset] !== '"') break;
+    offset++;
+
+    let code = "";
+    let closed = false;
+    while (offset < text.length) {
+      const ch = text[offset++];
+      if (ch === '"') {
+        closed = true;
+        break;
+      }
+      if (ch === "\\" && offset < text.length) {
+        const next = text[offset++];
+        code += next === '"' || next === "\\" ? next : `\\${next}`;
+      } else {
+        code += ch;
+      }
+    }
+    if (!closed) break;
+    const [eventName, ...modifiers] = name.split(".");
+    if (eventName === "keydown" || eventName === "input")
+      events.set(eventName, { code, modifiers: [...new Set(modifiers.filter(Boolean))] });
+  }
+  return events;
+}
+
+export function parseFenceDeclarations(markdown) {
+  const source = String(markdown ?? "");
+  const lines = source.split(/\r\n?|\n/);
+  let marker = "mdcui-fence-source";
+  let markerSuffix = 0;
+  while (source.toLowerCase().includes(marker))
+    marker = `mdcui-fence-source-${++markerSuffix}`;
+
+  const contentOffset = (line) => {
+    let offset = 0;
+    const skipWhitespace = () => {
+      while (line[offset] === " " || line[offset] === "\t") offset++;
+    };
+    skipWhitespace();
+    while (offset < line.length) {
+      if (line[offset] === ">") {
+        offset++;
+        skipWhitespace();
+        continue;
+      }
+      const listMarker = line.slice(offset).match(
+        /^(?:[-+*]|\d{1,9}[.)])(?=[ \t])/u,
+      );
+      if (!listMarker) break;
+      offset += listMarker[0].length;
+      skipWhitespace();
+    }
+    return offset;
+  };
+
+  const candidates = [];
+  const markedLines = lines.slice();
+  for (let index = 0; index < lines.length; index++) {
+    const line = lines[index];
+    const offset = contentOffset(line);
+    const opening = line.slice(offset).match(/^(`{3,}|~{3,})([^]*)$/u);
+    if (!opening) continue;
+
+    const info = String(opening[2] ?? "");
+    const leadingWhitespace = info.match(/^\s*/u)?.[0].length ?? 0;
+    const infoText = info.slice(leadingWhitespace);
+    const firstSpace = infoText.search(/\s/u);
+    const identityText =
+      firstSpace < 0 ? infoText : infoText.slice(0, firstSpace);
+    const attributesText =
+      firstSpace < 0 ? "" : infoText.slice(firstSpace);
+    const identity = parseIdentity(identityText);
+    if (!identity) continue;
+
+    const identityStart =
+      offset + opening[1].length + leadingWhitespace;
+    const ordinal = candidates.length;
+    candidates.push({
+      ...identity,
+      identity: identityText,
+      events: parseEventAttributes(attributesText),
+      line: index + 1,
+      source: line.trim(),
+    });
+    markedLines[index] =
+      line.slice(0, identityStart)
+      + `${marker}-${ordinal}`
+      + line.slice(identityStart + identityText.length);
+  }
+  if (candidates.length === 0) return [];
+
+  const declarations = [];
+  const languagePattern = new RegExp(`^${marker}-(\\d+)$`, "u");
+  Bun.markdown.render(markedLines.join("\n"), {
+    code(children, meta) {
+      const match = String(meta?.language ?? "").match(languagePattern);
+      const candidate = match ? candidates[Number(match[1])] : null;
+      if (candidate) declarations.push(candidate);
+      return "";
+    },
+  });
+  return declarations.sort((left, right) => left.line - right.line);
+}
+
+export function fenceEventMap(markdown) {
+  const result = new Map();
+  for (const declaration of parseFenceDeclarations(markdown)) {
+    if (
+      !["text", "textarea"].includes(declaration.tag)
+      || !declaration.id
+      || declaration.events.size === 0
+      || result.has(declaration.id)
+    ) continue;
+    result.set(declaration.id, declaration);
+  }
+  return result;
+}
+
+export function inlineFenceEventCode(handler) {
+  if (!handler) return "";
+  const prefix = handler.modifiers.includes("prevent") ? "event.preventDefault();" : "";
+  return prefix + handler.code;
+}