jsmdcui 0.5.0 → 0.7.0

package/src/cui/id-collision.mjs

@@ -0,0 +1,151 @@
+function markdownHeadingDeclarations(markdown) {
+  const lines = String(markdown).split(/\r?\n/);
+  const declarations = [];
+  let fence = null;
+
+  for (let index = 0; index < lines.length; index++) {
+    const line = lines[index];
+    const fenceMatch = line.match(/^ {0,3}(`{3,}|~{3,})/);
+    if (fenceMatch) {
+      const marker = fenceMatch[1][0];
+      const length = fenceMatch[1].length;
+      if (!fence) fence = { marker, length };
+      else if (marker === fence.marker && length >= fence.length) fence = null;
+      continue;
+    }
+    if (fence) continue;
+
+    const atx = line.match(/^ {0,3}(#{1,6})(?:[ \t]+(.*?)\s*#*\s*|[ \t]*)$/);
+    if (atx) {
+      declarations.push({
+        line: index + 1,
+        source: line.trim(),
+        markdown: line,
+      });
+      continue;
+    }
+
+    if (index + 1 < lines.length && line.trim() && /^ {0,3}(?:=+|-+)\s*$/.test(lines[index + 1])) {
+      declarations.push({
+        line: index + 1,
+        source: `${line.trim()} / ${lines[index + 1].trim()}`,
+        markdown: `${line}\n${lines[index + 1]}`,
+      });
+      index++;
+    }
+  }
+
+  if (!declarations.length) return [];
+  return declarations.map((item) => {
+    // Render headings independently so Bun cannot hide a source-level
+    // collision by suffixing later duplicates as "-1", "-2", and so on.
+    const html = String(Bun.markdown.html(item.markdown, { headings: { ids: true } }));
+    const id = html.match(/<h[1-6]\b[^>]*\bid="([^"]*)"[^>]*>/i)?.[1] ?? "";
+    return {
+      id,
+      kind: "heading",
+      line: item.line,
+      source: item.source,
+    };
+  }).filter((item) => item.id);
+}
+
+function fencedBlockDeclarations(markdown) {
+  const lines = String(markdown).split(/\r?\n/);
+  const declarations = [];
+  let fence = null;
+
+  for (let index = 0; index < lines.length; index++) {
+    const line = lines[index];
+    if (!fence) {
+      const opening = line.match(/^ {0,3}(`{3,}|~{3,})\s*(\S+)?\s*$/);
+      if (!opening) continue;
+      fence = { marker: opening[1][0], length: opening[1].length };
+      const identity = String(opening[2] ?? "").match(/^([A-Za-z_][\w:-]*)(?:#([A-Za-z_][\w:-]*))?(?:\.[A-Za-z_][\w:-]*)*$/);
+      if (identity?.[2]) {
+        declarations.push({
+          id: identity[2],
+          kind: `${identity[1]} fenced block`,
+          line: index + 1,
+          source: line.trim(),
+        });
+      }
+      continue;
+    }
+
+    const closing = line.match(/^ {0,3}(`{3,}|~{3,})\s*$/);
+    if (closing && closing[1][0] === fence.marker && closing[1].length >= fence.length)
+      fence = null;
+  }
+
+  return declarations;
+}
+
+export function checkMarkdownIdCollisions(markdown) {
+  const declarations = [
+    ...markdownHeadingDeclarations(markdown),
+    ...fencedBlockDeclarations(markdown),
+  ].sort((a, b) => a.line - b.line);
+  const byId = new Map();
+  for (const declaration of declarations) {
+    if (!byId.has(declaration.id)) byId.set(declaration.id, []);
+    byId.get(declaration.id).push(declaration);
+  }
+  const collisions = [...byId.entries()]
+    .filter(([, items]) => items.length > 1)
+    .map(([id, items]) => ({ id, declarations: items }));
+  return { declarations, collisions };
+}
+
+function inlineCode(value) {
+  const text = String(value);
+  const longest = Math.max(0, ...[...text.matchAll(/`+/g)].map((match) => match[0].length));
+  const delimiter = "`".repeat(longest + 1);
+  const padding = text.startsWith("`") || text.endsWith("`") ? " " : "";
+  return `${delimiter}${padding}${text}${padding}${delimiter}`;
+}
+
+export function formatMarkdownIdCheck(path, result) {
+  const headings = result.declarations.filter((item) => item.kind === "heading").length;
+  const fencedBlocks = result.declarations.length - headings;
+  const lines = [
+    "# Markdown UI ID Check",
+    "",
+    `- File: ${inlineCode(path)}`,
+    `- Selectable IDs: **${result.declarations.length}**`,
+    `  * Headings: **${headings}**`,
+    `  * Fenced blocks: **${fencedBlocks}**`,
+  ];
+
+  if (!result.collisions.length) {
+    lines.push("", "## No ID collisions found");
+    return lines.join("\n");
+  }
+
+  lines.push("", `## FAIL — Found ${result.collisions.length} colliding ID(s)`);
+  for (const collision of result.collisions) {
+    lines.push("", `### ID ${inlineCode(`#${collision.id}`)}`);
+    lines.push("", `- Declarations: **${collision.declarations.length}**`);
+    for (const declaration of collision.declarations) {
+      lines.push(`  * Line **${declaration.line}**`);
+      lines.push(`    - Type: ${declaration.kind}`);
+      lines.push(`    - Source: ${inlineCode(declaration.source)}`);
+    }
+  }
+  lines.push("", "## Suggested fix", "", "- Rename the heading or fenced block so every selectable ID is unique.");
+  return lines.join("\n");
+}
+
+function statusBanner(label, color, fallbackColor) {
+  const foreground = Bun.color?.(color, "ansi-16m") || fallbackColor;
+  return `${foreground}\x1b[1m${label}\x1b[0m\n${foreground}\x1b[2m${"═".repeat(label.length)}\x1b[0m\n`;
+}
+
+export function formatMarkdownIdCheckAnsi(path, result) {
+  let output = String(Bun.markdown.ansi(formatMarkdownIdCheck(path, result)));
+  if (!output.endsWith("\n")) output += "\n";
+  output += "\n" + (result.collisions.length
+    ? statusBanner("FAILED", "#ff3030", "\x1b[31m")
+    : statusBanner("PASSED", "#00d75f", "\x1b[32m"));
+  return output;
+}

package/src/cui/kitty-debug.mjs

@@ -0,0 +1,25 @@
+import { appendFileSync, writeFileSync } from "node:fs";
+import { resolve } from "node:path";
+
+export const KITTY_DEBUG_LOG = resolve(import.meta.dir, "../..", "kitty-placement.log");
+export const KITTY_DEBUG_ENABLED = /^(1|true|yes|on)$/i.test(
+  String(process.env.JSMDCUI_KITTY_DEBUG ?? ""),
+);
+
+if (KITTY_DEBUG_ENABLED) {
+  try {
+    writeFileSync(KITTY_DEBUG_LOG, "");
+  } catch {}
+}
+
+export function logKittyPlacement(stage, details = {}) {
+  if (!KITTY_DEBUG_ENABLED) return;
+  try {
+    appendFileSync(KITTY_DEBUG_LOG, JSON.stringify({
+      time: new Date().toISOString(),
+      pid: process.pid,
+      stage,
+      ...details,
+    }) + "\n");
+  } catch {}
+}

package/src/cui/kitty-images.mjs

@@ -0,0 +1,190 @@
+import { dirname, resolve } from "node:path";
+import { fileURLToPath } from "node:url";
+import { logKittyPlacement } from "./kitty-debug.mjs";
+import { fetchHttpBytes as defaultFetchHttpBytes } from "../platform/commands.js";
+
+const PNG = Buffer.from([0x89, 0x50, 0x4e, 0x47, 0x0d, 0x0a, 0x1a, 0x0a]);
+
+function imageSize(buffer) {
+  if (buffer.length >= 24 && buffer.subarray(0, 8).equals(PNG)) {
+    return { mime: "image/png", width: buffer.readUInt32BE(16), height: buffer.readUInt32BE(20) };
+  }
+  const gif = buffer.toString("ascii", 0, 6);
+  if (buffer.length >= 10 && (gif === "GIF87a" || gif === "GIF89a")) {
+    return { mime: "image/gif", width: buffer.readUInt16LE(6), height: buffer.readUInt16LE(8) };
+  }
+  if (buffer.length >= 26 && buffer.toString("ascii", 0, 2) === "BM") {
+    return { mime: "image/bmp", width: Math.abs(buffer.readInt32LE(18)), height: Math.abs(buffer.readInt32LE(22)) };
+  }
+  if (buffer.length >= 16 && buffer.toString("ascii", 0, 4) === "RIFF" && buffer.toString("ascii", 8, 12) === "WEBP") {
+    const kind = buffer.toString("ascii", 12, 16);
+    if (kind === "VP8 " && buffer.length >= 30) {
+      return {
+        mime: "image/webp",
+        width: buffer.readUInt16LE(26) & 0x3fff,
+        height: buffer.readUInt16LE(28) & 0x3fff,
+      };
+    }
+    if (kind === "VP8L" && buffer.length >= 25) {
+      const bits = buffer[21] | (buffer[22] << 8) | (buffer[23] << 16) | (buffer[24] << 24);
+      return {
+        mime: "image/webp",
+        width: (bits & 0x3fff) + 1,
+        height: ((bits >> 14) & 0x3fff) + 1,
+      };
+    }
+    if (kind === "VP8X" && buffer.length >= 30) {
+      return {
+        mime: "image/webp",
+        width: 1 + buffer.readUIntLE(24, 3),
+        height: 1 + buffer.readUIntLE(27, 3),
+      };
+    }
+  }
+  if (buffer.length >= 4 && buffer[0] === 0xff && buffer[1] === 0xd8) {
+    let offset = 2;
+    while (offset + 8 < buffer.length) {
+      if (buffer[offset] !== 0xff) { offset++; continue; }
+      const marker = buffer[offset + 1];
+      offset += 2;
+      if (marker === 0xd8 || marker === 0xd9 || (marker >= 0xd0 && marker <= 0xd7)) continue;
+      if (offset + 2 > buffer.length) break;
+      const length = buffer.readUInt16BE(offset);
+      if (length < 2 || offset + length > buffer.length) break;
+      const sof = (marker >= 0xc0 && marker <= 0xc3) ||
+        (marker >= 0xc5 && marker <= 0xc7) ||
+        (marker >= 0xc9 && marker <= 0xcb) ||
+        (marker >= 0xcd && marker <= 0xcf);
+      if (sof && length >= 7) {
+        return { mime: "image/jpeg", width: buffer.readUInt16BE(offset + 5), height: buffer.readUInt16BE(offset + 3) };
+      }
+      offset += length;
+    }
+  }
+  const svg = buffer.subarray(0, Math.min(buffer.length, 8192)).toString("utf8");
+  if (svg.includes("<svg")) {
+    const width = svg.match(/\bwidth=["']([0-9.]+)(?:px)?["']/i);
+    const height = svg.match(/\bheight=["']([0-9.]+)(?:px)?["']/i);
+    if (width && height) {
+      return { mime: "image/svg+xml", width: Math.round(Number(width[1])), height: Math.round(Number(height[1])) };
+    }
+    const viewBox = svg.match(/\bviewBox=["'][^"']*?([0-9.]+)[ ,]+([0-9.]+)\s*["']/i);
+    if (viewBox) {
+      return { mime: "image/svg+xml", width: Math.round(Number(viewBox[1])), height: Math.round(Number(viewBox[2])) };
+    }
+  }
+  return null;
+}
+
+function isHttpUrl(value) {
+  return /^https?:\/\//i.test(String(value ?? ""));
+}
+
+function imageSource(href, markdownPath, allowUrl) {
+  try {
+    if (href.startsWith("file:")) return { kind: "local", value: fileURLToPath(href) };
+    if (process.platform === "win32" && /^[A-Za-z]:[\\/]/.test(href)) {
+      return { kind: "local", value: resolve(href) };
+    }
+    if (isHttpUrl(href)) {
+      return allowUrl ? { kind: "remote", value: new URL(href).href } : null;
+    }
+    if (href.startsWith("//")) {
+      if (!allowUrl) return null;
+      const protocol = isHttpUrl(markdownPath) ? new URL(markdownPath).protocol : "https:";
+      return { kind: "remote", value: new URL(`${protocol}${href}`).href };
+    }
+    if (/^[A-Za-z][A-Za-z\d+.-]*:/.test(href)) return null;
+    if (isHttpUrl(markdownPath)) {
+      return allowUrl ? { kind: "remote", value: new URL(href, markdownPath).href } : null;
+    }
+    const decoded = decodeURIComponent(href.replace(/[?#].*$/, ""));
+    return {
+      kind: "local",
+      value: resolve(markdownPath ? dirname(markdownPath) : process.cwd(), decoded),
+    };
+  } catch {
+    return null;
+  }
+}
+
+function stableImageId(pathname, line, data) {
+  let hash = 2166136261;
+  for (const byte of Buffer.concat([Buffer.from(`${pathname}\0${line}\0`), data])) {
+    hash ^= byte;
+    hash = Math.imul(hash, 16777619);
+  }
+  return (hash >>> 0) % 2147483646 + 1;
+}
+
+export function fitKittyImageToWidth(image, maxCols) {
+  const originalCols = Math.max(1, Math.trunc(Number(image?.cols) || 1));
+  const originalRows = Math.max(1, Math.trunc(Number(image?.rows) || 1));
+  const availableCols = Math.max(1, Math.trunc(Number(maxCols) || 1));
+  const cols = Math.min(originalCols, availableCols);
+  const rows = Math.max(1, Math.round(originalRows * cols / originalCols));
+  return { cols, rows };
+}
+
+export async function prepareKittyImages(ansiText, markdownPath, terminalCols = 80, options = {}) {
+  const inputLines = String(ansiText).split("\n");
+  const outputLines = [];
+  const images = [];
+  const maxCols = Math.max(1, Math.trunc(Number(terminalCols) || 80));
+  const oscImage = /\x1b\]8;;([^\x1b]*)\x1b\\(?=[^\n]*📷)/;
+
+  for (let sourceLine = 0; sourceLine < inputLines.length; sourceLine++) {
+    const line = inputLines[sourceLine];
+    const match = line.match(oscImage);
+    const source = match ? imageSource(match[1], markdownPath, options.allowUrl === true) : null;
+    if (!source) {
+      outputLines.push(line);
+      continue;
+    }
+    try {
+      let data;
+      if (source.kind === "remote") {
+        const fetchBytes = options.fetchHttpBytes ?? defaultFetchHttpBytes;
+        data = Buffer.from(await fetchBytes(source.value));
+      } else {
+        const file = Bun.file(source.value);
+        if (!(await file.exists())) throw new Error("missing image");
+        data = Buffer.from(await file.arrayBuffer());
+      }
+      const size = imageSize(data);
+      if (!size?.width || !size?.height) throw new Error("unsupported image");
+      const estimatedCols = Math.max(1, Math.round(size.width / 8));
+      const cols = Math.min(maxCols, estimatedCols);
+      const rows = Math.max(1, Math.round((cols * size.height) / size.width / 2));
+      const lineIndex = outputLines.length;
+      outputLines.push(line, ...Array(Math.max(0, rows - 1)).fill(""));
+      images.push({
+        id: stableImageId(source.value, sourceLine, data),
+        line: lineIndex,
+        cols,
+        rows,
+        pixelWidth: size.width,
+        pixelHeight: size.height,
+        mime: size.mime,
+        data,
+        path: source.value,
+      });
+      logKittyPlacement("image-prepared", {
+        path: source.value,
+        sourceKind: source.kind,
+        sourceLine,
+        renderedLine: lineIndex,
+        imageId: images.at(-1).id,
+        intrinsicWidth: size.width,
+        intrinsicHeight: size.height,
+        cols,
+        rows,
+        terminalCols: maxCols + 1,
+      });
+    } catch {
+      // An unavailable or unsupported image remains the normal Markdown link.
+      outputLines.push(line);
+    }
+  }
+  return { rendered: outputLines.join("\n"), images };
+}

package/src/cui/rpc.mjs

@@ -66,6 +66,169 @@ function webDollarValue(element)
   return String(element?.textContent ?? "").replace(/\n$/, "");
 }
 
+function isWebHeading(element)
+{
+  return /^h[1-6]$/i.test(String(element?.tagName ?? ""));
+}
+
+function firstHeadingList(heading)
+{
+  for (let sibling = heading?.nextElementSibling; sibling; sibling = sibling.nextElementSibling) {
+    if (isWebHeading(sibling) || String(sibling.tagName ?? "").toLowerCase() === "section")
+      break;
+    if (sibling.matches?.("ul, ol")) return sibling;
+    const list = sibling.querySelector?.("ul, ol");
+    if (list) return list;
+  }
+  return null;
+}
+
+function directTaskCheckbox(item)
+{
+  for (const checkbox of item?.querySelectorAll?.('input[type="checkbox"]') ?? []) {
+    if (checkbox.closest?.("li.task-list-item") === item) return checkbox;
+  }
+  return null;
+}
+
+function webTaskItemValue(item, checkbox)
+{
+  const label = checkbox?.closest?.("label");
+  if (label && label.closest?.("li.task-list-item") === item)
+    return String(label.textContent ?? "").trim();
+
+  const copy = item.cloneNode?.(true);
+  for (const nested of copy?.querySelectorAll?.("ul, ol") ?? []) nested.remove?.();
+  for (const input of copy?.querySelectorAll?.('input[type="checkbox"]') ?? []) input.remove?.();
+  return String(copy?.textContent ?? "").trim();
+}
+
+function webHeadingValue(heading)
+{
+  const single = String(heading?.id ?? "").startsWith("select");
+  const list = firstHeadingList(heading);
+  if (!list) return single ? null : [];
+
+  const selected = [];
+  for (const item of list.children ?? []) {
+    if (!item.matches?.("li.task-list-item")) continue;
+    const checkbox = directTaskCheckbox(item);
+    if (!checkbox?.checked) continue;
+    const value = webTaskItemValue(item, checkbox);
+    if (single) return value;
+    selected.push(value);
+  }
+  return single ? null : selected;
+}
+
+function directWebTaskItems(list)
+{
+  const items = [];
+  for (const item of list?.children ?? []) {
+    if (!item.matches?.("li.task-list-item")) continue;
+    if (directTaskCheckbox(item)) items.push(item);
+  }
+  return items;
+}
+
+function webTaskItemSnapshot(item)
+{
+  const checkbox = directTaskCheckbox(item);
+  return {
+    value: webTaskItemValue(item, checkbox),
+    checked: Boolean(checkbox?.checked),
+  };
+}
+
+function normalizedTaskItem(input)
+{
+  if (input && typeof input === "object") {
+    return {
+      value: String(input.value ?? input.label ?? "").replace(/\r?\n/g, " "),
+      checked: Boolean(input.checked),
+    };
+  }
+  return {
+    value: String(input ?? "").replace(/\r?\n/g, " "),
+    checked: false,
+  };
+}
+
+function normalizedSpliceRange(length, argumentCount, start, deleteCount)
+{
+  if (argumentCount === 0) return { start: 0, deleteCount: 0 };
+  let relativeStart = Number(start);
+  if (Number.isNaN(relativeStart)) relativeStart = 0;
+  relativeStart = Math.trunc(relativeStart);
+  const actualStart = relativeStart < 0
+    ? Math.max(length + relativeStart, 0)
+    : Math.min(relativeStart, length);
+  if (argumentCount === 1) return { start: actualStart, deleteCount: length - actualStart };
+  let requestedDelete = Number(deleteCount);
+  if (Number.isNaN(requestedDelete)) requestedDelete = 0;
+  requestedDelete = Math.max(0, Math.trunc(requestedDelete));
+  return {
+    start: actualStart,
+    deleteCount: Math.min(requestedDelete, length - actualStart),
+  };
+}
+
+function appendWebTaskItem(list, input, before = null)
+{
+  const documentObject = list?.ownerDocument;
+  if (!documentObject?.createElement || !documentObject?.createTextNode) return false;
+
+  const itemValue = normalizedTaskItem(input);
+  const item = documentObject.createElement("li");
+  item.classList?.add("task-list-item");
+  const label = documentObject.createElement("label");
+  const checkbox = documentObject.createElement("input");
+  checkbox.type = "checkbox";
+  checkbox.classList?.add("task-list-item-checkbox");
+  checkbox.checked = itemValue.checked;
+  label.append(checkbox, documentObject.createTextNode(itemValue.value));
+  item.append(label);
+  list.insertBefore(item, before);
+  return true;
+}
+
+function mutateWebHeadingList(heading, method, args)
+{
+  const list = firstHeadingList(heading);
+  if (!list) {
+    if (method === "push" || method === "unshift") return 0;
+    if (method === "splice") return [];
+    return undefined;
+  }
+
+  const items = directWebTaskItems(list);
+  if (method === "splice") {
+    const range = normalizedSpliceRange(items.length, args.length, args[0], args[1]);
+    const removed = items
+      .slice(range.start, range.start + range.deleteCount)
+      .map((item) => webTaskItemValue(item, directTaskCheckbox(item)));
+    const before = items[range.start] ?? null;
+    for (const input of args.slice(2)) appendWebTaskItem(list, input, before);
+    for (const item of items.slice(range.start, range.start + range.deleteCount)) item.remove?.();
+    return removed;
+  }
+  if (method === "pop" || method === "shift") {
+    const item = method === "pop" ? items.at(-1) : items[0];
+    if (!item) return undefined;
+    const value = webTaskItemValue(item, directTaskCheckbox(item));
+    item.remove?.();
+    return value;
+  }
+
+  if (method === "push") {
+    for (const input of args) appendWebTaskItem(list, input);
+  } else {
+    const before = items[0] ?? list.firstChild ?? null;
+    for (const input of args) appendWebTaskItem(list, input, before);
+  }
+  return directWebTaskItems(list).length;
+}
+
 function resizeWebTextarea(element)
 {
   if (!element || String(element.tagName ?? "").toLowerCase() !== "textarea") return;
@@ -105,11 +268,23 @@ export function createWebDollar(documentObject = globalThis.document)
   return function $(selectorText) {
     const selector = parseDollarIdentity(selectorText, { selector: true });
     const selection = {
+      html() {
+        try {
+          const element = findWebDollarElement(documentObject, selectorText, selector);
+          return element ? String(element.innerHTML ?? "") : "";
+        } catch {
+          return "";
+        }
+      },
       val(...args) {
         try {
-          if (!selector) return args.length > 0 ? selection : "";
           const element = findWebDollarElement(documentObject, selectorText, selector);
           if (!element) return args.length > 0 ? selection : "";
+          if (isWebHeading(element)) {
+            if (args.length > 0) return selection;
+            return webHeadingValue(element);
+          }
+          if (!selector) return args.length > 0 ? selection : "";
           if (args.length > 0) {
             const value = String(args[0] ?? "");
             if ("value" in element) {
@@ -124,6 +299,57 @@ export function createWebDollar(documentObject = globalThis.document)
           return args.length > 0 ? selection : "";
         }
       },
+      push(...items) {
+        try {
+          const element = findWebDollarElement(documentObject, selectorText, selector);
+          return isWebHeading(element) ? mutateWebHeadingList(element, "push", items) : 0;
+        } catch {
+          return 0;
+        }
+      },
+      pop() {
+        try {
+          const element = findWebDollarElement(documentObject, selectorText, selector);
+          return isWebHeading(element) ? mutateWebHeadingList(element, "pop", []) : undefined;
+        } catch {
+          return undefined;
+        }
+      },
+      shift() {
+        try {
+          const element = findWebDollarElement(documentObject, selectorText, selector);
+          return isWebHeading(element) ? mutateWebHeadingList(element, "shift", []) : undefined;
+        } catch {
+          return undefined;
+        }
+      },
+      unshift(...items) {
+        try {
+          const element = findWebDollarElement(documentObject, selectorText, selector);
+          return isWebHeading(element) ? mutateWebHeadingList(element, "unshift", items) : 0;
+        } catch {
+          return 0;
+        }
+      },
+      splice(...args) {
+        try {
+          const element = findWebDollarElement(documentObject, selectorText, selector);
+          return isWebHeading(element) ? mutateWebHeadingList(element, "splice", args) : [];
+        } catch {
+          return [];
+        }
+      },
+      slice(...args) {
+        try {
+          const element = findWebDollarElement(documentObject, selectorText, selector);
+          if (!isWebHeading(element)) return [];
+          const list = firstHeadingList(element);
+          if (!list) return [];
+          return directWebTaskItems(list).map(webTaskItemSnapshot).slice(...args);
+        } catch {
+          return [];
+        }
+      },
     };
     return selection;
   };

package/src/cui/server.mjs

@@ -103,7 +103,7 @@ const server = Bun.serve({
   },
 });
 
-console.log(mda("- Bun RPC server listening on"));
+console.error(mda("- Bun RPC server listening on"));
 console.log(`http://localhost:${server.port}${pathname}`);
 
 

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