buninu-linux 0.2.0

package/initramfs/buninu/apps/jsmdcui/src/cui/server.mjs

@@ -0,0 +1,128 @@
+#!/usr/bin/env bun
+
+import { evalBack } from "./rpc.mjs";
+
+const csl = console.log
+const mda = Bun.markdown.ansi
+
+
+import homepage from "./testapp.md.html"
+import * as backmod from "./testapp.md.back.js";
+
+export { homepage };
+
+/*
+// Wait until Bun fixes dynamic html import bundle
+
+process.env.PUBLIC_MDPATH ||= "testapp.md"
+
+const { default: homepage } = 
+    await import(
+      "./" + 
+      process.env.PUBLIC_MDPATH + 
+      ".html"
+    ) ;
+
+const backmod = 
+    await import(
+      './' +
+      process.env.PUBLIC_MDPATH + 
+      ".back.js"
+    ) ;
+    
+*/
+
+
+function json(data, init = {}) {
+  return Response.json(data, {
+    headers: {
+      "access-control-allow-origin": "*",
+      ...init.headers,
+    },
+    ...init,
+  });
+}
+
+
+export function main()
+{
+
+
+
+const basePath = "/" + crypto.randomUUID()
+const pathname = basePath + "/"
+const serverOptions = {
+  port: Number(process.env.PORT || 3000),
+  development: {
+    hmr: true,
+    console: true,
+  },
+  routes: {
+    [basePath]: (req) => Response.redirect(new URL(pathname, req.url), 308),
+    [pathname]: homepage,
+
+    [pathname + "rpc"]: async (req) => {
+      csl("\n"+mda("## "+req.method+" "+req.url))
+    
+      if (req.method === "OPTIONS") {
+        return new Response(null, {
+          headers: {
+            "access-control-allow-origin": "*",
+            "access-control-allow-methods": "POST,OPTIONS",
+            "access-control-allow-headers": "content-type",
+          },
+        });
+      }
+
+      if (req.method !== "POST") {
+        csl('illegal method')
+        return new Response("Method Not Allowed", { status: 405 });
+      }
+
+      try {
+        const packet = await req.json();
+        
+        csl('req json:',packet)
+        
+        const result = await evalBack(backmod, packet);
+
+        return json(result ?? null);
+      } catch (error) {
+        return json(
+          {
+            ok: false,
+            error: error?.stack || String(error),
+          },
+          { status: 400 },
+        );
+      }
+    },
+  },
+
+  fetch() {
+    return new Response("Not Found", { status: 404 });
+  },
+};
+
+let server;
+try {
+  server = Bun.serve(serverOptions);
+} catch (error) {
+  const addressInUse = error?.code === "EADDRINUSE"
+    || error?.cause?.code === "EADDRINUSE"
+    || /EADDRINUSE|address already in use/i.test(String(error?.message || error));
+  if (serverOptions.port !== 3000 || !addressInUse) throw error;
+  server = Bun.serve({ ...serverOptions, port: 0 });
+}
+
+console.error(mda("- Bun RPC server listening on"));
+console.log(`http://localhost:${server.port}${pathname}`);
+
+
+
+return server
+
+} // main
+
+if(import.meta.main)
+  main()

package/initramfs/buninu/apps/jsmdcui/src/cui/table-render.mjs

