hd-garden 0.5.0 → 0.5.2

package/ui/garden/card-refresh.mjs

@@ -0,0 +1,92 @@
+/**
+ * Pure helpers for refreshing link cards in the browser. The DOM side lives in
+ * app/components/LinkCardRefresh.tsx.
+ */
+
+/** "2025-01-30" → "2025 年 1 月 30 日"; anything else → "". */
+export function cardDate(value) {
+  const match = /^(\d{4})-(\d{2})-(\d{2})/u.exec(value ?? "");
+  return match ? `${match[1]} 年 ${Number(match[2])} 月 ${Number(match[3])} 日` : "";
+}
+
+const LIMITS = { title: 200, description: 300, siteName: 80, author: 80 };
+
+/**
+ * Which text fields to change. Only fields the card already shows are
+ * touched, and empty answers never blank a field, so a refresh never adds or
+ * removes a line.
+ */
+export function cardUpdates(current, fresh) {
+  if (!fresh || typeof fresh !== "object") return {};
+  const changes = {};
+  for (const [field, shown] of Object.entries(current)) {
+    let next = fresh[field];
+    if (typeof next !== "string" || !next.trim()) continue;
+    next = next.replace(/\s+/gu, " ").trim();
+    if (field === "publishedTime") next = cardDate(next);
+    else if (LIMITS[field] && next.length > LIMITS[field]) next = `${next.slice(0, LIMITS[field] - 1)}…`;
+    if (next && next !== shown) changes[field] = next;
+  }
+  return changes;
+}
+
+/** Only cards the reader has not reached yet change, so nothing moves under their eyes. */
+export function safeToUpdate(cardTop, viewportHeight) {
+  return cardTop > viewportHeight;
+}
+
+/** The Worker URL for one card. */
+export function refreshUrl(endpoint, cardUrl) {
+  const base = String(endpoint ?? "").replace(/\/+$/u, "");
+  if (!/^https:\/\/|^http:\/\/(localhost|127\.0\.0\.1)(:\d+)?(\/|$)/u.test(base)) return "";
+  return `${base}/?url=${encodeURIComponent(cardUrl)}`;
+}
+
+/**
+ * A signal for one request: aborted when this request takes longer than
+ * `ms`, or when `shared` aborts (the page goes away). Each card gets its own,
+ * so one slow card never cancels the others. Uses AbortSignal.any/timeout when
+ * the browser has them, a controller and a timer otherwise.
+ *
+ * @param {AbortSignal} shared
+ * @param {number} ms
+ * @returns {{ signal: AbortSignal; done: () => void }}
+ */
+export function requestSignal(shared, ms, { Signal = globalThis.AbortSignal, Controller = globalThis.AbortController } = {}) {
+  if (typeof Signal?.any === "function" && typeof Signal?.timeout === "function") {
+    return { signal: Signal.any([shared, Signal.timeout(ms)]), done: () => {} };
+  }
+  const controller = new Controller();
+  const abort = () => controller.abort();
+  const timer = setTimeout(abort, ms);
+  if (shared.aborted) abort();
+  else shared.addEventListener("abort", abort, { once: true });
+  return {
+    signal: controller.signal,
+    done: () => {
+      clearTimeout(timer);
+      shared.removeEventListener("abort", abort);
+    },
+  };
+}
+
+export const CARD_TIMEOUT_MS = 6000;
+
+/**
+ * Ask the Worker for one card's current text. Resolves to the JSON answer, or
+ * null on any failure, timeout or abort.
+ *
+ * @param {string} target
+ * @param {{ shared: AbortSignal; fetcher?: typeof fetch; timeoutMs?: number; signalOptions?: object }} options
+ */
+export async function fetchCardText(target, { shared, fetcher = globalThis.fetch, timeoutMs = CARD_TIMEOUT_MS, signalOptions } = {}) {
+  const { signal, done } = requestSignal(shared, timeoutMs, signalOptions);
+  try {
+    const response = await fetcher(target, { mode: "cors", credentials: "omit", signal });
+    return response.ok ? await response.json() : null;
+  } catch {
+    return null;
+  } finally {
+    done();
+  }
+}

package/ui/garden/markdown-links.mjs

