wendang-react 0.0.0-stage → 0.5.5

package/dist/chunks/fuzzy-match-DYQR-4w2.js

@@ -0,0 +1,89 @@
+"use client";
+import pinyin from "tiny-pinyin";
+const cache = /* @__PURE__ */ new Map();
+const CACHE_LIMIT = 2e3;
+function pinyinIndex(title) {
+  const key = title;
+  const hit = cache.get(key);
+  if (hit) return hit;
+  let full;
+  let initials;
+  if (pinyin.isSupported()) {
+    const withSep = pinyin.convertToPinyin(title, "-", true).toLowerCase().replace(/\s+/g, "");
+    full = withSep.replace(/-/g, "");
+    initials = withSep.split("-").filter((seg) => seg.length > 0).map((seg) => seg[0]).join("");
+  } else {
+    full = title.toLowerCase();
+    initials = full;
+  }
+  const value = { full, initials };
+  if (cache.size >= CACHE_LIMIT) cache.clear();
+  cache.set(key, value);
+  return value;
+}
+function clearPinyinCache() {
+  cache.clear();
+}
+const SCORE = {
+  exact: 1e3,
+  startsWith: 900,
+  /** 出现在词边界（空格、连字符等分隔）之后 */
+  boundary: 850,
+  includes: 800,
+  pinyinStartsWith: 700,
+  pinyinIncludes: 650,
+  initialsExact: 680,
+  initialsStartsWith: 660,
+  initialsIncludes: 620
+};
+function normalize(q) {
+  return q.trim().toLowerCase();
+}
+function isLatinQuery(q) {
+  return /^[a-z0-9]+$/.test(q);
+}
+function matchTitle(input, rawQuery) {
+  const query = normalize(rawQuery);
+  if (query.length === 0) return { score: 0, kind: "title" };
+  const title = input.title.toLowerCase();
+  if (title === query) return { score: SCORE.exact, kind: "title" };
+  if (title.startsWith(query)) return { score: SCORE.startsWith, kind: "title" };
+  const idx = title.indexOf(query);
+  if (idx > 0) {
+    const prev = title[idx - 1];
+    const atBoundary = /[\s\-_/.,;:：，。、（）()]/.test(prev);
+    return {
+      score: atBoundary ? SCORE.boundary : SCORE.includes,
+      kind: "title"
+    };
+  }
+  if (!isLatinQuery(query)) return null;
+  const { full, initials } = pinyinIndex(input.title);
+  if (initials === query) return { score: SCORE.initialsExact, kind: "initials" };
+  if (initials.startsWith(query)) {
+    return { score: SCORE.initialsStartsWith, kind: "initials" };
+  }
+  if (full.startsWith(query)) {
+    return { score: SCORE.pinyinStartsWith, kind: "pinyin" };
+  }
+  if (full.includes(query)) return { score: SCORE.pinyinIncludes, kind: "pinyin" };
+  if (initials.includes(query)) {
+    return { score: SCORE.initialsIncludes, kind: "initials" };
+  }
+  return null;
+}
+function rankPages(pages, rawQuery) {
+  const out = [];
+  pages.forEach((page, order) => {
+    const match = matchTitle(page, rawQuery);
+    if (match) out.push({ page, match, order });
+  });
+  out.sort((a, b) => b.match.score - a.match.score || a.order - b.order);
+  return out.map(({ page, match }) => ({ page, match }));
+}
+export {
+  clearPinyinCache as c,
+  matchTitle as m,
+  pinyinIndex as p,
+  rankPages as r
+};

package/dist/chunks/hooks-C53Dp0pr.js

@@ -0,0 +1,35 @@
+"use client";
+import { useRef, useEffect, useCallback } from "react";
+function useLatest(value) {
+  const ref = useRef(value);
+  ref.current = value;
+  return ref;
+}
+function useReady() {
+  const state = useRef({ ready: false, disposed: false, waiters: [] });
+  useEffect(() => {
+    state.current.disposed = false;
+    return () => {
+      state.current.disposed = true;
+      state.current.ready = false;
+      for (const resolve of state.current.waiters.splice(0)) resolve();
+    };
+  }, []);
+  const markReady = useCallback(() => {
+    state.current.ready = true;
+    for (const resolve of state.current.waiters.splice(0)) resolve();
+  }, []);
+  return {
+    markReady,
+    isReady: () => state.current.ready,
+    whenReady: () => state.current.ready || state.current.disposed ? Promise.resolve() : new Promise((resolve) => state.current.waiters.push(resolve))
+  };
+}
+function asError(error) {
+  return error instanceof Error ? error : new Error(String(error));
+}
+export {
+  useReady as a,
+  asError as b,
+  useLatest as u
+};

