bunmicro 0.8.0

package/src/config/config.js

@@ -0,0 +1,118 @@
+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";
+
+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);
+    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") {
+    try { new TextDecoder(String(value || "utf-8")); }
+    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/src/config/defaults.js

@@ -0,0 +1,102 @@
+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: false,
+  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",
+  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"],
+  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"]);
+
+export function defaultAllSettings() {
+  return { ...DEFAULT_COMMON_SETTINGS, ...DEFAULT_GLOBAL_ONLY_SETTINGS };
+}
+
+function defaultFileFormat() {
+  return process.platform === "win32" ? "dos" : "unix";
+}

package/src/display/ansi-style.js

@@ -0,0 +1,60 @@
+const BASIC = {
+  black: 0,
+  red: 1,
+  green: 2,
+  yellow: 3,
+  blue: 4,
+  magenta: 5,
+  cyan: 6,
+  white: 7,
+  brightblack: 8,
+  lightblack: 8,
+  brightred: 9,
+  lightred: 9,
+  brightgreen: 10,
+  lightgreen: 10,
+  brightyellow: 11,
+  lightyellow: 11,
+  brightblue: 12,
+  lightblue: 12,
+  brightmagenta: 13,
+  lightmagenta: 13,
+  brightcyan: 14,
+  lightcyan: 14,
+  brightwhite: 15,
+  lightwhite: 15,
+};
+
+export function styleToAnsi(style = {}) {
+  const codes = [0];
+  if (style.bold) codes.push(1);
+  if (style.italic) codes.push(3);
+  if (style.underline) codes.push(4);
+  if (style.reverse) codes.push(7);
+  codes.push(...colorCodes(style.fg, false));
+  codes.push(...colorCodes(style.bg, true));
+  return `\x1b[${codes.join(";")}m`;
+}
+
+export function resetStyle() {
+  return "\x1b[0m";
+}
+
+export function styleResetTo(style = {}) {
+  return resetStyle() + styleToAnsi(style);
+}
+
+function colorCodes(color, background) {
+  if (color == null || color === "default") return [];
+  const base = background ? 48 : 38;
+  if (typeof color === "number") return [base, 5, color];
+  const value = String(color).toLowerCase();
+  if (/^#[0-9a-f]{6}$/.test(value)) {
+    const r = Number.parseInt(value.slice(1, 3), 16);
+    const g = Number.parseInt(value.slice(3, 5), 16);
+    const b = Number.parseInt(value.slice(5, 7), 16);
+    return [base, 2, r, g, b];
+  }
+  if (value in BASIC) return [base, 5, BASIC[value]];
+  return [];
+}

package/src/highlight/highlighter.js