@@ -0,0 +1,286 @@
+import {
+  collectMarkdownHeadingDeclarations,
+} from "./heading-ids.mjs";
+import {
+  colorAnsiPlainRange,
+  replaceAnsiPlainRangePreservingControls,
+} from "./table-row-edit.mjs";
+
+function tableTopRange(line) {
+  const text = String(line ?? "");
+  const start = text.indexOf("┌");
+  const end = text.lastIndexOf("┐");
+  if (start < 0 || end <= start) return null;
+  const frame = text.slice(start, end + 1);
+  return /^┌─+(?:┬─+)*┐$/u.test(frame)
+    ? { start, end, frame, prefix: text.slice(0, start) }
+    : null;
+}
+
+function tableFrame(line, range) {
+  const text = String(line ?? "");
+  if (!text.startsWith(range.prefix)) return "";
+  return text.slice(range.prefix.length).trimEnd();
+}
+
+function isTableBottom(line, range) {
+  return /^└─+(?:┴─+)*┘$/u.test(tableFrame(line, range));
+}
+
+function isTableContentRow(line, range) {
+  return /^│ .* │$/u.test(tableFrame(line, range));
+}
+
+function isTableSeparator(line, range) {
+  return /^├─+(?:┼─+)*┤$/u.test(tableFrame(line, range));
+}
+
+function middleBorder(line, range) {
+  const text = String(line ?? "");
+  const frame = range.frame
+    .replace("┌", "├")
+    .replaceAll("┬", "┼")
+    .replace("┐", "┤");
+  return text.slice(0, range.start) + frame + text.slice(range.end + 1);
+}
+
+function unusedRowMarker(markdown) {
+  const candidates = [
+    "\u2060",
+    "\u200b",
+    "\u200c",
+    "\u2061",
+    "\u2062",
+    "\u2063",
+    "\ufeff",
+  ];
+  return candidates.find(marker => !markdown.includes(marker)) ?? null;
+}
+
+function tableDelimiter(line) {
+  return /^\s*(?:>\s*)*\|?\s*:?-{3,}:?\s*(?:\|\s*:?-{3,}:?\s*)+\|?\s*$/u
+    .test(String(line ?? ""));
+}
+
+function tableRow(line) {
+  const text = String(line ?? "");
+  return text.includes("|") && !/^\s*$/u.test(text);
+}
+
+function invisibleMarkerLine(line) {
+  return /^[\u200b\u200c\u2060-\u2063\ufeff]+$/u.test(
+    String(line ?? "").trim(),
+  );
+}
+
+function insertRowMarker(line, marker) {
+  const text = String(line ?? "");
+  const opening = /^(\s*(?:>\s*)*\|?\s*)/u.exec(text)?.[0] ?? "";
+  return text.slice(0, opening.length) + marker + text.slice(opening.length);
+}
+
+function markTableCheckboxPrefixes(line) {
+  return String(line ?? "").replace(
+    /(^|(?<!\\)\|)(\s*)\[( |x|X)\]/gu,
+    (_whole, boundary, whitespace, state) =>
+      `${boundary}${whitespace}${state === " " ? "☐" : "☒"}`,
+  );
+}
+
+export function markHeadingTableRows(markdown) {
+  const source = String(markdown ?? "");
+  const lines = source.split(/\r\n?|\n/u);
+  const token = unusedRowMarker(source);
+  const markers = [];
+  if (!token) return { markdown: source, markers, token: null };
+  let tableOrdinal = 0;
+
+  const headings = collectMarkdownHeadingDeclarations(source, {
+    includeEndLine: true,
+  });
+  for (const heading of headings) {
+    let header = Math.max(0, Number(heading.endLine) || heading.line);
+    while (
+      header < lines.length
+      && (!lines[header].trim() || invisibleMarkerLine(lines[header]))
+    ) header++;
+    const delimiter = header + 1;
+    if (
+      delimiter >= lines.length
+      || !tableRow(lines[header])
+      || !tableDelimiter(lines[delimiter])
+    ) continue;
+
+    const rows = [header];
+    for (let row = delimiter + 1; row < lines.length; row++) {
+      if (!tableRow(lines[row])) break;
+      rows.push(row);
+    }
+    if (rows.length < 2) continue;
+
+    for (const [rowOrdinal, lineIndex] of rows.entries()) {
+      lines[lineIndex] = markTableCheckboxPrefixes(lines[lineIndex]);
+      lines[lineIndex] = insertRowMarker(lines[lineIndex], token);
+      markers.push({
+        tableOrdinal,
+        rowOrdinal,
+        insertBefore: rowOrdinal > 1,
+      });
+    }
+    tableOrdinal++;
+  }
+
+  return { markdown: lines.join("\n"), markers, token };
+}
+
+export function addTuiTableRowSeparators(ansiText, plan) {
+  const markers = Array.isArray(plan?.markers) ? plan.markers : [];
+  if (markers.length === 0) return String(ansiText ?? "");
+
+  const ansiLines = String(ansiText ?? "").split("\n");
+  const plainLines = Bun.stripANSI(String(ansiText ?? "")).split("\n");
+  const output = [];
+  const token = String(plan?.token ?? "");
+  let markerOrdinal = 0;
+  let activeRange = null;
+  let activeTopLine = "";
+
+  for (let index = 0; index < ansiLines.length; index++) {
+    const top = tableTopRange(plainLines[index]);
+    if (top) {
+      activeRange = top;
+      activeTopLine = plainLines[index];
+    }
+
+    const found = token && plainLines[index].includes(token)
+      ? markers[markerOrdinal++]
+      : null;
+    if (found?.insertBefore && activeRange) {
+      output.push(
+        `\x1b[2m${middleBorder(activeTopLine, activeRange)}\x1b[0m`,
+      );
+    }
+    let line = ansiLines[index];
+    if (token) line = line.replaceAll(token, "");
+    output.push(line);
+
+    if (activeRange && isTableBottom(plainLines[index], activeRange)) {
+      activeRange = null;
+      activeTopLine = "";
+    }
+  }
+
+  return output.join("\n");
+}
+
+export function convertTuiTableCheckboxes(ansiText) {
+  const ansiLines = String(ansiText ?? "").split("\n");
+  const plainLines = Bun.stripANSI(String(ansiText ?? "")).split("\n");
+  let activeRange = null;
+
+  for (let row = 0; row < plainLines.length; row++) {
+    const top = tableTopRange(plainLines[row]);
+    if (top) activeRange = top;
+    if (!activeRange) continue;
+    if (isTableBottom(plainLines[row], activeRange)) {
+      activeRange = null;
+      continue;
+    }
+    if (!isTableContentRow(plainLines[row], activeRange)) continue;
+
+    const separators = [];
+    for (let index = activeRange.start; index <= activeRange.end; index++) {
+      if (plainLines[row][index] === "│") separators.push(index);
+    }
+    for (let col = 0; col + 1 < separators.length; col++) {
+      const start = separators[col] + 1;
+      const end = separators[col + 1];
+      const source = plainLines[row].slice(start, end);
+      const match = /^(\s*)(?:\[( |x|X)\]|(☐|☒))/u.exec(source);
+      if (!match) continue;
+      const glyph = match[3] ?? (match[2] === " " ? "☐" : "☒");
+      let replacement = source;
+      if (!match[3]) {
+        replacement =
+          source.slice(0, match[1].length)
+          + glyph
+          + source.slice(match[0].length);
+        const missing = Bun.stringWidth(source) - Bun.stringWidth(replacement);
+        const trailing = replacement.match(/\s*$/u)?.[0].length ?? 0;
+        replacement =
+          replacement.slice(0, replacement.length - trailing)
+          + " ".repeat(Math.max(0, missing))
+          + replacement.slice(replacement.length - trailing);
+        ansiLines[row] = replaceAnsiPlainRangePreservingControls(
+          ansiLines[row],
+          start,
+          end,
+          replacement,
+        );
+      }
+      if (glyph === "☒") {
+        const checkboxAt = start + match[1].length;
+        ansiLines[row] = colorAnsiPlainRange(
+          ansiLines[row],
+          checkboxAt,
+          checkboxAt + glyph.length,
+          glyph,
+        );
+      }
+      plainLines[row] =
+        plainLines[row].slice(0, start)
+        + replacement
+        + plainLines[row].slice(end);
+    }
+  }
+  return ansiLines.join("\n");
+}
+
+export function tuiTableStripeRows(lines) {
+  const input = Array.isArray(lines) ? lines : [];
+  const striped = new Set();
+
+  for (let index = 0; index < input.length; index++) {
+    const range = tableTopRange(input[index]);
+    if (!range) continue;
+    let body = false;
+    let bodyRow = 0;
+    for (let row = index + 1; row < input.length; row++) {
+      if (isTableBottom(input[row], range)) {
+        index = row;
+        break;
+      }
+      if (isTableSeparator(input[row], range)) {
+        if (!body) {
+          body = true;
+          bodyRow = 1;
+        } else {
+          bodyRow++;
+        }
+        continue;
+      }
+      if (!isTableContentRow(input[row], range)) continue;
+      if (!body) {
+        striped.add(row);
+        continue;
+      }
+      if (bodyRow % 2 === 0) striped.add(row);
+    }
+  }
+  return striped;
+}
+
+export function markTuiTableStripeStyles(styleLines, lines) {
+  if (!Array.isArray(styleLines) || !Array.isArray(lines)) return styleLines;
+  for (const row of tuiTableStripeRows(lines)) {
+    const line = String(lines[row] ?? "");
+    const styles = styleLines[row] ?? (styleLines[row] = []);
+    for (let index = 0; index < line.length; index++) {
+      styles[index] = {
+        ...(styles[index] ?? {}),
+        mdcuiTableStripe: true,
+      };
+    }
+  }
+  return styleLines;
+}

