@suzumiyaaoba/mdxr 0.1.0

package/src/ui/deps.tsx

@@ -0,0 +1,78 @@
+import * as v from "valibot";
+
+import { defineComponent } from "../define.js";
+import { TITLE_PROP } from "./attrs.js";
+import { ListPanel, ListRow, RowIcon, RowNote, Tag } from "./bits.js";
+import { MONO_CLS, TONE_TEXT } from "./tones.js";
+
+export const DEP_KINDS = [
+  "calls",
+  "extends",
+  "implements",
+  "imports",
+  "reads",
+  "writes",
+] as const;
+export type DepKind = (typeof DEP_KINDS)[number];
+
+const KINDS: Record<DepKind, { cls: string; icon: string }> = {
+  calls: {
+    cls: TONE_TEXT.sky,
+    icon: "lucide:square-function",
+  },
+  extends: {
+    cls: TONE_TEXT.violet,
+    icon: "lucide:git-branch",
+  },
+  implements: {
+    cls: TONE_TEXT.teal,
+    icon: "lucide:layers",
+  },
+  imports: {
+    cls: TONE_TEXT.neutral,
+    icon: "lucide:package",
+  },
+  reads: {
+    cls: TONE_TEXT.neutral,
+    icon: "lucide:eye",
+  },
+  writes: {
+    cls: TONE_TEXT.amber,
+    icon: "lucide:pencil",
+  },
+};
+
+export const Deps = defineComponent(
+  {
+    description:
+      "依存関係エッジ一覧のコンテナ。<Dep> を並べる。title でキャプションバー",
+    schema: v.looseObject(TITLE_PROP),
+  },
+  ({ title, children }) => <ListPanel title={title}>{children}</ListPanel>
+);
+
+export const Dep = defineComponent(
+  {
+    description:
+      "依存エッジ1行。from → to。kind は imports|calls|extends|implements|reads|writes。children は注記",
+    schema: v.looseObject({
+      from: v.string(),
+      kind: v.optional(v.picklist(DEP_KINDS), "imports"),
+      to: v.string(),
+    }),
+  },
+  ({ from, to, kind, children }) => {
+    const k = KINDS[kind];
+    return (
+      <ListRow gapX="2">
+        <code className={MONO_CLS}>{from}</code>
+        <RowIcon name="lucide:arrow-right" />
+        <code className={MONO_CLS}>{to}</code>
+        <Tag className={k.cls} icon={k.icon}>
+          {kind}
+        </Tag>
+        <RowNote>{children}</RowNote>
+      </ListRow>
+    );
+  }
+);

package/src/ui/details.tsx

@@ -0,0 +1,43 @@
+import * as v from "valibot";
+
+import { defineComponent } from "../define.js";
+import { attrTrue, BOOLISH_PROP } from "./attrs.js";
+import { Icon } from "./icon.js";
+import { BORDER_CLS, TEXT, TRIM_CLS } from "./tones.js";
+
+/**
+ * Collapsible section on native `<details>` — opens/closes without client
+ * JS, unlike the shadcn Collapsible (which renders its initial state only).
+ */
+export const Details = defineComponent(
+  {
+    description:
+      '折りたたみセクション (ネイティブ <details> — JS なしで開閉)。summary="..." で要約、open で初期展開',
+    schema: v.looseObject({
+      open: BOOLISH_PROP,
+      summary: v.optional(v.string()),
+    }),
+  },
+  ({ summary, open, children }) => {
+    const isOpen = attrTrue(open);
+    return (
+      <details
+        className={`mdxr-details my-6 rounded-lg border ${BORDER_CLS}`}
+        open={isOpen}
+      >
+        <summary
+          className={`flex cursor-pointer items-center gap-2 rounded-lg px-4 py-2.5 text-sm font-medium ${TEXT.chip} transition-colors select-none hover:bg-neutral-50 active:bg-neutral-100 dark:hover:bg-neutral-900 dark:active:bg-neutral-800`}
+        >
+          <Icon
+            className={`mdxr-chev h-4 w-4 shrink-0 ${TEXT.faint}`}
+            name="lucide:chevron-right"
+          />
+          {summary ?? "Details"}
+        </summary>
+        <div className={`border-t px-4 py-3 ${BORDER_CLS} ${TRIM_CLS}`}>
+          {children}
+        </div>
+      </details>
+    );
+  }
+);