@@ -0,0 +1,237 @@
+export class Highlighter {
+  constructor(definition, definitions = []) {
+    this.definition = definition;
+    this.definitions = definitions;
+    this.rules = resolveRules(definition?.rules ?? [], definitions, new Set());
+  }
+
+  highlightLine(line, state = null, progress = null) {
+    const text = String(line);
+    const changes = new Map([[0, state?.group ?? "default"]]);
+    const nextState = state
+      ? scanRegion(changes, text, 0, state, this.rules, progress)
+      : scanTop(changes, text, 0, this.rules, progress);
+    return {
+      changes: normalizeChanges(changes, text.length),
+      state: nextState,
+    };
+  }
+
+  highlightString(input) {
+    const matches = [];
+    let state = null;
+    for (const line of String(input).split("\n")) {
+      const result = this.highlightLine(line, state);
+      matches.push(result.changes);
+      state = result.state;
+    }
+    return matches;
+  }
+}
+
+export function resolveRules(rules, definitions, seen) {
+  const out = [];
+  for (const rule of rules) {
+    if (rule.type === "include") {
+      if (seen.has(rule.include)) continue;
+      seen.add(rule.include);
+      const def = definitions.find((candidate) => candidate.filetype === rule.include);
+      if (def) out.push(...resolveRules(def.rules, definitions, seen));
+    } else if (rule.type === "region") {
+      out.push({ ...rule, rules: resolveRules(rule.rules ?? [], definitions, new Set(seen)) });
+    } else {
+      out.push(rule);
+    }
+  }
+  return out;
+}
+
+export function flattenRules(rules, definitions, seen) {
+  return resolveRules(rules, definitions, seen).flatMap((rule) => {
+    if (rule.type === "region") return flattenRules(rule.rules ?? [], definitions, new Set(seen));
+    return rule.type === "pattern" ? [rule] : [];
+  });
+}
+
+function scanTop(changes, line, pos, rules, progress = null) {
+  let cursor = pos;
+  while (cursor <= line.length) {
+    progress?.(cursor);
+    const regionStart = findFirstRegion(rules, line, cursor, progress);
+    if (!regionStart) {
+      applyPatterns(changes, line, cursor, line.length, rules, "default", progress);
+      changes.set(line.length, "default");
+      progress?.(line.length);
+      return null;
+    }
+
+    applyPatterns(changes, line, cursor, regionStart.start, rules, "default", progress);
+    changes.set(regionStart.start, regionStart.region.limitGroup ?? "default");
+    changes.set(regionStart.end, regionStart.region.group);
+    progress?.(regionStart.end);
+
+    const state = scanRegion(changes, line, regionStart.end, regionStart.region, rules, progress);
+    if (state) return state;
+    return null;
+  }
+  return null;
+}
+
+function scanRegion(changes, line, pos, region, rootRules, progress = null) {
+  let cursor = pos;
+  const rules = region.rules ?? [];
+  while (cursor <= line.length) {
+    progress?.(cursor);
+    const end = findMatch(region.end, line, cursor, region.skip, progress);
+    const nested = findFirstRegion(rules, line, cursor, progress);
+
+    if (end && (!nested || end.start <= nested.start)) {
+      applyPatterns(changes, line, cursor, end.start, rules, region.group, progress);
+      changes.set(end.start, region.limitGroup ?? region.group);
+      changes.set(end.end, parentGroup(region));
+      progress?.(end.end);
+      if (region.parent) return scanRegion(changes, line, end.end, region.parent, rootRules, progress);
+      return scanTop(changes, line, Math.max(end.end, end.start + 1), rootRules, progress);
+    }
+
+    if (nested) {
+      applyPatterns(changes, line, cursor, nested.start, rules, region.group, progress);
+      changes.set(nested.start, nested.region.limitGroup ?? region.group);
+      const child = { ...nested.region, parent: region };
+      changes.set(nested.end, child.group);
+      progress?.(nested.end);
+      const state = scanRegion(changes, line, nested.end, child, rootRules, progress);
+      if (state) return state;
+      cursor = Math.max(nested.end + 1, nextChangeAfter(changes, nested.end));
+      continue;
+    }
+
+    applyPatterns(changes, line, cursor, line.length, rules, region.group, progress);
+    changes.set(line.length, region.group);
+    progress?.(line.length);
+    return region;
+  }
+  return region;
+}
+
+function applyPatterns(changes, line, start, end, rules, fallbackGroup, progress = null) {
+  if (end < start) return;
+  const length = end - start;
+  if (length === 0) {
+    if (!changes.has(start)) changes.set(start, fallbackGroup);
+    return;
+  }
+  // Mirror Go's fullHighlights approach: later rules overwrite all positions in their match range,
+  // preventing earlier rules (e.g. symbol.operator matching "!") from leaking into spans that a
+  // later rule (e.g. the shebang comment pattern) should own entirely.
+  const fullHighlights = new Array(length).fill(null);
+  for (const rule of rules) {
+    if (rule.type !== "pattern" || !rule.regex) continue;
+    for (const match of findAllMatches(rule.regex, line, start, end, progress)) {
+      if (match.start === match.end) continue;
+      const lo = Math.max(match.start, start) - start;
+      const hi = Math.min(match.end, end) - start;
+      for (let i = lo; i < hi; i++) fullHighlights[i] = rule.group;
+    }
+    progress?.(end);
+  }
+  // Emit only color-change boundaries into the changes map (same as Go's transition loop).
+  let prev = changes.get(start) ?? fallbackGroup;
+  for (let i = 0; i < length; i++) {
+    const g = fullHighlights[i] ?? fallbackGroup;
+    if (g !== prev) { changes.set(start + i, g); prev = g; }
+  }
+  if (!changes.has(start)) changes.set(start, fullHighlights[0] ?? fallbackGroup);
+  if (!changes.has(end)) changes.set(end, fallbackGroup);
+}
+
+function findFirstRegion(rules, line, pos, progress = null) {
+  let best = null;
+  for (const region of rules.filter((rule) => rule.type === "region" && rule.start)) {
+    const match = findMatch(region.start, line, pos, region.skip, progress);
+    if (!match) continue;
+    if (!best || match.start < best.start) best = { ...match, region };
+  }
+  return best;
+}
+
+function findMatch(regex, line, pos, skip, progress = null) {
+  if (!regex) return null;
+  const masked = skip ? maskSkipped(line, skip) : line;
+  const global = globalize(regex);
+  global.lastIndex = pos;
+  let match;
+  if (!progress) {
+    match = global.exec(masked);
+    if (!match) return null;
+    const start = match.index ?? 0;
+    return { start, end: start + match[0].length };
+  }
+  while ((match = global.exec(masked)) !== null) {
+    const start = match.index ?? 0;
+    const end = start + match[0].length;
+    progress?.(start);
+    if (start >= pos) return { start, end };
+    if (match[0].length === 0) global.lastIndex++;
+  }
+  progress?.(line.length);
+  return null;
+}
+
+function findAllMatches(regex, line, start, end, progress = null) {
+  const out = [];
+  const global = globalize(regex);
+  global.lastIndex = start;
+  let match;
+  if (!progress) {
+    while ((match = global.exec(line)) !== null) {
+      const matchStart = match.index ?? 0;
+      if (matchStart >= end) break;
+      const matchEnd = matchStart + match[0].length;
+      if (matchEnd > start) out.push({ start: Math.max(matchStart, start), end: Math.min(matchEnd, end) });
+      if (match[0].length === 0) global.lastIndex++;
+    }
+    return out;
+  }
+  while ((match = global.exec(line)) !== null) {
+    const matchStart = match.index ?? 0;
+    const matchEnd = matchStart + match[0].length;
+    if (matchStart >= end) break;
+    progress?.(matchStart);
+    if (matchEnd <= start || matchStart >= end) continue;
+    out.push({ start: Math.max(matchStart, start), end: Math.min(matchEnd, end) });
+    if (match[0].length === 0) global.lastIndex++;
+  }
+  progress?.(end);
+  return out;
+}
+
+function maskSkipped(line, skip) {
+  return line.replace(globalize(skip), (value) => "\0".repeat(value.length));
+}
+
+function normalizeChanges(changes, lineLength) {
+  const normalized = new Map([...changes.entries()]
+    .filter(([index]) => index >= 0 && index <= lineLength)
+    .sort(([a], [b]) => a - b));
+  if (!normalized.has(0)) normalized.set(0, "default");
+  if (!normalized.has(lineLength)) normalized.set(lineLength, normalized.get([...normalized.keys()].at(-1)) ?? "default");
+  return new Map([...normalized.entries()].sort(([a], [b]) => a - b));
+}
+
+function parentGroup(region) {
+  return region.parent?.group ?? "default";
+}
+
+function nextChangeAfter(changes, index) {
+  for (const key of [...changes.keys()].sort((a, b) => a - b)) {
+    if (key > index) return key;
+  }
+  return index + 1;
+}
+
+function globalize(regex) {
+  const flags = new Set(regex.flags.split(""));
+  flags.add("g");
+  return new RegExp(regex.source, [...flags].join(""));
+}

