jsmdcui 0.3.0

package/src/runtime/assets.js

@@ -0,0 +1,90 @@
+const textDecoder = new TextDecoder();
+const textEncoder = new TextEncoder();
+
+export function hasInternalAssets() {
+  return Boolean(getAssetStore());
+}
+
+export function assetPath(...parts) {
+  return parts
+    .flatMap((part) => String(part).split(/[\\/]+/))
+    .filter(Boolean)
+    .join("/");
+}
+
+export function listInternalAssetPaths(prefix = "") {
+  const store = getAssetStore();
+  if (!store) return [];
+
+  const normalizedPrefix = assetPath(prefix);
+  const entries = iterateAssetKeys(store);
+  if (!normalizedPrefix) {
+    return entries.sort();
+  }
+
+  const base = `${normalizedPrefix}/`;
+  return entries.filter((path) => path === normalizedPrefix || path.startsWith(base)).sort();
+}
+
+export function listInternalAssetDirs(prefix = "") {
+  const normalizedPrefix = assetPath(prefix);
+  const base = normalizedPrefix ? `${normalizedPrefix}/` : "";
+  const dirs = new Set();
+
+  for (const path of listInternalAssetPaths(prefix)) {
+    const rest = normalizedPrefix ? path.slice(base.length) : path;
+    const [dir] = rest.split("/");
+    if (dir) dirs.add(dir);
+  }
+
+  return [...dirs].sort();
+}
+
+export function getInternalAsset(path) {
+  const store = getAssetStore();
+  if (!store) return null;
+  const key = assetPath(path);
+  if (store instanceof Map) return store.get(key) ?? null;
+  return store[key] ?? store[path] ?? null;
+}
+
+export function readInternalAssetBytes(path) {
+  const value = getInternalAsset(path);
+  if (value == null) return null;
+  if (value instanceof Uint8Array) return value;
+  if (ArrayBuffer.isView(value)) {
+    return new Uint8Array(value.buffer, value.byteOffset, value.byteLength);
+  }
+  if (value instanceof ArrayBuffer) return new Uint8Array(value);
+  if (typeof value === "string") return textEncoder.encode(value);
+  return textEncoder.encode(String(value));
+}
+
+export function readInternalAssetText(path) {
+  const bytes = readInternalAssetBytes(path);
+  if (!bytes) return null;
+  return textDecoder.decode(bytes);
+}
+
+export function internalAssetSource(path) {
+  return {
+    name: path.split("/").pop() ?? path,
+    path,
+    async text() {
+      return readInternalAssetText(path) ?? "";
+    },
+  };
+}
+
+function getAssetStore() {
+  const store = globalThis.internalAssets;
+  if (!store) return null;
+  if (store instanceof Map) return store;
+  if (typeof store === "object") return store;
+  return null;
+}
+
+function iterateAssetKeys(store) {
+  if (store instanceof Map) return [...store.keys()].map(String);
+  return Object.keys(store);
+}

package/src/runtime/compiled.js

@@ -0,0 +1,25 @@
+import { basename, dirname, resolve } from "node:path";
+import { readFileSync } from "node:fs";
+import { fileURLToPath } from "node:url";
+
+export function isCompiledBinary(argv = process.argv) {
+  return Boolean(argv?.[1]?.startsWith?.("/$bunfs/"));
+}
+
+export function resolveCompiledBaseDir({ argv = process.argv, execPath = process.execPath } = {}) {
+  const bn = basename(execPath);
+  if (bn.startsWith("ld") || 
+      bn.startsWith("libld") ||
+      bn.startsWith("linker") ) {
+    const realArgv = readFileSync("/proc/self/cmdline", "utf8").match(/[^\0]+/g);
+    return dirname(realArgv?.[1] ?? execPath);
+  }
+  return dirname(execPath) || process.cwd();
+}
+
+export function resolveRepoRoot(importMetaUrl, options = {}) {
+  if (isCompiledBinary(options.argv)) {
+    return resolveCompiledBaseDir(options);
+  }
+  return resolve(dirname(fileURLToPath(importMetaUrl)), "..");
+}