package/src/ui/diff-parse.ts

@@ -0,0 +1,307 @@
+/**
+ * Unified-diff parsing. `parseDiff` turns patch text into per-file
+ * structures; `DiffView` (diff.tsx) renders them. Bare `+`/`-` line
+ * streams (no `diff --git`/`@@` headers) parse as a single anonymous file.
+ */
+
+export interface DiffRow {
+  kind: "add" | "ctx" | "del" | "note";
+  newLine?: number;
+  oldLine?: number;
+  text: string;
+}
+
+export interface DiffHunk {
+  header?: string;
+  rows: DiffRow[];
+}
+
+export interface FileDiff {
+  adds: number;
+  dels: number;
+  hunks: DiffHunk[];
+  meta: string[];
+  newPath?: string;
+  oldPath?: string;
+  raw: string[];
+}
+
+/** One highlighted token inside a rendered diff row. */
+export interface DiffHlToken {
+  /** Shiki style string — `--shiki-light`/`--shiki-dark` vars. */
+  s?: string;
+  /** Token text. */
+  t: string;
+}
+
+/**
+ * Per-file highlight payload parked on `<code data-diffhl>` by rehypeShiki:
+ * `[file][hunk][row]` → token list. `null` means "render the row's plain
+ * text" — note rows, or files whose language could not be resolved.
+ */
+export type DiffHl = (DiffHlToken[] | null)[][][];
+
+/** JSON from the fence's `data-diffhl` attribute, or undefined when absent or
+ * malformed — malformed data degrades to unhighlighted rows, never a crash. */
+export const parseDiffHl = (raw: string | undefined): DiffHl | undefined => {
+  if (raw === undefined) {
+    return undefined;
+  }
+  try {
+    const parsed: unknown = JSON.parse(raw);
+    return Array.isArray(parsed) ? (parsed as DiffHl) : undefined;
+  } catch {
+    return undefined;
+  }
+};
+
+const GIT_RE =
+  /^diff --git (?:"(?<aq>[^"]+)" "(?<bq>[^"]+)"|(?<a>\S+) (?<b>\S+))/u;
+const OLD_RE = /^--- (?:"(?<q>[^"]+)"|(?<p>\S+))/u;
+const NEW_RE = /^\+\+\+ (?:"(?<q>[^"]+)"|(?<p>\S+))/u;
+const HUNK_RE =
+  /^@@ -(?<o>\d+)(?:,(?<oc>\d+))? \+(?<n>\d+)(?:,(?<nc>\d+))? @@/u;
+const RENAME_FROM_RE = /^rename from (?<p>.+)/u;
+const RENAME_TO_RE = /^rename to (?<p>.+)/u;
+
+/** `a/src/x.ts` → `src/x.ts`; quoted names unquoted; `/dev/null` → undefined. */
+const cleanPath = (p: string | undefined): string | undefined => {
+  if (p === undefined) {
+    return undefined;
+  }
+  const unq = p.replaceAll(/^"|"$/gu, "").replace(/^[ab]\//u, "");
+  return unq === "/dev/null" || unq === "" ? undefined : unq;
+};
+
+const newFile = (): FileDiff => ({
+  adds: 0,
+  dels: 0,
+  hunks: [],
+  meta: [],
+  raw: [],
+});
+
+interface ParseState {
+  cur?: FileDiff;
+  files: FileDiff[];
+  hunk?: DiffHunk;
+  /** Rows the declared hunk still expects on each side (Infinity for implicit
+   * hunks — bare +/- streams have no header counts to bound them). */
+  newLeft: number;
+  newNo: number;
+  oldLeft: number;
+  oldNo: number;
+  /** True once the current file consumed a `---`/`+++` header line — the
+   * paths a `diff --git` line sets don't count (a `---` after it belongs to
+   * the same file, not a new one). */
+  seenHeader: boolean;
+}
+
+/** The active hunk still has rows to consume per its `@@` counts. */
+const hunkLive = (st: ParseState): boolean =>
+  st.hunk !== undefined &&
+  st.hunk.header !== undefined &&
+  (st.oldLeft > 0 || st.newLeft > 0);
+
+/** Current file already carries content → a new `---` starts a new file. */
+const hasContent = (st: ParseState): boolean =>
+  st.cur !== undefined && (st.seenHeader || st.cur.hunks.length > 0);
+
+const ensureFile = (st: ParseState): FileDiff => {
+  if (st.cur === undefined) {
+    st.cur = newFile();
+    st.files.push(st.cur);
+  }
+  return st.cur;
+};
+
+const push = (st: ParseState, line: string): FileDiff => {
+  const f = ensureFile(st);
+  f.raw.push(line);
+  return f;
+};
+
+/** `---`/`+++` file headers. Returns true when the line was consumed. */
+const fileHeader = (st: ParseState, line: string): boolean => {
+  const oldM = OLD_RE.exec(line);
+  if (oldM?.groups !== undefined) {
+    if (hasContent(st)) {
+      st.cur = newFile();
+      st.files.push(st.cur);
+    }
+    push(st, line).oldPath = cleanPath(oldM.groups.q ?? oldM.groups.p);
+    st.hunk = undefined;
+    st.seenHeader = true;
+    return true;
+  }
+  const newM = NEW_RE.exec(line);
+  if (newM?.groups !== undefined) {
+    push(st, line).newPath = cleanPath(newM.groups.q ?? newM.groups.p);
+    st.hunk = undefined;
+    st.seenHeader = true;
+    return true;
+  }
+  return false;
+};
+
+/** One row inside an active hunk; tracks both line counters. */
+const hunkRow = (st: ParseState, line: string): void => {
+  const { hunk } = st;
+  if (hunk === undefined) {
+    return;
+  }
+  // Line numbers come from the `@@` tallies — an implicit hunk (bare +/-
+  // stream) has none, so its rows must not inherit stale counters from the
+  // previous counted hunk.
+  const numbered = hunk.header !== undefined;
+  const f = push(st, line);
+  if (line.startsWith("\\")) {
+    hunk.rows.push({ kind: "note", text: line });
+  } else if (line.startsWith("+")) {
+    f.adds += 1;
+    st.newLeft -= 1;
+    hunk.rows.push({
+      kind: "add",
+      newLine: numbered ? st.newNo : undefined,
+      text: line.slice(1),
+    });
+    st.newNo += 1;
+  } else if (line.startsWith("-")) {
+    f.dels += 1;
+    st.oldLeft -= 1;
+    hunk.rows.push({
+      kind: "del",
+      oldLine: numbered ? st.oldNo : undefined,
+      text: line.slice(1),
+    });
+    st.oldNo += 1;
+  } else {
+    st.oldLeft -= 1;
+    st.newLeft -= 1;
+    hunk.rows.push({
+      kind: "ctx",
+      newLine: numbered ? st.newNo : undefined,
+      oldLine: numbered ? st.oldNo : undefined,
+      text: line.startsWith(" ") ? line.slice(1) : line,
+    });
+    st.oldNo += 1;
+    st.newNo += 1;
+  }
+  // A counted hunk is done when its `@@` tallies run out — the next `---` /
+  // `diff --git` line is a file boundary again, not content.
+  if (hunk.header !== undefined && st.oldLeft <= 0 && st.newLeft <= 0) {
+    st.hunk = undefined;
+  }
+};
+
+/**
+ * A line with no hunk context: file meta (index/mode/rename/binary) or the
+ * first line of a bare +/- stream, which opens an implicit hunk.
+ */
+const looseLine = (st: ParseState, line: string): void => {
+  const f = push(st, line);
+  const rf = RENAME_FROM_RE.exec(line);
+  if (rf?.groups !== undefined) {
+    f.oldPath ??= cleanPath(rf.groups.p.trim());
+  }
+  const rt = RENAME_TO_RE.exec(line);
+  if (rt?.groups !== undefined) {
+    f.newPath ??= cleanPath(rt.groups.p.trim());
+  }
+  if (line.startsWith("+") || line.startsWith("-")) {
+    const kind = line.startsWith("+") ? "add" : "del";
+    f[kind === "add" ? "adds" : "dels"] += 1;
+    st.oldLeft = Number.POSITIVE_INFINITY;
+    st.newLeft = Number.POSITIVE_INFINITY;
+    st.hunk = { rows: [{ kind, text: line.slice(1) }] };
+    f.hunks.push(st.hunk);
+  } else if (line !== "") {
+    f.meta.push(line);
+  }
+};
+
+/** One input line of `parseDiff`: git/file headers, `@@` hunk headers, and
+ * hunk/loose content each consume the line and update `st`. */
+const parseLine = (st: ParseState, line: string, nextLine: string): void => {
+  const git = GIT_RE.exec(line);
+  if (git?.groups !== undefined) {
+    st.cur = newFile();
+    st.files.push(st.cur);
+    st.cur.raw.push(line);
+    st.cur.oldPath = cleanPath(git.groups.aq ?? git.groups.a);
+    st.cur.newPath = cleanPath(git.groups.bq ?? git.groups.b);
+    st.hunk = undefined;
+    st.seenHeader = false;
+    return;
+  }
+
+  // A `---`/`+++` pair is a file header — but only once the current counted
+  // hunk is exhausted. Inside a `@@` hunk body the pair is content: deleting
+  // a line like `-- a/x` and adding `++ b/x` emits exactly those rows (e.g.
+  // YAML frontmatter or nested diffs).
+  const pair = OLD_RE.test(line) && NEW_RE.test(nextLine);
+  if (
+    (st.hunk === undefined || (pair && !hunkLive(st))) &&
+    fileHeader(st, line)
+  ) {
+    return;
+  }
+
+  const hunkM = HUNK_RE.exec(line);
+  if (hunkM?.groups !== undefined) {
+    st.hunk = { header: line, rows: [] };
+    push(st, line).hunks.push(st.hunk);
+    st.oldNo = Number(hunkM.groups.o);
+    st.newNo = Number(hunkM.groups.n);
+    st.oldLeft = Number(hunkM.groups.oc ?? "1");
+    st.newLeft = Number(hunkM.groups.nc ?? "1");
+    return;
+  }
+
+  if (st.hunk === undefined) {
+    // `` follows the row it annotates — the hunk's
+    // counters may already have closed it, but the note still belongs inside.
+    const last = st.cur?.hunks.at(-1);
+    if (line.startsWith("\\") && last !== undefined) {
+      push(st, line);
+      last.rows.push({ kind: "note", text: line });
+      return;
+    }
+    looseLine(st, line);
+    return;
+  }
+  hunkRow(st, line);
+};
+
+/**
+ * Parse unified-diff text into per-file structures. `--- `/`+++ ` count as
+ * file headers only outside hunks (or when they form a `---`/`+++` pair —
+ * inside a hunk a lone `-`-prefixed line is content). Lines with no diff
+ * structure at all land in `meta`/`raw`; bare `+`/`-` streams without `@@`
+ * headers collect into an implicit hunk.
+ */
+export const parseDiff = (text: string): FileDiff[] => {
+  // Normalize CRLF — a trailing \r would leak into row text and break the
+  // regexes that test the *next* line's structure.
+  const lines = text.replaceAll("\r\n", "\n").replace(/\n+$/u, "").split("\n");
+  const st: ParseState = {
+    files: [],
+    newLeft: 0,
+    newNo: 0,
+    oldLeft: 0,
+    oldNo: 0,
+    seenHeader: false,
+  };
+  for (let i = 0; i < lines.length; i += 1) {
+    parseLine(st, lines[i] ?? "", lines[i + 1] ?? "");
+  }
+  // Drop shells that never got content — an empty input would otherwise
+  // yield one blank file card.
+  return st.files.filter(
+    (f) =>
+      f.hunks.length > 0 ||
+      f.meta.length > 0 ||
+      f.oldPath !== undefined ||
+      f.newPath !== undefined
+  );
+};