@@ -0,0 +1,84 @@
+/**
+ * External links written in a post body. Code (fenced blocks, indented blocks
+ * and inline spans) is skipped, so a URL in a snippet is never a link.
+ */
+
+const FENCE = /^ {0,3}(`{3,}|~{3,})/u;
+
+/** Call `visit(text)` for every stretch of Markdown that is not code; returns the rebuilt text. */
+export function mapOutsideCode(markdown, visit) {
+  const lines = String(markdown ?? "").split("\n");
+  const out = [];
+  let fence = "";
+  let prose = [];
+  const flush = () => {
+    if (!prose.length) return;
+    out.push(mapInline(prose.join("\n"), visit));
+    prose = [];
+  };
+  for (const line of lines) {
+    if (fence) {
+      out.push(line);
+      if (new RegExp(`^ {0,3}${fence[0]}{${fence.length},}\\s*$`, "u").test(line)) fence = "";
+      continue;
+    }
+    const open = FENCE.exec(line);
+    if (open) {
+      flush();
+      fence = open[1];
+      out.push(line);
+      continue;
+    }
+    prose.push(line);
+  }
+  flush();
+  return out.join("\n");
+}
+
+// Inline code spans: a run of backticks closed by the same-length run.
+function mapInline(text, visit) {
+  let result = "";
+  let index = 0;
+  const pattern = /(`+)[\s\S]*?(?<!`)\1(?!`)/gu;
+  for (const match of text.matchAll(pattern)) {
+    result += visit(text.slice(index, match.index)) + match[0];
+    index = match.index + match[0].length;
+  }
+  return result + visit(text.slice(index));
+}
+
+const LINK = /(!?)\[(?:[^\[\]]|\[[^\]]*\])*\]\(\s*<?(https?:\/\/[^\s)>]+)>?(?:\s+(?:"[^"]*"|'[^']*'))?\s*\)(\{card\})?/giu;
+const AUTOLINK = /<(https?:\/\/[^\s>]+)>/giu;
+const BARE = /(^|[\s(（：:，,。])(https?:\/\/[^\s<>()（）\]，。、]+[^\s<>()（）\].,;:!?，。、；：！？'"])/giu;
+
+/** Every external link in the body, in order: `{ url, card }`. Images are left out. */
+export function markdownLinks(markdown) {
+  const links = [];
+  mapOutsideCode(markdown, (text) => {
+    for (const match of text.matchAll(LINK)) {
+      if (match[1] !== "!") links.push({ url: match[2], card: Boolean(match[3]) });
+    }
+    const rest = text.replace(LINK, " ");
+    for (const match of rest.matchAll(AUTOLINK)) links.push({ url: match[1], card: false });
+    for (const match of rest.replace(AUTOLINK, " ").matchAll(BARE)) links.push({ url: match[2], card: false });
+    return text;
+  });
+  return links;
+}
+
+/** The marker that asks for a link card: `[text](url){card}`, nothing in between. */
+export const CARD_MARKER = "{card}";
+
+/**
+ * The same Markdown without `{card}` markers, for excerpts, RSS and the search
+ * index. Markers inside code stay, since there they are literal text.
+ */
+export function stripCardMarkers(markdown) {
+  if (!String(markdown ?? "").includes(CARD_MARKER)) return markdown;
+  return mapOutsideCode(markdown, (text) => text.replace(LINK, (whole, bang, url, card) => (card ? whole.slice(0, -CARD_MARKER.length) : whole)));
+}
+
+/** URLs the author asked to show as cards, in order, without repeats. */
+export function cardUrls(markdown) {
+  return [...new Set(markdownLinks(markdown).filter((link) => link.card).map((link) => link.url))];
+}

package/ui/garden/references.mjs

@@ -0,0 +1,21 @@
+/**
+ * The site a reference points to, shown after its title: the link's host
+ * without a leading "www.". Empty for missing or unparsable links.
+ */
+export function referenceDomain(url) {
+  if (typeof url !== "string" || !url.trim()) return "";
+  try {
+    const { hostname, protocol } = new URL(url.trim());
+    if (protocol !== "http:" && protocol !== "https:") return "";
+    return hostname.toLowerCase().replace(/^www\./, "");
+  } catch {
+    return "";
+  }
+}
+
+/** Short lists stay in one column; two columns start at this many entries. */
+export const REFERENCE_SPLIT_AT = 6;
+
+export function referenceColumns(count) {
+  return count >= REFERENCE_SPLIT_AT ? 2 : 1;
+}

package/ui/garden/same-site.mjs

@@ -0,0 +1,63 @@
+/**
+ * Links to the site's own address. A post may write a full URL such as
+ * `https://example.com/blog/post/`; it is still an internal link.
+ *
+ * The site address comes from `url` in site.config.yaml, falling back to the
+ * SITE_URL the build already uses. Both http and https count, and so do the
+ * host with and without `www.`. Any other subdomain is a different site.
+ */
+
+/** The configured site address, or "" when none is set. */
+export function configuredSiteAddress(config = {}, env = {}) {
+  const value = config?.url ?? config?.siteUrl ?? env.SITE_URL ?? env.NEXT_PUBLIC_SITE_URL ?? "";
+  return String(value).trim();
+}
+
+const hostKey = (hostname) => hostname.toLowerCase().replace(/\.$/u, "").replace(/^www\./u, "");
+const normalizeBase = (basePath) => {
+  const trimmed = String(basePath ?? "").trim().replace(/\/+$/u, "");
+  return !trimmed ? "" : trimmed.startsWith("/") ? trimmed : `/${trimmed}`;
+};
+
+/**
+ * Returns `href => path | null`. The path is root-relative and keeps the base
+ * path, query and hash; null means the link points somewhere else.
+ */
+export function sameSiteMatcher(siteAddress, basePath = "") {
+  let site;
+  try {
+    site = siteAddress ? new URL(siteAddress) : null;
+  } catch {
+    site = null;
+  }
+  if (!site || !/^https?:$/u.test(site.protocol)) return () => null;
+  const key = hostKey(site.hostname);
+  const port = site.port;
+  // A base path written into the site address counts the same as NEXT_PUBLIC_BASE_PATH.
+  const base = normalizeBase(basePath) || normalizeBase(site.pathname);
+  return (href) => {
+    if (typeof href !== "string" || !/^(https?:)?\/\//iu.test(href.trim())) return null;
+    let url;
+    try {
+      url = new URL(href.trim(), `${site.protocol}//${site.host}/`);
+    } catch {
+      return null;
+    }
+    if (!/^https?:$/u.test(url.protocol) || url.username || url.password) return null;
+    if (hostKey(url.hostname) !== key || url.port !== port) return null;
+    const pathname = url.pathname || "/";
+    if (base && pathname !== base && !pathname.startsWith(`${base}/`)) return null;
+    return `${pathname}${url.search}${url.hash}`;
+  };
+}
+
+/**
+ * How an article link renders: a link back to the site becomes its
+ * root-relative path and opens in place; other full URLs are external.
+ */
+export function articleLink(href, sameSite) {
+  if (!href) return { href, external: false };
+  const local = sameSite(href);
+  if (local !== null) return { href: local, external: false };
+  return { href, external: /^(https?:)?\/\//iu.test(href) };
+}

package/ui/garden/search-full.mjs

@@ -0,0 +1,131 @@
+/**
+ * Background loading of the full-text index, in the browser.
+ *
+ * The file name carries a hash, but GitHub Pages only lets browsers cache it
+ * for ten minutes, so the parsed docs are also kept in IndexedDB under that
+ * hash. Pages after the first read them from there without a request. Any
+ * storage problem quietly falls back to the network.
+ */
+
+const STORE = "full";
+
+/**
+ * `[[path, text], ...]` from the file's contents (`{ hash, texts, docs }`).
+ *
+ * @returns {Array<[string, string]>}
+ */
+export function expandFullIndex(data) {
+  if (!Array.isArray(data?.texts) || !Array.isArray(data?.docs)) throw new Error("full-text index is malformed");
+  return data.docs.map(([url, index]) => [url, String(data.texts[index] ?? "")]);
+}
+
+function request(req) {
+  return new Promise((resolve, reject) => {
+    req.onsuccess = () => resolve(req.result);
+    req.onerror = () => reject(req.error);
+  });
+}
+
+/**
+ * IndexedDB holding one entry: the docs for the current hash. One database per site path.
+ *
+ * @param {string} [scope]
+ * @param {IDBFactory | undefined} [idb]
+ */
+export function createIdbStore(scope = "", idb = globalThis.indexedDB) {
+  let opened = null;
+  const open = () => {
+    if (!idb) return Promise.reject(new Error("no IndexedDB"));
+    opened ??= new Promise((resolve, reject) => {
+      const req = idb.open(`garden-search${scope}`, 1);
+      req.onupgradeneeded = () => req.result.createObjectStore(STORE);
+      req.onsuccess = () => resolve(req.result);
+      req.onerror = () => reject(req.error);
+      req.onblocked = () => reject(new Error("blocked"));
+    }).catch((error) => {
+      opened = null;
+      throw error;
+    });
+    return opened;
+  };
+  return {
+    async get(hash) {
+      const db = await open();
+      return (await request(db.transaction(STORE, "readonly").objectStore(STORE).get(hash))) ?? null;
+    },
+    /** Store the docs for this hash and drop every other entry. */
+    async replace(hash, docs) {
+      const db = await open();
+      const tx = db.transaction(STORE, "readwrite");
+      const store = tx.objectStore(STORE);
+      store.clear();
+      store.put(docs, hash);
+      await new Promise((resolve, reject) => {
+        tx.oncomplete = resolve;
+        tx.onerror = () => reject(tx.error);
+        tx.onabort = () => reject(tx.error);
+      });
+    },
+  };
+}
+
+/**
+ * `[[path, text], ...]` for this hash: from the store when it has it, otherwise from the network.
+ *
+ * @param {{ url: string; hash: string; store?: { get(hash: string): Promise<unknown>; replace(hash: string, docs: unknown): Promise<void> } | null; fetcher?: typeof fetch }} options
+ * @returns {Promise<Array<[string, string]>>}
+ */
+export async function loadFullIndex({ url, hash, store, fetcher = globalThis.fetch }) {
+  try {
+    const cached = await store?.get(hash);
+    if (cached) return expandFullIndex(cached);
+  } catch {
+    // Storage unavailable or entry unreadable: use the network.
+  }
+  const response = await fetcher(url);
+  if (!response.ok) throw new Error(`full-text index ${response.status}`);
+  const data = await response.json();
+  const docs = expandFullIndex(data);
+  try {
+    await store?.replace(data.hash ?? hash, data);
+  } catch {
+    // Not cached this time; the next page fetches it again.
+  }
+  return docs;
+}
+
+/** The reader asked their browser to save data. */
+export function saveDataOn(nav = globalThis.navigator) {
+  return Boolean(nav?.connection?.saveData);
+}
+
+/**
+ * Run `task` once the page has fully loaded and the browser is idle, so it
+ * never competes with rendering. Falls back to a timer where
+ * requestIdleCallback is missing. Returns a cancel function.
+ */
+/**
+ * @param {() => void} task
+ * @param {{ win?: any; timeout?: number; fallbackDelay?: number }} [options]
+ */
+export function whenIdleAfterLoad(task, { win = globalThis.window, timeout = 4000, fallbackDelay = 1200 } = {}) {
+  let cancelled = false;
+  let handle = null;
+  const run = () => {
+    if (!cancelled) task();
+  };
+  const schedule = () => {
+    if (cancelled) return;
+    handle = typeof win.requestIdleCallback === "function"
+      ? { idle: win.requestIdleCallback(run, { timeout }) }
+      : { timer: win.setTimeout(run, fallbackDelay) };
+  };
+  if (win.document?.readyState === "complete") schedule();
+  else win.addEventListener("load", schedule, { once: true });
+  return () => {
+    cancelled = true;
+    win.removeEventListener?.("load", schedule);
+    if (handle?.idle != null) win.cancelIdleCallback?.(handle.idle);
+    if (handle?.timer != null) win.clearTimeout?.(handle.timer);
+  };
+}

package/ui/garden/search-index.mjs

@@ -0,0 +1,102 @@
+/**
+ * Two search indexes, both plain JSON files next to the site, never part of
+ * the page scripts:
+ * - search-index.json: titles, sections, tags, dates and short excerpts,
+ *   loaded when search is about to open;
+ * - search-full.<hash>.json: the plain text of every body, fetched in the
+ *   background after the page has loaded and kept in IndexedDB by hash.
+ */
+import crypto from "node:crypto";
+import { contentToSearchText } from "../core/transform.mjs";
+
+/** Plain text of a post body, as search and word counts see it. */
+export function searchableText(markdown) {
+  return contentToSearchText(markdown)
+    .replace(/```[^\n]*\n([\s\S]*?)```/g, " $1 ")
+    .replace(/!\[([^\]]*)\]\([^)]+\)/g, " $1 ")
+    .replace(/\[([^\]]+)\]\([^)]+\)/g, " $1 ")
+    .replace(/<[^>]+>/g, " ")
+    .replace(/[#>*_~`|[\]{}()]/g, " ")
+    .replace(/\s+/g, " ")
+    .trim();
+}
+
+/** Code blocks longer than this many lines are left out of the full-text index. */
+export const MAX_INDEXED_CODE_LINES = 4;
+
+/**
+ * Body text for full-text search: markdown, HTML and math blocks stripped,
+ * short code blocks kept as words, long ones dropped.
+ */
+export function fullText(markdown) {
+  // Widgets and snapshots become their captions first, so they are not mistaken for long code.
+  const withoutLongCode = contentToSearchText(String(markdown ?? ""))
+    .replace(/^([ \t]*)(`{3,}|~{3,})[^\n]*\n([\s\S]*?)^\1\2[ \t]*$/gmu, (block, _indent, _fence, body) =>
+      body.split("\n").filter((line) => line.trim()).length > MAX_INDEXED_CODE_LINES ? "\n" : block)
+    .replace(/^\$\$[\s\S]*?^\$\$[ \t]*$/gmu, "\n")
+    // List and task markers, callout labels and footnote markers are not words.
+    .replace(/^[ \t>]*(?:[-*+]|\d+[.)])[ \t]+(?:\[[ xX]\][ \t]+)?/gmu, "")
+    .replace(/\[![A-Za-z]+\][+-]?/gu, " ")
+    .replace(/\[\^[^\]\s]+\]:?/gu, " ");
+  // Underscores inside identifiers (snake_case) are part of the word, not emphasis.
+  return searchableText(withoutLongCode.replace(/(?<=[\p{L}\p{N}])_(?=[\p{L}\p{N}])/gu, "\u0001"))
+    .replaceAll("\u0001", "_")
+    .replace(/!\[[^\]]*\]\[[^\]]*\]/gu, " ")
+    .replace(/https?:\/\/\S+/gu, " ")
+    .replace(/&[a-z]+;|&#\d+;/giu, " ")
+    .replace(/\s+/gu, " ")
+    .trim();
+}
+
+export const EXCERPT_LENGTH = 240;
+
+const excerpt = (text, length = EXCERPT_LENGTH) => {
+  const chars = Array.from(text);
+  return chars.length > length ? `${chars.slice(0, length).join("")}…` : text;
+};
+
+const columnEntryPath = (entry) =>
+  entry.column && entry.path.startsWith(`${entry.column}/`) ? entry.path.slice(entry.column.length + 1) : entry.path;
+
+/** Records in the same order the header has always listed them: posts, column entries, thoughts. */
+export function buildSearchIndex({ posts = [], columns = [], thoughts = [] }, { length = EXCERPT_LENGTH } = {}) {
+  const record = (item, extra) => {
+    const text = searchableText(item.content ?? "");
+    return {
+      title: item.title,
+      description: item.description ?? "",
+      date: item.date,
+      tags: item.tags ?? [],
+      content: excerpt(text, length),
+      ...extra(text),
+    };
+  };
+  return [
+    ...posts.map((item) => record(item, () => ({ section: "文章", path: `/blog/${item.path}` }))),
+    ...columns.map((item) => record(item, () => ({ section: item.columnTitle ?? "专栏", path: `/columns/${item.column}/${columnEntryPath(item)}` }))),
+    ...thoughts.map((item) => record(item, (text) => ({ section: "随想", path: `/thoughts/${item.slug}`, description: excerpt(text, length) }))),
+  ];
+}
+
+/**
+ * The full-text file: `{ hash, texts, docs }`, where docs is
+ * `[[path, textIndex], ...]` in the small index's order. A post that also
+ * sits in a column has one body under two paths, so texts are stored once.
+ * The hash is of the contents, so the file name changes exactly when they do.
+ */
+export function buildFullIndex({ posts = [], columns = [], thoughts = [] }) {
+  const items = [...posts, ...columns, ...thoughts];
+  const texts = [];
+  const seen = new Map();
+  const docs = buildSearchIndex({ posts, columns, thoughts }).map((record, index) => {
+    const text = fullText(items[index].content ?? "");
+    if (!seen.has(text)) {
+      seen.set(text, texts.length);
+      texts.push(text);
+    }
+    return [record.path, seen.get(text)];
+  });
+  const hash = crypto.createHash("sha256").update(JSON.stringify([texts, docs])).digest("hex").slice(0, 10);
+  return { hash, texts, docs, fileName: `search-full.${hash}.json`, json: JSON.stringify({ hash, texts, docs }) };
+}
+

package/ui/garden/search-match.mjs

@@ -0,0 +1,96 @@
+/**
+ * Substring search over titles, descriptions, tags and body text. Works the
+ * same for Chinese and English: every word of the query has to appear
+ * somewhere in the entry. Plain indexOf over ~1-2 MB of text stays well under
+ * a frame, so it runs on the main thread.
+ */
+
+const MAX_RANGES_PER_TERM = 12;
+
+/** Query words: split on spaces, lowercased, duplicates dropped. */
+export function queryTerms(query) {
+  return [...new Set(String(query ?? "").toLowerCase().split(/\s+/u).filter(Boolean))];
+}
+
+function occurrences(haystack, term, limit = MAX_RANGES_PER_TERM) {
+  const ranges = [];
+  let from = 0;
+  while (ranges.length < limit) {
+    const at = haystack.indexOf(term, from);
+    if (at === -1) break;
+    ranges.push([at, at + term.length - 1]);
+    from = at + term.length;
+  }
+  return ranges;
+}
+
+const lower = (text) => {
+  const value = String(text ?? "");
+  const folded = value.toLowerCase();
+  // Highlights need positions that line up with the original text.
+  return folded.length === value.length ? folded : null;
+};
+
+/**
+ * `records` come from search-index.json; `bodies` is a Map of path → full
+ * text, or null while only the excerpts are loaded. Results have the shape the
+ * header renders: `{ item, matches: [{ key, indices }] }`, where item.content
+ * is the body the snippet is cut from.
+ *
+ * @param {Array<{ title: string; description?: string; path: string; content?: string; tags?: string[] }>} records
+ * @param {Map<string, string> | null} [bodies]
+ */
+export function createSearch(records, bodies = null) {
+  const docs = records.map((record, order) => {
+    const content = bodies?.get(record.path) ?? record.content ?? "";
+    const tags = (record.tags ?? []).map((tag) => String(tag).toLowerCase());
+    return {
+      order,
+      item: { ...record, content },
+      title: lower(record.title),
+      description: lower(record.description),
+      body: lower(content),
+      tags,
+      tagText: tags.join(" "),
+    };
+  });
+
+  function search(query, limit = 6) {
+    const terms = queryTerms(query);
+    if (!terms.length) return [];
+    const hits = [];
+    for (const doc of docs) {
+      let score = 0;
+      const ranges = { title: [], description: [], content: [] };
+      let all = true;
+      for (const term of terms) {
+        const inTitle = doc.title ? occurrences(doc.title, term) : [];
+        const inDescription = doc.description ? occurrences(doc.description, term) : [];
+        const inBody = doc.body ? occurrences(doc.body, term) : [];
+        const tagExact = doc.tags.includes(term);
+        const inTags = tagExact || doc.tagText.includes(term);
+        if (!inTitle.length && !inDescription.length && !inBody.length && !inTags) {
+          all = false;
+          break;
+        }
+        if (inTitle.length) score += 8;
+        if (tagExact) score += 6;
+        else if (inTags) score += 3;
+        if (inDescription.length) score += 3;
+        if (inBody.length) score += 1 + inBody.length * 0.1;
+        ranges.title.push(...inTitle);
+        ranges.description.push(...inDescription);
+        ranges.content.push(...inBody);
+      }
+      if (!all) continue;
+      const matches = Object.entries(ranges)
+        .filter(([, indices]) => indices.length)
+        .map(([key, indices]) => ({ key, indices: indices.sort((a, b) => a[0] - b[0]) }));
+      hits.push({ score, order: doc.order, item: doc.item, matches });
+    }
+    hits.sort((a, b) => b.score - a.score || a.order - b.order);
+    return hits.slice(0, limit).map(({ item, matches }) => ({ item, matches }));
+  }
+
+  return { full: Boolean(bodies), search };
+}