@consilioweb/spellcheck 0.10.1

package/dist/client.js

@@ -0,0 +1,1702 @@
+"use client";
+import React3, { useState, useRef, useEffect, useCallback } from 'react';
+import { useDocumentInfo } from '@payloadcms/ui';
+import { jsxs, jsx, Fragment } from 'react/jsx-runtime';
+
+// src/components/SpellCheckField.tsx
+var styles = {
+  card: {
+    border: "1px solid var(--theme-elevation-150)",
+    borderRadius: "4px",
+    padding: "12px",
+    marginBottom: "8px",
+    backgroundColor: "var(--theme-elevation-50)"
+  },
+  header: {
+    display: "flex",
+    justifyContent: "space-between",
+    alignItems: "flex-start",
+    gap: "8px",
+    marginBottom: "8px"
+  },
+  message: {
+    fontSize: "13px",
+    lineHeight: "1.4",
+    color: "var(--theme-text)",
+    flex: 1
+  },
+  badge: {
+    fontSize: "10px",
+    padding: "2px 6px",
+    borderRadius: "3px",
+    backgroundColor: "var(--theme-elevation-200)",
+    color: "var(--theme-elevation-800)",
+    whiteSpace: "nowrap",
+    flexShrink: 0
+  },
+  context: {
+    fontSize: "12px",
+    color: "var(--theme-elevation-500)",
+    backgroundColor: "var(--theme-elevation-100)",
+    padding: "6px 8px",
+    borderRadius: "3px",
+    fontFamily: "monospace",
+    marginBottom: "8px",
+    wordBreak: "break-word"
+  },
+  original: {
+    textDecoration: "line-through",
+    color: "var(--theme-error-500)",
+    fontWeight: 600
+  },
+  suggestion: {
+    display: "flex",
+    alignItems: "center",
+    gap: "6px",
+    marginBottom: "8px"
+  },
+  suggestionLabel: {
+    fontSize: "11px",
+    color: "var(--theme-elevation-500)"
+  },
+  suggestionText: {
+    fontSize: "13px",
+    fontWeight: 600,
+    color: "var(--theme-success-500)"
+  },
+  actions: {
+    display: "flex",
+    gap: "6px"
+  },
+  btn: {
+    fontSize: "11px",
+    padding: "4px 10px",
+    borderRadius: "3px",
+    border: "1px solid var(--theme-elevation-200)",
+    backgroundColor: "var(--theme-elevation-0)",
+    color: "var(--theme-text)",
+    cursor: "pointer"
+  },
+  btnFix: {
+    fontSize: "11px",
+    padding: "4px 10px",
+    borderRadius: "3px",
+    border: "none",
+    backgroundColor: "var(--theme-success-500)",
+    color: "#fff",
+    cursor: "pointer",
+    fontWeight: 600
+  },
+  fixed: {
+    opacity: 0.5,
+    pointerEvents: "none"
+  },
+  diff: {
+    padding: "8px 10px",
+    borderRadius: "3px",
+    backgroundColor: "var(--theme-elevation-100)",
+    marginBottom: "8px",
+    fontSize: "13px",
+    lineHeight: "1.6",
+    fontFamily: "monospace",
+    wordBreak: "break-word"
+  },
+  diffBefore: {
+    textDecoration: "line-through",
+    backgroundColor: "rgba(239, 68, 68, 0.15)",
+    color: "var(--theme-error-500)",
+    padding: "1px 3px",
+    borderRadius: "2px"
+  },
+  diffAfter: {
+    backgroundColor: "rgba(34, 197, 94, 0.15)",
+    color: "var(--theme-success-500)",
+    fontWeight: 600,
+    padding: "1px 3px",
+    borderRadius: "2px"
+  },
+  diffArrow: {
+    display: "inline-block",
+    margin: "0 6px",
+    color: "var(--theme-elevation-400)",
+    fontSize: "12px"
+  }
+};
+var IssueCard = ({
+  issue,
+  onFix,
+  onIgnore,
+  onAddToDict,
+  isFixed = false
+}) => {
+  const [showDiff, setShowDiff] = useState(false);
+  const [selectedReplacement, setSelectedReplacement] = useState(0);
+  const [manualEdit, setManualEdit] = useState(false);
+  const [manualValue, setManualValue] = useState("");
+  const [addedToDict, setAddedToDict] = useState(false);
+  const getContextIdx = (ctx, original) => {
+    if (typeof issue.contextOffset === "number" && issue.contextOffset >= 0) {
+      return issue.contextOffset;
+    }
+    return ctx.indexOf(original);
+  };
+  const highlightContext = (ctx, original) => {
+    const idx = getContextIdx(ctx, original);
+    if (!original || idx < 0) return ctx;
+    return /* @__PURE__ */ jsxs(Fragment, { children: [
+      ctx.slice(0, idx),
+      /* @__PURE__ */ jsx("span", { style: styles.original, children: original }),
+      ctx.slice(idx + original.length)
+    ] });
+  };
+  const renderDiff = (ctx, original, replacement) => {
+    const idx = getContextIdx(ctx, original);
+    if (!original || idx < 0) {
+      return /* @__PURE__ */ jsxs("div", { style: styles.diff, children: [
+        /* @__PURE__ */ jsx("span", { style: styles.diffBefore, children: original }),
+        /* @__PURE__ */ jsx("span", { style: styles.diffArrow, children: "\u2192" }),
+        /* @__PURE__ */ jsx("span", { style: styles.diffAfter, children: replacement })
+      ] });
+    }
+    return /* @__PURE__ */ jsxs("div", { style: styles.diff, children: [
+      /* @__PURE__ */ jsx("div", { style: { marginBottom: "4px", color: "var(--theme-elevation-400)", fontSize: "10px", textTransform: "uppercase", letterSpacing: "0.5px" }, children: "Avant / Apr\xE8s" }),
+      /* @__PURE__ */ jsxs("div", { children: [
+        ctx.slice(0, idx),
+        /* @__PURE__ */ jsx("span", { style: styles.diffBefore, children: original }),
+        ctx.slice(idx + original.length)
+      ] }),
+      /* @__PURE__ */ jsxs("div", { style: { marginTop: "4px" }, children: [
+        ctx.slice(0, idx),
+        /* @__PURE__ */ jsx("span", { style: styles.diffAfter, children: replacement }),
+        ctx.slice(idx + original.length)
+      ] })
+    ] });
+  };
+  const currentReplacement = manualEdit && manualValue ? manualValue : issue.replacements[selectedReplacement] || "";
+  return /* @__PURE__ */ jsxs("div", { style: { ...styles.card, ...isFixed ? styles.fixed : {} }, children: [
+    /* @__PURE__ */ jsxs("div", { style: styles.header, children: [
+      /* @__PURE__ */ jsx("div", { style: styles.message, children: issue.message }),
+      /* @__PURE__ */ jsx("span", { style: styles.badge, children: issue.source === "claude" ? "IA" : issue.category })
+    ] }),
+    showDiff && issue.context && currentReplacement ? renderDiff(issue.context, issue.original, currentReplacement) : issue.context ? /* @__PURE__ */ jsx("div", { style: styles.context, children: highlightContext(issue.context, issue.original) }) : null,
+    !manualEdit && issue.replacements.length > 0 && /* @__PURE__ */ jsxs("div", { style: styles.suggestion, children: [
+      /* @__PURE__ */ jsx("span", { style: styles.suggestionLabel, children: "Suggestion :" }),
+      issue.replacements.length > 1 ? /* @__PURE__ */ jsx(
+        "select",
+        {
+          value: selectedReplacement,
+          onChange: (e) => setSelectedReplacement(Number(e.target.value)),
+          style: {
+            fontSize: "13px",
+            fontWeight: 600,
+            color: "var(--theme-success-500)",
+            border: "1px solid var(--theme-elevation-200)",
+            borderRadius: "3px",
+            padding: "2px 4px",
+            backgroundColor: "var(--theme-elevation-0)"
+          },
+          children: issue.replacements.map((r, i) => /* @__PURE__ */ jsx("option", { value: i, children: r }, i))
+        }
+      ) : /* @__PURE__ */ jsx("span", { style: styles.suggestionText, children: currentReplacement })
+    ] }),
+    manualEdit && !isFixed && /* @__PURE__ */ jsxs("div", { style: { marginBottom: "8px" }, children: [
+      /* @__PURE__ */ jsx("div", { style: { fontSize: "11px", color: "var(--theme-elevation-500)", marginBottom: "4px" }, children: "Correction manuelle :" }),
+      /* @__PURE__ */ jsx(
+        "input",
+        {
+          type: "text",
+          value: manualValue,
+          onChange: (e) => setManualValue(e.target.value),
+          placeholder: issue.original,
+          style: {
+            width: "100%",
+            padding: "6px 8px",
+            fontSize: "13px",
+            border: "1px solid var(--theme-elevation-200)",
+            borderRadius: "3px",
+            backgroundColor: "var(--theme-elevation-0)",
+            color: "var(--theme-text)",
+            boxSizing: "border-box"
+          }
+        }
+      )
+    ] }),
+    /* @__PURE__ */ jsxs("div", { style: styles.actions, children: [
+      issue.context && currentReplacement && !isFixed && /* @__PURE__ */ jsx(
+        "button",
+        {
+          type: "button",
+          style: { ...styles.btn, fontSize: "10px" },
+          onClick: () => setShowDiff(!showDiff),
+          children: showDiff ? "Masquer" : "Avant/Apr\xE8s"
+        }
+      ),
+      !isFixed && /* @__PURE__ */ jsx(
+        "button",
+        {
+          type: "button",
+          style: { ...styles.btn, fontSize: "10px" },
+          onClick: () => {
+            setManualEdit(!manualEdit);
+            if (!manualEdit) setManualValue(issue.original);
+          },
+          children: manualEdit ? "Suggestion" : "Manuel"
+        }
+      ),
+      currentReplacement && onFix && !isFixed && /* @__PURE__ */ jsx(
+        "button",
+        {
+          type: "button",
+          style: styles.btnFix,
+          onClick: () => onFix(issue.original, currentReplacement, issue.offset, issue.length),
+          children: "Corriger"
+        }
+      ),
+      onAddToDict && !isFixed && !addedToDict && issue.original && /* @__PURE__ */ jsx(
+        "button",
+        {
+          type: "button",
+          style: { ...styles.btn, fontSize: "10px" },
+          onClick: () => {
+            onAddToDict(issue.original);
+            setAddedToDict(true);
+          },
+          title: "Ajouter au dictionnaire",
+          children: "+ Dico"
+        }
+      ),
+      addedToDict && /* @__PURE__ */ jsx("span", { style: { fontSize: "11px", color: "var(--theme-success-500)" }, children: "Ajout\xE9 au dico" }),
+      onIgnore && !isFixed && /* @__PURE__ */ jsx(
+        "button",
+        {
+          type: "button",
+          style: styles.btn,
+          onClick: () => onIgnore(issue.ruleId),
+          children: "Ignorer"
+        }
+      ),
+      isFixed && /* @__PURE__ */ jsx("span", { style: { fontSize: "11px", color: "var(--theme-success-500)" }, children: "Corrige" })
+    ] })
+  ] });
+};
+var styles2 = {
+  container: {
+    padding: "12px 0"
+  },
+  header: {
+    display: "flex",
+    justifyContent: "space-between",
+    alignItems: "center",
+    marginBottom: "12px"
+  },
+  title: {
+    fontSize: "13px",
+    fontWeight: 600,
+    color: "var(--theme-text)",
+    textTransform: "uppercase",
+    letterSpacing: "0.5px"
+  },
+  scoreBadge: (score) => ({
+    fontSize: "14px",
+    fontWeight: 700,
+    padding: "3px 10px",
+    borderRadius: "12px",
+    color: "#fff",
+    backgroundColor: score >= 95 ? "var(--theme-success-500)" : score >= 80 ? "#f59e0b" : "var(--theme-error-500)"
+  }),
+  checkBtn: {
+    display: "block",
+    width: "100%",
+    padding: "8px 12px",
+    fontSize: "13px",
+    fontWeight: 600,
+    border: "1px solid var(--theme-elevation-200)",
+    borderRadius: "4px",
+    backgroundColor: "var(--theme-elevation-0)",
+    color: "var(--theme-text)",
+    cursor: "pointer",
+    textAlign: "center",
+    marginBottom: "12px"
+  },
+  checkBtnDisabled: {
+    opacity: 0.6,
+    cursor: "not-allowed"
+  },
+  stats: {
+    display: "flex",
+    justifyContent: "space-between",
+    fontSize: "12px",
+    color: "var(--theme-elevation-500)",
+    marginBottom: "12px",
+    padding: "6px 8px",
+    backgroundColor: "var(--theme-elevation-50)",
+    borderRadius: "4px"
+  },
+  issueList: {
+    maxHeight: "400px",
+    overflowY: "auto"
+  },
+  empty: {
+    textAlign: "center",
+    padding: "20px 0",
+    fontSize: "13px",
+    color: "var(--theme-elevation-500)"
+  },
+  error: {
+    padding: "8px 12px",
+    fontSize: "12px",
+    color: "var(--theme-error-500)",
+    backgroundColor: "var(--theme-error-100)",
+    borderRadius: "4px",
+    marginBottom: "12px"
+  }
+};
+var SpellCheckField = () => {
+  const { id, collectionSlug } = useDocumentInfo();
+  const [result, setResult] = useState(null);
+  const [resultDbId, setResultDbId] = useState(null);
+  const [loading, setLoading] = useState(false);
+  const [error, setError] = useState(null);
+  const resultRef = useRef(result);
+  resultRef.current = result;
+  const resultDbIdRef = useRef(resultDbId);
+  resultDbIdRef.current = resultDbId;
+  useEffect(() => {
+    if (!id || !collectionSlug) return;
+    fetch(`/api/spellcheck-results?where[docId][equals]=${id}&where[collection][equals]=${collectionSlug}&limit=1`).then((res) => res.json()).then((data) => {
+      if (data.docs?.[0]) {
+        setResultDbId(data.docs[0].id);
+        setResult({
+          docId: String(id),
+          collection: collectionSlug,
+          score: data.docs[0].score,
+          issueCount: data.docs[0].issueCount,
+          wordCount: data.docs[0].wordCount || 0,
+          issues: data.docs[0].issues || [],
+          lastChecked: data.docs[0].lastChecked
+        });
+      }
+    }).catch(() => {
+    });
+  }, [id, collectionSlug]);
+  const handleCheck = useCallback(async () => {
+    if (!id || !collectionSlug || loading) return;
+    setLoading(true);
+    setError(null);
+    try {
+      const res = await fetch("/api/spellcheck/validate", {
+        method: "POST",
+        headers: { "Content-Type": "application/json" },
+        body: JSON.stringify({ id, collection: collectionSlug })
+      });
+      if (!res.ok) {
+        const err = await res.json();
+        throw new Error(err.error || `HTTP ${res.status}`);
+      }
+      const data = await res.json();
+      setResult(data);
+    } catch (err) {
+      setError(err.message);
+    } finally {
+      setLoading(false);
+    }
+  }, [id, collectionSlug, loading]);
+  const removeIssue = useCallback((matcher) => {
+    const prev = resultRef.current;
+    if (!prev) return;
+    const updatedIssues = prev.issues.filter((issue) => {
+      if (typeof matcher.offset === "number" && issue.offset === matcher.offset) {
+        if (matcher.original && issue.original !== matcher.original) return true;
+        if (matcher.ruleId && issue.ruleId !== matcher.ruleId) return true;
+        return false;
+      }
+      return true;
+    });
+    const updatedCount = updatedIssues.length;
+    const updatedScore = prev.wordCount > 0 ? Math.min(100, Math.max(0, Math.round(100 - updatedCount / prev.wordCount * 1e3))) : prev.score;
+    setResult({ ...prev, issues: updatedIssues, issueCount: updatedCount, score: updatedScore });
+    if (resultDbIdRef.current) {
+      fetch(`/api/spellcheck-results/${resultDbIdRef.current}`, {
+        method: "PATCH",
+        headers: { "Content-Type": "application/json" },
+        body: JSON.stringify({ issues: updatedIssues, issueCount: updatedCount, score: updatedScore })
+      }).catch(() => {
+      });
+    }
+  }, []);
+  const handleFix = useCallback(async (original, replacement, offset, length) => {
+    if (!id || !collectionSlug) return;
+    try {
+      const res = await fetch("/api/spellcheck/fix", {
+        method: "POST",
+        headers: { "Content-Type": "application/json" },
+        body: JSON.stringify({ id, collection: collectionSlug, original, replacement, offset, length })
+      });
+      if (res.ok) {
+        removeIssue({ offset, original });
+      }
+    } catch {
+    }
+  }, [id, collectionSlug, removeIssue]);
+  return /* @__PURE__ */ jsxs("div", { style: styles2.container, children: [
+    /* @__PURE__ */ jsxs("div", { style: styles2.header, children: [
+      /* @__PURE__ */ jsx("span", { style: styles2.title, children: "Orthographe" }),
+      result && /* @__PURE__ */ jsx("span", { style: styles2.scoreBadge(result.score), children: result.score })
+    ] }),
+    /* @__PURE__ */ jsx(
+      "button",
+      {
+        type: "button",
+        style: {
+          ...styles2.checkBtn,
+          ...loading ? styles2.checkBtnDisabled : {}
+        },
+        onClick: handleCheck,
+        disabled: loading,
+        children: loading ? "V\xE9rification..." : "V\xE9rifier"
+      }
+    ),
+    error && /* @__PURE__ */ jsx("div", { style: styles2.error, children: error }),
+    result && /* @__PURE__ */ jsxs(Fragment, { children: [
+      /* @__PURE__ */ jsxs("div", { style: styles2.stats, children: [
+        /* @__PURE__ */ jsxs("span", { children: [
+          result.wordCount,
+          " mots"
+        ] }),
+        /* @__PURE__ */ jsxs("span", { children: [
+          result.issueCount,
+          " probl\xE8me",
+          result.issueCount !== 1 ? "s" : ""
+        ] }),
+        result.lastChecked && /* @__PURE__ */ jsx("span", { children: new Date(result.lastChecked).toLocaleTimeString("fr-FR", {
+          hour: "2-digit",
+          minute: "2-digit"
+        }) })
+      ] }),
+      result.issues.length > 0 ? /* @__PURE__ */ jsx("div", { style: styles2.issueList, children: result.issues.map((issue, i) => /* @__PURE__ */ jsx(
+        IssueCard,
+        {
+          issue,
+          onFix: handleFix,
+          onIgnore: () => {
+            removeIssue({ offset: issue.offset, ruleId: issue.ruleId });
+            if (resultDbIdRef.current) {
+              fetch(`/api/spellcheck-results/${resultDbIdRef.current}?depth=0`).then((res) => res.json()).then((data) => {
+                const existing = Array.isArray(data.ignoredIssues) ? data.ignoredIssues : [];
+                const alreadyIgnored = existing.some((e) => e.ruleId === issue.ruleId && e.original === issue.original);
+                if (!alreadyIgnored) {
+                  fetch(`/api/spellcheck-results/${resultDbIdRef.current}`, {
+                    method: "PATCH",
+                    headers: { "Content-Type": "application/json" },
+                    body: JSON.stringify({ ignoredIssues: [...existing, { ruleId: issue.ruleId, original: issue.original }] })
+                  }).catch(() => {
+                  });
+                }
+              }).catch(() => {
+              });
+            }
+          },
+          onAddToDict: (word) => {
+            fetch("/api/spellcheck/dictionary", {
+              method: "POST",
+              headers: { "Content-Type": "application/json" },
+              body: JSON.stringify({ word })
+            }).catch(() => {
+            });
+            removeIssue({ offset: issue.offset, ruleId: issue.ruleId });
+          }
+        },
+        `${issue.ruleId}-${issue.offset}-${i}`
+      )) }) : /* @__PURE__ */ jsx("div", { style: styles2.empty, children: "Aucun probl\xE8me d\xE9tect\xE9 \u2713" })
+    ] }),
+    !result && !loading && /* @__PURE__ */ jsx("div", { style: styles2.empty, children: 'Cliquez sur "V\xE9rifier" pour analyser le contenu' })
+  ] });
+};
+var styles3 = {
+  container: {
+    padding: "24px",
+    maxWidth: "1200px"
+  },
+  header: {
+    display: "flex",
+    justifyContent: "space-between",
+    alignItems: "center",
+    marginBottom: "24px"
+  },
+  title: {
+    fontSize: "24px",
+    fontWeight: 700,
+    color: "var(--theme-text)",
+    margin: 0
+  },
+  description: {
+    fontSize: "14px",
+    color: "var(--theme-elevation-500)",
+    marginTop: "4px"
+  },
+  scanBtn: {
+    padding: "10px 20px",
+    fontSize: "14px",
+    fontWeight: 600,
+    border: "none",
+    borderRadius: "4px",
+    backgroundColor: "var(--theme-elevation-900)",
+    color: "var(--theme-elevation-0)",
+    cursor: "pointer"
+  },
+  scanBtnDisabled: {
+    opacity: 0.6,
+    cursor: "not-allowed"
+  },
+  summary: {
+    display: "grid",
+    gridTemplateColumns: "repeat(auto-fit, minmax(180px, 1fr))",
+    gap: "16px",
+    marginBottom: "24px"
+  },
+  summaryCard: {
+    padding: "16px",
+    borderRadius: "6px",
+    backgroundColor: "var(--theme-elevation-50)",
+    border: "1px solid var(--theme-elevation-150)"
+  },
+  summaryLabel: {
+    fontSize: "12px",
+    color: "var(--theme-elevation-500)",
+    textTransform: "uppercase",
+    letterSpacing: "0.5px",
+    marginBottom: "4px"
+  },
+  summaryValue: {
+    fontSize: "24px",
+    fontWeight: 700,
+    color: "var(--theme-text)"
+  },
+  progress: {
+    padding: "12px 16px",
+    marginBottom: "16px",
+    borderRadius: "4px",
+    backgroundColor: "var(--theme-elevation-50)",
+    border: "1px solid var(--theme-elevation-150)",
+    fontSize: "13px",
+    color: "var(--theme-text)"
+  },
+  progressBar: {
+    height: "4px",
+    backgroundColor: "var(--theme-elevation-150)",
+    borderRadius: "2px",
+    marginTop: "8px",
+    overflow: "hidden"
+  },
+  progressFill: (pct) => ({
+    height: "100%",
+    width: `${pct}%`,
+    backgroundColor: "var(--theme-success-500)",
+    borderRadius: "2px",
+    transition: "width 0.3s"
+  }),
+  table: {
+    width: "100%",
+    borderCollapse: "collapse",
+    fontSize: "13px"
+  },
+  th: {
+    textAlign: "left",
+    padding: "10px 12px",
+    borderBottom: "2px solid var(--theme-elevation-200)",
+    fontSize: "11px",
+    fontWeight: 600,
+    textTransform: "uppercase",
+    letterSpacing: "0.5px",
+    color: "var(--theme-elevation-500)",
+    cursor: "pointer"
+  },
+  td: {
+    padding: "10px 12px",
+    borderBottom: "1px solid var(--theme-elevation-100)",
+    verticalAlign: "middle"
+  },
+  tr: {
+    cursor: "pointer"
+  },
+  trHover: {
+    backgroundColor: "var(--theme-elevation-50)"
+  },
+  scoreBadge: (score) => ({
+    display: "inline-block",
+    fontSize: "12px",
+    fontWeight: 700,
+    padding: "2px 8px",
+    borderRadius: "10px",
+    color: "#fff",
+    backgroundColor: score >= 95 ? "var(--theme-success-500)" : score >= 80 ? "#f59e0b" : "var(--theme-error-500)"
+  }),
+  expandedRow: {
+    padding: "16px",
+    backgroundColor: "var(--theme-elevation-50)",
+    borderBottom: "1px solid var(--theme-elevation-150)"
+  },
+  empty: {
+    textAlign: "center",
+    padding: "40px 0",
+    color: "var(--theme-elevation-500)",
+    fontSize: "14px"
+  },
+  link: {
+    color: "var(--theme-text)",
+    textDecoration: "none",
+    fontWeight: 500
+  },
+  // Tab styles
+  tabs: {
+    display: "flex",
+    gap: "0",
+    marginBottom: "24px",
+    borderBottom: "2px solid var(--theme-elevation-150)"
+  },
+  tab: (active) => ({
+    padding: "10px 20px",
+    fontSize: "14px",
+    fontWeight: active ? 600 : 400,
+    color: active ? "var(--theme-text)" : "var(--theme-elevation-500)",
+    backgroundColor: "transparent",
+    border: "none",
+    borderBottom: active ? "2px solid var(--theme-text)" : "2px solid transparent",
+    marginBottom: "-2px",
+    cursor: "pointer"
+  })
+};
+var SpellCheckDashboard = () => {
+  const [activeTab, setActiveTab] = useState("results");
+  const [results, setResults] = useState([]);
+  const [loading, setLoading] = useState(true);
+  const [scanning, setScanning] = useState(false);
+  const [scanProgress, setScanProgress] = useState("");
+  const [expandedId, setExpandedId] = useState(null);
+  const [sortKey, setSortKey] = useState("score");
+  const [sortDir, setSortDir] = useState("asc");
+  const [hoveredRow, setHoveredRow] = useState(null);
+  const [selectedIds, setSelectedIds] = useState(/* @__PURE__ */ new Set());
+  const [filterCollection, setFilterCollection] = useState("");
+  const [allDocs, setAllDocs] = useState([]);
+  const [loadingDocs, setLoadingDocs] = useState(true);
+  const [dictWords, setDictWords] = useState([]);
+  const [dictLoading, setDictLoading] = useState(false);
+  const [dictSearch, setDictSearch] = useState("");
+  const [dictInput, setDictInput] = useState("");
+  const [dictSelectedIds, setDictSelectedIds] = useState(/* @__PURE__ */ new Set());
+  const [dictToast, setDictToast] = useState("");
+  const [showImport, setShowImport] = useState(false);
+  const [importText, setImportText] = useState("");
+  const resultsRef = useRef(results);
+  resultsRef.current = results;
+  const loadResults = useCallback(async () => {
+    setLoading(true);
+    try {
+      const res = await fetch("/api/spellcheck-results?limit=0&sort=-lastChecked");
+      const data = await res.json();
+      setResults(data.docs || []);
+    } catch {
+    } finally {
+      setLoading(false);
+    }
+  }, []);
+  const loadAllDocs = useCallback(async () => {
+    setLoadingDocs(true);
+    try {
+      let collections2 = ["pages", "posts"];
+      try {
+        const configRes = await fetch("/api/spellcheck/collections");
+        if (configRes.ok) {
+          const configData = await configRes.json();
+          if (Array.isArray(configData.collections)) {
+            collections2 = configData.collections;
+          }
+        }
+      } catch {
+      }
+      const docs = [];
+      for (const col of collections2) {
+        try {
+          const res = await fetch(`/api/${col}?limit=0&depth=0&where[_status][equals]=published`);
+          const data = await res.json();
+          if (data.docs) {
+            for (const doc of data.docs) {
+              docs.push({
+                id: String(doc.id),
+                collection: col,
+                title: doc.title || doc.slug || String(doc.id),
+                slug: doc.slug || ""
+              });
+            }
+          }
+        } catch {
+        }
+      }
+      setAllDocs(docs);
+    } finally {
+      setLoadingDocs(false);
+    }
+  }, []);
+  const loadDictionary = useCallback(async () => {
+    setDictLoading(true);
+    try {
+      const res = await fetch("/api/spellcheck/dictionary");
+      const data = await res.json();
+      setDictWords(data.words || []);
+    } catch {
+    } finally {
+      setDictLoading(false);
+    }
+  }, []);
+  useEffect(() => {
+    loadResults();
+    loadAllDocs();
+  }, [loadResults, loadAllDocs]);
+  useEffect(() => {
+    if (activeTab === "dictionary") {
+      loadDictionary();
+    }
+  }, [activeTab, loadDictionary]);
+  useEffect(() => {
+    if (!dictToast) return;
+    const t = setTimeout(() => setDictToast(""), 3e3);
+    return () => clearTimeout(t);
+  }, [dictToast]);
+  const toggleSelect = useCallback((docId, collection) => {
+    const key = `${collection}:${docId}`;
+    setSelectedIds((prev) => {
+      const next = new Set(prev);
+      if (next.has(key)) {
+        next.delete(key);
+      } else {
+        next.add(key);
+      }
+      return next;
+    });
+  }, []);
+  const [scanCurrent, setScanCurrent] = useState(0);
+  const [scanTotal, setScanTotal] = useState(0);
+  const [scanCurrentDoc, setScanCurrentDoc] = useState("");
+  useEffect(() => {
+    if (!scanning) return;
+    const interval = setInterval(async () => {
+      try {
+        const res = await fetch("/api/spellcheck/status");
+        if (!res.ok) return;
+        const data = await res.json();
+        if (data.status === "running") {
+          setScanCurrent(data.current || 0);
+          setScanTotal(data.total || 0);
+          setScanCurrentDoc(data.currentDoc || "");
+          setScanProgress(
+            `Analyse en cours... ${data.current}/${data.total} \u2014 ${data.currentDoc || ""}`
+          );
+        } else if (data.status === "completed") {
+          setScanProgress(
+            `Termin\xE9 \u2014 ${data.totalDocuments} documents, ${data.totalIssues} probl\xE8mes, score moyen ${data.averageScore}`
+          );
+          setScanning(false);
+          setScanCurrent(0);
+          setScanTotal(0);
+          setScanCurrentDoc("");
+          loadResults();
+        } else if (data.status === "error") {
+          setScanProgress(`Erreur : ${data.error || "Erreur inconnue"}`);
+          setScanning(false);
+          loadResults();
+        } else if (data.status === "idle") {
+          setScanProgress("");
+          setScanning(false);
+          loadResults();
+        }
+      } catch {
+      }
+    }, 2e3);
+    return () => clearInterval(interval);
+  }, [scanning, loadResults]);
+  useEffect(() => {
+    fetch("/api/spellcheck/status").then((res) => res.json()).then((data) => {
+      if (data.status === "running") {
+        setScanning(true);
+        setScanCurrent(data.current || 0);
+        setScanTotal(data.total || 0);
+        setScanCurrentDoc(data.currentDoc || "");
+        setScanProgress(
+          `Analyse en cours... ${data.current}/${data.total} \u2014 ${data.currentDoc || ""}`
+        );
+      }
+    }).catch(() => {
+    });
+  }, []);
+  const handleForceReset = useCallback(async () => {
+    try {
+      const res = await fetch("/api/spellcheck/bulk", {
+        method: "POST",
+        headers: { "Content-Type": "application/json" },
+        body: JSON.stringify({ force: true })
+      });
+      if (res.ok) {
+        setScanning(true);
+        setScanCurrent(0);
+        setScanTotal(0);
+        setScanProgress("Scan pr\xE9c\xE9dent r\xE9initialis\xE9, red\xE9marrage...");
+      }
+    } catch {
+      setScanProgress("Erreur r\xE9seau");
+    }
+  }, []);
+  const handleScan = useCallback(async (onlySelected = false) => {
+    if (scanning) return;
+    setScanning(true);
+    setSelectedIds(/* @__PURE__ */ new Set());
+    setScanCurrent(0);
+    setScanTotal(0);
+    setScanProgress("D\xE9marrage de l'analyse...");
+    const idsToScan = onlySelected ? [...selectedIds].map((key) => {
+      const [collection, id] = key.split(":");
+      return { id, collection };
+    }) : void 0;
+    try {
+      const res = await fetch("/api/spellcheck/bulk", {
+        method: "POST",
+        headers: { "Content-Type": "application/json" },
+        body: JSON.stringify(idsToScan ? { ids: idsToScan } : {})
+      });
+      if (res.ok) {
+        setScanProgress("Analyse en cours... 0/? \u2014 d\xE9marrage");
+      } else if (res.status === 409) {
+        setScanProgress("Une analyse est d\xE9j\xE0 en cours...");
+        setScanning(false);
+      } else {
+        setScanProgress("Erreur lors du lancement de l'analyse");
+        setScanning(false);
+      }
+    } catch {
+      setScanProgress("Erreur r\xE9seau");
+      setScanning(false);
+    }
+  }, [scanning, selectedIds]);
+  const removeIssueFromResults = useCallback((docId, collection, issueIdentifier) => {
+    const target = resultsRef.current.find(
+      (r) => r.docId === docId && r.collection === collection
+    );
+    if (!target) return;
+    const updatedIssues = target.issues.filter((issue) => {
+      if (typeof issueIdentifier.offset !== "number") return true;
+      if (issue.offset !== issueIdentifier.offset) return true;
+      if (issueIdentifier.original && issue.original !== issueIdentifier.original) return true;
+      if (issueIdentifier.ruleId && issue.ruleId !== issueIdentifier.ruleId) return true;
+      return false;
+    });
+    const updatedCount = updatedIssues.length;
+    const updatedScore = target.wordCount > 0 ? Math.min(100, Math.max(0, Math.round(100 - updatedCount / target.wordCount * 1e3))) : target.score;
+    setResults((prev) => prev.map((r) => {
+      if (r.id !== target.id) return r;
+      return { ...r, issues: updatedIssues, issueCount: updatedCount, score: updatedScore };
+    }));
+    if (target.id) {
+      fetch(`/api/spellcheck-results/${target.id}`, {
+        method: "PATCH",
+        headers: { "Content-Type": "application/json" },
+        body: JSON.stringify({ issues: updatedIssues, issueCount: updatedCount, score: updatedScore })
+      }).catch(() => {
+      });
+    }
+  }, []);
+  const handleFix = useCallback(async (docId, collection, original, replacement, offset, length) => {
+    try {
+      const res = await fetch("/api/spellcheck/fix", {
+        method: "POST",
+        headers: { "Content-Type": "application/json" },
+        body: JSON.stringify({ id: docId, collection, original, replacement, offset, length })
+      });
+      if (res.ok) {
+        removeIssueFromResults(docId, collection, { offset, original });
+      }
+    } catch {
+    }
+  }, [removeIssueFromResults]);
+  const handleIgnore = useCallback((docId, collection, ruleId, offset, original) => {
+    removeIssueFromResults(docId, collection, { offset, ruleId });
+    const target = resultsRef.current.find(
+      (r) => r.docId === docId && r.collection === collection
+    );
+    if (target?.id) {
+      fetch(`/api/spellcheck-results/${target.id}?depth=0`).then((res) => res.json()).then((data) => {
+        const existing = Array.isArray(data.ignoredIssues) ? data.ignoredIssues : [];
+        const alreadyIgnored = existing.some((e) => e.ruleId === ruleId && e.original === original);
+        if (!alreadyIgnored) {
+          fetch(`/api/spellcheck-results/${target.id}`, {
+            method: "PATCH",
+            headers: { "Content-Type": "application/json" },
+            body: JSON.stringify({ ignoredIssues: [...existing, { ruleId, original }] })
+          }).catch(() => {
+          });
+        }
+      }).catch(() => {
+      });
+    }
+  }, [removeIssueFromResults]);
+  const handleAddToDict = useCallback(async (word) => {
+    try {
+      const res = await fetch("/api/spellcheck/dictionary", {
+        method: "POST",
+        headers: { "Content-Type": "application/json" },
+        body: JSON.stringify({ word })
+      });
+      if (res.ok) {
+        setDictToast(`"${word}" ajout\xE9 au dictionnaire`);
+        if (activeTab === "dictionary") loadDictionary();
+      }
+    } catch {
+    }
+  }, [activeTab, loadDictionary]);
+  const handleDictAdd = useCallback(async () => {
+    if (!dictInput.trim()) return;
+    const words = dictInput.split(/[,;\n]+/).map((w) => w.trim()).filter(Boolean);
+    if (words.length === 0) return;
+    try {
+      const res = await fetch("/api/spellcheck/dictionary", {
+        method: "POST",
+        headers: { "Content-Type": "application/json" },
+        body: JSON.stringify({ words })
+      });
+      if (res.ok) {
+        const data = await res.json();
+        setDictToast(`${data.count} mot(s) ajout\xE9(s)${data.skipped.length > 0 ? `, ${data.skipped.length} doublon(s)` : ""}`);
+        setDictInput("");
+        loadDictionary();
+      }
+    } catch {
+      setDictToast("Erreur lors de l'ajout");
+    }
+  }, [dictInput, loadDictionary]);
+  const handleDictDelete = useCallback(async (ids) => {
+    try {
+      const res = await fetch("/api/spellcheck/dictionary", {
+        method: "DELETE",
+        headers: { "Content-Type": "application/json" },
+        body: JSON.stringify({ ids })
+      });
+      if (res.ok) {
+        const data = await res.json();
+        setDictToast(`${data.deleted} mot(s) supprim\xE9(s)`);
+        setDictSelectedIds(/* @__PURE__ */ new Set());
+        loadDictionary();
+      }
+    } catch {
+      setDictToast("Erreur lors de la suppression");
+    }
+  }, [loadDictionary]);
+  const handleDictImport = useCallback(async () => {
+    const words = importText.split(/[,;\n]+/).map((w) => w.trim()).filter(Boolean);
+    if (words.length === 0) return;
+    try {
+      const res = await fetch("/api/spellcheck/dictionary", {
+        method: "POST",
+        headers: { "Content-Type": "application/json" },
+        body: JSON.stringify({ words })
+      });
+      if (res.ok) {
+        const data = await res.json();
+        setDictToast(`${data.count} mot(s) import\xE9(s)${data.skipped.length > 0 ? `, ${data.skipped.length} doublon(s)` : ""}`);
+        setImportText("");
+        setShowImport(false);
+        loadDictionary();
+      }
+    } catch {
+      setDictToast("Erreur lors de l'import");
+    }
+  }, [importText, loadDictionary]);
+  const handleDictExport = useCallback(() => {
+    const content = dictWords.map((w) => w.word).join("\n");
+    const blob = new Blob([content], { type: "text/plain" });
+    const url = URL.createObjectURL(blob);
+    const a = document.createElement("a");
+    a.href = url;
+    a.download = "spellcheck-dictionary.txt";
+    a.click();
+    URL.revokeObjectURL(url);
+    setDictToast("Dictionnaire export\xE9");
+  }, [dictWords]);
+  const handleSort = (key) => {
+    if (sortKey === key) {
+      setSortDir(sortDir === "asc" ? "desc" : "asc");
+    } else {
+      setSortKey(key);
+      setSortDir(key === "score" ? "asc" : "desc");
+    }
+  };
+  const mergedDocs = React3.useMemo(() => {
+    const resultMap = /* @__PURE__ */ new Map();
+    for (const r of results) {
+      resultMap.set(`${r.collection}:${r.docId}`, r);
+    }
+    const seen = /* @__PURE__ */ new Set();
+    const merged = [];
+    for (const doc of allDocs) {
+      const key = `${doc.collection}:${doc.id}`;
+      seen.add(key);
+      const existing = resultMap.get(key);
+      merged.push({
+        docId: doc.id,
+        collection: doc.collection,
+        title: doc.title,
+        slug: doc.slug,
+        score: existing?.score ?? null,
+        issueCount: existing?.issueCount ?? 0,
+        wordCount: existing?.wordCount ?? 0,
+        issues: existing?.issues ?? [],
+        lastChecked: existing?.lastChecked ?? null,
+        resultId: existing?.id ?? null
+      });
+    }
+    for (const r of results) {
+      const key = `${r.collection}:${r.docId}`;
+      if (!seen.has(key)) {
+        merged.push({
+          docId: r.docId,
+          collection: r.collection,
+          title: r.title,
+          slug: r.slug,
+          score: r.score,
+          issueCount: r.issueCount,
+          wordCount: r.wordCount,
+          issues: r.issues,
+          lastChecked: r.lastChecked,
+          resultId: r.id
+        });
+      }
+    }
+    return merged;
+  }, [results, allDocs]);
+  const collections = React3.useMemo(() => {
+    return [...new Set(mergedDocs.map((d) => d.collection))].sort();
+  }, [mergedDocs]);
+  const filteredMergedDocs = React3.useMemo(() => {
+    return filterCollection ? mergedDocs.filter((d) => d.collection === filterCollection) : mergedDocs;
+  }, [mergedDocs, filterCollection]);
+  const sortedResults = [...filteredMergedDocs].sort((a, b) => {
+    const dir = sortDir === "asc" ? 1 : -1;
+    switch (sortKey) {
+      case "title":
+        return dir * (a.title || "").localeCompare(b.title || "");
+      case "score":
+        return dir * ((a.score ?? 101) - (b.score ?? 101));
+      case "issueCount":
+        return dir * (a.issueCount - b.issueCount);
+      case "wordCount":
+        return dir * ((a.wordCount || 0) - (b.wordCount || 0));
+      case "lastChecked": {
+        const aTime = a.lastChecked ? new Date(a.lastChecked).getTime() : 0;
+        const bTime = b.lastChecked ? new Date(b.lastChecked).getTime() : 0;
+        return dir * (aTime - bTime);
+      }
+      default:
+        return 0;
+    }
+  });
+  const scannedResults = results.filter((r) => !filterCollection || r.collection === filterCollection);
+  const totalIssues = scannedResults.reduce((sum, r) => sum + r.issueCount, 0);
+  const avgScore = scannedResults.length > 0 ? Math.round(scannedResults.reduce((sum, r) => sum + r.score, 0) / scannedResults.length) : 0;
+  const sortIndicator = (key) => {
+    if (sortKey !== key) return "";
+    return sortDir === "asc" ? " \u2191" : " \u2193";
+  };
+  const docsWithErrors = React3.useMemo(() => {
+    return filteredMergedDocs.filter((d) => d.issueCount > 0 && d.lastChecked);
+  }, [filteredMergedDocs]);
+  const handleToggleSelectAll = () => {
+    if (selectedIds.size === filteredMergedDocs.length && filteredMergedDocs.length > 0) {
+      setSelectedIds(/* @__PURE__ */ new Set());
+    } else {
+      setSelectedIds(new Set(filteredMergedDocs.map((d) => `${d.collection}:${d.docId}`)));
+    }
+  };
+  const handleScanErrors = useCallback(() => {
+    if (scanning || docsWithErrors.length === 0) return;
+    const errorIds = new Set(docsWithErrors.map((d) => `${d.collection}:${d.docId}`));
+    setSelectedIds(errorIds);
+    setTimeout(() => {
+      setScanning(true);
+      setScanCurrent(0);
+      setScanTotal(0);
+      setScanProgress("D\xE9marrage de l'analyse des pages avec erreurs...");
+      const idsToScan = docsWithErrors.map((d) => ({ id: d.docId, collection: d.collection }));
+      fetch("/api/spellcheck/bulk", {
+        method: "POST",
+        headers: { "Content-Type": "application/json" },
+        body: JSON.stringify({ ids: idsToScan })
+      }).then((res) => {
+        if (res.ok) {
+          setScanProgress(`Analyse en cours... 0/${idsToScan.length} \u2014 d\xE9marrage`);
+        } else if (res.status === 409) {
+          setScanProgress("Une analyse est d\xE9j\xE0 en cours...");
+        } else {
+          setScanProgress("Erreur lors du lancement");
+          setScanning(false);
+        }
+      }).catch(() => {
+        setScanProgress("Erreur r\xE9seau");
+        setScanning(false);
+      });
+    }, 0);
+  }, [scanning, docsWithErrors]);
+  const filteredDictWords = React3.useMemo(() => {
+    if (!dictSearch.trim()) return dictWords;
+    const q = dictSearch.toLowerCase();
+    return dictWords.filter((w) => w.word.toLowerCase().includes(q));
+  }, [dictWords, dictSearch]);
+  const handleDictToggleSelectAll = () => {
+    if (dictSelectedIds.size === filteredDictWords.length && filteredDictWords.length > 0) {
+      setDictSelectedIds(/* @__PURE__ */ new Set());
+    } else {
+      setDictSelectedIds(new Set(filteredDictWords.map((w) => w.id)));
+    }
+  };
+  return /* @__PURE__ */ jsxs("div", { style: styles3.container, children: [
+    /* @__PURE__ */ jsxs("div", { style: styles3.header, children: [
+      /* @__PURE__ */ jsxs("div", { children: [
+        /* @__PURE__ */ jsx("h1", { style: styles3.title, children: "Correcteur orthographique" }),
+        /* @__PURE__ */ jsx("p", { style: styles3.description, children: "Analyse orthographique et grammaticale du contenu via LanguageTool" })
+      ] }),
+      activeTab === "results" && /* @__PURE__ */ jsxs("div", { style: { display: "flex", gap: "8px", alignItems: "center", flexWrap: "wrap" }, children: [
+        selectedIds.size > 0 && /* @__PURE__ */ jsx(
+          "button",
+          {
+            type: "button",
+            style: {
+              ...styles3.scanBtn,
+              backgroundColor: "var(--theme-success-500)",
+              ...scanning ? styles3.scanBtnDisabled : {}
+            },
+            onClick: () => handleScan(true),
+            disabled: scanning,
+            children: scanning ? "Analyse..." : `Scanner (${selectedIds.size})`
+          }
+        ),
+        docsWithErrors.length > 0 && selectedIds.size === 0 && /* @__PURE__ */ jsx(
+          "button",
+          {
+            type: "button",
+            style: {
+              ...styles3.scanBtn,
+              backgroundColor: "var(--theme-error-500)",
+              ...scanning ? styles3.scanBtnDisabled : {}
+            },
+            onClick: handleScanErrors,
+            disabled: scanning,
+            children: scanning ? "Analyse..." : `Rescanner erreurs (${docsWithErrors.length})`
+          }
+        ),
+        /* @__PURE__ */ jsx(
+          "button",
+          {
+            type: "button",
+            style: {
+              ...styles3.scanBtn,
+              ...scanning ? styles3.scanBtnDisabled : {}
+            },
+            onClick: () => handleScan(false),
+            disabled: scanning,
+            children: scanning ? "Analyse..." : "Scanner tout"
+          }
+        )
+      ] })
+    ] }),
+    /* @__PURE__ */ jsxs("div", { style: styles3.tabs, children: [
+      /* @__PURE__ */ jsx(
+        "button",
+        {
+          type: "button",
+          style: styles3.tab(activeTab === "results"),
+          onClick: () => setActiveTab("results"),
+          children: "R\xE9sultats"
+        }
+      ),
+      /* @__PURE__ */ jsxs(
+        "button",
+        {
+          type: "button",
+          style: styles3.tab(activeTab === "dictionary"),
+          onClick: () => setActiveTab("dictionary"),
+          children: [
+            "Dictionnaire ",
+            dictWords.length > 0 && `(${dictWords.length})`
+          ]
+        }
+      )
+    ] }),
+    dictToast && /* @__PURE__ */ jsx("div", { style: {
+      padding: "8px 16px",
+      marginBottom: "16px",
+      borderRadius: "4px",
+      backgroundColor: "var(--theme-success-100, #dcfce7)",
+      border: "1px solid var(--theme-success-500)",
+      color: "var(--theme-success-700, #15803d)",
+      fontSize: "13px"
+    }, children: dictToast }),
+    activeTab === "results" && /* @__PURE__ */ jsxs(Fragment, { children: [
+      /* @__PURE__ */ jsxs("div", { style: { display: "flex", gap: "12px", alignItems: "center", marginBottom: "16px", flexWrap: "wrap" }, children: [
+        collections.length > 1 && /* @__PURE__ */ jsxs(
+          "select",
+          {
+            value: filterCollection,
+            onChange: (e) => {
+              setFilterCollection(e.target.value);
+              setSelectedIds(/* @__PURE__ */ new Set());
+            },
+            style: {
+              padding: "6px 10px",
+              fontSize: "13px",
+              border: "1px solid var(--theme-elevation-200)",
+              borderRadius: "4px",
+              backgroundColor: "var(--theme-elevation-0)",
+              color: "var(--theme-text)"
+            },
+            children: [
+              /* @__PURE__ */ jsx("option", { value: "", children: "Toutes les collections" }),
+              collections.map((c) => /* @__PURE__ */ jsx("option", { value: c, children: c }, c))
+            ]
+          }
+        ),
+        /* @__PURE__ */ jsxs("span", { style: { fontSize: "12px", color: "var(--theme-elevation-500)" }, children: [
+          filteredMergedDocs.length,
+          " document(s)",
+          selectedIds.size > 0 && ` \u2014 ${selectedIds.size} s\xE9lectionn\xE9(s)`
+        ] })
+      ] }),
+      scanProgress && /* @__PURE__ */ jsxs("div", { style: styles3.progress, children: [
+        /* @__PURE__ */ jsxs("div", { style: { display: "flex", justifyContent: "space-between", alignItems: "center" }, children: [
+          /* @__PURE__ */ jsx("span", { children: scanProgress }),
+          scanProgress.includes("d\xE9j\xE0 en cours") && !scanning && /* @__PURE__ */ jsx(
+            "button",
+            {
+              type: "button",
+              onClick: handleForceReset,
+              style: {
+                padding: "4px 12px",
+                fontSize: "12px",
+                fontWeight: 600,
+                border: "none",
+                borderRadius: "4px",
+                backgroundColor: "var(--theme-error-500)",
+                color: "#fff",
+                cursor: "pointer",
+                marginLeft: "12px"
+              },
+              children: "Forcer r\xE9initialisation"
+            }
+          )
+        ] }),
+        scanning && scanTotal > 0 && /* @__PURE__ */ jsx("div", { style: styles3.progressBar, children: /* @__PURE__ */ jsx("div", { style: styles3.progressFill(Math.round(scanCurrent / scanTotal * 100)) }) })
+      ] }),
+      results.length > 0 && /* @__PURE__ */ jsxs("div", { style: styles3.summary, children: [
+        /* @__PURE__ */ jsxs("div", { style: styles3.summaryCard, children: [
+          /* @__PURE__ */ jsx("div", { style: styles3.summaryLabel, children: "Documents" }),
+          /* @__PURE__ */ jsx("div", { style: styles3.summaryValue, children: results.length })
+        ] }),
+        /* @__PURE__ */ jsxs("div", { style: styles3.summaryCard, children: [
+          /* @__PURE__ */ jsx("div", { style: styles3.summaryLabel, children: "Score moyen" }),
+          /* @__PURE__ */ jsx("div", { style: styles3.summaryValue, children: avgScore })
+        ] }),
+        /* @__PURE__ */ jsxs("div", { style: styles3.summaryCard, children: [
+          /* @__PURE__ */ jsx("div", { style: styles3.summaryLabel, children: "Probl\xE8mes" }),
+          /* @__PURE__ */ jsx("div", { style: styles3.summaryValue, children: totalIssues })
+        ] }),
+        /* @__PURE__ */ jsxs("div", { style: styles3.summaryCard, children: [
+          /* @__PURE__ */ jsx("div", { style: styles3.summaryLabel, children: "Sans erreurs" }),
+          /* @__PURE__ */ jsx("div", { style: styles3.summaryValue, children: results.filter((r) => r.issueCount === 0).length })
+        ] })
+      ] }),
+      loading && loadingDocs ? /* @__PURE__ */ jsx("div", { style: styles3.empty, children: "Chargement..." }) : sortedResults.length === 0 ? /* @__PURE__ */ jsx("div", { style: styles3.empty, children: "Aucun document trouv\xE9. V\xE9rifiez la configuration des collections." }) : /* @__PURE__ */ jsxs("table", { style: styles3.table, children: [
+        /* @__PURE__ */ jsx("thead", { children: /* @__PURE__ */ jsxs("tr", { children: [
+          /* @__PURE__ */ jsx("th", { style: { ...styles3.th, width: "36px" }, children: /* @__PURE__ */ jsx(
+            "input",
+            {
+              type: "checkbox",
+              checked: selectedIds.size === filteredMergedDocs.length && filteredMergedDocs.length > 0,
+              onChange: handleToggleSelectAll,
+              style: { cursor: "pointer" }
+            }
+          ) }),
+          /* @__PURE__ */ jsxs("th", { style: styles3.th, onClick: () => handleSort("title"), children: [
+            "Document",
+            sortIndicator("title")
+          ] }),
+          /* @__PURE__ */ jsx("th", { style: styles3.th, children: "Collection" }),
+          /* @__PURE__ */ jsxs("th", { style: styles3.th, onClick: () => handleSort("score"), children: [
+            "Score",
+            sortIndicator("score")
+          ] }),
+          /* @__PURE__ */ jsxs("th", { style: styles3.th, onClick: () => handleSort("issueCount"), children: [
+            "Probl\xE8mes",
+            sortIndicator("issueCount")
+          ] }),
+          /* @__PURE__ */ jsxs("th", { style: styles3.th, onClick: () => handleSort("wordCount"), children: [
+            "Mots",
+            sortIndicator("wordCount")
+          ] }),
+          /* @__PURE__ */ jsxs("th", { style: styles3.th, onClick: () => handleSort("lastChecked"), children: [
+            "V\xE9rifi\xE9",
+            sortIndicator("lastChecked")
+          ] })
+        ] }) }),
+        /* @__PURE__ */ jsx("tbody", { children: sortedResults.map((r) => {
+          const rowKey = `${r.collection}:${r.docId}`;
+          const isSelected = selectedIds.has(rowKey);
+          return /* @__PURE__ */ jsxs(React3.Fragment, { children: [
+            /* @__PURE__ */ jsxs(
+              "tr",
+              {
+                style: {
+                  ...styles3.tr,
+                  ...hoveredRow === rowKey ? styles3.trHover : {},
+                  ...isSelected ? { backgroundColor: "var(--theme-elevation-100)" } : {}
+                },
+                onClick: () => {
+                  if (r.issues && r.issues.length > 0) {
+                    setExpandedId(expandedId === rowKey ? null : rowKey);
+                  }
+                },
+                onMouseEnter: () => setHoveredRow(rowKey),
+                onMouseLeave: () => setHoveredRow(null),
+                children: [
+                  /* @__PURE__ */ jsx("td", { style: styles3.td, children: /* @__PURE__ */ jsx(
+                    "input",
+                    {
+                      type: "checkbox",
+                      checked: isSelected,
+                      onChange: () => toggleSelect(r.docId, r.collection),
+                      onClick: (e) => e.stopPropagation(),
+                      style: { cursor: "pointer" }
+                    }
+                  ) }),
+                  /* @__PURE__ */ jsx("td", { style: styles3.td, children: /* @__PURE__ */ jsx(
+                    "a",
+                    {
+                      href: `/admin/collections/${r.collection}/${r.docId}`,
+                      style: styles3.link,
+                      onClick: (e) => e.stopPropagation(),
+                      children: r.title || r.slug || r.docId
+                    }
+                  ) }),
+                  /* @__PURE__ */ jsx("td", { style: styles3.td, children: r.collection }),
+                  /* @__PURE__ */ jsx("td", { style: styles3.td, children: r.score !== null ? /* @__PURE__ */ jsx("span", { style: styles3.scoreBadge(r.score), children: r.score }) : /* @__PURE__ */ jsx("span", { style: { fontSize: "11px", color: "var(--theme-elevation-400)" }, children: "\u2014" }) }),
+                  /* @__PURE__ */ jsx("td", { style: styles3.td, children: r.lastChecked ? r.issueCount : "\u2014" }),
+                  /* @__PURE__ */ jsx("td", { style: styles3.td, children: r.wordCount || "\u2014" }),
+                  /* @__PURE__ */ jsx("td", { style: styles3.td, children: r.lastChecked ? new Date(r.lastChecked).toLocaleString("fr-FR", {
+                    day: "2-digit",
+                    month: "2-digit",
+                    hour: "2-digit",
+                    minute: "2-digit",
+                    second: "2-digit"
+                  }) : "\u2014" })
+                ]
+              }
+            ),
+            expandedId === rowKey && r.issues && r.issues.length > 0 && /* @__PURE__ */ jsx("tr", { children: /* @__PURE__ */ jsx("td", { colSpan: 7, style: styles3.expandedRow, children: r.issues.map((issue, i) => /* @__PURE__ */ jsx(
+              IssueCard,
+              {
+                issue,
+                onFix: (original, replacement, offset, length) => handleFix(r.docId, r.collection, original, replacement, offset, length),
+                onIgnore: () => handleIgnore(r.docId, r.collection, issue.ruleId, issue.offset, issue.original),
+                onAddToDict: handleAddToDict
+              },
+              `${issue.ruleId}-${issue.offset}-${i}`
+            )) }) })
+          ] }, rowKey);
+        }) })
+      ] })
+    ] }),
+    activeTab === "dictionary" && /* @__PURE__ */ jsxs(Fragment, { children: [
+      /* @__PURE__ */ jsxs("div", { style: { display: "flex", gap: "8px", marginBottom: "16px", alignItems: "center" }, children: [
+        /* @__PURE__ */ jsx(
+          "input",
+          {
+            type: "text",
+            value: dictInput,
+            onChange: (e) => setDictInput(e.target.value),
+            onKeyDown: (e) => {
+              if (e.key === "Enter") handleDictAdd();
+            },
+            placeholder: "Ajouter un mot (virgules pour plusieurs)...",
+            style: {
+              flex: 1,
+              padding: "8px 12px",
+              fontSize: "13px",
+              border: "1px solid var(--theme-elevation-200)",
+              borderRadius: "4px",
+              backgroundColor: "var(--theme-elevation-0)",
+              color: "var(--theme-text)"
+            }
+          }
+        ),
+        /* @__PURE__ */ jsx(
+          "button",
+          {
+            type: "button",
+            onClick: handleDictAdd,
+            disabled: !dictInput.trim(),
+            style: {
+              ...styles3.scanBtn,
+              padding: "8px 16px",
+              fontSize: "13px",
+              ...!dictInput.trim() ? styles3.scanBtnDisabled : {}
+            },
+            children: "Ajouter"
+          }
+        )
+      ] }),
+      /* @__PURE__ */ jsxs("div", { style: { display: "flex", gap: "8px", marginBottom: "16px", alignItems: "center", flexWrap: "wrap" }, children: [
+        /* @__PURE__ */ jsx(
+          "input",
+          {
+            type: "text",
+            value: dictSearch,
+            onChange: (e) => setDictSearch(e.target.value),
+            placeholder: "Rechercher...",
+            style: {
+              padding: "6px 10px",
+              fontSize: "13px",
+              border: "1px solid var(--theme-elevation-200)",
+              borderRadius: "4px",
+              backgroundColor: "var(--theme-elevation-0)",
+              color: "var(--theme-text)",
+              width: "200px"
+            }
+          }
+        ),
+        /* @__PURE__ */ jsxs("span", { style: { fontSize: "12px", color: "var(--theme-elevation-500)" }, children: [
+          filteredDictWords.length,
+          " mot(s)",
+          dictSelectedIds.size > 0 && ` \u2014 ${dictSelectedIds.size} s\xE9lectionn\xE9(s)`
+        ] }),
+        /* @__PURE__ */ jsx("div", { style: { flex: 1 } }),
+        dictSelectedIds.size > 0 && /* @__PURE__ */ jsxs(
+          "button",
+          {
+            type: "button",
+            onClick: () => handleDictDelete([...dictSelectedIds]),
+            style: {
+              ...styles3.scanBtn,
+              padding: "6px 14px",
+              fontSize: "12px",
+              backgroundColor: "var(--theme-error-500)"
+            },
+            children: [
+              "Supprimer (",
+              dictSelectedIds.size,
+              ")"
+            ]
+          }
+        ),
+        /* @__PURE__ */ jsx(
+          "button",
+          {
+            type: "button",
+            onClick: () => setShowImport(!showImport),
+            style: {
+              ...styles3.scanBtn,
+              padding: "6px 14px",
+              fontSize: "12px",
+              backgroundColor: "var(--theme-elevation-600)"
+            },
+            children: showImport ? "Annuler" : "Importer"
+          }
+        ),
+        /* @__PURE__ */ jsx(
+          "button",
+          {
+            type: "button",
+            onClick: handleDictExport,
+            disabled: dictWords.length === 0,
+            style: {
+              ...styles3.scanBtn,
+              padding: "6px 14px",
+              fontSize: "12px",
+              backgroundColor: "var(--theme-elevation-600)",
+              ...dictWords.length === 0 ? styles3.scanBtnDisabled : {}
+            },
+            children: "Exporter"
+          }
+        )
+      ] }),
+      showImport && /* @__PURE__ */ jsxs("div", { style: {
+        marginBottom: "16px",
+        padding: "16px",
+        borderRadius: "6px",
+        backgroundColor: "var(--theme-elevation-50)",
+        border: "1px solid var(--theme-elevation-150)"
+      }, children: [
+        /* @__PURE__ */ jsx("div", { style: { fontSize: "13px", marginBottom: "8px", color: "var(--theme-text)" }, children: "Un mot par ligne, ou s\xE9par\xE9s par des virgules :" }),
+        /* @__PURE__ */ jsx(
+          "textarea",
+          {
+            value: importText,
+            onChange: (e) => setImportText(e.target.value),
+            rows: 6,
+            style: {
+              width: "100%",
+              padding: "8px",
+              fontSize: "13px",
+              border: "1px solid var(--theme-elevation-200)",
+              borderRadius: "4px",
+              backgroundColor: "var(--theme-elevation-0)",
+              color: "var(--theme-text)",
+              fontFamily: "monospace",
+              boxSizing: "border-box",
+              resize: "vertical"
+            },
+            placeholder: "mot1\nmot2\nmot3, mot4, mot5"
+          }
+        ),
+        /* @__PURE__ */ jsxs(
+          "button",
+          {
+            type: "button",
+            onClick: handleDictImport,
+            disabled: !importText.trim(),
+            style: {
+              ...styles3.scanBtn,
+              marginTop: "8px",
+              padding: "8px 16px",
+              fontSize: "13px",
+              ...!importText.trim() ? styles3.scanBtnDisabled : {}
+            },
+            children: [
+              "Importer ",
+              importText.trim() ? `(${importText.split(/[,;\n]+/).filter((w) => w.trim()).length} mots)` : ""
+            ]
+          }
+        )
+      ] }),
+      dictLoading ? /* @__PURE__ */ jsx("div", { style: styles3.empty, children: "Chargement du dictionnaire..." }) : filteredDictWords.length === 0 ? /* @__PURE__ */ jsx("div", { style: styles3.empty, children: dictSearch ? "Aucun mot trouv\xE9." : "Dictionnaire vide. Ajoutez des mots ci-dessus." }) : /* @__PURE__ */ jsxs("table", { style: styles3.table, children: [
+        /* @__PURE__ */ jsx("thead", { children: /* @__PURE__ */ jsxs("tr", { children: [
+          /* @__PURE__ */ jsx("th", { style: { ...styles3.th, width: "36px", cursor: "default" }, children: /* @__PURE__ */ jsx(
+            "input",
+            {
+              type: "checkbox",
+              checked: dictSelectedIds.size === filteredDictWords.length && filteredDictWords.length > 0,
+              onChange: handleDictToggleSelectAll,
+              style: { cursor: "pointer" }
+            }
+          ) }),
+          /* @__PURE__ */ jsx("th", { style: { ...styles3.th, cursor: "default" }, children: "Mot" }),
+          /* @__PURE__ */ jsx("th", { style: { ...styles3.th, cursor: "default" }, children: "Ajout\xE9 par" }),
+          /* @__PURE__ */ jsx("th", { style: { ...styles3.th, cursor: "default" }, children: "Date" }),
+          /* @__PURE__ */ jsx("th", { style: { ...styles3.th, width: "60px", cursor: "default" } })
+        ] }) }),
+        /* @__PURE__ */ jsx("tbody", { children: filteredDictWords.map((w) => {
+          const isSelected = dictSelectedIds.has(w.id);
+          const addedByName = w.addedBy && typeof w.addedBy === "object" ? w.addedBy.name || w.addedBy.email || "\u2014" : "\u2014";
+          return /* @__PURE__ */ jsxs(
+            "tr",
+            {
+              style: {
+                ...isSelected ? { backgroundColor: "var(--theme-elevation-100)" } : {}
+              },
+              children: [
+                /* @__PURE__ */ jsx("td", { style: styles3.td, children: /* @__PURE__ */ jsx(
+                  "input",
+                  {
+                    type: "checkbox",
+                    checked: isSelected,
+                    onChange: () => {
+                      setDictSelectedIds((prev) => {
+                        const next = new Set(prev);
+                        if (next.has(w.id)) next.delete(w.id);
+                        else next.add(w.id);
+                        return next;
+                      });
+                    },
+                    style: { cursor: "pointer" }
+                  }
+                ) }),
+                /* @__PURE__ */ jsx("td", { style: { ...styles3.td, fontFamily: "monospace", fontWeight: 500 }, children: w.word }),
+                /* @__PURE__ */ jsx("td", { style: { ...styles3.td, fontSize: "12px", color: "var(--theme-elevation-500)" }, children: addedByName }),
+                /* @__PURE__ */ jsx("td", { style: { ...styles3.td, fontSize: "12px", color: "var(--theme-elevation-500)" }, children: w.createdAt ? new Date(w.createdAt).toLocaleString("fr-FR", {
+                  day: "2-digit",
+                  month: "2-digit",
+                  year: "2-digit"
+                }) : "\u2014" }),
+                /* @__PURE__ */ jsx("td", { style: styles3.td, children: /* @__PURE__ */ jsx(
+                  "button",
+                  {
+                    type: "button",
+                    onClick: () => handleDictDelete([w.id]),
+                    style: {
+                      background: "none",
+                      border: "none",
+                      cursor: "pointer",
+                      color: "var(--theme-error-500)",
+                      fontSize: "14px",
+                      padding: "2px 6px"
+                    },
+                    title: "Supprimer",
+                    children: "\u2715"
+                  }
+                ) })
+              ]
+            },
+            w.id
+          );
+        }) })
+      ] })
+    ] })
+  ] });
+};
+var SpellCheckScoreCell = ({
+  rowData,
+  collectionSlug
+}) => {
+  const [score, setScore] = useState(null);
+  const [issueCount, setIssueCount] = useState(null);
+  useEffect(() => {
+    if (!rowData?.id || !collectionSlug) return;
+    fetch(
+      `/api/spellcheck-results?where[docId][equals]=${rowData.id}&where[collection][equals]=${collectionSlug}&limit=1&depth=0`
+    ).then((res) => res.json()).then((data) => {
+      if (data.docs?.[0]) {
+        setScore(data.docs[0].score);
+        setIssueCount(data.docs[0].issueCount ?? 0);
+      }
+    }).catch(() => {
+    });
+  }, [rowData?.id, collectionSlug]);
+  if (score === null) {
+    return /* @__PURE__ */ jsx("span", { style: { fontSize: "12px", color: "var(--theme-elevation-400)" }, children: "\u2014" });
+  }
+  const bgColor = score >= 95 ? "var(--theme-success-500)" : score >= 80 ? "#f59e0b" : "var(--theme-error-500)";
+  return /* @__PURE__ */ jsxs(
+    "span",
+    {
+      style: {
+        display: "inline-flex",
+        alignItems: "center",
+        gap: "6px"
+      },
+      children: [
+        /* @__PURE__ */ jsx(
+          "span",
+          {
+            style: {
+              display: "inline-block",
+              padding: "2px 8px",
+              borderRadius: "10px",
+              fontSize: "12px",
+              fontWeight: 700,
+              color: "#fff",
+              backgroundColor: bgColor
+            },
+            children: score
+          }
+        ),
+        issueCount !== null && issueCount > 0 && /* @__PURE__ */ jsx("span", { style: { fontSize: "11px", color: "var(--theme-error-500)" }, children: issueCount })
+      ]
+    }
+  );
+};
+
+export { IssueCard, SpellCheckDashboard, SpellCheckField, SpellCheckScoreCell };