package/src/runtime/encodings.js

@@ -0,0 +1,10 @@
+const HEX3_ENCODINGS = new Set(["hex3", "hex3gz", "hex3zst"]);
+const MDCUI_ENCODING = "mdcui";
+
+export function isHex3Encoding(encoding) {
+  return HEX3_ENCODINGS.has(String(encoding || "utf-8").toLowerCase());
+}
+
+export function isMdcuiEncoding(encoding) {
+  return String(encoding || "utf-8").toLowerCase() === MDCUI_ENCODING;
+}

package/src/runtime/registry.js

@@ -0,0 +1,134 @@
+import { existsSync } from "node:fs";
+import { readdir, readFile } from "node:fs/promises";
+import { basename, extname, join } from "node:path";
+import { assetPath, hasInternalAssets, listInternalAssetPaths, readInternalAssetBytes } from "./assets.js";
+
+export const RTColorscheme = 0;
+export const RTSyntax = 1;
+export const RTHelp = 2;
+export const RTPlugin = 3;
+export const RTSyntaxHeader = 4;
+
+export class RuntimeRegistry {
+  constructor({ repoRoot, configDir }) {
+    this.repoRoot = repoRoot;
+    this.configDir = configDir;
+    this.files = [[], [], [], [], []];
+    this.realFiles = [[], [], [], [], []];
+    this.fallbackFiles = [[], [], [], [], []];
+  }
+
+  async init({ user = true } = {}) {
+    this.files = [[], [], [], [], []];
+    this.realFiles = [[], [], [], [], []];
+    this.fallbackFiles = [[], [], [], [], []];
+    await this.addRuntimeKind(RTColorscheme, "colorschemes", ".micro", user);
+    await this.addRuntimeKind(RTSyntax, "syntax", ".yaml", user);
+    await this.addRuntimeKind(RTSyntaxHeader, "syntax", ".hdr", user);
+    await this.addRuntimeKind(RTHelp, "help", ".md", user);
+  }
+
+  async addRuntimeKind(kind, dir, extension, user) {
+    if (user) await this.addDirectory(kind, join(this.configDir, dir), extension, true);
+    const internalPrefix = assetPath("runtime", dir);
+    if (hasInternalAssets() && await this.addInternalDirectory(kind, internalPrefix, extension, false)) {
+      return;
+    }
+    await this.addDirectory(kind, join(this.repoRoot, "runtime", dir), extension, false);
+  }
+
+  async addDirectory(kind, dir, extension, real) {
+    if (!existsSync(dir)) return;
+    const entries = await readdir(dir, { withFileTypes: true });
+    for (const entry of entries) {
+      if (entry.isDirectory() || !entry.name.endsWith(extension)) continue;
+      const file = new RuntimeFile(join(dir, entry.name), real);
+      if (!real && this.realFiles[kind].some((f) => f.name === file.name)) {
+        this.fallbackFiles[kind].push(file);
+        continue;
+      }
+      this.files[kind].push(file);
+      if (real) this.realFiles[kind].push(file);
+    }
+  }
+
+  async addInternalDirectory(kind, prefix, extension, real) {
+    const entries = listInternalAssetPaths(prefix);
+    if (entries.length === 0) return false;
+
+    const base = `${assetPath(prefix)}/`;
+    let added = false;
+    for (const path of entries) {
+      const rel = path.slice(base.length);
+      if (!rel || rel.includes("/")) continue;
+      if (!rel.endsWith(extension)) continue;
+
+      const data = readInternalAssetBytes(path);
+      if (!data) continue;
+      const file = new MemoryRuntimeFile(path, data);
+      if (!real && this.realFiles[kind].some((f) => f.name === file.name)) {
+        this.fallbackFiles[kind].push(file);
+        continue;
+      }
+      this.files[kind].push(file);
+      if (real) this.realFiles[kind].push(file);
+      added = true;
+    }
+    return added;
+  }
+
+  addMemoryFile(kind, name, data) {
+    this.files[kind].push(new MemoryRuntimeFile(name, data));
+  }
+
+  list(kind) {
+    return this.files[kind] ?? [];
+  }
+
+  find(kind, name) {
+    return this.list(kind).find((file) => file.name === name) ?? null;
+  }
+
+  fallback(kind, name) {
+    return this.fallbackFiles[kind]?.find((file) => file.name === name) ?? null;
+  }
+}
+
+class RuntimeFile {
+  constructor(path, real) {
+    this.path = path;
+    this.real = real;
+    this.name = basename(path, extname(path));
+  }
+
+  async data() {
+    return readFile(this.path);
+  }
+
+  async text() {
+    return readFile(this.path, "utf8");
+  }
+}
+
+class MemoryRuntimeFile {
+  constructor(name, data) {
+    this.name = basename(name, extname(name));
+    this.path = name;
+    this.real = false;
+    this._data = data;
+  }
+
+  async data() {
+    if (this._data instanceof Uint8Array) return this._data;
+    if (ArrayBuffer.isView(this._data)) {
+      return new Uint8Array(this._data.buffer, this._data.byteOffset, this._data.byteLength);
+    }
+    if (this._data instanceof ArrayBuffer) return new Uint8Array(this._data);
+    return new TextEncoder().encode(String(this._data));
+  }
+
+  async text() {
+    if (typeof this._data === "string") return this._data;
+    return new TextDecoder().decode(await this.data());
+  }
+}