package/dist/chunks/host-C-V688Rq.js

@@ -0,0 +1,197 @@
+"use client";
+import { jsx } from "react/jsx-runtime";
+import { useState, useRef, useEffect, useContext, createContext } from "react";
+const unavailableAttachment = async () => {
+  throw new Error("未配置附件读取服务");
+};
+const defaultAttachmentFetcher = unavailableAttachment;
+const PRIMED_LIMIT = 16;
+const primedAttachments = /* @__PURE__ */ new Map();
+function primeAttachment(id, blob) {
+  if (!id || !blob) return;
+  primedAttachments.delete(id);
+  primedAttachments.set(id, blob);
+  while (primedAttachments.size > PRIMED_LIMIT) {
+    const oldest = primedAttachments.keys().next();
+    if (oldest.done) break;
+    primedAttachments.delete(oldest.value);
+  }
+}
+function takePrimedAttachment(id) {
+  const blob = primedAttachments.get(id);
+  if (!blob) return null;
+  primedAttachments.delete(id);
+  return blob;
+}
+const attachmentCache = /* @__PURE__ */ new Map();
+const inflightFetches = /* @__PURE__ */ new Map();
+const MAX_CACHE_BYTES = 48 * 1024 * 1024;
+let cachedBytes = 0;
+let touchClock = 0;
+function cacheKey(id, scope) {
+  return scope ? `${scope}\0${id}` : id;
+}
+function trimCache() {
+  if (cachedBytes <= MAX_CACHE_BYTES) return;
+  const evictable = [...attachmentCache.entries()].filter(([, entry]) => entry.refs === 0).sort((a, b) => a[1].touched - b[1].touched);
+  for (const [id, entry] of evictable) {
+    if (cachedBytes <= MAX_CACHE_BYTES) break;
+    attachmentCache.delete(id);
+    cachedBytes -= entry.blob.size;
+    URL.revokeObjectURL(entry.url);
+  }
+}
+function acquireEntry(key, blob) {
+  let entry = attachmentCache.get(key);
+  if (!entry) {
+    entry = { blob, url: URL.createObjectURL(blob), refs: 0, touched: ++touchClock };
+    attachmentCache.set(key, entry);
+    cachedBytes += blob.size;
+  }
+  entry.touched = ++touchClock;
+  return entry;
+}
+function attachmentObjectUrl(id, onReady, fetcher = unavailableAttachment, onError, scope) {
+  const key = cacheKey(id, scope);
+  let released = false;
+  const dispose = () => {
+    if (released) return;
+    released = true;
+    releaseEntry(key);
+  };
+  const existing = attachmentCache.get(key);
+  if (existing) {
+    existing.refs += 1;
+    existing.touched = ++touchClock;
+    onReady(existing.url);
+    return dispose;
+  }
+  const primed = takePrimedAttachment(id);
+  if (primed) {
+    const entry = acquireEntry(key, primed);
+    entry.refs += 1;
+    onReady(entry.url);
+    trimCache();
+    return dispose;
+  }
+  let pending = inflightFetches.get(key);
+  if (!pending) {
+    pending = fetcher(id).finally(() => {
+      inflightFetches.delete(key);
+    });
+    inflightFetches.set(key, pending);
+  }
+  void pending.then((blob) => {
+    if (released) return;
+    const entry = acquireEntry(key, blob);
+    entry.refs += 1;
+    onReady(entry.url);
+    trimCache();
+  }).catch(() => {
+    if (!released) onError == null ? void 0 : onError();
+  });
+  return dispose;
+}
+function releaseEntry(key) {
+  const entry = attachmentCache.get(key);
+  if (!entry || entry.refs === 0) return;
+  entry.refs -= 1;
+  if (entry.refs === 0) {
+    entry.touched = ++touchClock;
+    trimCache();
+  }
+}
+function clearAttachmentCache(scope) {
+  const matches = (key) => scope === void 0 || key.startsWith(`${scope}\0`);
+  for (const [key, entry] of attachmentCache) if (matches(key)) {
+    URL.revokeObjectURL(entry.url);
+    attachmentCache.delete(key);
+    cachedBytes -= entry.blob.size;
+  }
+  for (const key of inflightFetches.keys()) if (matches(key)) inflightFetches.delete(key);
+  if (scope === void 0) primedAttachments.clear();
+}
+async function downloadAttachment(attachmentId, filename, fetcher = defaultAttachmentFetcher) {
+  const blob = await fetcher(attachmentId);
+  const url = URL.createObjectURL(blob);
+  const a = document.createElement("a");
+  a.href = url;
+  a.download = filename || "attachment";
+  document.body.appendChild(a);
+  a.click();
+  a.remove();
+  setTimeout(() => URL.revokeObjectURL(url), 1e4);
+}
+function formatBytes(bytes) {
+  if (!Number.isFinite(bytes) || bytes <= 0) return "";
+  const units = ["B", "KB", "MB", "GB"];
+  let n = bytes;
+  let i = 0;
+  while (n >= 1024 && i < units.length - 1) {
+    n /= 1024;
+    i += 1;
+  }
+  return `${n >= 10 || i === 0 ? Math.round(n) : n.toFixed(1)} ${units[i]}`;
+}
+const Context = createContext({ host: {}, theme: "light", accent: "#2f6feb", portal: null });
+function useContentContext() {
+  return useContext(Context);
+}
+function useContentHost() {
+  return useContentContext().host;
+}
+function ContentContextBridge({ value, children }) {
+  return /* @__PURE__ */ jsx(Context.Provider, { value, children });
+}
+function ContentProvider({ host = {}, theme = "light", accent = "#2f6feb", unstyled = false, children, className = "" }) {
+  const [portal, setPortal] = useState(null);
+  const previousScope = useRef(host.scope), latestTheme = useRef({ theme, accent, unstyled });
+  latestTheme.current = { theme, accent, unstyled };
+  useEffect(() => {
+    const element = document.createElement("div");
+    const { theme: currentTheme, accent: currentAccent, unstyled: currentUnstyled } = latestTheme.current;
+    element.className = `wendang-portal ${currentUnstyled ? "" : "wendang"}`.trim();
+    element.dataset.wendangPortal = "";
+    element.dataset.wendangTheme = currentTheme;
+    element.style.setProperty("--wendang-accent", currentAccent);
+    element.style.colorScheme = currentTheme;
+    document.body.append(element);
+    setPortal(element);
+    return () => {
+      element.remove();
+    };
+  }, []);
+  useEffect(() => {
+    if (previousScope.current !== host.scope) {
+      clearAttachmentCache(previousScope.current);
+      previousScope.current = host.scope;
+    }
+  }, [host.scope]);
+  useEffect(() => {
+    if (!portal) return;
+    portal.className = `wendang-portal ${unstyled ? "" : "wendang"}`.trim();
+    portal.dataset.wendangTheme = theme;
+    portal.style.setProperty("--wendang-accent", accent);
+    portal.style.colorScheme = theme;
+  }, [portal, theme, accent, unstyled]);
+  return /* @__PURE__ */ jsx(Context.Provider, { value: { host, theme, accent, portal }, children: /* @__PURE__ */ jsx(
+    "div",
+    {
+      className: `wendang-root ${className}`,
+      "data-wendang-theme": theme,
+      style: { "--wendang-accent": accent, colorScheme: theme },
+      children: /* @__PURE__ */ jsx("div", { className: unstyled ? void 0 : "wendang", "data-wendang-theme": theme, children }, host.scope ?? "")
+    }
+  ) });
+}
+export {
+  ContentProvider as C,
+  useContentContext as a,
+  useContentHost as b,
+  attachmentObjectUrl as c,
+  downloadAttachment as d,
+  ContentContextBridge as e,
+  formatBytes as f,
+  primeAttachment as p,
+  unavailableAttachment as u
+};