package/src/highlight/parser.js

@@ -0,0 +1,137 @@
+import { basename } from "node:path";
+
+export class SyntaxHeader {
+  constructor({ filetype = "", filename = "", header = "", signature = "" } = {}) {
+    this.filetype = filetype;
+    this.filename = filename;
+    this.header = header;
+    this.signature = signature;
+    this.fileNameRegex = compileRegex(filename);
+    this.headerRegex = compileRegex(header);
+    this.signatureRegex = compileRegex(signature);
+  }
+
+  matchFileName(path) {
+    return !!this.fileNameRegex?.test(basename(path));
+  }
+
+  matchHeader(firstLine) {
+    return !!this.headerRegex?.test(firstLine);
+  }
+
+  hasSignature() {
+    return !!this.signatureRegex;
+  }
+
+  matchSignature(line) {
+    return !!this.signatureRegex?.test(line);
+  }
+}
+
+export class SyntaxDefinition {
+  constructor(header, source) {
+    this.header = header;
+    this.filetype = header.filetype;
+    this.source = source;
+    this.rules = parseRules(source.rules ?? []);
+  }
+}
+
+export async function loadSyntaxDefinitions(runtime) {
+  const headers = new Map();
+  for (const file of runtime.list(4)) {
+    headers.set(file.name, parseHeaderFile(await file.text()));
+  }
+
+  const definitions = [];
+  for (const file of runtime.list(1)) {
+    const source = Bun.YAML.parse(await file.text());
+    const header = headers.get(file.name) ?? parseHeaderYaml(source);
+    definitions.push(new SyntaxDefinition(header, source));
+  }
+  return definitions;
+}
+
+export function detectSyntax(definitions, { path = "", firstLine = "", lines = [] } = {}) {
+  for (const def of definitions) {
+    if (path && def.header.matchFileName(path)) return def;
+  }
+  for (const def of definitions) {
+    if (firstLine && def.header.matchHeader(firstLine)) return def;
+  }
+  for (const def of definitions) {
+    if (!def.header.hasSignature()) continue;
+    if (lines.some((line) => def.header.matchSignature(line))) return def;
+  }
+  return null;
+}
+
+export function parseHeaderFile(text) {
+  const [filetype = "", filename = "", header = "", signature = ""] = String(text).split(/\r?\n/);
+  return new SyntaxHeader({ filetype, filename, header, signature });
+}
+
+export function parseHeaderYaml(source) {
+  return new SyntaxHeader({
+    filetype: source?.filetype ?? "",
+    filename: source?.detect?.filename ?? "",
+    header: source?.detect?.header ?? "",
+    signature: source?.detect?.signature ?? "",
+  });
+}
+
+function parseRules(rules) {
+  return rules.map((rule) => parseRule(rule)).filter(Boolean);
+}
+
+function parseRule(rule) {
+  if (typeof rule === "string") return { type: "include", include: rule };
+  if (!rule || typeof rule !== "object") return null;
+  const [[group, value]] = Object.entries(rule);
+  if (group === "include") return { type: "include", include: value };
+  if (typeof value === "string") return { type: "pattern", group, regex: compileRegex(value), source: value };
+  if (value && typeof value === "object") {
+    return {
+      type: "region",
+      group,
+      start: compileRegex(value.start),
+      end: compileRegex(value.end),
+      skip: compileRegex(value.skip),
+      limitGroup: value["limit-group"] ?? group,
+      rules: parseRules(value.rules ?? []),
+      source: value,
+    };
+  }
+  return null;
+}
+
+function compileRegex(pattern) {
+  if (!pattern) return null;
+  const translated = translateGoRegexp(pattern);
+  try {
+    return new RegExp(translated, "u");
+  } catch {
+    try {
+      return new RegExp(translated);
+    } catch {
+      return null;
+    }
+  }
+}
+
+function translateGoRegexp(pattern) {
+  return String(pattern)
+    .replaceAll("[[:alnum:]]", "[A-Za-z0-9]")
+    .replaceAll("[[:alpha:]]", "[A-Za-z]")
+    .replaceAll("[[:ascii:]]", "[\\x00-\\x7F]")
+    .replaceAll("[[:blank:]]", "[ \\t]")
+    .replaceAll("[[:cntrl:]]", "[\\x00-\\x1F\\x7F]")
+    .replaceAll("[[:digit:]]", "[0-9]")
+    .replaceAll("[[:graph:]]", "[!-~]")
+    .replaceAll("[[:lower:]]", "[a-z]")
+    .replaceAll("[[:print:]]", "[ -~]")
+    .replaceAll("[[:space:]]", "\\s")
+    .replaceAll("[[:upper:]]", "[A-Z]")
+    .replaceAll("[[:word:]]", "[A-Za-z0-9_]")
+    .replaceAll("[[:xdigit:]]", "[A-Fa-f0-9]");
+}