package/src/screen/cell-buffer.js

@@ -0,0 +1,81 @@
+export class Cell {
+  constructor(ch = " ", style = null, combining = [], filler = false) {
+    this.ch = ch;
+    this.style = style ? { ...style } : null;
+    this.combining = [...combining];
+    this.filler = filler; // right-half placeholder for a wide (double-width) character
+    this.styleKey = styleKey(this.style);
+  }
+
+  equals(other) {
+    return this.ch === other?.ch && this.styleKey === other?.styleKey && this.filler === other?.filler && arrayEquals(this.combining, other?.combining);
+  }
+
+  clone() {
+    return new Cell(this.ch, this.style, this.combining, this.filler);
+  }
+}
+
+export class CellBuffer {
+  constructor(cols, rows, style = null) {
+    this.cols = cols;
+    this.rows = rows;
+    this.cells = Array.from({ length: rows }, () => Array.from({ length: cols }, () => new Cell(" ", style)));
+  }
+
+  resize(cols, rows, style = null) {
+    if (cols === this.cols && rows === this.rows) return;
+    this.cols = cols;
+    this.rows = rows;
+    this.cells = Array.from({ length: rows }, (_, y) =>
+      Array.from({ length: cols }, (_, x) => this.cells[y]?.[x] ?? new Cell(" ", style)));
+  }
+
+  setContent(x, y, ch, style = null, combining = [], filler = false) {
+    if (x < 0 || y < 0 || x >= this.cols || y >= this.rows) return;
+    this.cells[y][x] = new Cell(ch, style, combining, filler);
+  }
+
+  setFiller(x, y, style = null) {
+    if (x < 0 || y < 0 || x >= this.cols || y >= this.rows) return;
+    this.cells[y][x] = new Cell(" ", style, [], true);
+  }
+
+  getContent(x, y) {
+    if (x < 0 || y < 0 || x >= this.cols || y >= this.rows) return new Cell();
+    return this.cells[y][x];
+  }
+
+  fill(ch = " ", style = null) {
+    for (let y = 0; y < this.rows; y++) {
+      for (let x = 0; x < this.cols; x++) this.setContent(x, y, ch, style);
+    }
+  }
+
+  diff(previous) {
+    const changes = [];
+    for (let y = 0; y < this.rows; y++) {
+      for (let x = 0; x < this.cols; x++) {
+        const cell = this.getContent(x, y);
+        if (!cell.equals(previous?.getContent(x, y))) changes.push({ x, y, cell });
+      }
+    }
+    return changes;
+  }
+
+  clone() {
+    const copy = new CellBuffer(this.cols, this.rows);
+    copy.cells = this.cells.map((row) => row.map((cell) => cell.clone()));
+    return copy;
+  }
+}
+
+function styleKey(style) {
+  if (!style) return "";
+  return JSON.stringify(Object.keys(style).sort().map((key) => [key, style[key]]));
+}
+
+function arrayEquals(a = [], b = []) {
+  if (a.length !== b.length) return false;
+  return a.every((value, index) => value === b[index]);
+}

