@strapi-ai/translator 0.0.1

package/dist/admin/index-DQ3-ym--.js

@@ -0,0 +1,1693 @@
+"use strict";
+const react = require("react");
+const jsxRuntime = require("react/jsx-runtime");
+const admin = require("@strapi/strapi/admin");
+const reactIntl = require("react-intl");
+const icons = require("@strapi/icons");
+const designSystem = require("@strapi/design-system");
+const styledComponents = require("styled-components");
+const __variableDynamicImportRuntimeHelper = (glob, path, segs) => {
+  const v = glob[path];
+  if (v) {
+    return typeof v === "function" ? v() : Promise.resolve(v);
+  }
+  return new Promise((_, reject) => {
+    (typeof queueMicrotask === "function" ? queueMicrotask : setTimeout)(
+      reject.bind(
+        null,
+        new Error(
+          "Unknown variable dynamic import: " + path + (path.split("/").length !== segs ? ". Note that variables only represent file names one level deep." : "")
+        )
+      )
+    );
+  });
+};
+const PLUGIN_ID = "ai-translator";
+function getTranslation(id) {
+  return [PLUGIN_ID, id].join(".");
+}
+function Initializer({ setPlugin }) {
+  const setPluginRef = react.useRef(setPlugin);
+  react.useEffect(() => {
+    setPluginRef.current(PLUGIN_ID);
+  }, []);
+  return null;
+}
+const I18N_LOCALE_PARAM = "plugins[i18n][locale]";
+const FALLBACK_LOCALE = "en";
+const getContentManagerLocale = () => {
+  if (typeof window === "undefined" || !window.location) {
+    return FALLBACK_LOCALE;
+  }
+  const query = window.location.href.split("?")[1] ?? "";
+  return new URLSearchParams(query).get(I18N_LOCALE_PARAM) || FALLBACK_LOCALE;
+};
+async function* parseSSEStream(response) {
+  const reader = response.body.getReader();
+  const decoder = new TextDecoder();
+  let buffer = "";
+  let dataLines = [];
+  const parseEvent = () => {
+    if (dataLines.length === 0) {
+      return null;
+    }
+    const rawData = dataLines.join("\n");
+    dataLines = [];
+    try {
+      return JSON.parse(rawData);
+    } catch {
+      return null;
+    }
+  };
+  const processLine = (line) => {
+    const normalizedLine = line.endsWith("\r") ? line.slice(0, -1) : line;
+    if (normalizedLine.startsWith("data:")) {
+      dataLines.push(normalizedLine.slice(5).trimStart());
+      return null;
+    }
+    if (normalizedLine === "") {
+      return parseEvent();
+    }
+    return null;
+  };
+  try {
+    while (true) {
+      const { done, value } = await reader.read();
+      if (done) {
+        if (buffer) {
+          const event2 = processLine(buffer);
+          if (event2) {
+            yield event2;
+          }
+          buffer = "";
+        }
+        const event = parseEvent();
+        if (event) {
+          yield event;
+        }
+        break;
+      }
+      buffer += decoder.decode(value, { stream: true });
+      const lines = buffer.split("\n");
+      buffer = lines.pop() || "";
+      for (const line of lines) {
+        const event = processLine(line);
+        if (event) {
+          yield event;
+        }
+      }
+    }
+  } finally {
+    reader.releaseLock();
+  }
+}
+const FORBIDDEN_SEGMENTS = /* @__PURE__ */ new Set(["__proto__", "constructor", "prototype"]);
+const cloneValue = (value) => {
+  if (typeof structuredClone === "function") {
+    return structuredClone(value);
+  }
+  return JSON.parse(JSON.stringify(value));
+};
+const pathToLabel = (path) => {
+  if (!path || path.length === 0) {
+    return "";
+  }
+  return path.reduce((label, segment) => {
+    if (typeof segment === "number") {
+      return `${label}[${segment}]`;
+    }
+    return label ? `${label}.${segment}` : segment;
+  }, "");
+};
+const getValueByPath = (source, path) => path.reduce((cursor, segment) => {
+  if (cursor === void 0 || cursor === null) {
+    return void 0;
+  }
+  return cursor[segment];
+}, source);
+const setValueByPath = (source, path, value) => {
+  const clone = cloneValue(source);
+  if (path.some((segment) => typeof segment === "string" && FORBIDDEN_SEGMENTS.has(segment))) {
+    return clone;
+  }
+  let cursor = clone;
+  for (let index2 = 0; index2 < path.length - 1; index2 += 1) {
+    const segment = path[index2];
+    const nextSegment = path[index2 + 1];
+    if (cursor[segment] === void 0 || cursor[segment] === null) {
+      cursor[segment] = typeof nextSegment === "number" ? [] : {};
+    }
+    cursor = cursor[segment];
+  }
+  cursor[path[path.length - 1]] = value;
+  return clone;
+};
+const applyTranslationPatch = (source, patch) => patch.operations.reduce(
+  (entry, operation) => setValueByPath(entry, operation.path, operation.value),
+  cloneValue(source)
+);
+const applyTranslationPatchToFillData = (fillData, sourceData, patch) => applyTranslationPatch(fillData ?? sourceData, patch);
+const isEmptyValue = (value) => value === void 0 || value === null || value === "" || Array.isArray(value) && value.length === 0;
+const isPlainObject = (value) => Boolean(value) && typeof value === "object" && !Array.isArray(value);
+const MAX_BACKFILL_DEPTH = 32;
+const backfillEmptyLeaves = (target, source, depth = 0) => {
+  if (depth > MAX_BACKFILL_DEPTH) {
+    return;
+  }
+  for (const [key, sourceValue] of Object.entries(source)) {
+    if (FORBIDDEN_SEGMENTS.has(key)) {
+      continue;
+    }
+    const targetValue = target[key];
+    if (isEmptyValue(targetValue)) {
+      target[key] = sourceValue;
+    } else if (isPlainObject(targetValue) && isPlainObject(sourceValue)) {
+      backfillEmptyLeaves(targetValue, sourceValue, depth + 1);
+    }
+  }
+};
+const mergeTranslationResult = ({
+  formValues,
+  fillData,
+  patch
+}) => {
+  const base = cloneValue(formValues ?? {});
+  if (fillData) {
+    backfillEmptyLeaves(base, fillData);
+  }
+  return applyTranslationPatch(base, patch);
+};
+const hasTextContent = (value) => {
+  if (typeof value === "string") {
+    return value.trim().length > 0;
+  }
+  if (Array.isArray(value)) {
+    return value.some(hasTextContent);
+  }
+  if (value && typeof value === "object") {
+    return Object.values(value).some(hasTextContent);
+  }
+  return false;
+};
+const TRANSLATABLE_TYPES = /* @__PURE__ */ new Set(["string", "text", "richtext", "blocks", "json"]);
+const EXCLUDED_FIELDS = /* @__PURE__ */ new Set([
+  "id",
+  "documentId",
+  "locale",
+  "createdAt",
+  "updatedAt",
+  "publishedAt",
+  "createdBy",
+  "updatedBy",
+  "slug",
+  "uid"
+]);
+const isLocalized = (attribute) => attribute?.pluginOptions?.i18n?.localized !== false;
+const componentHasText = (uid, components, depth = 0) => {
+  if (!uid || depth > 8) return false;
+  return Object.values(components[uid]?.attributes || {}).some(
+    (attribute) => TRANSLATABLE_TYPES.has(attribute?.type) || attribute?.type === "component" && componentHasText(attribute.component, components, depth + 1)
+  );
+};
+const listTranslatableFields = (contentType, components) => Object.entries(contentType?.attributes || {}).filter(([name, attribute]) => {
+  if (EXCLUDED_FIELDS.has(name) || !isLocalized(attribute)) return false;
+  if (TRANSLATABLE_TYPES.has(attribute?.type)) return true;
+  if (attribute?.type === "component") return componentHasText(attribute.component, components);
+  return attribute?.type === "dynamiczone";
+}).map(([name]) => name);
+const STATUS_BADGE = {
+  pending: {
+    background: "neutral150",
+    color: "neutral600",
+    id: "diff.field_status.pending",
+    defaultMessage: "Waiting"
+  },
+  translating: {
+    background: "primary100",
+    color: "primary700",
+    id: "diff.field_status.translating",
+    defaultMessage: "Translating…"
+  },
+  done: {
+    background: "success100",
+    color: "success700",
+    id: "diff.field_status.translated",
+    defaultMessage: "Translated"
+  },
+  failed: {
+    background: "danger100",
+    color: "danger700",
+    id: "diff.field_status.failed",
+    defaultMessage: "Failed"
+  },
+  unchanged: {
+    background: "neutral150",
+    color: "neutral600",
+    id: "diff.field_status.unchanged",
+    defaultMessage: "Unchanged"
+  },
+  skipped: {
+    background: "neutral150",
+    color: "neutral600",
+    id: "diff.field_status.skipped",
+    defaultMessage: "Skipped"
+  }
+};
+const paneTextStyle = {
+  whiteSpace: "pre-wrap",
+  wordBreak: "break-word",
+  fontSize: "13px",
+  lineHeight: 1.6
+};
+const INVARIANT_PATTERNS = [
+  /```[\s\S]*?```/g,
+  /`[^`\n]+`/g,
+  /https?:\/\/[^\s)"'<>\]]+/g,
+  /<\/?[a-zA-Z][^>]*>/g
+];
+const countInvariants = (text) => {
+  const counts = /* @__PURE__ */ new Map();
+  for (const pattern of INVARIANT_PATTERNS) {
+    for (const token of text.match(pattern) ?? []) {
+      counts.set(token, (counts.get(token) ?? 0) + 1);
+    }
+  }
+  return counts;
+};
+const missingInvariants = (original, translated) => {
+  const source = countInvariants(original);
+  const target = countInvariants(translated);
+  const missing = [];
+  for (const [token, count] of source) {
+    if ((target.get(token) ?? 0) < count) {
+      missing.push(token);
+    }
+  }
+  return missing;
+};
+const untranslatedSegments = (original, translated) => {
+  const segments = original.split(/\n{2,}/).map((segment) => segment.trim()).filter(
+    (segment) => segment.length > 30 && /\p{L}/u.test(segment) && !segment.startsWith("```") && !segment.startsWith("<") && !/^https?:\/\//.test(segment)
+  );
+  return segments.filter((segment) => translated.includes(segment));
+};
+const estimateRows = (text) => {
+  const lines = text.split("\n").reduce((total, line) => {
+    const wide = line.match(/[ᄀ-￦]/g)?.length ?? 0;
+    return total + Math.max(1, Math.ceil((line.length + wide) / 80));
+  }, 0);
+  return Math.max(3, lines + 1);
+};
+const VIEW_MODES = [
+  {
+    mode: "split",
+    id: "diff.view.split",
+    defaultMessage: "Compare",
+    hintId: "diff.view.split.hint",
+    hint: "Source text and translation side by side, with inline editing"
+  },
+  {
+    mode: "preview",
+    id: "diff.view.preview",
+    defaultMessage: "Preview",
+    hintId: "diff.view.preview.hint",
+    hint: "Translation only, as it will read after applying"
+  },
+  {
+    mode: "diff",
+    id: "diff.view.diff",
+    defaultMessage: "Changes",
+    hintId: "diff.view.diff.hint",
+    hint: "What will change compared to the current content of this locale"
+  }
+];
+const diffLines = (oldText, newText) => {
+  const a = oldText ? oldText.split("\n") : [];
+  const b = newText ? newText.split("\n") : [];
+  const m = a.length;
+  const n = b.length;
+  if (m * n > 25e4) return null;
+  const dp = Array.from({ length: m + 1 }, () => new Uint32Array(n + 1));
+  for (let i2 = m - 1; i2 >= 0; i2 -= 1) {
+    for (let j2 = n - 1; j2 >= 0; j2 -= 1) {
+      dp[i2][j2] = a[i2] === b[j2] ? dp[i2 + 1][j2 + 1] + 1 : Math.max(dp[i2 + 1][j2], dp[i2][j2 + 1]);
+    }
+  }
+  const out = [];
+  let i = 0;
+  let j = 0;
+  while (i < m && j < n) {
+    if (a[i] === b[j]) {
+      out.push({ type: "same", text: a[i] });
+      i += 1;
+      j += 1;
+    } else if (dp[i + 1][j] >= dp[i][j + 1]) {
+      out.push({ type: "del", text: a[i] });
+      i += 1;
+    } else {
+      out.push({ type: "add", text: b[j] });
+      j += 1;
+    }
+  }
+  while (i < m) out.push({ type: "del", text: a[(i += 1) - 1] });
+  while (j < n) out.push({ type: "add", text: b[(j += 1) - 1] });
+  return out;
+};
+const DiffPane = ({ label, oldText, newText }) => {
+  const theme = styledComponents.useTheme();
+  const lines = react.useMemo(() => diffLines(oldText, newText), [oldText, newText]);
+  if (!lines) {
+    return /* @__PURE__ */ jsxRuntime.jsx(Pane, { label, text: newText });
+  }
+  return /* @__PURE__ */ jsxRuntime.jsxs(designSystem.Flex, { direction: "column", alignItems: "stretch", gap: 2, padding: 4, style: { minWidth: 0 }, children: [
+    /* @__PURE__ */ jsxRuntime.jsx(designSystem.Typography, { variant: "sigma", textColor: "neutral600", children: label }),
+    /* @__PURE__ */ jsxRuntime.jsx("div", { style: paneTextStyle, children: lines.map((line, index2) => /* @__PURE__ */ jsxRuntime.jsx(
+      "div",
+      {
+        style: line.type === "add" ? { background: theme.colors.success100, color: theme.colors.success700 } : line.type === "del" ? {
+          background: theme.colors.danger100,
+          color: theme.colors.danger700,
+          textDecoration: "line-through"
+        } : void 0,
+        children: line.text || " "
+      },
+      index2
+    )) })
+  ] });
+};
+const Pane = ({ label, text, muted }) => /* @__PURE__ */ jsxRuntime.jsxs(designSystem.Flex, { direction: "column", alignItems: "stretch", gap: 2, padding: 4, style: { minWidth: 0 }, children: [
+  label ? /* @__PURE__ */ jsxRuntime.jsx(designSystem.Typography, { variant: "sigma", textColor: "neutral600", children: label }) : null,
+  /* @__PURE__ */ jsxRuntime.jsx(designSystem.Typography, { tag: "div", textColor: muted ? "neutral600" : "neutral800", style: paneTextStyle, children: text })
+] });
+const FieldCard = ({
+  entry,
+  isStreaming,
+  viewMode,
+  sourceLabel,
+  targetLabel,
+  currentLabel,
+  onToggleField,
+  onEditField
+}) => {
+  const { formatMessage } = reactIntl.useIntl();
+  const theme = styledComponents.useTheme();
+  const [folded, setFolded] = react.useState(false);
+  const divider = `1px solid ${theme.colors.neutral200}`;
+  const reviewing = entry.changed && !isStreaming;
+  const skipped = reviewing && !entry.included;
+  const autoCollapsed = isStreaming ? !entry.translated : !entry.changed || skipped;
+  const collapsed = autoCollapsed || folded;
+  const editing = reviewing && viewMode === "split" && entry.included && entry.editable && Boolean(onEditField);
+  const hasCurrent = Boolean(entry.current && entry.current !== entry.translated);
+  const missing = reviewing && !skipped ? missingInvariants(entry.original, entry.translated) : [];
+  const untranslated = reviewing && !skipped ? untranslatedSegments(entry.original, entry.translated) : [];
+  const badge = entry.status ? STATUS_BADGE[entry.status] : skipped ? STATUS_BADGE.skipped : STATUS_BADGE[entry.changed ? "done" : "unchanged"];
+  return /* @__PURE__ */ jsxRuntime.jsxs(
+    designSystem.Box,
+    {
+      background: "neutral0",
+      hasRadius: true,
+      "data-diff-card": entry.key,
+      style: { border: divider, overflow: "hidden", width: "100%" },
+      children: [
+        /* @__PURE__ */ jsxRuntime.jsxs(
+          designSystem.Flex,
+          {
+            justifyContent: "space-between",
+            alignItems: "center",
+            gap: 2,
+            paddingTop: 2,
+            paddingBottom: 2,
+            paddingLeft: 4,
+            paddingRight: 4,
+            background: "neutral100",
+            style: { borderBottom: collapsed ? void 0 : divider },
+            children: [
+              /* @__PURE__ */ jsxRuntime.jsxs(designSystem.Flex, { gap: 2, alignItems: "baseline", style: { minWidth: 0 }, children: [
+                /* @__PURE__ */ jsxRuntime.jsx(designSystem.Typography, { variant: "omega", fontWeight: "bold", ellipsis: true, children: entry.key }),
+                !collapsed ? /* @__PURE__ */ jsxRuntime.jsx(designSystem.Typography, { variant: "pi", textColor: "neutral500", children: formatMessage(
+                  {
+                    id: getTranslation("diff.chars"),
+                    defaultMessage: "{originalChars} → {translatedChars} chars"
+                  },
+                  {
+                    originalChars: entry.original.length.toLocaleString(),
+                    translatedChars: entry.translated.length.toLocaleString()
+                  }
+                ) }) : null
+              ] }),
+              /* @__PURE__ */ jsxRuntime.jsxs(designSystem.Flex, { gap: 3, alignItems: "center", children: [
+                reviewing && hasCurrent ? /* @__PURE__ */ jsxRuntime.jsx(designSystem.Badge, { backgroundColor: "warning100", textColor: "warning700", children: formatMessage({
+                  id: getTranslation("diff.overwrite"),
+                  defaultMessage: "Overwrites existing"
+                }) }) : null,
+                /* @__PURE__ */ jsxRuntime.jsx(designSystem.Badge, { backgroundColor: badge.background, textColor: badge.color, children: formatMessage({ id: getTranslation(badge.id), defaultMessage: badge.defaultMessage }) }),
+                reviewing && onToggleField ? /* @__PURE__ */ jsxRuntime.jsx(
+                  designSystem.Checkbox,
+                  {
+                    checked: entry.included,
+                    onCheckedChange: (checked) => onToggleField(entry.key, checked === true),
+                    children: formatMessage({
+                      id: getTranslation("diff.use_translation"),
+                      defaultMessage: "Use translation"
+                    })
+                  }
+                ) : null,
+                !autoCollapsed ? /* @__PURE__ */ jsxRuntime.jsx(
+                  designSystem.IconButton,
+                  {
+                    variant: "ghost",
+                    label: formatMessage(
+                      folded ? { id: getTranslation("diff.expand"), defaultMessage: "Expand" } : { id: getTranslation("diff.collapse"), defaultMessage: "Collapse" }
+                    ),
+                    onClick: () => setFolded((previous) => !previous),
+                    children: folded ? /* @__PURE__ */ jsxRuntime.jsx(icons.ChevronDown, {}) : /* @__PURE__ */ jsxRuntime.jsx(icons.ChevronUp, {})
+                  }
+                ) : null
+              ] })
+            ]
+          }
+        ),
+        collapsed ? null : /* @__PURE__ */ jsxRuntime.jsxs(jsxRuntime.Fragment, { children: [
+          missing.length > 0 ? /* @__PURE__ */ jsxRuntime.jsxs(
+            designSystem.Box,
+            {
+              background: "danger100",
+              paddingTop: 2,
+              paddingBottom: 2,
+              paddingLeft: 4,
+              paddingRight: 4,
+              style: { borderBottom: divider },
+              children: [
+                /* @__PURE__ */ jsxRuntime.jsx(designSystem.Typography, { variant: "pi", textColor: "danger700", fontWeight: "bold", children: formatMessage(
+                  {
+                    id: getTranslation("diff.invariants.warning"),
+                    defaultMessage: "{count} URL/code/tag elements were altered or dropped by the translation:"
+                  },
+                  { count: missing.length }
+                ) }),
+                missing.slice(0, 5).map((token) => /* @__PURE__ */ jsxRuntime.jsx(
+                  designSystem.Typography,
+                  {
+                    tag: "div",
+                    variant: "pi",
+                    textColor: "danger700",
+                    style: { ...paneTextStyle, fontFamily: "monospace" },
+                    children: token.length > 160 ? `${token.slice(0, 160)}…` : token
+                  },
+                  token
+                ))
+              ]
+            }
+          ) : null,
+          untranslated.length > 0 ? /* @__PURE__ */ jsxRuntime.jsxs(
+            designSystem.Box,
+            {
+              background: "warning100",
+              paddingTop: 2,
+              paddingBottom: 2,
+              paddingLeft: 4,
+              paddingRight: 4,
+              style: { borderBottom: divider },
+              children: [
+                /* @__PURE__ */ jsxRuntime.jsx(designSystem.Typography, { variant: "pi", textColor: "warning700", fontWeight: "bold", children: formatMessage(
+                  {
+                    id: getTranslation("diff.untranslated.warning"),
+                    defaultMessage: "{count} paragraph(s) appear untranslated:"
+                  },
+                  { count: untranslated.length }
+                ) }),
+                untranslated.slice(0, 3).map((segment) => /* @__PURE__ */ jsxRuntime.jsx(
+                  designSystem.Typography,
+                  {
+                    tag: "div",
+                    variant: "pi",
+                    textColor: "warning700",
+                    style: paneTextStyle,
+                    children: segment.length > 160 ? `${segment.slice(0, 160)}…` : segment
+                  },
+                  segment.slice(0, 40)
+                ))
+              ]
+            }
+          ) : null,
+          isStreaming ? /* @__PURE__ */ jsxRuntime.jsx(Pane, { label: targetLabel, text: entry.translated }) : viewMode === "preview" ? /* @__PURE__ */ jsxRuntime.jsx(Pane, { label: targetLabel, text: entry.translated }) : viewMode === "diff" ? /* @__PURE__ */ jsxRuntime.jsx(
+            DiffPane,
+            {
+              label: hasCurrent ? `${currentLabel} → ${targetLabel}` : targetLabel,
+              oldText: entry.current ?? "",
+              newText: entry.translated
+            }
+          ) : /* @__PURE__ */ jsxRuntime.jsxs("div", { style: { display: "grid", gridTemplateColumns: "1fr 1fr" }, children: [
+            /* @__PURE__ */ jsxRuntime.jsx("div", { style: { borderRight: divider, minWidth: 0 }, children: /* @__PURE__ */ jsxRuntime.jsx(Pane, { label: sourceLabel, text: entry.original, muted: true }) }),
+            editing ? /* @__PURE__ */ jsxRuntime.jsxs(
+              designSystem.Flex,
+              {
+                direction: "column",
+                alignItems: "stretch",
+                gap: 2,
+                padding: 4,
+                style: { minWidth: 0 },
+                children: [
+                  /* @__PURE__ */ jsxRuntime.jsx(designSystem.Typography, { variant: "sigma", textColor: "neutral600", children: targetLabel }),
+                  /* @__PURE__ */ jsxRuntime.jsx(
+                    designSystem.Textarea,
+                    {
+                      value: entry.translated,
+                      rows: estimateRows(entry.translated),
+                      style: { fieldSizing: "content", overflow: "hidden" },
+                      onChange: (event) => onEditField(entry.key, event.target.value)
+                    }
+                  )
+                ]
+              }
+            ) : /* @__PURE__ */ jsxRuntime.jsx(Pane, { label: targetLabel, text: entry.translated })
+          ] })
+        ] })
+      ]
+    }
+  );
+};
+const DiffView = ({
+  entries,
+  isStreaming,
+  viewMode,
+  sourceLocale,
+  targetLocale,
+  onToggleField,
+  onToggleAll,
+  onEditField
+}) => {
+  const { formatMessage } = reactIntl.useIntl();
+  const changed = entries.filter(
+    (entry) => isStreaming ? entry.status === "done" : entry.changed
+  ).length;
+  const skipped = entries.filter((entry) => entry.changed && !entry.included).length;
+  const unchanged = entries.length - changed;
+  const sourceLabel = `${formatMessage({
+    id: getTranslation("diff.pane.source"),
+    defaultMessage: "Source"
+  })}${sourceLocale ? ` (${sourceLocale})` : ""}`;
+  const targetLabel = `${formatMessage({
+    id: getTranslation("diff.pane.translation"),
+    defaultMessage: "Translation"
+  })}${targetLocale ? ` (${targetLocale})` : ""}`;
+  const currentLabel = `${formatMessage({
+    id: getTranslation("diff.pane.current"),
+    defaultMessage: "Current"
+  })}${targetLocale ? ` (${targetLocale})` : ""}`;
+  return /* @__PURE__ */ jsxRuntime.jsxs(designSystem.Flex, { direction: "column", alignItems: "stretch", gap: 3, children: [
+    /* @__PURE__ */ jsxRuntime.jsx(
+      designSystem.Box,
+      {
+        background: "neutral0",
+        paddingTop: 1,
+        paddingBottom: 1,
+        style: { position: "sticky", top: 0, zIndex: 1 },
+        children: /* @__PURE__ */ jsxRuntime.jsxs(designSystem.Flex, { gap: 3, alignItems: "center", justifyContent: "space-between", children: [
+          /* @__PURE__ */ jsxRuntime.jsxs(designSystem.Flex, { gap: 3, alignItems: "center", children: [
+            /* @__PURE__ */ jsxRuntime.jsx(designSystem.Typography, { variant: "pi", textColor: "success600", fontWeight: "bold", children: formatMessage(
+              {
+                id: getTranslation("diff.summary.translated"),
+                defaultMessage: "{count} translated"
+              },
+              { count: changed }
+            ) }),
+            skipped > 0 && !isStreaming ? /* @__PURE__ */ jsxRuntime.jsx(designSystem.Typography, { variant: "pi", textColor: "neutral500", children: formatMessage(
+              {
+                id: getTranslation("diff.summary.skipped"),
+                defaultMessage: "{count} skipped"
+              },
+              { count: skipped }
+            ) }) : null,
+            unchanged > 0 && !isStreaming ? /* @__PURE__ */ jsxRuntime.jsx(designSystem.Typography, { variant: "pi", textColor: "neutral500", children: formatMessage(
+              {
+                id: getTranslation("diff.summary.unchanged"),
+                defaultMessage: "{count} unchanged"
+              },
+              { count: unchanged }
+            ) }) : null
+          ] }),
+          !isStreaming && onToggleAll && changed > 0 ? /* @__PURE__ */ jsxRuntime.jsxs(designSystem.Flex, { gap: 1, children: [
+            /* @__PURE__ */ jsxRuntime.jsx(designSystem.Button, { variant: "ghost", size: "S", onClick: () => onToggleAll(true), children: formatMessage({ id: getTranslation("diff.use_all"), defaultMessage: "Use all" }) }),
+            /* @__PURE__ */ jsxRuntime.jsx(designSystem.Button, { variant: "ghost", size: "S", onClick: () => onToggleAll(false), children: formatMessage({
+              id: getTranslation("diff.skip_all"),
+              defaultMessage: "Skip all"
+            }) })
+          ] }) : null
+        ] })
+      }
+    ),
+    /* @__PURE__ */ jsxRuntime.jsx(designSystem.Flex, { direction: "column", alignItems: "stretch", gap: 3, children: entries.map((entry) => /* @__PURE__ */ jsxRuntime.jsx(
+      FieldCard,
+      {
+        entry,
+        isStreaming,
+        viewMode,
+        sourceLabel,
+        targetLabel,
+        currentLabel,
+        onToggleField,
+        onEditField
+      },
+      entry.key
+    )) })
+  ] });
+};
+const ProgressBar = ({ current, total, label }) => {
+  const percent = total > 0 ? Math.round(current / total * 100) : 0;
+  return /* @__PURE__ */ jsxRuntime.jsxs(designSystem.Box, { paddingTop: 1, children: [
+    /* @__PURE__ */ jsxRuntime.jsx(designSystem.Box, { background: "neutral200", hasRadius: true, style: { height: "4px", overflow: "hidden" }, children: /* @__PURE__ */ jsxRuntime.jsx(
+      designSystem.Box,
+      {
+        background: "primary600",
+        style: {
+          height: "100%",
+          width: `${percent}%`,
+          transition: "width 0.4s cubic-bezier(0.4, 0, 0.2, 1)",
+          borderRadius: "4px"
+        }
+      }
+    ) }),
+    label && /* @__PURE__ */ jsxRuntime.jsxs(
+      designSystem.Typography,
+      {
+        variant: "pi",
+        textColor: "neutral500",
+        style: { marginTop: "4px", display: "block" },
+        children: [
+          label,
+          " - ",
+          percent,
+          "%"
+        ]
+      }
+    )
+  ] });
+};
+const TranslationModal = ({
+  isOpen,
+  isStreaming,
+  sourceLocale,
+  targetLocale,
+  diffEntries,
+  progress,
+  currentField,
+  failedFields,
+  elapsedTime,
+  onAccept,
+  onCancel,
+  onRetryFailed,
+  onToggleField,
+  onToggleAll,
+  onEditField
+}) => {
+  const { formatMessage } = reactIntl.useIntl();
+  const contentRef = react.useRef(null);
+  const [fullScreen, setFullScreen] = react.useState(false);
+  const [follow, setFollow] = react.useState(true);
+  const [viewMode, setViewMode] = react.useState("split");
+  const applyCount = diffEntries.filter((entry) => entry.changed && entry.included).length;
+  const canAccept = !isStreaming && applyCount > 0;
+  const streamedChars = diffEntries.reduce((total, entry) => total + entry.translated.length, 0);
+  react.useEffect(() => {
+    if (isStreaming) setFollow(true);
+  }, [isStreaming]);
+  react.useEffect(() => {
+    if (!isStreaming || !follow || !contentRef.current || !currentField) return;
+    const container = contentRef.current;
+    const card = container.querySelector(`[data-diff-card="${CSS.escape(currentField)}"]`);
+    if (!card) return;
+    const cardRect = card.getBoundingClientRect();
+    const containerRect = container.getBoundingClientRect();
+    const delta = cardRect.bottom - containerRect.bottom + 16;
+    if (delta > 0 || cardRect.bottom < containerRect.top) {
+      container.scrollTop += delta;
+    }
+  }, [isStreaming, follow, currentField, streamedChars]);
+  const stopFollowing = () => {
+    if (isStreaming) setFollow(false);
+  };
+  const requestClose = () => {
+    if (isStreaming && !window.confirm(
+      formatMessage({
+        id: getTranslation("modal.confirm_cancel"),
+        defaultMessage: "Translation is in progress. Cancel and discard?"
+      })
+    )) {
+      return;
+    }
+    onCancel();
+  };
+  return /* @__PURE__ */ jsxRuntime.jsx(
+    designSystem.Modal.Root,
+    {
+      open: isOpen,
+      onOpenChange: (open) => {
+        if (!open) requestClose();
+      },
+      children: /* @__PURE__ */ jsxRuntime.jsxs(
+        designSystem.Modal.Content,
+        {
+          style: fullScreen ? {
+            maxWidth: "100vw",
+            width: "100vw",
+            height: "100vh",
+            maxHeight: "100vh",
+            borderRadius: 0
+          } : { maxWidth: "min(1280px, 96vw)", width: "96vw" },
+          children: [
+            /* @__PURE__ */ jsxRuntime.jsx(
+              designSystem.Modal.Header,
+              {
+                closeLabel: formatMessage({ id: getTranslation("modal.close"), defaultMessage: "Close" }),
+                children: /* @__PURE__ */ jsxRuntime.jsxs(designSystem.Flex, { gap: 2, alignItems: "center", children: [
+                  /* @__PURE__ */ jsxRuntime.jsx(designSystem.Modal.Title, { children: formatMessage({
+                    id: getTranslation("modal.title"),
+                    defaultMessage: "Translation Review"
+                  }) }),
+                  /* @__PURE__ */ jsxRuntime.jsx(
+                    designSystem.IconButton,
+                    {
+                      label: formatMessage(
+                        fullScreen ? {
+                          id: getTranslation("modal.exit_full_screen"),
+                          defaultMessage: "Exit full screen"
+                        } : { id: getTranslation("modal.full_screen"), defaultMessage: "Full screen" }
+                      ),
+                      variant: "ghost",
+                      onClick: () => setFullScreen((previous) => !previous),
+                      children: /* @__PURE__ */ jsxRuntime.jsx(icons.Expand, {})
+                    }
+                  ),
+                  !isStreaming && diffEntries.length > 0 ? /* @__PURE__ */ jsxRuntime.jsx(designSystem.Flex, { gap: 1, paddingLeft: 2, children: VIEW_MODES.map(({ mode, id, defaultMessage, hintId, hint }) => /* @__PURE__ */ jsxRuntime.jsx(
+                    designSystem.Tooltip,
+                    {
+                      label: formatMessage({ id: getTranslation(hintId), defaultMessage: hint }),
+                      children: /* @__PURE__ */ jsxRuntime.jsx(
+                        designSystem.Button,
+                        {
+                          variant: viewMode === mode ? "secondary" : "ghost",
+                          size: "S",
+                          onClick: () => setViewMode(mode),
+                          children: formatMessage({ id: getTranslation(id), defaultMessage })
+                        }
+                      )
+                    },
+                    mode
+                  )) }) : null
+                ] })
+              }
+            ),
+            /* @__PURE__ */ jsxRuntime.jsx(designSystem.Modal.Body, { children: /* @__PURE__ */ jsxRuntime.jsxs(designSystem.Flex, { direction: "column", alignItems: "stretch", gap: 4, children: [
+              /* @__PURE__ */ jsxRuntime.jsxs(designSystem.Flex, { justifyContent: "space-between", gap: 4, alignItems: "center", children: [
+                /* @__PURE__ */ jsxRuntime.jsxs(designSystem.Flex, { gap: 2, alignItems: "center", children: [
+                  /* @__PURE__ */ jsxRuntime.jsx(designSystem.Typography, { variant: "omega", fontWeight: "semiBold", textColor: "neutral600", children: sourceLocale }),
+                  /* @__PURE__ */ jsxRuntime.jsx(designSystem.Typography, { variant: "omega", textColor: "neutral400", children: "→" }),
+                  /* @__PURE__ */ jsxRuntime.jsx(designSystem.Typography, { variant: "omega", fontWeight: "semiBold", textColor: "primary600", children: targetLocale })
+                ] }),
+                elapsedTime > 0 && !isStreaming ? /* @__PURE__ */ jsxRuntime.jsx(designSystem.Typography, { variant: "pi", textColor: "neutral500", children: formatMessage(
+                  {
+                    id: getTranslation("modal.completed_in"),
+                    defaultMessage: "Completed in {seconds}s"
+                  },
+                  { seconds: elapsedTime }
+                ) }) : null,
+                isStreaming && !follow ? /* @__PURE__ */ jsxRuntime.jsx(designSystem.Button, { variant: "ghost", size: "S", onClick: () => setFollow(true), children: formatMessage({
+                  id: getTranslation("modal.follow"),
+                  defaultMessage: "Follow latest"
+                }) }) : null
+              ] }),
+              isStreaming && progress ? /* @__PURE__ */ jsxRuntime.jsx(
+                ProgressBar,
+                {
+                  current: progress.current,
+                  total: progress.total,
+                  label: currentField ? `${currentField} (${progress.current}/${progress.total})` : `${progress.current}/${progress.total}`
+                }
+              ) : null,
+              failedFields.length > 0 ? /* @__PURE__ */ jsxRuntime.jsx(designSystem.Typography, { variant: "pi", textColor: "danger600", children: formatMessage(
+                {
+                  id: getTranslation("modal.failed_fields"),
+                  defaultMessage: "{count} field(s) failed: {fields}"
+                },
+                { count: failedFields.length, fields: failedFields.join(", ") }
+              ) }) : null,
+              /* @__PURE__ */ jsxRuntime.jsx(
+                designSystem.Box,
+                {
+                  ref: contentRef,
+                  onWheel: stopFollowing,
+                  onTouchMove: stopFollowing,
+                  style: {
+                    maxHeight: fullScreen ? "calc(100vh - 250px)" : "min(64vh, 680px)",
+                    overflowY: "auto"
+                  },
+                  children: diffEntries.length > 0 ? /* @__PURE__ */ jsxRuntime.jsx(
+                    DiffView,
+                    {
+                      entries: diffEntries,
+                      isStreaming,
+                      viewMode,
+                      sourceLocale,
+                      targetLocale,
+                      onToggleField,
+                      onToggleAll,
+                      onEditField
+                    }
+                  ) : isStreaming ? /* @__PURE__ */ jsxRuntime.jsx(designSystem.Flex, { justifyContent: "center", alignItems: "center", padding: 8, children: /* @__PURE__ */ jsxRuntime.jsx(designSystem.Typography, { variant: "delta", textColor: "neutral500", children: formatMessage({
+                    id: getTranslation("modal.waiting"),
+                    defaultMessage: "Starting translation..."
+                  }) }) }) : null
+                }
+              )
+            ] }) }),
+            /* @__PURE__ */ jsxRuntime.jsxs(designSystem.Modal.Footer, { justifyContent: "space-between", children: [
+              /* @__PURE__ */ jsxRuntime.jsx(designSystem.Button, { variant: "tertiary", onClick: requestClose, children: isStreaming ? formatMessage({
+                id: getTranslation("actions.cancel_streaming"),
+                defaultMessage: "Cancel"
+              }) : formatMessage({
+                id: getTranslation("actions.cancel"),
+                defaultMessage: "Cancel"
+              }) }),
+              /* @__PURE__ */ jsxRuntime.jsxs(designSystem.Flex, { gap: 2, children: [
+                !isStreaming && failedFields.length > 0 ? /* @__PURE__ */ jsxRuntime.jsx(designSystem.Button, { variant: "danger-light", onClick: onRetryFailed, children: formatMessage(
+                  {
+                    id: getTranslation("actions.retry_failed"),
+                    defaultMessage: "Retry failed ({count})"
+                  },
+                  { count: failedFields.length }
+                ) }) : null,
+                canAccept ? /* @__PURE__ */ jsxRuntime.jsx(designSystem.Button, { variant: "success", onClick: onAccept, children: formatMessage(
+                  {
+                    id: getTranslation("actions.accept"),
+                    defaultMessage: "Accept Translation ({count})"
+                  },
+                  { count: applyCount }
+                ) }) : null
+              ] })
+            ] })
+          ]
+        }
+      )
+    }
+  );
+};
+const TranslationWorkflow = () => {
+  const [state, setState] = react.useState("idle");
+  const [progress, setProgress] = react.useState(null);
+  const [currentField, setCurrentField] = react.useState("");
+  const [streamingPreview, setStreamingPreview] = react.useState({});
+  const [translatedData, setTranslatedData] = react.useState(null);
+  const [sourceData, setSourceData] = react.useState(null);
+  const [failedUnits, setFailedUnits] = react.useState([]);
+  const [unitStatus, setUnitStatus] = react.useState({});
+  const [reviewPaths, setReviewPaths] = react.useState([]);
+  const [fillData, setFillData] = react.useState(null);
+  const [elapsedTime, setElapsedTime] = react.useState(0);
+  const [sourceLocale, setSourceLocale] = react.useState("");
+  const [availableLocales, setAvailableLocales] = react.useState([]);
+  const [dialogOpen, setDialogOpen] = react.useState(false);
+  const [dialogLocale, setDialogLocale] = react.useState("");
+  const [translatableFields, setTranslatableFields] = react.useState([]);
+  const [selectedFields, setSelectedFields] = react.useState(/* @__PURE__ */ new Set());
+  const [excludedFields, setExcludedFields] = react.useState(/* @__PURE__ */ new Set());
+  const [editedValues, setEditedValues] = react.useState({});
+  const abortRef = react.useRef(null);
+  const patchRef = react.useRef(null);
+  const reviewLabelsRef = react.useRef(/* @__PURE__ */ new Set());
+  const { formatMessage } = reactIntl.useIntl();
+  const { form, contentType, components, collectionType } = admin.unstable_useContentManagerContext();
+  const { toggleNotification } = admin.useNotification();
+  const { get } = admin.useFetchClient();
+  const setValues = admin.useForm("TranslateWithAI", (state2) => state2.setValues);
+  const isI18nEnabled = contentType?.pluginOptions?.i18n?.localized || false;
+  const { values } = form;
+  const currentLocale = getContentManagerLocale();
+  const addReviewPath = (path) => {
+    const label = pathToLabel(path);
+    if (reviewLabelsRef.current.has(label)) return;
+    reviewLabelsRef.current.add(label);
+    setReviewPaths((prev) => [...prev, path]);
+  };
+  const uniqueReviewPaths = (paths) => {
+    const labels = /* @__PURE__ */ new Set();
+    return paths.filter((path) => {
+      const label = pathToLabel(path);
+      if (labels.has(label)) {
+        return false;
+      }
+      labels.add(label);
+      return true;
+    });
+  };
+  const stringifyReviewValue = (value) => {
+    if (typeof value === "string") {
+      return value;
+    }
+    if (value === void 0 || value === null) {
+      return "";
+    }
+    return JSON.stringify(value, null, 2);
+  };
+  react.useEffect(() => {
+    return () => {
+      abortRef.current?.abort();
+    };
+  }, []);
+  react.useEffect(() => {
+    if (!isI18nEnabled) return;
+    const fetchLocales = async () => {
+      try {
+        const localeRes = await get("/i18n/locales");
+        const allLocales = (localeRes.data || []).map((l) => ({
+          code: l.code,
+          name: l.name || l.code,
+          isDefault: Boolean(l.isDefault),
+          status: void 0
+        }));
+        const contentTypeUid = contentType?.uid;
+        const documentId = getDocumentId();
+        if (contentTypeUid && documentId && documentId !== "create") {
+          try {
+            const docRes = await get(
+              `/content-manager/collection-types/${contentTypeUid}/${documentId}?locale=${currentLocale}`
+            );
+            const metaLocales = docRes.data?.meta?.availableLocales || [];
+            for (const ml of metaLocales) {
+              const match = allLocales.find((l) => l.code === ml.locale);
+              if (match) match.status = ml.status;
+            }
+          } catch {
+          }
+        }
+        setAvailableLocales(allLocales);
+        if (!sourceLocale) {
+          const defaultL = allLocales.find((l) => l.isDefault && l.code !== currentLocale);
+          const en = allLocales.find((l) => l.code === "en" && l.code !== currentLocale);
+          const anyWithContent = allLocales.find((l) => l.code !== currentLocale && l.status);
+          const fallback = allLocales.find((l) => l.code !== currentLocale);
+          const pick = defaultL || en || anyWithContent || fallback;
+          if (pick) setSourceLocale(pick.code);
+        }
+      } catch {
+      }
+    };
+    fetchLocales();
+  }, [isI18nEnabled, currentLocale]);
+  if (!isI18nEnabled) return null;
+  const getToken = () => {
+    const fromStorage = localStorage.getItem("jwtToken");
+    if (fromStorage) {
+      try {
+        return JSON.parse(fromStorage);
+      } catch {
+        return fromStorage;
+      }
+    }
+    return document.cookie.match(/jwtToken=([^;]+)/)?.[1] ?? "";
+  };
+  const doSSEFetch = async (dataToSend, signal) => {
+    const backendURL = window.strapi?.backendURL || "";
+    const token = getToken();
+    let response = await fetch(`${backendURL}/${PLUGIN_ID}/translate`, {
+      method: "POST",
+      headers: {
+        "Content-Type": "application/json",
+        Authorization: `Bearer ${token}`
+      },
+      body: JSON.stringify(dataToSend),
+      signal
+    });
+    if (response.status === 401) {
+      const refreshRes = await fetch(`${backendURL}/admin/access-token`, {
+        method: "POST",
+        credentials: "include",
+        headers: { Accept: "application/json", "Content-Type": "application/json" },
+        signal
+      });
+      if (!refreshRes.ok) throw new Error("Authentication failed");
+      const { data } = await refreshRes.json();
+      if (!data?.token) throw new Error("Authentication failed");
+      if (localStorage.getItem("jwtToken")) {
+        localStorage.setItem("jwtToken", JSON.stringify(data.token));
+      }
+      response = await fetch(`${backendURL}/${PLUGIN_ID}/translate`, {
+        method: "POST",
+        headers: {
+          "Content-Type": "application/json",
+          Authorization: `Bearer ${data.token}`
+        },
+        body: JSON.stringify(dataToSend),
+        signal
+      });
+    }
+    if (!response.ok) throw new Error(`HTTP ${response.status}: ${response.statusText}`);
+    return response;
+  };
+  const getDocumentId = () => {
+    if (values?.documentId) return values.documentId;
+    const pathParts = window.location.pathname.split("/").filter(Boolean);
+    const cmIndex = pathParts.indexOf("collection-types");
+    if (cmIndex >= 0 && pathParts[cmIndex + 2]) return pathParts[cmIndex + 2];
+    return new URLSearchParams(window.location.search).get("documentId");
+  };
+  const getContentTypeUid = () => contentType?.uid;
+  const getCollectionType = () => collectionType || (contentType?.kind === "singleType" ? "single-types" : "collection-types");
+  const fetchFillData = async (locale) => {
+    const contentTypeUid = getContentTypeUid();
+    const documentId = getDocumentId();
+    if (!documentId || !contentTypeUid || documentId === "create") {
+      throw new Error("Cannot determine document ID. Please save the entry first.");
+    }
+    const response = await get(
+      `/i18n/content-manager/get-fill-from-locale/${contentTypeUid}?documentId=${documentId}&sourceLocale=${locale}&targetLocale=${currentLocale}&collectionType=${getCollectionType()}`
+    );
+    if (!response.data?.data) {
+      throw new Error(`No content found for locale "${locale}".`);
+    }
+    return response.data.data;
+  };
+  const fetchSourceContent = async (locale) => {
+    const contentTypeUid = getContentTypeUid();
+    const documentId = getDocumentId();
+    if (!contentTypeUid || getCollectionType() !== "single-types" && !documentId) {
+      throw new Error("Cannot determine document ID. Please save the entry first.");
+    }
+    const path = getCollectionType() === "single-types" ? `/content-manager/single-types/${contentTypeUid}?locale=${locale}` : `/content-manager/collection-types/${contentTypeUid}/${documentId}?locale=${locale}`;
+    const response = await get(path);
+    if (!response.data?.data) {
+      throw new Error(`No content found for locale "${locale}".`);
+    }
+    return response.data.data;
+  };
+  const handleTranslateFrom = async (fromLocale, retryPaths) => {
+    const effectiveSourceLocale = fromLocale || sourceLocale;
+    if (!effectiveSourceLocale || effectiveSourceLocale === currentLocale) {
+      toggleNotification({
+        type: "warning",
+        message: formatMessage({
+          id: getTranslation("notification.no-source"),
+          defaultMessage: "Please select a source language different from the current locale."
+        })
+      });
+      return;
+    }
+    const sourceLocaleInfo = availableLocales.find((l) => l.code === effectiveSourceLocale);
+    if (!sourceLocaleInfo?.status) {
+      toggleNotification({
+        type: "warning",
+        message: formatMessage(
+          {
+            id: getTranslation("notification.no-source-content"),
+            defaultMessage: 'No content found for source locale "{locale}".'
+          },
+          { locale: effectiveSourceLocale }
+        )
+      });
+      return;
+    }
+    const abort = new AbortController();
+    abortRef.current = abort;
+    const isRetry = Boolean(retryPaths?.length && sourceData);
+    try {
+      setState("translating");
+      setProgress(null);
+      setCurrentField("");
+      setFailedUnits([]);
+      setElapsedTime(0);
+      if (isRetry) {
+        setStreamingPreview(translatedData ?? {});
+        setTranslatedData(null);
+        setUnitStatus((prev) => {
+          const next = { ...prev };
+          for (const path of retryPaths) delete next[pathToLabel(path)];
+          return next;
+        });
+      } else {
+        setStreamingPreview({});
+        setTranslatedData(null);
+        setUnitStatus({});
+        setReviewPaths([]);
+        setExcludedFields(/* @__PURE__ */ new Set());
+        setEditedValues({});
+        reviewLabelsRef.current = /* @__PURE__ */ new Set();
+        patchRef.current = null;
+      }
+      const startTime = Date.now();
+      let entryFillData = fillData;
+      let sourceFields = sourceData;
+      if (!isRetry || !sourceFields) {
+        const [freshFill, freshSource] = await Promise.all([
+          fetchFillData(effectiveSourceLocale).catch(() => null),
+          fetchSourceContent(effectiveSourceLocale)
+        ]);
+        if (!hasTextContent(freshSource)) {
+          throw new Error(`No content found in source locale "${effectiveSourceLocale}".`);
+        }
+        setSourceData({ ...freshSource });
+        setFillData(freshFill);
+        entryFillData = freshFill;
+        sourceFields = freshSource;
+      }
+      if (!sourceFields) {
+        throw new Error(`No content found in source locale "${effectiveSourceLocale}".`);
+      }
+      const include = retryPaths ?? (selectedFields.size > 0 && selectedFields.size < translatableFields.length ? [...selectedFields].map((field) => [field]) : void 0);
+      const dataToSend = {
+        contentType: contentType ?? {},
+        entry: sourceFields,
+        components: components ?? {},
+        sourceLocale: effectiveSourceLocale,
+        targetLocale: currentLocale,
+        ...include ? { include } : {}
+      };
+      const response = await doSSEFetch(dataToSend, abort.signal);
+      const accumulated = {};
+      let summaryData = null;
+      let completedUnits = 0;
+      let totalUnits = 0;
+      for await (const event of parseSSEStream(response)) {
+        if (abort.signal.aborted) break;
+        switch (event.type) {
+          case "session_started":
+            totalUnits = event.totalUnits || 0;
+            setProgress({ current: 0, total: totalUnits });
+            for (const unitPath of event.unitPaths ?? []) {
+              addReviewPath(unitPath);
+            }
+            break;
+          case "unit_started": {
+            const startedPath = event.unit?.path;
+            setCurrentField(pathToLabel(startedPath));
+            if (startedPath) {
+              setUnitStatus((prev) => ({ ...prev, [pathToLabel(startedPath)]: "translating" }));
+            }
+            break;
+          }
+          case "unit_delta":
+            if (event.path && event.content != null) {
+              addReviewPath(event.path);
+              setStreamingPreview((prev) => ({
+                ...setValueByPath(prev, event.path, event.content)
+              }));
+            }
+            break;
+          case "unit_retry_scheduled":
+            if (event.path) {
+              setCurrentField(
+                formatMessage(
+                  {
+                    id: getTranslation("workflow.retrying"),
+                    defaultMessage: "{field} — retrying (attempt {attempt})"
+                  },
+                  { field: pathToLabel(event.path), attempt: event.attempt ?? 1 }
+                )
+              );
+            }
+            break;
+          case "unit_fallback_used":
+            if (event.path) {
+              setCurrentField(
+                formatMessage(
+                  {
+                    id: getTranslation("workflow.fallback"),
+                    defaultMessage: "{field} — using fallback model"
+                  },
+                  { field: pathToLabel(event.path) }
+                )
+              );
+            }
+            break;
+          case "unit_completed":
+            completedUnits += 1;
+            if (event.path && event.translatedText != null) {
+              addReviewPath(event.path);
+              setStreamingPreview(
+                (prev) => setValueByPath(prev, event.path, event.translatedText)
+              );
+              setUnitStatus((prev) => ({ ...prev, [pathToLabel(event.path)]: "done" }));
+            }
+            if (totalUnits > 0) {
+              setProgress({ current: completedUnits, total: totalUnits });
+            }
+            break;
+          case "unit_failed": {
+            completedUnits += 1;
+            const failedPath = event.path;
+            if (failedPath) {
+              setFailedUnits((prev) => [...prev, failedPath]);
+              setUnitStatus((prev) => ({ ...prev, [pathToLabel(failedPath)]: "failed" }));
+            }
+            if (totalUnits > 0) {
+              setProgress({ current: completedUnits, total: totalUnits });
+            }
+            break;
+          }
+          case "session_completed": {
+            summaryData = event;
+            if (event.patch) {
+              const newLabels = new Set(
+                event.patch.operations.map((operation) => pathToLabel(operation.path))
+              );
+              const previousOperations = isRetry && patchRef.current ? patchRef.current.operations.filter(
+                (operation) => !newLabels.has(pathToLabel(operation.path))
+              ) : [];
+              const mergedPatch = {
+                operations: [...previousOperations, ...event.patch.operations]
+              };
+              patchRef.current = mergedPatch;
+              const finalPaths = uniqueReviewPaths(
+                mergedPatch.operations.map((operation) => operation.path)
+              );
+              reviewLabelsRef.current = new Set(finalPaths.map(pathToLabel));
+              setReviewPaths(finalPaths);
+              Object.assign(
+                accumulated,
+                applyTranslationPatchToFillData(entryFillData, sourceFields, mergedPatch)
+              );
+            }
+            break;
+          }
+          case "session_failed":
+            throw new Error(event.error || "Translation failed");
+        }
+      }
+      if (abort.signal.aborted) {
+        return;
+      }
+      setTranslatedData(accumulated);
+      setStreamingPreview({});
+      setElapsedTime(Math.round((Date.now() - startTime) / 1e3));
+      if ((summaryData?.summary?.failedUnitIds?.length ?? 0) > 0) {
+        setState("partial");
+      } else if (Object.keys(accumulated).length > 0) {
+        setState("preview");
+      } else {
+        throw new Error("No translation data received");
+      }
+    } catch (err) {
+      if (!abort.signal.aborted) {
+        setState("error");
+        toggleNotification({
+          type: "danger",
+          message: formatMessage(
+            {
+              id: getTranslation("notification.error"),
+              defaultMessage: "Translation failed: {error}"
+            },
+            { error: err.message }
+          )
+        });
+      }
+    }
+  };
+  const buildEffectivePatch = (patch) => ({
+    operations: patch.operations.filter((operation) => !excludedFields.has(pathToLabel(operation.path))).map((operation) => {
+      const edited = editedValues[pathToLabel(operation.path)];
+      return edited !== void 0 && typeof operation.value === "string" ? { ...operation, value: edited } : operation;
+    })
+  });
+  const handleAccept = () => {
+    const patch = patchRef.current;
+    const merged = patch ? mergeTranslationResult({ formValues: values, fillData, patch: buildEffectivePatch(patch) }) : { ...fillData || {}, ...translatedData || {} };
+    if (Object.keys(merged).length > 0) {
+      setValues(merged);
+    }
+    setState("success");
+    setTranslatedData(null);
+    setSourceData(null);
+    setFillData(null);
+    setStreamingPreview({});
+    setReviewPaths([]);
+    setExcludedFields(/* @__PURE__ */ new Set());
+    setEditedValues({});
+    setFailedUnits([]);
+    setUnitStatus({});
+    patchRef.current = null;
+    reviewLabelsRef.current = /* @__PURE__ */ new Set();
+    toggleNotification({
+      type: "success",
+      message: formatMessage({
+        id: getTranslation("notification.success"),
+        defaultMessage: "Translation applied - remember to save."
+      })
+    });
+    setTimeout(() => setState((s) => s === "success" ? "idle" : s), 5e3);
+  };
+  const handleCancel = () => {
+    if (abortRef.current) abortRef.current.abort();
+    setState("idle");
+    setTranslatedData(null);
+    setSourceData(null);
+    setFillData(null);
+    setStreamingPreview({});
+    setReviewPaths([]);
+    setExcludedFields(/* @__PURE__ */ new Set());
+    setEditedValues({});
+    patchRef.current = null;
+    reviewLabelsRef.current = /* @__PURE__ */ new Set();
+    setProgress(null);
+    setCurrentField("");
+    setFailedUnits([]);
+    setUnitStatus({});
+  };
+  const buildDiffEntries = () => {
+    const entries = [];
+    const dataSource = translatedData || streamingPreview;
+    if (!sourceData) return entries;
+    const paths = reviewPaths.length > 0 ? reviewPaths : Object.keys(dataSource).map((key) => [key]);
+    for (const path of paths) {
+      const label = pathToLabel(path);
+      const translatedValue = getValueByPath(dataSource, path);
+      const originalValue = getValueByPath(sourceData, path);
+      const tStr = stringifyReviewValue(translatedValue);
+      const oStr = stringifyReviewValue(originalValue);
+      if (!oStr && !tStr) continue;
+      const displayed = editedValues[label] ?? tStr;
+      entries.push({
+        key: label,
+        original: oStr || "",
+        translated: displayed || "",
+        current: stringifyReviewValue(getValueByPath(values ?? {}, path)),
+        changed: oStr !== tStr,
+        editable: typeof translatedValue === "string",
+        included: !excludedFields.has(label),
+        status: state === "translating" ? unitStatus[label] ?? "pending" : void 0
+      });
+    }
+    return entries;
+  };
+  const handleToggleAll = (included) => {
+    setExcludedFields(
+      included ? /* @__PURE__ */ new Set() : new Set(
+        buildDiffEntries().filter((entry) => entry.changed).map((entry) => entry.key)
+      )
+    );
+  };
+  const handleToggleField = (key, included) => {
+    setExcludedFields((prev) => {
+      const next = new Set(prev);
+      if (included) {
+        next.delete(key);
+      } else {
+        next.add(key);
+      }
+      return next;
+    });
+  };
+  const handleEditField = (key, value) => {
+    setEditedValues((prev) => ({ ...prev, [key]: value }));
+  };
+  const handleRetryFailed = () => {
+    if (failedUnits.length === 0) return;
+    handleTranslateFrom(sourceLocale, failedUnits);
+  };
+  const isModalOpen = state === "translating" || state === "preview" || state === "partial";
+  const otherLocales = availableLocales.filter((l) => l.code !== currentLocale);
+  const openDialog = () => {
+    const fields = listTranslatableFields(contentType, components ?? {});
+    setTranslatableFields(fields);
+    setSelectedFields(new Set(fields));
+    const defaultL = otherLocales.find((l) => l.isDefault && l.status);
+    const en = otherLocales.find((l) => l.code === "en" && l.status);
+    const anyWithContent = otherLocales.find((l) => l.status);
+    setDialogLocale((defaultL || en || anyWithContent || otherLocales[0])?.code || "");
+    setDialogOpen(true);
+  };
+  const confirmTranslate = () => {
+    if (!dialogLocale || selectedFields.size === 0) return;
+    const locale = otherLocales.find((l) => l.code === dialogLocale);
+    if (!locale?.status) return;
+    setSourceLocale(dialogLocale);
+    setDialogOpen(false);
+    handleTranslateFrom(dialogLocale);
+  };
+  return /* @__PURE__ */ jsxRuntime.jsxs(designSystem.Box, { children: [
+    state === "idle" || state === "error" ? otherLocales.length === 0 ? /* @__PURE__ */ jsxRuntime.jsx(
+      designSystem.Tooltip,
+      {
+        label: formatMessage({
+          id: getTranslation("panel.no_other_locales"),
+          defaultMessage: "Add another locale in Settings → Internationalization to enable AI translation."
+        }),
+        children: /* @__PURE__ */ jsxRuntime.jsx(designSystem.Box, { children: /* @__PURE__ */ jsxRuntime.jsx(
+          designSystem.Button,
+          {
+            variant: "secondary",
+            startIcon: /* @__PURE__ */ jsxRuntime.jsx(icons.Magic, {}),
+            size: "S",
+            onClick: openDialog,
+            disabled: true,
+            children: formatMessage({
+              id: getTranslation("panel.status.idle"),
+              defaultMessage: "Translate content"
+            })
+          }
+        ) })
+      }
+    ) : /* @__PURE__ */ jsxRuntime.jsx(
+      designSystem.Button,
+      {
+        variant: state === "error" ? "danger" : "secondary",
+        startIcon: state === "error" ? /* @__PURE__ */ jsxRuntime.jsx(icons.WarningCircle, {}) : /* @__PURE__ */ jsxRuntime.jsx(icons.Magic, {}),
+        size: "S",
+        onClick: openDialog,
+        children: state === "error" ? formatMessage({
+          id: getTranslation("panel.status.error"),
+          defaultMessage: "Retry translation"
+        }) : formatMessage({
+          id: getTranslation("panel.status.idle"),
+          defaultMessage: "Translate content"
+        })
+      }
+    ) : state === "translating" ? /* @__PURE__ */ jsxRuntime.jsx(designSystem.Button, { variant: "secondary", size: "S", loading: true, disabled: true, children: formatMessage({
+      id: getTranslation("panel.status.loading"),
+      defaultMessage: "Translating..."
+    }) }) : state === "success" ? /* @__PURE__ */ jsxRuntime.jsx(designSystem.Button, { variant: "success", size: "S", startIcon: /* @__PURE__ */ jsxRuntime.jsx(icons.CheckCircle, {}), disabled: true, children: formatMessage({ id: getTranslation("panel.status.success"), defaultMessage: "Applied" }) }) : null,
+    /* @__PURE__ */ jsxRuntime.jsx(designSystem.Dialog.Root, { open: dialogOpen, onOpenChange: setDialogOpen, children: /* @__PURE__ */ jsxRuntime.jsxs(designSystem.Dialog.Content, { children: [
+      /* @__PURE__ */ jsxRuntime.jsx(designSystem.Dialog.Body, { children: /* @__PURE__ */ jsxRuntime.jsxs(designSystem.Flex, { direction: "column", gap: 4, children: [
+        /* @__PURE__ */ jsxRuntime.jsxs(designSystem.Flex, { direction: "column", gap: 2, alignItems: "center", children: [
+          /* @__PURE__ */ jsxRuntime.jsx(icons.Magic, { width: "24px", height: "24px", fill: "primary600" }),
+          /* @__PURE__ */ jsxRuntime.jsx(designSystem.Typography, { variant: "omega", fontWeight: "bold", children: formatMessage({
+            id: getTranslation("dialog.title"),
+            defaultMessage: "AI translation"
+          }) }),
+          /* @__PURE__ */ jsxRuntime.jsx(designSystem.Typography, { textAlign: "center", variant: "omega", children: formatMessage({
+            id: getTranslation("dialog.body"),
+            defaultMessage: "Translatable fields will be translated by AI. Non-translatable fields (media, dates, relations) will be copied from the source locale."
+          }) })
+        ] }),
+        /* @__PURE__ */ jsxRuntime.jsxs(
+          designSystem.Field.Root,
+          {
+            width: "100%",
+            hint: formatMessage({
+              id: getTranslation("dialog.source.hint"),
+              defaultMessage: "Content from this locale will be used as the translation source."
+            }),
+            children: [
+              /* @__PURE__ */ jsxRuntime.jsx(designSystem.Field.Label, { children: formatMessage({
+                id: getTranslation("dialog.source.label"),
+                defaultMessage: "Select source locale"
+              }) }),
+              /* @__PURE__ */ jsxRuntime.jsx(
+                designSystem.SingleSelect,
+                {
+                  value: dialogLocale,
+                  onChange: (value) => setDialogLocale(String(value)),
+                  children: otherLocales.map((locale) => {
+                    const hasContent = Boolean(locale.status);
+                    const isPublished = locale.status === "published";
+                    const isDraft = locale.status === "draft";
+                    const isModified = locale.status === "modified";
+                    const statusLabel = isPublished ? formatMessage({
+                      id: getTranslation("locale.status.published"),
+                      defaultMessage: "Published"
+                    }) : isModified ? formatMessage({
+                      id: getTranslation("locale.status.modified"),
+                      defaultMessage: "Modified"
+                    }) : isDraft ? formatMessage({
+                      id: getTranslation("locale.status.draft"),
+                      defaultMessage: "Draft"
+                    }) : formatMessage({
+                      id: getTranslation("locale.status.none"),
+                      defaultMessage: "No content"
+                    });
+                    const name = locale.name.includes(locale.code) ? locale.name : `${locale.name} (${locale.code})`;
+                    return /* @__PURE__ */ jsxRuntime.jsx(
+                      designSystem.SingleSelectOption,
+                      {
+                        value: locale.code,
+                        disabled: !hasContent,
+                        children: `${name} - ${statusLabel}`
+                      },
+                      locale.code
+                    );
+                  })
+                }
+              ),
+              /* @__PURE__ */ jsxRuntime.jsx(designSystem.Field.Hint, {})
+            ]
+          }
+        ),
+        translatableFields.length > 0 ? /* @__PURE__ */ jsxRuntime.jsxs(designSystem.Field.Root, { width: "100%", children: [
+          /* @__PURE__ */ jsxRuntime.jsx(designSystem.Field.Label, { children: formatMessage({
+            id: getTranslation("dialog.fields.label"),
+            defaultMessage: "Fields to translate"
+          }) }),
+          /* @__PURE__ */ jsxRuntime.jsx(
+            designSystem.Box,
+            {
+              hasRadius: true,
+              borderColor: "neutral200",
+              borderStyle: "solid",
+              borderWidth: "1px",
+              padding: 3,
+              style: { maxHeight: "220px", overflowY: "auto" },
+              children: /* @__PURE__ */ jsxRuntime.jsxs(designSystem.Flex, { direction: "column", alignItems: "stretch", gap: 2, children: [
+                /* @__PURE__ */ jsxRuntime.jsx(
+                  designSystem.Checkbox,
+                  {
+                    checked: selectedFields.size === translatableFields.length ? true : selectedFields.size === 0 ? false : "indeterminate",
+                    onCheckedChange: (checked) => setSelectedFields(
+                      checked === true ? new Set(translatableFields) : /* @__PURE__ */ new Set()
+                    ),
+                    children: formatMessage(
+                      {
+                        id: getTranslation("dialog.fields.all"),
+                        defaultMessage: "All fields ({count})"
+                      },
+                      { count: translatableFields.length }
+                    )
+                  }
+                ),
+                translatableFields.map((field) => /* @__PURE__ */ jsxRuntime.jsx(
+                  designSystem.Checkbox,
+                  {
+                    checked: selectedFields.has(field),
+                    onCheckedChange: (checked) => setSelectedFields((prev) => {
+                      const next = new Set(prev);
+                      if (checked === true) {
+                        next.add(field);
+                      } else {
+                        next.delete(field);
+                      }
+                      return next;
+                    }),
+                    children: hasTextContent(values?.[field]) ? formatMessage(
+                      {
+                        id: getTranslation("dialog.fields.has_content"),
+                        defaultMessage: "{field} — already has content here"
+                      },
+                      { field }
+                    ) : field
+                  },
+                  field
+                ))
+              ] })
+            }
+          )
+        ] }) : null
+      ] }) }),
+      /* @__PURE__ */ jsxRuntime.jsxs(designSystem.Dialog.Footer, { children: [
+        /* @__PURE__ */ jsxRuntime.jsx(designSystem.Dialog.Cancel, { children: /* @__PURE__ */ jsxRuntime.jsx(designSystem.Button, { variant: "tertiary", children: formatMessage({ id: getTranslation("actions.cancel"), defaultMessage: "Cancel" }) }) }),
+        /* @__PURE__ */ jsxRuntime.jsx(designSystem.Dialog.Action, { children: /* @__PURE__ */ jsxRuntime.jsx(
+          designSystem.Button,
+          {
+            variant: "default",
+            onClick: confirmTranslate,
+            disabled: !dialogLocale || !otherLocales.find((l) => l.code === dialogLocale)?.status || selectedFields.size === 0,
+            startIcon: /* @__PURE__ */ jsxRuntime.jsx(icons.Magic, {}),
+            children: formatMessage({
+              id: getTranslation("dialog.confirm"),
+              defaultMessage: "Translate"
+            })
+          }
+        ) })
+      ] })
+    ] }) }),
+    /* @__PURE__ */ jsxRuntime.jsx(
+      TranslationModal,
+      {
+        isOpen: isModalOpen,
+        isStreaming: state === "translating",
+        sourceLocale: sourceLocale || "source",
+        targetLocale: currentLocale,
+        diffEntries: buildDiffEntries(),
+        progress,
+        currentField,
+        failedFields: failedUnits.map(pathToLabel),
+        elapsedTime,
+        onAccept: handleAccept,
+        onCancel: handleCancel,
+        onRetryFailed: handleRetryFailed,
+        onToggleField: handleToggleField,
+        onToggleAll: handleToggleAll,
+        onEditField: handleEditField
+      }
+    )
+  ] });
+};
+const TranslationPanel = () => {
+  const { formatMessage } = reactIntl.useIntl();
+  const { contentType } = admin.unstable_useContentManagerContext();
+  const isI18nEnabled = Boolean(contentType?.pluginOptions?.i18n?.localized);
+  if (!isI18nEnabled) {
+    return null;
+  }
+  return {
+    title: formatMessage({ id: getTranslation("plugin.name"), defaultMessage: "AI Translator" }),
+    content: /* @__PURE__ */ jsxRuntime.jsx(TranslationWorkflow, {})
+  };
+};
+const index = {
+  register(app) {
+    app.createSettingSection(
+      {
+        id: PLUGIN_ID,
+        intlLabel: { id: getTranslation("plugin.name"), defaultMessage: "AI Translator" }
+      },
+      [
+        {
+          id: PLUGIN_ID,
+          to: `/settings/${PLUGIN_ID}`,
+          intlLabel: { id: getTranslation("settings.label"), defaultMessage: "Configuration" },
+          permissions: [{ action: `plugin::${PLUGIN_ID}.settings.manage`, subject: null }],
+          Component: async () => {
+            const { SettingsPage } = await Promise.resolve().then(() => require("./SettingsPage-CD90jfwT.js"));
+            return { default: SettingsPage };
+          }
+        }
+      ]
+    );
+    app.registerPlugin({
+      id: PLUGIN_ID,
+      initializer: Initializer,
+      isReady: false,
+      name: PLUGIN_ID
+    });
+  },
+  bootstrap(app) {
+    const contentManager = app.getPlugin("content-manager");
+    const contentManagerApis = contentManager?.apis;
+    if (typeof contentManagerApis?.addEditViewSidePanel === "function") {
+      contentManagerApis.addEditViewSidePanel([TranslationPanel]);
+    }
+  },
+  async registerTrads({ locales }) {
+    return Promise.all(
+      locales.map(async (locale) => {
+        try {
+          const { default: data } = await __variableDynamicImportRuntimeHelper(/* @__PURE__ */ Object.assign({ "./translations/en.json": () => Promise.resolve().then(() => require("./en-I9cvzxfF.js")) }), `./translations/${locale}.json`, 3);
+          return { data, locale };
+        } catch {
+          return { data: {}, locale };
+        }
+      })
+    );
+  }
+};
+exports.PLUGIN_ID = PLUGIN_ID;
+exports.getTranslation = getTranslation;
+exports.index = index;