package/initramfs/buninu/apps/jsmdcui/src/cui/table-row-edit.mjs

@@ -0,0 +1,226 @@
+const graphemeSegmenter = typeof Intl.Segmenter === "function"
+  ? new Intl.Segmenter(undefined, { granularity: "grapheme" })
+  : null;
+
+export function isMdcuiTableRow(line) {
+  return /^\s*│ .* │\s*$/u.test(String(line ?? ""));
+}
+
+function graphemes(line) {
+  const text = String(line ?? "");
+  if (graphemeSegmenter) {
+    return [...graphemeSegmenter.segment(text)].map((item, index, items) => ({
+      text: item.segment,
+      start: item.index,
+      end: items[index + 1]?.index ?? text.length,
+    }));
+  }
+  const result = [];
+  for (let start = 0; start < text.length;) {
+    const codePoint = text.codePointAt(start);
+    const length = codePoint > 0xffff ? 2 : 1;
+    result.push({ text: text.slice(start, start + length), start, end: start + length });
+    start += length;
+  }
+  return result;
+}
+
+function stringWidth(text) {
+  return typeof globalThis.Bun?.stringWidth === "function"
+    ? Bun.stringWidth(String(text ?? ""))
+    : [...String(text ?? "")].length;
+}
+
+function replacementResult(line, target, replacement, cursor) {
+  const next = line.slice(0, target.start) + replacement + line.slice(target.end);
+  if (stringWidth(next) !== stringWidth(line)) return null;
+  return {
+    line: next,
+    cursor,
+    start: target.start,
+    end: target.end,
+    replacement,
+  };
+}
+
+function isTableSeparator(target) {
+  return target?.text === "│";
+}
+
+function isTablePadding(line, target) {
+  return target?.text === " " && (
+    line[target.start - 1] === "│"
+    || line[target.end] === "│"
+  );
+}
+
+export function backspaceMdcuiTableRow(line, cursor) {
+  const text = String(line ?? "");
+  if (!isMdcuiTableRow(text)) return null;
+  const target = graphemes(text)
+    .filter(item => item.end <= cursor)
+    .at(-1);
+  if (
+    !target
+    || isTableSeparator(target)
+    || isTablePadding(text, target)
+  ) return null;
+  return replacementResult(
+    text,
+    target,
+    " ".repeat(Math.max(1, stringWidth(target.text))),
+    target.start,
+  );
+}
+
+export function deleteMdcuiTableRow(line, cursor) {
+  const text = String(line ?? "");
+  if (!isMdcuiTableRow(text)) return null;
+  const target = graphemes(text)
+    .find(item => item.start >= cursor || (item.start < cursor && item.end > cursor));
+  if (!target || isTableSeparator(target)) return null;
+  return replacementResult(
+    text,
+    target,
+    " ".repeat(Math.max(1, stringWidth(target.text))),
+    target.start,
+  );
+}
+
+export function overwriteMdcuiTableRow(line, cursor, input) {
+  const text = String(line ?? "");
+  const value = String(input ?? "");
+  if (!isMdcuiTableRow(text) || !value || /\r|\n/u.test(value)) return null;
+  const inputWidth = stringWidth(value);
+  const items = graphemes(text);
+  const targetIndex = items.findIndex(
+    item => item.start >= cursor || (item.start < cursor && item.end > cursor),
+  );
+  const target = items[targetIndex];
+  if (
+    !target
+    || isTableSeparator(target)
+    || (isTablePadding(text, target) && value !== " ")
+  ) return null;
+  if (inputWidth <= 0) return null;
+
+  let end = target.end;
+  let targetWidth = stringWidth(target.text);
+  for (
+    let index = targetIndex + 1;
+    targetWidth < inputWidth && index < items.length;
+    index++
+  ) {
+    const next = items[index];
+    if (isTableSeparator(next) || isTablePadding(text, next)) return null;
+    targetWidth += stringWidth(next.text);
+    end = next.end;
+  }
+  if (inputWidth > targetWidth) return null;
+  const replacement = value + " ".repeat(targetWidth - inputWidth);
+  return replacementResult(
+    text,
+    { ...target, end },
+    replacement,
+    target.start + value.length,
+  );
+}
+
+function ansiControlEnd(input, start) {
+  if (input[start] !== "\x1b") return start;
+  if (input[start + 1] === "[") {
+    let index = start + 2;
+    while (index < input.length) {
+      const code = input.charCodeAt(index++);
+      if (code >= 0x40 && code <= 0x7e) break;
+    }
+    return index;
+  }
+  if (input[start + 1] === "]") {
+    const bel = input.indexOf("\x07", start + 2);
+    const st = input.indexOf("\x1b\\", start + 2);
+    if (bel < 0 && st < 0) return input.length;
+    return bel >= 0 && (st < 0 || bel < st) ? bel + 1 : st + 2;
+  }
+  return Math.min(input.length, start + 2);
+}
+
+function ansiRawOffset(input, target, controlsAtBoundary) {
+  let plain = 0;
+  for (let raw = 0; raw < input.length;) {
+    if (!controlsAtBoundary && plain >= target) return raw;
+    if (input[raw] === "\x1b") {
+      raw = ansiControlEnd(input, raw);
+      continue;
+    }
+    if (plain >= target) return raw;
+    const codePoint = input.codePointAt(raw);
+    const length = codePoint > 0xffff ? 2 : 1;
+    plain += length;
+    raw += length;
+  }
+  return input.length;
+}
+
+export function replaceAnsiPlainRange(ansiLine, start, end, replacement) {
+  const input = String(ansiLine ?? "");
+  const rawStart = ansiRawOffset(input, start, true);
+  const rawEnd = ansiRawOffset(input, end, false);
+  return input.slice(0, rawStart) + replacement + input.slice(rawEnd);
+}
+
+export function replaceAnsiPlainRangePreservingControls(
+  ansiLine,
+  start,
+  end,
+  replacement,
+) {
+  const input = String(ansiLine ?? "");
+  const rawStart = ansiRawOffset(input, start, true);
+  const rawEnd = ansiRawOffset(input, end, false);
+  const segment = input.slice(rawStart, rawEnd);
+  let controls = "";
+  let inserted = false;
+
+  for (let raw = 0; raw < segment.length;) {
+    if (segment[raw] === "\x1b") {
+      const controlEnd = ansiControlEnd(segment, raw);
+      controls += segment.slice(raw, controlEnd);
+      raw = controlEnd;
+      continue;
+    }
+    if (!inserted) {
+      controls += String(replacement ?? "");
+      inserted = true;
+    }
+    const codePoint = segment.codePointAt(raw);
+    raw += codePoint > 0xffff ? 2 : 1;
+  }
+  if (!inserted) controls += String(replacement ?? "");
+  return input.slice(0, rawStart) + controls + input.slice(rawEnd);
+}
+
+export function colorAnsiPlainRange(
+  ansiLine,
+  start,
+  end,
+  text,
+  sgr = "\x1b[32m",
+) {
+  const input = String(ansiLine ?? "");
+  const rawStart = ansiRawOffset(input, start, true);
+  const active = [];
+  for (const match of input.slice(0, rawStart).matchAll(/\x1b\[([0-9;]*)m/gu)) {
+    const parameters = match[1].split(";").filter(Boolean).map(Number);
+    if (parameters.length === 0 || parameters.includes(0)) active.length = 0;
+    active.push(match[0]);
+  }
+  const replacement =
+    sgr + String(text ?? "") + "\x1b[0m" + active.join("");
+  return replaceAnsiPlainRangePreservingControls(
+    input,
+    start,
+    end,
+    replacement,
+  );
+}

package/initramfs/buninu/apps/jsmdcui/src/cui/task-checkbox.mjs

@@ -0,0 +1,60 @@
+export function toggleTaskCheckboxBeforeColumn(line, column) {
+  const text = String(line ?? "");
+  const end = Math.max(0, Math.min(text.length, Math.trunc(Number(column) || 0) + 1));
+  const prefix = text.slice(0, end);
+  const uncheckedAt = prefix.lastIndexOf("☐");
+  const checkedAt = prefix.lastIndexOf("☒");
+  const checkboxAt = Math.max(uncheckedAt, checkedAt);
+
+  if (checkboxAt < 0) return { line: text, toggled: false };
+
+  const replacement = text[checkboxAt] === "☐" ? "☒" : "☐";
+  return {
+    line: text.slice(0, checkboxAt) + replacement + text.slice(checkboxAt + 1),
+    toggled: true,
+    checkboxAt,
+    checked: replacement === "☒",
+  };
+}
+
+export function updateAnsiTaskCheckbox(ansiLine, checkboxAt, checked) {
+  const input = String(ansiLine ?? "");
+  const target = checked ? "☒" : "☐";
+  const sgr = `\x1b[${checked ? "32" : "2"}m`;
+  let plainIndex = 0;
+
+  for (let i = 0; i < input.length;) {
+    if (input[i] === "\x1b" && input[i + 1] === "[") {
+      let end = i + 2;
+      while (end < input.length) {
+        const code = input.charCodeAt(end);
+        if (code >= 0x40 && code <= 0x7e) { end++; break; }
+        end++;
+      }
+      i = end;
+      continue;
+    }
+    if (input[i] === "\x1b" && input[i + 1] === "]") {
+      const bel = input.indexOf("\x07", i + 2);
+      const st = input.indexOf("\x1b\\", i + 2);
+      if (bel < 0 && st < 0) break;
+      i = bel >= 0 && (st < 0 || bel < st) ? bel + 1 : st + 2;
+      continue;
+    }
+
+    const codePoint = input.codePointAt(i);
+    const charLength = codePoint > 0xffff ? 2 : 1;
+    if (plainIndex === checkboxAt && (input[i] === "☐" || input[i] === "☒")) {
+      const prefix = input.slice(0, i);
+      const immediateSgr = prefix.match(/\x1b\[[0-9;]*m$/);
+      const beforeStyle = immediateSgr
+        ? prefix.slice(0, prefix.length - immediateSgr[0].length) + sgr
+        : prefix;
+      return beforeStyle + target + input.slice(i + charLength);
+    }
+    plainIndex += charLength;
+    i += charLength;
+  }
+
+  return input;
+}