yamlover 0.3.4 → 0.3.6

package/src/client/paste-html.ts

@@ -1,228 +0,0 @@
-// HTML-clipboard paste: a selection copied from a web page (Wikipedia, docs, …) arrives as
-// text/html alongside the plain text. When it carries STRUCTURE the plain flavor loses —
-// images, headings — it becomes a RICH paste: headings nest subchapters (by level), images
-// become separate chunks (downloaded in the browser — e.g. Wikimedia sends
-// `access-control-allow-origin: *`), text blocks become marklower prose. Formatted text with
-// no images/headings stays a plain text paste. Used by NodeView's paste listener.
-
-/** The client-side draft: images still by URL (downloaded later by resolveImages). */
-export interface RichDraft {
-  title?: string;
-  chunks: Array<{ text: string } | { image: { url: string; alt: string } }>;
-  children: RichDraft[];
-}
-
-/** The wire payload for POST /api/paste {rich}: images resolved to inline file bytes. */
-export interface RichNode {
-  title?: string;
-  chunks: Array<{ text: string } | { file: { name: string; contentBase64: string } }>;
-  children: RichNode[];
-}
-
-type Block =
-  | { kind: "heading"; level: number; text: string }
-  | { kind: "image"; url: string; alt: string }
-  | { kind: "text"; text: string };
-
-const SKIP = new Set(["script", "style", "noscript", "template", "iframe", "svg", "head", "title"]);
-const BLOCKS = new Set(["p", "div", "section", "article", "main", "aside", "header", "footer", "figure", "figcaption", "ul", "ol", "table", "thead", "tbody", "tr", "dl", "dt", "dd", "nav", "form", "body", "html"]);
-
-/** Parse an HTML clipboard fragment into a chapter draft — or null when it has no images and
- *  no headings (plain formatted text: the normal text paste serves it better). */
-export function htmlToRich(html: string): RichDraft | null {
-  const doc = new DOMParser().parseFromString(html, "text/html");
-  const blocks = mergeBullets(blocksOf(doc.body));
-  if (!blocks.some((b) => b.kind !== "text")) return null;
-
-  // headings nest by level: deeper headings open children of the nearest shallower one
-  const root: RichDraft = { chunks: [], children: [] };
-  const stack: Array<{ node: RichDraft; level: number }> = [{ node: root, level: 0 }];
-  for (const b of blocks) {
-    if (b.kind === "heading") {
-      while (stack.length > 1 && stack[stack.length - 1].level >= b.level) stack.pop();
-      const child: RichDraft = { title: b.text || "Untitled", chunks: [], children: [] };
-      stack[stack.length - 1].node.children.push(child);
-      stack.push({ node: child, level: b.level });
-    } else {
-      const top = stack[stack.length - 1].node;
-      top.chunks.push(b.kind === "image" ? { image: { url: b.url, alt: b.alt } } : { text: b.text });
-    }
-  }
-  return root;
-}
-
-/** Walk the fragment in document order, flushing inline text at block boundaries. */
-function blocksOf(body: HTMLElement): Block[] {
-  const out: Block[] = [];
-  let buf = "";
-  const flush = () => {
-    const t = buf.replace(/[ \t]+/g, " ").replace(/ ?\n ?/g, "\n").replace(/\n{2,}/g, "\n").trim();
-    buf = "";
-    if (t) out.push({ kind: "text", text: t });
-  };
-  const walk = (n: Node): void => {
-    if (n.nodeType === Node.TEXT_NODE) {
-      buf += n.textContent ?? "";
-      return;
-    }
-    if (!(n instanceof Element)) return;
-    const tag = n.tagName.toLowerCase();
-    if (SKIP.has(tag)) return;
-    if (/^h[1-6]$/.test(tag)) {
-      flush();
-      // Wikipedia headings carry an "[edit]" section link — noise in a title
-      out.push({ kind: "heading", level: Number(tag[1]), text: (n.textContent ?? "").replace(/\[edit\]/gi, "").trim() });
-      return;
-    }
-    if (tag === "img") {
-      flush();
-      const url = imageUrl(n);
-      if (url) out.push({ kind: "image", url, alt: n.getAttribute("alt") ?? "" });
-      return;
-    }
-    if (tag === "li") {
-      // one bullet per line; images inside the item still surface as their own chunks
-      flush();
-      n.childNodes.forEach(walk);
-      const t = buf.replace(/\s+/g, " ").trim();
-      buf = "";
-      if (t) out.push({ kind: "text", text: "- " + t });
-      return;
-    }
-    if (tag === "pre") {
-      flush();
-      const t = (n.textContent ?? "").replace(/\n+$/, "");
-      if (t.trim()) out.push({ kind: "text", text: "```\n" + t + "\n```" });
-      return;
-    }
-    if (tag === "blockquote") {
-      flush();
-      n.childNodes.forEach(walk);
-      const t = buf.trim();
-      buf = "";
-      if (t) out.push({ kind: "text", text: t.split("\n").map((l) => "> " + l).join("\n") });
-      return;
-    }
-    if (tag === "br") {
-      buf += "\n";
-      return;
-    }
-    if (tag === "td" || tag === "th") {
-      n.childNodes.forEach(walk);
-      buf += " ";
-      return;
-    }
-    if (BLOCKS.has(tag)) {
-      flush();
-      n.childNodes.forEach(walk);
-      flush();
-      return;
-    }
-    // an inline element: render to marklower — unless an image hides inside (then descend, so
-    // the image becomes its own chunk rather than vanishing into the text)
-    if (!n.querySelector("img")) {
-      buf += inlineMd(n);
-      return;
-    }
-    n.childNodes.forEach(walk);
-  };
-  walk(body);
-  flush();
-  return out;
-}
-
-/** Inline content → marklower: links, emphasis, code; everything else passes through as text. */
-function inlineMd(n: Node): string {
-  if (n.nodeType === Node.TEXT_NODE) return n.textContent ?? "";
-  if (!(n instanceof Element)) return "";
-  const tag = n.tagName.toLowerCase();
-  if (SKIP.has(tag)) return "";
-  if (tag === "br") return "\n";
-  const inner = Array.from(n.childNodes).map(inlineMd).join("");
-  if (tag === "a") {
-    const href = n.getAttribute("href") ?? "";
-    const t = inner.trim();
-    return /^https?:\/\//.test(href) && t ? `[${t}](${href})` : inner;
-  }
-  if (tag === "strong" || tag === "b") return inner.trim() ? `**${inner.trim()}**` : "";
-  if (tag === "em" || tag === "i") return inner.trim() ? `*${inner.trim()}*` : "";
-  if (tag === "code") return inner.trim() ? "`" + inner.trim() + "`" : "";
-  return inner;
-}
-
-/** A usable image URL: absolute http(s) or data:; protocol-relative gains https:; lazy-load
- *  attributes win over a missing/placeholder src; anything relative is dropped (a clipboard
- *  fragment has no base to resolve it against). */
-function imageUrl(img: Element): string | null {
-  const raw = img.getAttribute("src") || img.getAttribute("data-src") || "";
-  if (raw.startsWith("//")) return "https:" + raw;
-  if (/^https?:\/\//.test(raw) || raw.startsWith("data:image/")) return raw;
-  return null;
-}
-
-/** Consecutive single-bullet blocks (one per <li>) merge into one list chunk. */
-function mergeBullets(blocks: Block[]): Block[] {
-  const out: Block[] = [];
-  for (const b of blocks) {
-    const prev = out[out.length - 1];
-    if (b.kind === "text" && b.text.startsWith("- ") && prev?.kind === "text" && prev.text.startsWith("- ")) {
-      prev.text += "\n" + b.text;
-    } else out.push(b);
-  }
-  return out;
-}
-
-const MIME_EXT: Record<string, string> = {
-  "image/png": "png", "image/jpeg": "jpg", "image/gif": "gif", "image/webp": "webp",
-  "image/svg+xml": "svg", "image/bmp": "bmp", "image/tiff": "tiff", "image/avif": "avif",
-};
-
-/** Download every image of a draft (order kept) into inline file chunks; a failed fetch
- *  degrades to a marklower image link, so the reference survives even when the bytes don't. */
-export async function resolveImages(draft: RichDraft): Promise<RichNode> {
-  return {
-    title: draft.title,
-    chunks: await Promise.all(
-      draft.chunks.map(async (c) => {
-        if ("text" in c) return { text: c.text };
-        try {
-          const res = await fetch(c.image.url);
-          if (!res.ok) throw new Error(`HTTP ${res.status}`);
-          const blob = await res.blob();
-          return { file: { name: imageName(c.image.url, blob.type), contentBase64: await blobBase64(blob) } };
-        } catch {
-          return { text: `![${c.image.alt}](${c.image.url})` };
-        }
-      }),
-    ),
-    children: await Promise.all(draft.children.map(resolveImages)),
-  };
-}
-
-/** A filename for a downloaded image: the URL path's basename, extension from the MIME type
- *  when the URL has none (data: URLs, extensionless CDNs). */
-function imageName(url: string, mime: string): string {
-  let base = "";
-  try {
-    base = decodeURIComponent(new URL(url).pathname.split("/").pop() ?? "");
-  } catch {
-    /* data: or malformed — synthesize below */
-  }
-  if (!base || url.startsWith("data:")) base = "image";
-  if (!/\.[A-Za-z0-9]{2,5}$/.test(base)) base += "." + (MIME_EXT[mime] || "bin");
-  return base;
-}
-
-function blobBase64(blob: Blob): Promise<string> {
-  return new Promise((resolve, reject) => {
-    const r = new FileReader();
-    r.onload = () => resolve(String(r.result).split(",")[1] || "");
-    r.onerror = () => reject(new Error("could not read image"));
-    r.readAsDataURL(blob);
-  });
-}
-
-/** How many images a draft holds (for the progress toast). */
-export function countImages(draft: RichDraft): number {
-  return draft.chunks.filter((c) => "image" in c).length + draft.children.reduce((n, k) => n + countImages(k), 0);
-}

package/src/client/paste-links.ts

@@ -1,42 +0,0 @@
-// Pasted-LINK handlers: a paste that is EXACTLY one well-known URL means the linked CONTENT is
-// wanted, not the URL text. Each recognizer turns the link into something the normal paste flows
-// accept — a file to upload (arXiv) or a text to chunk (a tweet). A link inside longer text is
-// left alone (the prose is the paste). Used by NodeView's paste listener.
-
-/** The arXiv paper behind a pasted link: a lone `arxiv.org/{abs|pdf|html}/<id>` URL — fetch its
- *  PDF (arXiv sends `access-control-allow-origin: *`) and run the normal file-paste flow. New
- *  (`2605.00615v2`) and old (`math/0211159`) id styles. */
-export function arxivPdf(text: string): { url: string; name: string } | null {
-  const m = /^(?:https?:\/\/)?(?:www\.)?arxiv\.org\/(?:abs|pdf|html)\/(.+?)(?:\.pdf)?(?:[?#][^\s]*)?$/i.exec(text.trim());
-  if (!m) return null;
-  const id = m[1];
-  if (!/^(?:\d{4}\.\d{4,5}|[a-z-]+(?:\.[A-Z]{2})?\/\d{7})(?:v\d+)?$/.test(id)) return null;
-  return { url: `https://arxiv.org/pdf/${id}`, name: `arxiv-${id.replace(/\//g, "-")}.pdf` };
-}
-
-/** The tweet behind a pasted `x.com`/`twitter.com` status link, canonicalized; null if the text
- *  is not exactly one such link. */
-export function tweetUrl(text: string): string | null {
-  const m = /^(?:https?:\/\/)?(?:www\.|mobile\.)?(?:x\.com|twitter\.com)\/(\w{1,15})\/status(?:es)?\/(\d+)(?:[/?#][^\s]*)?$/i.exec(text.trim());
-  return m ? `https://twitter.com/${m[1]}/status/${m[2]}` : null;
-}
-
-/** Fetch a tweet's FULL content via X's public oEmbed endpoint (`publish.x.com/oembed` — the
- *  embedded-tweet API: no auth, CORS-open) and compose it as pasteable text — the whole message,
- *  then an author/date attribution line, then the link. */
-export async function fetchTweetText(statusUrl: string): Promise<string> {
-  const res = await fetch(`https://publish.x.com/oembed?url=${encodeURIComponent(statusUrl)}&omit_script=true&dnt=true`);
-  if (!res.ok) throw new Error(`oEmbed HTTP ${res.status}`);
-  const o = (await res.json()) as { html?: string; author_name?: string; author_url?: string; url?: string };
-  // the payload's `html` is a <blockquote><p>tweet…</p>— Author (@handle) <a>date</a></blockquote>
-  const doc = new DOMParser().parseFromString((o.html ?? "").replace(/<br\s*\/?>/gi, "\n"), "text/html");
-  const quote = doc.querySelector("blockquote");
-  const body = quote?.querySelector("p")?.textContent?.trim();
-  if (!body) throw new Error("no tweet text in the oEmbed payload");
-  const handle = (o.author_url ?? "").split("/").filter(Boolean).pop();
-  const dateLinks = quote ? Array.from(quote.querySelectorAll(":scope > a")) : [];
-  const date = dateLinks[dateLinks.length - 1]?.textContent?.trim();
-  const who = [o.author_name, handle && `@${handle}`].filter(Boolean).join(" ");
-  const attribution = [who && `— ${who}`, date].filter(Boolean).join(", ");
-  return [body, "", [attribution, o.url ?? statusUrl].filter(Boolean).join("\n")].join("\n");
-}

package/src/client/paths.ts

@@ -1,139 +0,0 @@
-// JSON-space path helpers. The CANONICAL client path is COLON-form (SEPARATOR.md M4):
-// `:key[0]:sub`, root `:` — what the API speaks and the UI displays. The BROWSER URL
-// stays SLASH-transported (`/key[0]/sub` — ruling: "the URL should be slashed, of
-// course"), converted at this boundary only.
-//
-// A key may itself contain `:`, `/`, `[`, or `]` (e.g. `@vitejs/plugin-react`), so each
-// key is percent-encoded (encodeURIComponent) — the structural separators then
-// unambiguously tokenize, and the URL spelling is address-bar-safe as is.
-
-export type Seg = string | number;
-
-/** Canonical client path: `:key[0]:sub` (keys percent-encoded), root `:`. */
-export function segsToStr(segs: Seg[]): string {
-  return segs.map((s) => (typeof s === "number" ? `[${s}]` : `:${encodeURIComponent(s)}`)).join("") || ":";
-}
-
-const PATH_TOKEN = /\[\d+\]|[^:\[\]]+/g; // canonical (colon) form
-const URL_TOKEN = /\[\d+\]|[^/\[\]]+/g; // URL (slash) transport form
-
-export function strToSegs(str: string): Seg[] {
-  const out: Seg[] = [];
-  for (const tok of str.match(PATH_TOKEN) || []) {
-    out.push(/^\[\d+\]$/.test(tok) ? Number(tok.slice(1, -1)) : safeDecode(tok));
-  }
-  return out;
-}
-
-/** Canonical key for cross-SCOPE comparison: collapse the colon scope ladder so a
- *  project ref (`::yamlover:…`), a document ref (`:yamlover:…`), and a server-echoed
- *  `:`-form path all compare equal. The ladder colons are not tokens (PATH_TOKEN), so
- *  re-emitting drops them; keys are normalized through one decode→encode pass. */
-export function canonPath(p: string): string {
-  return segsToStr(strToSegs(p));
-}
-
-function safeDecode(s: string): string {
-  try {
-    return decodeURIComponent(s);
-  } catch {
-    return s;
-  }
-}
-
-/** The current JSON path taken from the browser URL (slash transport), in canonical
- *  COLON form. The pathname is already per-key-encoded, so it is tokenized *before*
- *  decoding — segments ride through encoded into the canonical string. */
-export function pathFromUrl(): string {
-  const segs: Seg[] = [];
-  for (const tok of window.location.pathname.match(URL_TOKEN) || []) {
-    segs.push(/^\[\d+\]$/.test(tok) ? Number(tok.slice(1, -1)) : safeDecode(tok));
-  }
-  return segsToStr(segs);
-}
-
-/** The slash-transport URL spelling of a canonical path (`:a[0]:b` → `/a[0]/b`). */
-export function urlOfPath(path: string): string {
-  const segs = strToSegs(path);
-  return segs.map((s) => (typeof s === "number" ? `[${s}]` : `/${encodeURIComponent(s)}`)).join("") || "/";
-}
-
-/** A human-readable form of a canonical path: each key decoded (so a percent-encoded
- *  segment like `%D0%9F…` shows as its actual characters), colon-separated, indices as
- *  `[i]`. For display only — tooltips, labels — never for URLs or navigation. */
-export function displayPath(path: string): string {
-  const segs = strToSegs(path);
-  if (!segs.length) return ":";
-  return segs.map((s) => (typeof s === "number" ? `[${s}]` : `:${s}`)).join("");
-}
-
-/** A human-readable form of a path-LIKE key whose structure must survive verbatim —
- *  a relations key (`..`, `:eve`, `::a:b`), where {@link displayPath} would mangle the
- *  leading `::` or a bare `..`. Each key token is decoded in place; display only. */
-export function displayKey(key: string): string {
-  return key.replace(/[^:/\[\]]+/g, (tok) => safeDecode(tok));
-}
-
-/** Whether canonical path `a` is a (strict) ancestor of `p`. Root `:` is an ancestor
- *  of everything; otherwise `p` must continue past `a` at a `:` or `[`. */
-export function isAncestorPath(a: string, p: string): boolean {
-  if (a === p) return false;
-  if (a === ":") return true;
-  return p.startsWith(a + ":") || p.startsWith(a + "[");
-}
-
-/** The current representation taken from the URL's `?format=` (or `fallback`). */
-export function formatFromUrl(fallback: string): string {
-  return new URLSearchParams(window.location.search).get("format") || fallback;
-}
-
-/** The current page from the URL's `?page=` (1-based). 1 when absent, ≤1, or not an integer —
- *  used by paged viewers (PDF/DjVu) to restore where the reader left off. */
-export function pageFromUrl(): number {
-  const n = Number(new URLSearchParams(window.location.search).get("page"));
-  return Number.isInteger(n) && n > 1 ? n : 1;
-}
-
-/** Record the current page in `?page=` via replaceState — preserving every other param, and
- *  DROPPING the param at page 1 (the implicit default). This does NOT remount the renderer (only
- *  path/format/refreshSignal do), so a paged viewer can update it freely while scrolling. */
-export function writePageToUrl(n: number): void {
-  const params = new URLSearchParams(window.location.search);
-  if (n > 1) params.set("page", String(n));
-  else params.delete("page");
-  const qs = params.toString();
-  const url = window.location.pathname + (qs ? "?" + qs : "");
-  if (url !== window.location.pathname + window.location.search) window.history.replaceState({}, "", url);
-}
-
-/** Write the JSON path (canonical colon form, converted to the slash-transport URL)
- *  plus `?format=` into the URL. Path navigation pushes a history entry; switching
- *  format replaces. Any other query params already present are kept (e.g. a renderer's
- *  own options such as the CSV `sep`/`header`), so only `format` is overwritten here. */
-export function writeUrl(path: string, format: string, replace = false): void {
-  const params = new URLSearchParams(window.location.search);
-  params.set("format", format);
-  // `?page=` is node-specific: a format switch (replace) keeps it, but navigating to another node
-  // (push) must not carry the old node's page over — drop it there.
-  if (!replace) params.delete("page");
-  const url = `${urlOfPath(path || ":")}?${params.toString()}`;
-  if (url === window.location.pathname + window.location.search) return;
-  if (replace) window.history.replaceState({}, "", url);
-  else window.history.pushState({}, "", url);
-}
-
-/** Breadcrumb crumbs for a path. The head is the CLI ROOT (`rootLabel`); it is
- *  omitted when blank, so a default (cwd) root shows just the in-tree segments.
- *  e.g. (":a:b", "examples") → [examples, a, b] (each decoded, linking to its path). */
-export function crumbs(p: string, rootLabel: string): { label: string; path: string }[] {
-  const segs = strToSegs(p);
-  const out: { label: string; path: string }[] = [];
-  if (rootLabel) out.push({ label: rootLabel, path: ":" });
-  segs.forEach((s, i) => {
-    out.push({
-      label: typeof s === "number" ? `[${s}]` : s,
-      path: segsToStr(segs.slice(0, i + 1)),
-    });
-  });
-  return out;
-}