jsmdcui 0.3.0

package/src/buffer/backup.js

@@ -0,0 +1,160 @@
+// Crash recovery backup system compatible with Go micro's internal/buffer/backup.go.
+
+import { join } from "node:path";
+import { existsSync, statSync, unlinkSync } from "node:fs";
+import { mkdir, writeFile, readFile, rename } from "node:fs/promises";
+import { homedir } from "node:os";
+import { createHash } from "node:crypto";
+
+export const BACKUP_SUFFIX = ".micro-backup";
+
+export function getBackupDir(buf, configDir) {
+  const raw = String(buf?.Settings?.backupdir ?? "");
+  if (!raw) return join(configDir, "backups");
+  if (raw === "~" || raw.startsWith("~/") || raw.startsWith("~\\")) {
+    return raw.replace(/^~/, homedir());
+  }
+  // Node has no portable equivalent of Go's user.Lookup for ~otheruser.
+  if (raw.startsWith("~")) return join(configDir, "backups");
+  return raw;
+}
+
+function queryEscapePath(path) {
+  return encodeURIComponent(String(path).replaceAll("\\", "/"))
+    .replace(/[!'()*]/g, (ch) => `%${ch.charCodeAt(0).toString(16).toUpperCase()}`)
+    .replace(/%20/g, "+"); 
+} // '
+
+function legacyEscapePath(path) {
+  let escaped = String(path).replaceAll("\\", "/");
+  if (process.platform === "win32") escaped = escaped.replaceAll(":", "%");
+  return escaped.replaceAll("/", "%");
+}
+
+export function determineBackupPath(backupDirPath, absPath) {
+  const urlName = join(backupDirPath, queryEscapePath(absPath));
+  if (existsSync(urlName)) return { name: urlName, resolveName: null };
+
+  const legacyName = join(backupDirPath, legacyEscapePath(absPath));
+  if (existsSync(legacyName)) return { name: legacyName, resolveName: null };
+
+  if (Buffer.byteLength(urlName + BACKUP_SUFFIX) > 255) {
+    const hash = createHash("md5").update(absPath).digest("hex");
+    return {
+      name: join(backupDirPath, hash),
+      resolveName: join(backupDirPath, hash + ".path"),
+    };
+  }
+  return { name: urlName, resolveName: null };
+}
+
+export async function writeBackup(buf, configDir, path = buf?.AbsPath ?? buf?.path, { force = false } = {}) {
+  if ((!force && !buf?.Settings?.backup) || !path || buf.type !== "default") return false;
+  const dir = getBackupDir(buf, configDir);
+  await mkdir(dir, { recursive: true });
+  const { name, resolveName } = determineBackupPath(dir, path);
+  const tmp = name + BACKUP_SUFFIX;
+  try {
+    await writeFile(tmp, buf.lines.join("\n"), "utf8");
+    await rename(tmp, name);
+    if (resolveName) await writeFile(resolveName, path, "utf8");
+    return true;
+  } catch (error) {
+    try { unlinkSync(tmp); } catch {}
+    throw error;
+  }
+}
+
+export function removeBackup(buf, configDir, path = buf?.AbsPath ?? buf?.path) {
+  if (buf?.Settings?.permbackup || buf?._forceKeepBackup) return;
+  if (!path || buf.type !== "default") return;
+  const dir = getBackupDir(buf, configDir);
+  const { name, resolveName } = determineBackupPath(dir, path);
+  try { unlinkSync(name); } catch {}
+  if (resolveName) try { unlinkSync(resolveName); } catch {}
+}
+
+// promptFn(msg) -> Promise<string>
+// Returns { recovered: bool, abort: bool }
+export async function applyBackup(buf, configDir, promptFn) {
+  if (!buf?.Settings?.backup || buf?.Settings?.permbackup) return { recovered: false, abort: false };
+  if (!buf.path || buf.type !== "default") return { recovered: false, abort: false };
+
+  const dir = getBackupDir(buf, configDir);
+  const { name: backupFile, resolveName } = determineBackupPath(dir, buf.AbsPath ?? buf.path);
+  if (!existsSync(backupFile)) return { recovered: false, abort: false };
+
+  let info;
+  try { info = statSync(backupFile); } catch { return { recovered: false, abort: false }; }
+
+  const t = info.mtime;
+  const dateStr =
+    t.toLocaleDateString("en-US", { weekday: "short", month: "short", day: "numeric" }) +
+    " at " +
+    t.toLocaleTimeString("en-US", { hour: "2-digit", minute: "2-digit", hour12: false }) +
+    ", " + t.getFullYear();
+
+  const ticcc='```';
+
+  const msg = `
+# Backup detected! ⚠️
+- File path/url:
+${ticcc}
+${buf.path}
+${ticcc}
+- either micro crashed
+- or another micro is running
+- or an error occurred while saving
+- The file may be corrupted
+# Date of backup 🕰
+- ${dateStr}
+# Path of backup 
+${ticcc}
+${backupFile}
+${ticcc}
+# Recovery options
+## r = 'recover'
+- Apply the backup 
+- as unsaved changes to the current buffer
+- When the buffer is closed, the backup will be removed.
+## i = 'ignore'
+- Ignore & remove the backup
+## a = 'abort' 
+- Abort the open operation
+- Open an empty buffer
+- Keep the backup
+### Your choice
+- [r]ecover, [i]gnore, [a]bort
+`;
+
+  const options = ["r", "i", "a", "recover", "ignore", "abort"];
+  let choice = -1;
+  let prompt = msg;
+  while (choice === -1) {
+    const resp = await promptFn(prompt);
+    const idx = options.indexOf(resp.trim().toLowerCase());
+    if (idx !== -1) choice = idx % 3;
+    else prompt = "\n#### Invalid choice!";
+  }
+
+  if (choice === 0) {
+    try {
+      const text = await readFile(backupFile, "utf8");
+      buf.lines = text.replace(/\r\n/g, "\n").replace(/\r/g, "\n").split("\n");
+      if (!buf.lines.length) buf.lines = [""];
+      buf._recovered = true;
+      buf._savedSerial = -1;
+      buf.setModified?.(true);
+      if (!buf.setModified) buf.modified = true;
+      return { recovered: true, abort: false };
+    } catch {
+      return { recovered: false, abort: false };
+    }
+  }
+  if (choice === 1) {
+    try { unlinkSync(backupFile); } catch {}
+    if (resolveName) try { unlinkSync(resolveName); } catch {}
+    return { recovered: false, abort: false };
+  }
+  return { recovered: false, abort: true };
+}

package/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/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/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/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/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();
+  }
+}