package/src/screen/events.js

@@ -0,0 +1,263 @@
+const decoder = new TextDecoder();
+
+export const ENABLE_MOUSE = "\x1b[?1000h\x1b[?1002h\x1b[?1006h";
+export const DISABLE_MOUSE = "\x1b[?1006l\x1b[?1002l\x1b[?1000l";
+export const ENABLE_PASTE = "\x1b[?2004h";
+export const DISABLE_PASTE = "\x1b[?2004l";
+
+export class KeyEvent {
+  constructor(key, raw) {
+    this.type = "key";
+    this.key = key;
+    this.raw = raw;
+  }
+}
+
+export class MouseEvent {
+  constructor({ x, y, button, action, modifiers = 0, raw = "" }) {
+    this.type = "mouse";
+    this.x = x;
+    this.y = y;
+    this.button = button;
+    this.action = action;
+    this.modifiers = modifiers;
+    this.raw = raw;
+  }
+}
+
+export class PasteEvent {
+  constructor(text, raw) {
+    this.type = "paste";
+    this.text = text;
+    this.raw = raw;
+  }
+}
+
+export class ResizeEvent {
+  constructor(cols, rows) {
+    this.type = "resize";
+    this.cols = cols;
+    this.rows = rows;
+  }
+}
+
+export function parseInputEvents(data) {
+  const bytes = typeof data === "string" ? new TextEncoder().encode(data) : new Uint8Array(data);
+  const text = typeof data === "string" ? data : decoder.decode(data);
+  const paste = parseBracketedPaste(text);
+  if (paste) return [paste];
+  const events = [...parseSgrMouseEvents(text), ...parseX10MouseEvents(bytes)];
+  if (events.length > 0) return events.sort((a, b) => text.indexOf(a.raw) - text.indexOf(b.raw));
+  return parseKeyEvents(text);
+}
+
+function parseBracketedPaste(text) {
+  const start = text.indexOf("\x1b[200~");
+  const end = text.indexOf("\x1b[201~");
+  if (start === -1 || end === -1 || end < start) return null;
+  const raw = text.slice(start, end + 7);
+  return new PasteEvent(text.slice(start + 6, end), raw);
+}
+
+export function parseSgrMouse(text) {
+  return parseSgrMouseSequence(text);
+}
+
+function parseSgrMouseEvents(text) {
+  const events = [];
+  const re = /\x1b\[<(\d+);(\d+);(\d+)([mM])/g;
+  for (const match of text.matchAll(re)) {
+    const event = sgrMatchToEvent(match);
+    if (event) events.push(event);
+  }
+  return events;
+}
+
+function parseSgrMouseSequence(text) {
+  const match = /^\x1b\[<(\d+);(\d+);(\d+)([mM])$/.exec(text);
+  return match ? sgrMatchToEvent(match) : null;
+}
+
+function sgrMatchToEvent(match) {
+  const code = Number(match[1]);
+  const x = Number(match[2]) - 1;
+  const y = Number(match[3]) - 1;
+  const release = match[4] === "m";
+  const buttonCode = code & 0b11;
+  const wheel = (code & 64) !== 0;
+  const drag = (code & 32) !== 0;
+  const modifiers = code & (4 | 8 | 16);
+  let button = "left";
+  if (wheel) button = buttonCode === 0 ? "wheel-up" : "wheel-down";
+  else if (buttonCode === 1) button = "middle";
+  else if (buttonCode === 2) button = "right";
+  else if (buttonCode === 3) button = "none";
+  const action = release ? "up" : drag ? "drag" : "down";
+  return new MouseEvent({ x, y, button, action, modifiers, raw: match[0] });
+}
+
+function parseX10MouseEvents(bytes) {
+  const events = [];
+  for (let i = 0; i + 5 < bytes.length; i++) {
+    if (bytes[i] !== 0x1b || bytes[i + 1] !== 0x5b || bytes[i + 2] !== 0x4d) continue;
+    const code = bytes[i + 3] - 32;
+    const x = bytes[i + 4] - 33;
+    const y = bytes[i + 5] - 33;
+    if (x < 0 || y < 0) continue;
+    const buttonCode = code & 0b11;
+    const wheel = (code & 64) !== 0;
+    const drag = (code & 32) !== 0;
+    let button = "left";
+    if (wheel) button = buttonCode === 0 ? "wheel-up" : "wheel-down";
+    else if (buttonCode === 1) button = "middle";
+    else if (buttonCode === 2) button = "right";
+    else if (buttonCode === 3) button = "none";
+    const action = buttonCode === 3 ? "up" : drag ? "drag" : "down";
+    events.push(new MouseEvent({ x, y, button, action, modifiers: code & (4 | 8 | 16), raw: decoder.decode(bytes.slice(i, i + 6)) }));
+    i += 5;
+  }
+  return events;
+}
+
+const KEY_MAP = {
+  "\x01": "ctrl-a",
+  "\x02": "ctrl-b",
+  "\x03": "ctrl-c",
+  "\x04": "ctrl-d",
+  "\x05": "ctrl-e",
+  "\x0c": "ctrl-l",
+  "\x06": "ctrl-f",
+  "\x07": "ctrl-g",
+  "\t": "tab",
+  "\x0b": "ctrl-k",
+  "\x0e": "ctrl-n",
+  "\x0f": "ctrl-o",
+  "\x10": "ctrl-p",
+  "\x11": "ctrl-q",
+  "\x12": "ctrl-r",
+  "\x13": "ctrl-s",
+  "\x14": "ctrl-t",
+  "\x15": "ctrl-u",
+  "\x16": "ctrl-v",
+  "\x17": "ctrl-w",
+  "\x18": "ctrl-x",
+  "\x19": "ctrl-y",
+  "\x1a": "ctrl-z",
+  "\x1f": "ctrl-underscore",
+  "\x7f": "backspace",
+  "\b": "backspace",
+  "\r": "enter",
+  "\n": "enter",
+  "\x1b": "escape",
+  "\x1b[A": "up",
+  "\x1b[B": "down",
+  "\x1b[C": "right",
+  "\x1b[D": "left",
+  "\x1b[1;2A": "shift-up",
+  "\x1b[1;2B": "shift-down",
+  "\x1b[1;2C": "shift-right",
+  "\x1b[1;2D": "shift-left",
+  "\x1b[2A": "shift-up",
+  "\x1b[2B": "shift-down",
+  "\x1b[2C": "shift-right",
+  "\x1b[2D": "shift-left",
+  "\x1b[1;5A": "ctrl-up",
+  "\x1b[1;5B": "ctrl-down",
+  "\x1b[1;5C": "ctrl-right",
+  "\x1b[1;5D": "ctrl-left",
+  "\x1b[1;5H": "ctrl-home",
+  "\x1b[1;5F": "ctrl-end",
+  "\x1b[5H": "ctrl-home",
+  "\x1b[5F": "ctrl-end",
+  "\x1b[5A": "ctrl-up",
+  "\x1b[5B": "ctrl-down",
+  "\x1b[5C": "ctrl-right",
+  "\x1b[5D": "ctrl-left",
+  "\x1b[1;6A": "shift-ctrl-up",
+  "\x1b[1;6B": "shift-ctrl-down",
+  "\x1b[1;6C": "shift-ctrl-right",
+  "\x1b[1;6D": "shift-ctrl-left",
+  // Shift+Home/End
+  "\x1b[1;2H": "shift-home",
+  "\x1b[2;1H": "shift-home",
+  "\x1b[1;2F": "shift-end",
+  "\x1b[2;1F": "shift-end",
+  // Shift+PageUp/Down
+  "\x1b[5;2~": "shift-pageup",
+  "\x1b[6;2~": "shift-pagedown",
+  // Alt+arrows
+  "\x1b[1;3A": "alt-up",
+  "\x1b[1;3B": "alt-down",
+  "\x1b[1;3C": "alt-right",
+  "\x1b[1;3D": "alt-left",
+  // Alt+Shift+arrows
+  "\x1b[1;4A": "alt-shift-up",
+  "\x1b[1;4B": "alt-shift-down",
+  "\x1b[1;4C": "alt-shift-right",
+  "\x1b[1;4D": "alt-shift-left",
+  "\x1b[H": "home",
+  "\x1b[F": "end",
+  "\x1b[1~": "home",
+  "\x1b[4~": "end",
+  "\x1b[3~": "delete",
+  "\x1b[5~": "pageup",
+  "\x1b[6~": "pagedown",
+  "\x1b[5;5~": "ctrl-pageup",
+  "\x1b[6;5~": "ctrl-pagedown",
+  "\x1b[7;5~": "ctrl-home",
+  "\x1b[8;5~": "ctrl-end",
+  "\x1b[Z": "backtab",
+  "\x1b,": "alt-comma",
+  "\x1b.": "alt-period",
+  "\x1b/": "alt-/",
+  "\x1b[": "alt-[",
+  "\x1b]": "alt-]",
+  "\x1b\t": "alt-tab",
+  "\x1b\r": "alt-enter",
+};
+
+const KEY_SEQUENCES = Object.keys(KEY_MAP)
+  .filter((seq) => seq !== "\x1b")
+  .sort((a, b) => b.length - a.length);
+
+function parseKeyEvents(text) {
+  const events = [];
+  let i = 0;
+  while (i < text.length) {
+    const match = KEY_SEQUENCES.find((seq) => text.startsWith(seq, i));
+    if (match) {
+      events.push(new KeyEvent(parseKey(match), match));
+      i += match.length;
+      continue;
+    }
+
+    if (text.charCodeAt(i) === 0x1b) {
+      const alt = text.slice(i, i + 2);
+      if (alt.length === 2 && alt[1] >= " " && alt[1] <= "~") {
+        events.push(new KeyEvent(parseKey(alt), alt));
+        i += 2;
+      } else {
+        events.push(new KeyEvent("escape", "\x1b"));
+        i++;
+      }
+      continue;
+    }
+
+    let j = i + 1;
+    while (j < text.length && text.charCodeAt(j) !== 0x1b && !KEY_MAP[text[j]]) j++;
+    const raw = text.slice(i, j);
+    events.push(new KeyEvent(parseKey(raw), raw));
+    i = j;
+  }
+  return events;
+}
+
+export function parseKey(text) {
+  if (KEY_MAP[text]) return KEY_MAP[text];
+  // ESC + single printable ASCII -> alt-{char}
+  if (text.length === 2 && text.charCodeAt(0) === 0x1b) {
+    const ch = text[1];
+    if (ch >= " " && ch <= "~") return `alt-${ch}`;
+  }
+  return text;
+}