@smartcat/sanity-plugin 1.0.0 → 1.1.0

package/dist/index.cjs

@@ -0,0 +1,2172 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: !0 });
+var sanity = require("sanity"), icons = require("@sanity/icons"), constants = require("./_chunks-cjs/constants.cjs"), jsxRuntime = require("react/jsx-runtime"), react = require("react"), ui = require("@sanity/ui"), uuid = require("@sanity/uuid"), workflow = require("./_chunks-cjs/workflow.cjs"), progress = require("./_chunks-cjs/index.cjs"), locjson = require("./_chunks-cjs/index2.cjs"), router = require("sanity/router"), styled = require("styled-components");
+function _interopDefaultCompat(e) {
+  return e && typeof e == "object" && "default" in e ? e : { default: e };
+}
+var styled__default = /* @__PURE__ */ _interopDefaultCompat(styled);
+const STATUS_OPTIONS = [
+  { title: "Draft", value: "draft" },
+  { title: "Queued", value: "queued" },
+  { title: "Sent", value: "sent" },
+  { title: "In progress", value: "translating" },
+  { title: "Importing", value: "importing" },
+  { title: "Downloaded", value: "downloaded" },
+  { title: "Completed", value: "completed" },
+  { title: "Error", value: "error" }
+];
+function createTranslationProjectType() {
+  return sanity.defineType({
+    name: constants.TRANSLATION_PROJECT_TYPE,
+    title: "Translation project",
+    type: "document",
+    icon: icons.TranslateIcon,
+    fields: [
+      sanity.defineField({
+        name: "name",
+        title: "Project name",
+        type: "string",
+        validation: (rule) => rule.required()
+      }),
+      sanity.defineField({
+        name: "status",
+        type: "string",
+        // Driven by the dashboard and Functions, not edited by hand.
+        readOnly: !0,
+        initialValue: "draft",
+        options: { list: STATUS_OPTIONS, layout: "radio" }
+      }),
+      sanity.defineField({
+        name: "sourceLanguage",
+        title: "Source language",
+        type: "string"
+      }),
+      // Workflow chosen at creation: `template:<id>` or a standard preset.
+      // Read by the export Function to build Smartcat's createProject params.
+      sanity.defineField({ name: "workflow", type: "string", readOnly: !0, hidden: !0 }),
+      sanity.defineField({
+        name: "targetLanguages",
+        title: "Target languages",
+        type: "array",
+        of: [sanity.defineArrayMember({ type: "string" })],
+        options: { layout: "tags" }
+      }),
+      // Sanity-id → Smartcat-code mapping for this project's source + target
+      // languages, stamped by the browser at export time so the thin Functions
+      // (which can't see plugin config) can map to/from Smartcat codes.
+      sanity.defineField({
+        name: "smartcatLanguages",
+        type: "array",
+        readOnly: !0,
+        hidden: !0,
+        of: [
+          sanity.defineArrayMember({
+            type: "object",
+            name: "smartcatLanguageMapping",
+            fields: [
+              sanity.defineField({ name: "sanityId", type: "string" }),
+              sanity.defineField({ name: "smartcatLanguage", type: "string" })
+            ]
+          })
+        ]
+      }),
+      sanity.defineField({
+        name: "items",
+        title: "Items",
+        description: "Content added to this project for translation.",
+        // Populated by the "Add to translation project" action, not by hand.
+        readOnly: !0,
+        type: "array",
+        of: [
+          sanity.defineArrayMember({
+            type: "object",
+            name: "smartcat.projectItem",
+            title: "Project item",
+            fields: [
+              sanity.defineField({ name: "docId", title: "Document ID", type: "string" }),
+              sanity.defineField({ name: "docType", title: "Document type", type: "string" }),
+              // Set when the item was added from the published perspective, so the
+              // export translates the published document. Absent/false (incl. all
+              // legacy items) prefers the draft — see itemDocDerefRespectingDraft.
+              sanity.defineField({ name: "sourceIsPublished", title: "Source is published", type: "boolean" })
+            ],
+            preview: { select: { title: "docId", subtitle: "docType" } }
+          })
+        ]
+      }),
+      sanity.defineField({
+        name: "smartcatProjectId",
+        title: "Smartcat project ID",
+        type: "string",
+        readOnly: !0,
+        description: "GUID of the corresponding project in Smartcat."
+      }),
+      sanity.defineField({
+        name: "smartcatProjectUrl",
+        title: "Smartcat project URL",
+        type: "url",
+        readOnly: !0,
+        description: "Link to the project in Smartcat (set by the export Function)."
+      }),
+      sanity.defineField({ name: "lastExportAt", type: "datetime", readOnly: !0 }),
+      sanity.defineField({ name: "lastImportAt", type: "datetime", readOnly: !0 }),
+      // Per-document, per-language, per-stage translation progress, mirrored from
+      // Smartcat. The export captures the target document ids; the progress/import
+      // Functions refresh the stage percentages; the browser sets `imported`.
+      sanity.defineField({
+        name: "progress",
+        title: "Translation progress",
+        type: "array",
+        readOnly: !0,
+        of: [
+          sanity.defineArrayMember({
+            type: "object",
+            name: "smartcatDocProgress",
+            fields: [
+              sanity.defineField({ name: "sourceDocId", type: "string" }),
+              sanity.defineField({ name: "title", type: "string" }),
+              sanity.defineField({
+                name: "targets",
+                type: "array",
+                of: [
+                  sanity.defineArrayMember({
+                    type: "object",
+                    name: "smartcatTargetProgress",
+                    fields: [
+                      sanity.defineField({ name: "language", type: "string" }),
+                      sanity.defineField({ name: "smartcatDocumentId", type: "string" }),
+                      sanity.defineField({
+                        name: "stages",
+                        type: "array",
+                        of: [
+                          sanity.defineArrayMember({
+                            type: "object",
+                            name: "smartcatStageProgress",
+                            fields: [
+                              sanity.defineField({ name: "name", type: "string" }),
+                              sanity.defineField({ name: "percent", type: "number" })
+                            ]
+                          })
+                        ]
+                      }),
+                      // All stages at 100% (set by the progress/import Functions).
+                      sanity.defineField({ name: "complete", type: "boolean" }),
+                      // A locale variant has been built from this target (set by the browser).
+                      sanity.defineField({ name: "imported", type: "boolean" }),
+                      sanity.defineField({ name: "syncedAt", type: "datetime" })
+                    ]
+                  })
+                ]
+              })
+            ]
+          })
+        ]
+      }),
+      // Handshake fields for the on-demand progress refresh: the browser bumps
+      // `progressRequestedAt`; the smartcat-progress Function reacts and writes
+      // `progressSyncedAt`. Keeping them distinct stops the Function re-triggering
+      // on its own write (filter is delta::changedAny(progressRequestedAt)).
+      sanity.defineField({ name: "progressRequestedAt", type: "datetime", readOnly: !0, hidden: !0 }),
+      sanity.defineField({ name: "progressSyncedAt", type: "datetime", readOnly: !0, hidden: !0 }),
+      sanity.defineField({
+        name: "lastError",
+        title: "Last error",
+        type: "string",
+        readOnly: !0,
+        description: "Most recent export/import error, if any."
+      }),
+      // JSON-encoded LogLine[] from the most recent Function run (export upload or
+      // import download). Transient diagnostic data the browser merges into its
+      // live Log panel; overwritten each run.
+      sanity.defineField({
+        name: "functionLog",
+        type: "text",
+        readOnly: !0,
+        hidden: !0
+      }),
+      // Transient transport buffers. The browser (plugin) serializes content into
+      // `outbox`; the thin export Function uploads it. The thin import Function
+      // downloads translated files into `inbox`; the browser turns them into
+      // locale variants. Both are cleared after processing.
+      sanity.defineField({
+        name: "outbox",
+        type: "array",
+        readOnly: !0,
+        hidden: !0,
+        of: [
+          sanity.defineArrayMember({
+            type: "object",
+            name: "smartcatOutboxItem",
+            fields: [
+              sanity.defineField({ name: "filename", type: "string" }),
+              sanity.defineField({ name: "locjson", type: "text" })
+            ]
+          })
+        ]
+      }),
+      sanity.defineField({
+        name: "inbox",
+        type: "array",
+        readOnly: !0,
+        hidden: !0,
+        of: [
+          sanity.defineArrayMember({
+            type: "object",
+            name: "smartcatInboxItem",
+            fields: [
+              sanity.defineField({ name: "sourceDocId", type: "string" }),
+              sanity.defineField({ name: "targetLanguage", type: "string" }),
+              sanity.defineField({ name: "smartcatDocumentId", type: "string" }),
+              sanity.defineField({ name: "locjson", type: "text" })
+            ]
+          })
+        ]
+      }),
+      // Transient: items the browser marked for deletion. On the next export the
+      // Function deletes the Smartcat document and removes the item + its progress.
+      sanity.defineField({
+        name: "pendingDeletions",
+        type: "array",
+        readOnly: !0,
+        hidden: !0,
+        of: [
+          sanity.defineArrayMember({
+            type: "object",
+            name: "smartcatPendingDeletion",
+            fields: [
+              sanity.defineField({ name: "itemKey", type: "string" }),
+              sanity.defineField({ name: "sourceDocId", type: "string" }),
+              sanity.defineField({ name: "smartcatDocumentId", type: "string" })
+            ]
+          })
+        ]
+      })
+    ],
+    preview: {
+      select: { name: "name", status: "status", items: "items" },
+      prepare({ name, status, items }) {
+        const count = Array.isArray(items) ? items.length : 0;
+        return {
+          title: name || "Untitled project",
+          subtitle: `${status || "draft"} \xB7 ${count} item${count === 1 ? "" : "s"}`
+        };
+      }
+    }
+  });
+}
+function createSettingsType() {
+  return sanity.defineType({
+    name: constants.SETTINGS_TYPE,
+    title: "Smartcat settings",
+    type: "document",
+    icon: icons.CogIcon,
+    fields: [
+      sanity.defineField({
+        name: "templates",
+        title: "Project templates",
+        type: "array",
+        readOnly: !0,
+        of: [
+          sanity.defineArrayMember({
+            type: "object",
+            name: "smartcatTemplate",
+            fields: [
+              sanity.defineField({ name: "id", type: "string" }),
+              sanity.defineField({ name: "name", type: "string" })
+            ],
+            preview: { select: { title: "name", subtitle: "id" } }
+          })
+        ]
+      }),
+      // Handshake fields for the on-demand template refresh: the browser bumps
+      // `templatesRequestedAt`; the smartcat-templates Function writes
+      // `templatesSyncedAt`. Distinct fields stop the Function re-triggering on
+      // its own write (filter is delta::changedAny(templatesRequestedAt)).
+      sanity.defineField({ name: "templatesRequestedAt", type: "datetime", readOnly: !0, hidden: !0 }),
+      sanity.defineField({ name: "templatesSyncedAt", type: "datetime", readOnly: !0, hidden: !0 })
+    ],
+    preview: {
+      select: { templates: "templates", syncedAt: "templatesSyncedAt" },
+      prepare({ templates, syncedAt }) {
+        const count = Array.isArray(templates) ? templates.length : 0;
+        return {
+          title: "Smartcat settings",
+          subtitle: syncedAt ? `${count} template${count === 1 ? "" : "s"} cached` : "Not synced yet"
+        };
+      }
+    }
+  });
+}
+function WorkflowSelect({ value, onChange, templates, disabled }) {
+  return /* @__PURE__ */ jsxRuntime.jsxs(ui.Select, { value, onChange: (e) => onChange(e.currentTarget.value), disabled, children: [
+    /* @__PURE__ */ jsxRuntime.jsx("option", { value: "", disabled: !0, children: "Select a workflow\u2026" }),
+    templates.length > 0 && /* @__PURE__ */ jsxRuntime.jsx("optgroup", { label: "Templates", children: templates.map((t) => /* @__PURE__ */ jsxRuntime.jsx("option", { value: `${workflow.TEMPLATE_PREFIX}${t.id}`, children: t.name }, t.id)) }),
+    /* @__PURE__ */ jsxRuntime.jsx("optgroup", { label: "Standard workflows", children: workflow.STANDARD_WORKFLOW_OPTIONS.map((o) => /* @__PURE__ */ jsxRuntime.jsx("option", { value: o.value, children: o.label }, o.value)) })
+  ] });
+}
+const SETTINGS_QUERY = "*[_id == $id][0]{templates, templatesRequestedAt, templatesSyncedAt}", REQUEST_STALE_MS = 3e4;
+function isRefreshInFlight(s) {
+  const requested = s?.templatesRequestedAt;
+  return !requested || !(!s?.templatesSyncedAt || requested > s.templatesSyncedAt) ? !1 : Date.now() - Date.parse(requested) < REQUEST_STALE_MS;
+}
+function useTemplates() {
+  const client = sanity.useClient({ apiVersion: constants.API_VERSION }), [settings, setSettings] = react.useState(null), [loaded, setLoaded] = react.useState(!1), settingsRef = react.useRef(null);
+  settingsRef.current = settings, react.useEffect(() => {
+    let cancelled = !1;
+    const load = () => client.fetch(SETTINGS_QUERY, { id: constants.SETTINGS_DOC_ID }).then((s) => {
+      cancelled || (setSettings(s), setLoaded(!0));
+    }).catch(() => {
+    });
+    load();
+    const sub = client.listen(SETTINGS_QUERY, { id: constants.SETTINGS_DOC_ID }, { visibility: "query" }).subscribe({ next: load, error: () => {
+    } });
+    return () => {
+      cancelled = !0, sub.unsubscribe();
+    };
+  }, [client]);
+  const requestRefresh = react.useCallback(() => {
+    isRefreshInFlight(settingsRef.current) || client.transaction().createIfNotExists({ _id: constants.SETTINGS_DOC_ID, _type: constants.SETTINGS_TYPE }).patch(constants.SETTINGS_DOC_ID, (p) => p.set({ templatesRequestedAt: (/* @__PURE__ */ new Date()).toISOString() })).commit({ visibility: "async" }).catch(() => {
+    });
+  }, [client]);
+  return { templates: settings?.templates ?? [], loaded, requestRefresh };
+}
+const STORAGE_KEY = "smartcat:lastWorkflow";
+function readLastWorkflow() {
+  try {
+    return localStorage.getItem(STORAGE_KEY) ?? "";
+  } catch {
+    return "";
+  }
+}
+function writeLastWorkflow(value) {
+  try {
+    localStorage.setItem(STORAGE_KEY, value);
+  } catch {
+  }
+}
+function useWorkflowSelection(active, templates, loaded) {
+  const [workflow$1, setWorkflowState] = react.useState(""), initialized = react.useRef(!1), templateIds = react.useMemo(() => templates.map((t) => t.id), [templates]);
+  react.useEffect(() => {
+    if (!active) {
+      initialized.current = !1;
+      return;
+    }
+    if (initialized.current || !loaded) return;
+    initialized.current = !0;
+    const saved = readLastWorkflow();
+    setWorkflowState(workflow.isWorkflowValid(saved, templateIds) ? saved : "");
+  }, [active, loaded, templateIds]), react.useEffect(() => {
+    !active || !loaded || !workflow$1 || workflow.isWorkflowValid(workflow$1, templateIds) || setWorkflowState("");
+  }, [active, loaded, workflow$1, templateIds]);
+  const setWorkflow = react.useCallback((value) => {
+    setWorkflowState(value), value && writeLastWorkflow(value);
+  }, []);
+  return [workflow$1, setWorkflow];
+}
+const UNTITLED = "Untitled";
+function resolveDocumentTitle(schema, doc) {
+  const type = schema.get(doc._type);
+  if (type)
+    try {
+      const preview = sanity.prepareForPreview(doc, type);
+      return typeof preview?.title == "string" ? preview.title : void 0;
+    } catch {
+      return;
+    }
+}
+const bareId = (id) => id.replace(/^drafts\./, "");
+function collectRefs(node, out = /* @__PURE__ */ new Set()) {
+  if (!node || typeof node != "object") return out;
+  if (Array.isArray(node)) {
+    for (const item of node) collectRefs(item, out);
+    return out;
+  }
+  const obj = node;
+  typeof obj._ref == "string" && out.add(bareId(obj._ref));
+  for (const [key, value] of Object.entries(obj))
+    key !== "_ref" && collectRefs(value, out);
+  return out;
+}
+function pickPreferDraft(docs) {
+  const chosen = /* @__PURE__ */ new Map();
+  for (const doc of docs ?? []) {
+    const bare = bareId(doc._id);
+    (!chosen.has(bare) || doc._id.startsWith("drafts.")) && chosen.set(bare, doc);
+  }
+  return chosen;
+}
+async function gatherLinkedDocuments({
+  client,
+  rootId,
+  isRoot,
+  isTranslatable,
+  batchSize = 50
+}) {
+  const start = bareId(rootId), seen = /* @__PURE__ */ new Set([start]), result = [];
+  let frontier = [start];
+  for (; frontier.length; ) {
+    const batch = frontier.splice(0, batchSize), bodies = await client.fetch(
+      "*[_id in $ids]",
+      { ids: batch.flatMap((id) => [id, `drafts.${id}`]) }
+    ), candidates = /* @__PURE__ */ new Set();
+    for (const doc of pickPreferDraft(bodies).values())
+      for (const ref of collectRefs(doc)) candidates.add(ref);
+    const fresh = [...candidates].filter((id) => !seen.has(id));
+    if (!fresh.length) continue;
+    fresh.forEach((id) => seen.add(id));
+    const typed = await client.fetch(
+      "*[_id in $ids]{_id, _type}",
+      { ids: fresh.flatMap((id) => [id, `drafts.${id}`]) }
+    );
+    for (const [id, doc] of pickPreferDraft(typed)) {
+      const type = doc._type;
+      !type || isRoot(type) || !isTranslatable(type) || (result.push({ docId: id, docType: type }), frontier.push(id));
+    }
+  }
+  return result;
+}
+const PROJECTS_QUERY$1 = `*[_type == $type] | order(name asc){
+  _id,
+  name,
+  status,
+  "count": count(items)
+}`, CREATE_NEW = "__create_new__";
+function createAddToProjectAction(config) {
+  const sourceLanguage = config.sourceLanguage;
+  return (props) => {
+    const { id, draft, published, onComplete } = props, client = sanity.useClient({ apiVersion: constants.API_VERSION }), schema = sanity.useSchema(), toast = ui.useToast(), { selectedPerspectiveName } = sanity.usePerspective(), sourceIsPublished = selectedPerspectiveName === "published" || !draft, [open, setOpen] = react.useState(!1), [projects, setProjects] = react.useState(null), [selection, setSelection] = react.useState(CREATE_NEW), [newName, setNewName] = react.useState(""), [busy, setBusy] = react.useState(!1), [includeLinked, setIncludeLinked] = react.useState(!0), { templates, loaded, requestRefresh } = useTemplates(), [workflow2, setWorkflow] = useWorkflowSelection(open, templates, loaded), publishedId2 = id.replace(/^drafts\./, ""), doc = draft ?? published, docTitle = doc && resolveDocumentTitle(schema, doc) || UNTITLED;
+    react.useEffect(() => {
+      if (!open) return;
+      requestRefresh();
+      let cancelled = !1;
+      return setProjects(null), client.fetch(PROJECTS_QUERY$1, { type: constants.TRANSLATION_PROJECT_TYPE }).then((res) => {
+        cancelled || (setProjects(res), setSelection(res.length > 0 ? res[0]._id : CREATE_NEW));
+      }).catch((err) => {
+        cancelled || toast.push({ status: "error", title: "Failed to load projects", description: String(err) });
+      }), () => {
+        cancelled = !0;
+      };
+    }, [open, client, toast, requestRefresh]);
+    const close = react.useCallback(() => {
+      setOpen(!1), setNewName(""), onComplete();
+    }, [onComplete]), handleConfirm = react.useCallback(async () => {
+      setBusy(!0);
+      try {
+        const makeItem = (docId, docType) => ({
+          _type: "smartcat.projectItem",
+          _key: uuid.uuid(),
+          docId,
+          docType,
+          sourceIsPublished
+        }), collected = /* @__PURE__ */ new Map([[publishedId2, doc?._type]]);
+        if (includeLinked) {
+          const linked = await gatherLinkedDocuments({ client, rootId: publishedId2, isRoot: (type) => config.rootTypes.includes(type), isTranslatable: (type) => locjson.getTranslatableFields(schema.get(type), { exclude: [config.documentI18nLanguageField] }).length > 0 });
+          for (const { docId, docType } of linked) collected.has(docId) || collected.set(docId, docType);
+        }
+        if (selection === CREATE_NEW) {
+          const name = newName.trim() || `Translation project ${(/* @__PURE__ */ new Date()).toISOString().slice(0, 10)}`, items = [...collected].map(([docId, docType]) => makeItem(docId, docType));
+          await client.create({
+            _type: constants.TRANSLATION_PROJECT_TYPE,
+            name,
+            status: "draft",
+            sourceLanguage,
+            workflow: workflow2,
+            items
+          }), toast.push({
+            status: "success",
+            title: `Created \u201C${name}\u201D with ${items.length} document${items.length === 1 ? "" : "s"}`
+          });
+        } else {
+          const existing = await client.fetch(
+            `*[_id == $pid][0].items[]{"id": ${progress.ITEM_ID}}`,
+            { pid: selection }
+          ), existingIds = new Set((existing ?? []).map((e) => e.id)), newItems = [...collected].filter(([docId]) => !existingIds.has(docId)).map(([docId, docType]) => makeItem(docId, docType)), projName = projects?.find((p) => p._id === selection)?.name ?? "project";
+          if (newItems.length === 0)
+            toast.push({ status: "info", title: `Already in \u201C${projName}\u201D` });
+          else {
+            await client.patch(selection).setIfMissing({ items: [] }).insert("after", "items[-1]", newItems).commit();
+            const skipped = collected.size - newItems.length;
+            toast.push({
+              status: "success",
+              title: `Added ${newItems.length} document${newItems.length === 1 ? "" : "s"} to \u201C${projName}\u201D`,
+              description: skipped > 0 ? `${skipped} already in the project` : void 0
+            });
+          }
+        }
+        close();
+      } catch (err) {
+        toast.push({ status: "error", title: "Failed to add to project", description: String(err) });
+      } finally {
+        setBusy(!1);
+      }
+    }, [selection, newName, workflow2, publishedId2, doc, includeLinked, sourceIsPublished, schema, client, projects, close]), content = react.useMemo(() => projects === null ? /* @__PURE__ */ jsxRuntime.jsx(ui.Flex, { align: "center", justify: "center", padding: 4, children: /* @__PURE__ */ jsxRuntime.jsx(ui.Spinner, { muted: !0 }) }) : /* @__PURE__ */ jsxRuntime.jsxs(ui.Stack, { space: 4, children: [
+      /* @__PURE__ */ jsxRuntime.jsxs(ui.Stack, { space: 3, children: [
+        /* @__PURE__ */ jsxRuntime.jsx(ui.Label, { size: 1, children: "Project" }),
+        /* @__PURE__ */ jsxRuntime.jsxs(
+          ui.Select,
+          {
+            value: selection,
+            onChange: (e) => setSelection(e.currentTarget.value),
+            disabled: busy,
+            children: [
+              projects.map((p) => /* @__PURE__ */ jsxRuntime.jsxs("option", { value: p._id, children: [
+                p.name,
+                " (",
+                p.count,
+                " item",
+                p.count === 1 ? "" : "s",
+                ")"
+              ] }, p._id)),
+              /* @__PURE__ */ jsxRuntime.jsx("option", { value: CREATE_NEW, children: "\u2795 Create new project\u2026" })
+            ]
+          }
+        )
+      ] }),
+      selection === CREATE_NEW && /* @__PURE__ */ jsxRuntime.jsxs(jsxRuntime.Fragment, { children: [
+        /* @__PURE__ */ jsxRuntime.jsxs(ui.Stack, { space: 3, children: [
+          /* @__PURE__ */ jsxRuntime.jsx(ui.Label, { size: 1, children: "New project name" }),
+          /* @__PURE__ */ jsxRuntime.jsx(
+            ui.TextInput,
+            {
+              value: newName,
+              placeholder: "e.g. Spring campaign",
+              onChange: (e) => setNewName(e.currentTarget.value),
+              disabled: busy
+            }
+          )
+        ] }),
+        /* @__PURE__ */ jsxRuntime.jsxs(ui.Stack, { space: 3, children: [
+          /* @__PURE__ */ jsxRuntime.jsx(ui.Label, { size: 1, children: "Workflow" }),
+          /* @__PURE__ */ jsxRuntime.jsx(
+            WorkflowSelect,
+            {
+              value: workflow2,
+              onChange: setWorkflow,
+              templates,
+              disabled: busy
+            }
+          )
+        ] })
+      ] }),
+      /* @__PURE__ */ jsxRuntime.jsx(ui.Card, { padding: 3, radius: 2, tone: "transparent", border: !0, children: /* @__PURE__ */ jsxRuntime.jsxs(ui.Stack, { space: 4, children: [
+        /* @__PURE__ */ jsxRuntime.jsxs(ui.Text, { size: 1, muted: !0, children: [
+          "Adding",
+          " ",
+          /* @__PURE__ */ jsxRuntime.jsx(
+            ui.Badge,
+            {
+              tone: sourceIsPublished ? "positive" : "caution",
+              fontSize: 1,
+              paddingX: 2,
+              style: { verticalAlign: "middle" },
+              children: sourceIsPublished ? "Published" : "Draft"
+            }
+          ),
+          " ",
+          "version of ",
+          /* @__PURE__ */ jsxRuntime.jsx("strong", { children: docTitle }),
+          " to the selected project."
+        ] }),
+        /* @__PURE__ */ jsxRuntime.jsxs(ui.Flex, { align: "flex-start", gap: 3, children: [
+          /* @__PURE__ */ jsxRuntime.jsx(
+            ui.Switch,
+            {
+              checked: includeLinked,
+              onChange: (e) => setIncludeLinked(e.currentTarget.checked),
+              disabled: busy
+            }
+          ),
+          /* @__PURE__ */ jsxRuntime.jsxs(ui.Stack, { space: 2, children: [
+            /* @__PURE__ */ jsxRuntime.jsx(ui.Text, { size: 1, weight: "medium", children: "Include linked content" }),
+            /* @__PURE__ */ jsxRuntime.jsx(ui.Text, { size: 1, muted: !0, children: "Also add documents this one references, recursively \u2014 skipping any already in the project." })
+          ] })
+        ] })
+      ] }) }),
+      /* @__PURE__ */ jsxRuntime.jsxs(ui.Flex, { justify: "flex-end", gap: 2, children: [
+        /* @__PURE__ */ jsxRuntime.jsx(ui.Button, { mode: "bleed", text: "Cancel", onClick: close, disabled: busy }),
+        /* @__PURE__ */ jsxRuntime.jsx(
+          ui.Button,
+          {
+            tone: "primary",
+            text: "Add to project",
+            icon: icons.AddIcon,
+            onClick: handleConfirm,
+            loading: busy,
+            disabled: selection === CREATE_NEW && !workflow2
+          }
+        )
+      ] })
+    ] }), [projects, selection, newName, workflow2, templates, busy, includeLinked, docTitle, sourceIsPublished, close, handleConfirm]);
+    return {
+      label: "Add to translation project",
+      icon: icons.TranslateIcon,
+      onHandle: () => setOpen(!0),
+      dialog: open && {
+        type: "dialog",
+        header: "Add to translation project",
+        onClose: close,
+        content
+      }
+    };
+  };
+}
+const PROJECTS_QUERY = `*[_type == "${constants.TRANSLATION_PROJECT_TYPE}"] | order(_createdAt desc){
+  _id,
+  name,
+  status,
+  _createdAt,
+  _updatedAt,
+  "count": count(items)
+}`, PROJECT_DETAIL_QUERY = `*[_id == $id][0]{
+  _id,
+  name,
+  status,
+  sourceLanguage,
+  targetLanguages,
+  smartcatProjectId,
+  smartcatProjectUrl,
+  lastError,
+  functionLog,
+  importRemaining,
+  progressSyncedAt,
+  items[]{
+    _key,
+    "docId": ${progress.ITEM_ID},
+    sourceIsPublished,
+    "doc": ${progress.itemDocDeref("{_id, _type}")},
+    "translations": *[_type == "translation.metadata" && references(${progress.ITEM_ID_FROM_SUBQUERY})][0]
+      .translations[]{language, "id": value._ref}
+  },
+  progress[]{
+    _key,
+    sourceDocId,
+    title,
+    targets[]{_key, language, smartcatDocumentId, stages, complete, imported, syncedAt}
+  }
+}`, TONES = {
+  draft: "default",
+  queued: "caution",
+  sent: "primary",
+  translating: "primary",
+  importing: "caution",
+  downloaded: "primary",
+  completed: "positive",
+  error: "critical"
+}, LABELS = Object.fromEntries(
+  STATUS_OPTIONS.map((o) => [o.value, o.title])
+);
+function statusLabel(status) {
+  return LABELS[status] ?? status;
+}
+function StatusBadge({ status }) {
+  return /* @__PURE__ */ jsxRuntime.jsx(ui.Badge, { tone: TONES[status] ?? "default", fontSize: 0, padding: 2, radius: 2, children: statusLabel(status) });
+}
+function ProjectRow({ project: p, onOpen }) {
+  const createdAgo = sanity.useRelativeTime(p._createdAt, { useTemporalPhrase: !0 });
+  return /* @__PURE__ */ jsxRuntime.jsx(
+    ui.Card,
+    {
+      padding: 3,
+      radius: 2,
+      shadow: 1,
+      as: "button",
+      onClick: () => onOpen(p._id),
+      style: { cursor: "pointer", textAlign: "left", width: "100%" },
+      children: /* @__PURE__ */ jsxRuntime.jsxs(ui.Flex, { align: "center", gap: 3, children: [
+        /* @__PURE__ */ jsxRuntime.jsx(ui.Box, { style: { width: 110 }, children: /* @__PURE__ */ jsxRuntime.jsx(ui.Text, { size: 1, muted: !0, title: new Date(p._createdAt).toLocaleString(), children: createdAgo }) }),
+        /* @__PURE__ */ jsxRuntime.jsx(ui.Box, { style: { width: 100 }, children: /* @__PURE__ */ jsxRuntime.jsx(StatusBadge, { status: p.status }) }),
+        /* @__PURE__ */ jsxRuntime.jsx(ui.Box, { children: /* @__PURE__ */ jsxRuntime.jsx(icons.TranslateIcon, {}) }),
+        /* @__PURE__ */ jsxRuntime.jsx(ui.Box, { flex: 1, children: /* @__PURE__ */ jsxRuntime.jsx(ui.Text, { weight: "semibold", children: p.name }) }),
+        /* @__PURE__ */ jsxRuntime.jsxs(ui.Text, { size: 1, muted: !0, children: [
+          p.count,
+          " item",
+          p.count === 1 ? "" : "s"
+        ] })
+      ] })
+    }
+  );
+}
+function ProjectsView({ sourceLanguage, onOpenProject }) {
+  const client = sanity.useClient({ apiVersion: constants.API_VERSION }), toast = ui.useToast(), [projects, setProjects] = react.useState(null), [creating, setCreating] = react.useState(!1), [newName, setNewName] = react.useState(""), [busy, setBusy] = react.useState(!1), { templates, loaded, requestRefresh } = useTemplates(), [workflow2, setWorkflow] = useWorkflowSelection(creating, templates, loaded);
+  react.useEffect(() => {
+    creating && requestRefresh();
+  }, [creating, requestRefresh]);
+  const load = react.useCallback(() => client.fetch(PROJECTS_QUERY).then(setProjects).catch((err) => toast.push({ status: "error", title: "Failed to load projects", description: String(err) })), [client, toast]);
+  react.useEffect(() => {
+    load();
+    const sub = client.listen(PROJECTS_QUERY, {}, { visibility: "query" }).subscribe({ next: () => load(), error: () => {
+    } });
+    return () => sub.unsubscribe();
+  }, [client, load]);
+  const handleCreate = react.useCallback(async () => {
+    const name = newName.trim();
+    if (name) {
+      setBusy(!0);
+      try {
+        const created = await client.create({
+          _type: constants.TRANSLATION_PROJECT_TYPE,
+          name,
+          status: "draft",
+          sourceLanguage,
+          workflow: workflow2,
+          items: []
+        });
+        toast.push({ status: "success", title: `Created \u201C${name}\u201D` }), setCreating(!1), setNewName(""), onOpenProject(created._id);
+      } catch (err) {
+        toast.push({ status: "error", title: "Failed to create project", description: String(err) });
+      } finally {
+        setBusy(!1);
+      }
+    }
+  }, [newName, workflow2, client, sourceLanguage, toast, onOpenProject]);
+  return /* @__PURE__ */ jsxRuntime.jsxs(ui.Stack, { space: 4, children: [
+    /* @__PURE__ */ jsxRuntime.jsxs(ui.Flex, { align: "center", justify: "space-between", children: [
+      /* @__PURE__ */ jsxRuntime.jsx(ui.Heading, { size: 2, children: "Translation projects" }),
+      /* @__PURE__ */ jsxRuntime.jsx(ui.Button, { icon: icons.AddIcon, text: "New project", tone: "primary", onClick: () => setCreating(!0) })
+    ] }),
+    projects === null ? /* @__PURE__ */ jsxRuntime.jsx(ui.Flex, { align: "center", justify: "center", padding: 5, children: /* @__PURE__ */ jsxRuntime.jsx(ui.Spinner, { muted: !0 }) }) : projects.length === 0 ? /* @__PURE__ */ jsxRuntime.jsx(ui.Card, { padding: 5, radius: 2, tone: "transparent", border: !0, children: /* @__PURE__ */ jsxRuntime.jsxs(ui.Stack, { space: 3, children: [
+      /* @__PURE__ */ jsxRuntime.jsx(ui.Text, { muted: !0, align: "center", children: "No translation projects yet." }),
+      /* @__PURE__ */ jsxRuntime.jsx(ui.Flex, { justify: "center", children: /* @__PURE__ */ jsxRuntime.jsx(ui.Button, { icon: icons.AddIcon, text: "Create your first project", onClick: () => setCreating(!0) }) })
+    ] }) }) : /* @__PURE__ */ jsxRuntime.jsx(ui.Stack, { space: 2, children: projects.map((p) => /* @__PURE__ */ jsxRuntime.jsx(ProjectRow, { project: p, onOpen: onOpenProject }, p._id)) }),
+    creating && /* @__PURE__ */ jsxRuntime.jsx(
+      ui.Dialog,
+      {
+        id: "create-project",
+        header: "New translation project",
+        onClose: () => {
+          setCreating(!1), setNewName("");
+        },
+        width: 1,
+        children: /* @__PURE__ */ jsxRuntime.jsx(ui.Box, { padding: 4, children: /* @__PURE__ */ jsxRuntime.jsxs(ui.Stack, { space: 4, children: [
+          /* @__PURE__ */ jsxRuntime.jsxs(ui.Stack, { space: 3, children: [
+            /* @__PURE__ */ jsxRuntime.jsx(ui.Label, { size: 1, children: "Project name" }),
+            /* @__PURE__ */ jsxRuntime.jsx(
+              ui.TextInput,
+              {
+                value: newName,
+                placeholder: "e.g. Spring campaign",
+                autoFocus: !0,
+                onChange: (e) => setNewName(e.currentTarget.value),
+                onKeyDown: (e) => {
+                  e.key === "Enter" && handleCreate();
+                },
+                disabled: busy
+              }
+            )
+          ] }),
+          /* @__PURE__ */ jsxRuntime.jsxs(ui.Stack, { space: 3, children: [
+            /* @__PURE__ */ jsxRuntime.jsx(ui.Label, { size: 1, children: "Workflow" }),
+            /* @__PURE__ */ jsxRuntime.jsx(
+              WorkflowSelect,
+              {
+                value: workflow2,
+                onChange: setWorkflow,
+                templates,
+                disabled: busy
+              }
+            )
+          ] }),
+          /* @__PURE__ */ jsxRuntime.jsxs(ui.Flex, { justify: "flex-end", gap: 2, children: [
+            /* @__PURE__ */ jsxRuntime.jsx(
+              ui.Button,
+              {
+                mode: "bleed",
+                text: "Cancel",
+                onClick: () => {
+                  setCreating(!1), setNewName("");
+                },
+                disabled: busy
+              }
+            ),
+            /* @__PURE__ */ jsxRuntime.jsx(
+              ui.Button,
+              {
+                tone: "primary",
+                text: "Create",
+                onClick: handleCreate,
+                loading: busy,
+                disabled: !newName.trim() || !workflow2
+              }
+            )
+          ] })
+        ] }) })
+      }
+    )
+  ] });
+}
+const METADATA_TYPE = "translation.metadata", REFERENCE_VALUE_TYPE = "internationalizedArrayReferenceValue";
+function parseHtml(html) {
+  return new DOMParser().parseFromString(html, "text/html");
+}
+const VALUE_PREVIEW_CAP = 2e3;
+function valuePreview(value) {
+  if (value == null) return;
+  const text = typeof value == "string" ? value : JSON.stringify(value, null, 2);
+  if (text)
+    return text.length > VALUE_PREVIEW_CAP ? `${text.slice(0, VALUE_PREVIEW_CAP)}\u2026` : text;
+}
+function errorMessage(err) {
+  return err instanceof Error ? err.message : String(err);
+}
+function memberLocalesWithContent(members, languageKey) {
+  if (!Array.isArray(members)) return [];
+  const locales = [];
+  for (const member of members) {
+    if (!member || typeof member != "object") continue;
+    const locale = member[languageKey], value = member.value, hasContent = typeof value == "string" ? value.trim().length > 0 : Array.isArray(value) ? value.length > 0 : value != null;
+    typeof locale == "string" && hasContent && locales.push(locale);
+  }
+  return locales;
+}
+function schemaFieldNames(schema, type) {
+  return (schema.get(type)?.fields ?? []).map((f) => f?.name).filter((n) => typeof n == "string" && !n.startsWith("_"));
+}
+function blockContentTypeFor(schema, type, fieldPath) {
+  const fieldType = schema.get(type)?.fields?.find((f) => f.name === fieldPath)?.type;
+  return locjson.isInternationalizedArrayType(fieldType) ? locjson.innerValueType(fieldType) : fieldType;
+}
+const ITEMS_QUERY = `*[_id == $id][0]{
+  sourceLanguage,
+  items[]{
+    "docId": ${progress.ITEM_ID},
+    "docType": docType,
+    "doc": ${progress.itemDocDerefRespectingDraft()}
+  }
+}`;
+async function prepareExport({
+  client,
+  schema,
+  projectId,
+  targetLanguages,
+  sourceLanguage,
+  languages,
+  translatableTypes,
+  exclude,
+  fieldLanguageKey,
+  deletions = [],
+  onLog
+}) {
+  const log = onLog ?? (() => {
+  }), project = await client.fetch(ITEMS_QUERY, { id: projectId }), source = project?.sourceLanguage || sourceLanguage, smartcatLanguages = progress.buildLanguageMappings(languages, [source, ...targetLanguages]), dups = progress.findDuplicateSmartcatLanguages(
+    smartcatLanguages.filter((m) => targetLanguages.includes(m.sanityId))
+  );
+  if (dups.length > 0) {
+    const detail = dups.map((d) => `${d.sanityIds.join(", ")} \u2192 ${d.smartcatLanguage}`).join("; ");
+    throw new Error(`Multiple target languages map to the same Smartcat language: ${detail}`);
+  }
+  const deletedDocIds = new Set(deletions.map((d) => d.sourceDocId)), items = (project?.items ?? []).filter(
+    (item) => !(item.docId && deletedDocIds.has(item.docId))
+  ), unresolved = items.filter((item) => !item.doc), docs = items.map((item) => item.doc).filter((d) => !!d), fieldsByType = /* @__PURE__ */ new Map(), fieldsFor = (type) => {
+    let fields = fieldsByType.get(type);
+    return fields || (fields = locjson.getTranslatableFields(schema.get(type), { exclude }), fieldsByType.set(type, fields)), fields;
+  }, configuredLanguages = languages.map((l) => l.id).join(", ") || "(none)", configuredTypes = translatableTypes === void 0 ? "all types" : translatableTypes.join(", ") || "(none)";
+  log({ level: "info", message: `Config \u2014 source language: ${sourceLanguage}` }), log({ level: "info", indent: !0, message: `languages: ${configuredLanguages}` }), log({ level: "info", indent: !0, message: `translatable types: ${configuredTypes}` }), log({ level: "info", message: `Project \u2014 source: ${source} \u2192 targets: ${targetLanguages.join(", ") || "(no targets)"}` }), log({ level: "info", message: `Export \u2014 ${docs.length} document(s)` });
+  for (const item of unresolved)
+    log({
+      level: "error",
+      message: `${item.docId ?? "unknown document"} (${item.docType ?? "unknown type"}): no document found \u2014 it may be unpublished or deleted; skipped`
+    });
+  const outbox = [];
+  for (const rawDoc of docs) {
+    const isDraft = rawDoc._id.startsWith("drafts."), doc = isDraft ? { ...rawDoc, _id: publishedId(rawDoc._id) } : rawDoc, name = resolveDocumentTitle(schema, doc);
+    log({ level: "info", message: `${name || doc._id}  \xB7  ${doc._type}${isDraft ? " (draft)" : ""}` });
+    try {
+      const fields = fieldsFor(doc._type), skippedBlockTypes = /* @__PURE__ */ new Map(), locjson$1 = locjson.serializeToLocjson(doc, fields, {
+        sourceLanguage: source,
+        fieldLanguageKey,
+        onSkippedField: ({ fieldPath, types }) => skippedBlockTypes.set(fieldPath, types)
+      }), unitByKey = new Map(locjson$1.units.map((u) => [u.key, u]));
+      for (const field of fields) {
+        const unit = unitByKey.get(field.path), skippedTypes = skippedBlockTypes.get(field.path);
+        if (unit)
+          log({ level: "success", indent: !0, message: `${field.title || field.path}: serialized (${field.kind})`, value: unit.source.join("") });
+        else if (skippedTypes)
+          log({
+            level: "error",
+            indent: !0,
+            message: `${field.title || field.path}: not translated \u2014 contains block type(s) that can't be translated: ${skippedTypes.join(", ")}. The whole field was left untranslated to avoid losing this content.`
+          });
+        else {
+          const otherLocales = field.localization === "field" ? memberLocalesWithContent(locjson.getAtPath(doc, field.path), fieldLanguageKey).filter((l) => l !== source) : [], reason = otherLocales.length ? `no '${source}' content (I see only: ${otherLocales.join(", ")})` : "no source content";
+          log({ level: "skip", indent: !0, message: `${field.title || field.path}: skipped \u2014 ${reason}` });
+        }
+      }
+      const selected = new Set(fields.map((f) => f.path)), excluded = new Set(exclude ?? []);
+      for (const fieldName of schemaFieldNames(schema, doc._type))
+        selected.has(fieldName) || excluded.has(fieldName) || log({ level: "skip", indent: !0, message: `${fieldName}: skipped \u2014 not translatable` });
+      if (locjson$1.units.length === 0) {
+        skippedBlockTypes.size > 0 ? log({
+          level: "error",
+          indent: !0,
+          message: "not sent \u2014 its only translatable content is in field(s) with block type(s) that can\u2019t be translated (see above)"
+        }) : log({ level: "skip", indent: !0, message: "no translatable content \u2014 not sent" });
+        continue;
+      }
+      outbox.push({
+        _key: uuid.uuid(),
+        sourceDocId: doc._id,
+        title: name,
+        filename: locjson.buildLocjsonFilename(doc._type, doc._id, name, { draft: isDraft }),
+        locjson: JSON.stringify(locjson$1)
+      });
+    } catch (err) {
+      log({ level: "error", indent: !0, message: `failed to serialize: ${errorMessage(err)}` });
+    }
+  }
+  return log({ level: "success", message: `Queued ${outbox.length} file(s)${deletions.length ? ` \xB7 ${deletions.length} for deletion` : ""}` }), await client.patch(projectId).set({
+    outbox,
+    pendingDeletions: deletions,
+    targetLanguages,
+    sourceLanguage: source,
+    smartcatLanguages,
+    status: "queued",
+    lastError: null
+  }).commit(), { prepared: outbox.length, deleting: deletions.length };
+}
+const INBOX_QUERY = `*[_id == $id][0]{
+  sourceLanguage,
+  inbox[]{ sourceDocId, targetLanguage, smartcatDocumentId, locjson },
+  progress[]{_key, sourceDocId, title, targets[]{_key, language, smartcatDocumentId, stages, complete, imported, syncedAt}}
+}`;
+async function applyImportedTranslations({
+  client,
+  schema,
+  projectId,
+  documentLanguageField,
+  fieldLanguageKey,
+  onLog
+}) {
+  const log = onLog ?? (() => {
+  }), project = await client.fetch(INBOX_QUERY, { id: projectId }), sourceLanguage = constants.requireSourceLanguage(project?.sourceLanguage), inbox = project?.inbox ?? [], titleByDoc = /* @__PURE__ */ new Map();
+  for (const p of project?.progress ?? [])
+    p.sourceDocId && p.title && titleByDoc.set(p.sourceDocId, p.title);
+  let imported = 0;
+  const importedKeys = /* @__PURE__ */ new Set(), modeByType = /* @__PURE__ */ new Map(), modeFor = (type) => {
+    let mode = modeByType.get(type);
+    return mode || (mode = locjson.localizationMode(schema.get(type)), modeByType.set(type, mode)), mode;
+  }, descriptorsByType = /* @__PURE__ */ new Map(), descriptorsFor = (type) => {
+    let d = descriptorsByType.get(type);
+    return d || (d = locjson.getTranslatableFields(schema.get(type), { exclude: [documentLanguageField] }), descriptorsByType.set(type, d)), d;
+  };
+  log({ level: "info", message: `Import \u2014 ${inbox.length} translated file(s)` });
+  for (const item of inbox) {
+    let parsed;
+    try {
+      parsed = JSON.parse(item.locjson);
+    } catch {
+      log({ level: "error", message: `${item.sourceDocId || "unknown"} \u2192 ${item.targetLanguage}: invalid LocJSON, skipped` });
+      continue;
+    }
+    const type = parsed.properties?.["x-sanity"]?.documentType, result = locjson.deserializeFromLocjson(parsed, {
+      parseHtml,
+      getBlockContentType: (fieldPath) => type ? blockContentTypeFor(schema, type, fieldPath) : void 0
+    });
+    if (!result.documentId || !result.documentType) {
+      log({ level: "error", message: `${item.sourceDocId || "unknown"} \u2192 ${item.targetLanguage}: missing document id/type, skipped` });
+      continue;
+    }
+    const mode = modeFor(result.documentType), title = titleByDoc.get(result.documentId), label = title ? `${title} (Sanity ID: ${result.documentId})` : result.documentId;
+    log({ level: "info", message: `${label} \u2192 ${item.targetLanguage}  \xB7  ${result.documentType} (${mode} mode)` });
+    let ok = !1;
+    try {
+      ok = mode === "field" ? await applyFieldLevelTranslations(client, {
+        schema,
+        type: result.documentType,
+        docId: result.documentId,
+        locale: item.targetLanguage,
+        sourceLanguage: result.sourceLanguage || sourceLanguage,
+        descriptors: descriptorsFor(result.documentType),
+        translations: result.fields,
+        sources: result.sources,
+        languageKey: fieldLanguageKey
+      }, log) : await upsertVariant(client, {
+        sourceId: result.documentId,
+        type: result.documentType,
+        sourceLanguage,
+        locale: item.targetLanguage,
+        fields: result.fields,
+        sources: result.sources,
+        languageField: documentLanguageField
+      }, log);
+    } catch (err) {
+      log({ level: "error", indent: !0, message: `failed: ${errorMessage(err)}` });
+    }
+    ok && (imported++, importedKeys.add(`${result.documentId}__${item.targetLanguage}`));
+  }
+  const progress$1 = (project?.progress ?? []).map((doc) => ({
+    ...doc,
+    targets: doc.targets.map(
+      (target) => importedKeys.has(`${doc.sourceDocId}__${target.language}`) ? { ...target, imported: !0 } : target
+    )
+  })), status = progress.summarizeCompletion(progress$1).allDone ? "completed" : "translating";
+  return await client.patch(projectId).set({ progress: progress$1, status, lastImportAt: (/* @__PURE__ */ new Date()).toISOString() }).unset(["inbox"]).commit(), { imported, status };
+}
+function isPotentialJson(value) {
+  return typeof value == "string" && value.trimStart().startsWith("{");
+}
+function malformedJsonError(source, translated) {
+  if (!isPotentialJson(source)) return null;
+  try {
+    JSON.parse(source);
+  } catch {
+    return null;
+  }
+  if (typeof translated != "string") return "translated value is not a string";
+  try {
+    return JSON.parse(translated), null;
+  } catch (err) {
+    return err instanceof Error ? err.message : String(err);
+  }
+}
+const DRAFTS_PREFIX = "drafts.";
+function publishedId(id) {
+  return id.startsWith(DRAFTS_PREFIX) ? id.slice(DRAFTS_PREFIX.length) : id;
+}
+function draftId(id) {
+  return id.startsWith(DRAFTS_PREFIX) ? id : DRAFTS_PREFIX + id;
+}
+async function loadEditableDraft(client, id) {
+  const dId = draftId(id), draft = await client.fetch("*[_id == $id][0]", { id: dId });
+  if (draft) return { draftId: dId, base: draft, exists: !0 };
+  const published = await client.fetch("*[_id == $id][0]", { id: publishedId(id) });
+  return published ? { draftId: dId, base: published, exists: !1 } : null;
+}
+async function commitToDraft(client, editable, attrs) {
+  editable.exists || await client.createIfNotExists({ ...stripSystemFields(editable.base), _id: editable.draftId, _type: editable.base._type }), await client.patch(editable.draftId).set(attrs).commit();
+}
+async function applyFieldLevelTranslations(client, { docId, locale, sourceLanguage, descriptors, translations, sources, languageKey }, log) {
+  const editable = await loadEditableDraft(client, docId);
+  if (!editable)
+    return log({ level: "error", indent: !0, message: `source document not found: ${docId}` }), !1;
+  const doc = editable.base, byKey = languageKey === "_key", patchSet = {};
+  for (const field of descriptors) {
+    if (field.localization !== "field") continue;
+    const existing = Array.isArray(locjson.getAtPath(doc, field.path)) ? locjson.getAtPath(doc, field.path) : [], template = (existing.find((m) => m?.[languageKey] === sourceLanguage) ?? existing.find((m) => m?.value !== void 0))?.value;
+    let target = structuredClone(template), changed = !1;
+    for (const leaf of locjson.enumerateLeaves(field, template)) {
+      let value = translations[leaf.fullKey];
+      if (value === void 0) continue;
+      leaf.kind === "portableText" && Array.isArray(value) && (value = value.map((b) => keyBlock(b)));
+      const jsonError = malformedJsonError(sources[leaf.fullKey], value);
+      if (jsonError) {
+        log({ level: "error", indent: !0, message: `${leaf.fullKey}: '${locale}' translation is not valid JSON \u2014 skipped`, value: valuePreview(value), error: jsonError });
+        continue;
+      }
+      target = leaf.valuePath ? locjson.setAtPath(target, leaf.valuePath, value) : value, changed = !0;
+    }
+    if (!changed) continue;
+    const idx = existing.findIndex((m) => m?.[languageKey] === locale);
+    if (idx >= 0 && sameValue(existing[idx]?.value, target)) {
+      log({ level: "skip", indent: !0, message: `${field.path}: '${locale}' unchanged \u2014 skipped` });
+      continue;
+    }
+    if (idx >= 0)
+      patchSet[field.path] = existing.map((m, i) => i === idx ? { ...m, value: target } : m), log({ level: "update", indent: !0, message: `${field.path}: updating '${locale}' field variant`, before: valuePreview(existing[idx]?.value), value: valuePreview(target) });
+    else {
+      const _type = existing.find((m) => m?._type)?._type;
+      patchSet[field.path] = [
+        ...existing,
+        byKey ? { _key: locale, _type, value: target } : { _key: uuid.uuid(), _type, [languageKey]: locale, value: target }
+      ], log({ level: "info", indent: !0, message: `${field.path}: creating '${locale}' field variant`, value: valuePreview(target) });
+    }
+  }
+  return Object.keys(patchSet).length === 0 ? (log({ level: "success", indent: !0, message: `${docId}: no field changes` }), !0) : (await commitToDraft(client, editable, patchSet), log({ level: "success", indent: !0, message: `saved ${Object.keys(patchSet).length} field(s) on draft of ${docId}` }), !0);
+}
+async function upsertVariant(client, { sourceId, type, sourceLanguage, locale, fields, sources, languageField }, log) {
+  const source = await client.fetch("*[_id == $id][0]", { id: sourceId });
+  if (!source)
+    return log({ level: "error", indent: !0, message: `source document not found: ${sourceId}` }), !1;
+  const translatedFields = keyPortableText(fields), metadata = await client.fetch(
+    "*[_type == $metaType && references($sourceId)][0]{_id, translations}",
+    { metaType: METADATA_TYPE, sourceId }
+  ), existingVariantId = metadata?.translations?.find((t) => t.language === locale)?.value?._ref;
+  let variantId;
+  if (existingVariantId) {
+    const editable = await loadEditableDraft(client, existingVariantId);
+    if (!editable)
+      return log({ level: "error", indent: !0, message: `'${locale}' document variant not found: ${existingVariantId}` }), !1;
+    const variant = editable.base, changed = {};
+    for (const [path, value] of Object.entries(translatedFields)) {
+      if (sameValue(variant[path], value)) {
+        log({ level: "skip", indent: !0, message: `${path}: unchanged \u2014 skipped` });
+        continue;
+      }
+      const jsonError = malformedJsonError(sources[path], value);
+      if (jsonError) {
+        log({
+          level: "error",
+          indent: !0,
+          message: `${path}: translation is not valid JSON \u2014 skipped`,
+          before: valuePreview(variant[path]),
+          value: valuePreview(value),
+          error: jsonError
+        });
+        continue;
+      }
+      changed[path] = value, log({
+        level: "update",
+        indent: !0,
+        message: `${path}: updating`,
+        before: valuePreview(variant[path]),
+        value: valuePreview(value)
+      });
+    }
+    Object.keys(changed).length > 0 ? (await commitToDraft(client, editable, changed), log({ level: "success", indent: !0, message: `updated ${Object.keys(changed).length} field(s) on '${locale}' document variant draft` })) : log({ level: "success", indent: !0, message: `'${locale}' document variant already up to date` }), variantId = publishedId(existingVariantId);
+  } else {
+    const writableFields = {};
+    for (const [path, value] of Object.entries(translatedFields)) {
+      const jsonError = malformedJsonError(sources[path], value);
+      if (jsonError) {
+        log({
+          level: "error",
+          indent: !0,
+          message: `${path}: translation is not valid JSON \u2014 skipped`,
+          value: valuePreview(value),
+          error: jsonError
+        });
+        continue;
+      }
+      writableFields[path] = value, log({ level: "info", indent: !0, message: `${path}`, value: valuePreview(value) });
+    }
+    log({ level: "info", indent: !0, message: `creating new '${locale}' document variant draft` }), variantId = uuid.uuid(), await client.create({ ...stripSystemFields(source), _id: draftId(variantId), [languageField]: locale, ...writableFields });
+  }
+  return metadata?._id ? existingVariantId || (log({ level: "info", indent: !0, message: "linking variant into translation metadata" }), await client.patch(metadata._id).setIfMissing({ translations: [] }).insert("after", "translations[-1]", [translationEntry(locale, variantId)]).commit()) : (log({ level: "info", indent: !0, message: "creating translation metadata" }), await client.create({
+    _type: METADATA_TYPE,
+    schemaTypes: [type],
+    translations: [translationEntry(sourceLanguage, sourceId), translationEntry(locale, variantId)]
+  })), log({ level: "success", indent: !0, message: `'${locale}' document variant ready: ${variantId}` }), !0;
+}
+function translationEntry(language, ref) {
+  return {
+    _key: uuid.uuid(),
+    _type: REFERENCE_VALUE_TYPE,
+    language,
+    value: { _type: "reference", _ref: ref, _weak: !0 }
+  };
+}
+function stripSystemFields(doc) {
+  const { _id, _rev, _createdAt, _updatedAt, ...rest } = doc;
+  return rest;
+}
+function keyPortableText(fields) {
+  const out = {};
+  for (const [key, value] of Object.entries(fields))
+    Array.isArray(value) && value.some((v) => v && typeof v == "object" && "_type" in v) ? out[key] = value.map((b) => keyBlock(b)) : out[key] = value;
+  return out;
+}
+function keyBlock(block) {
+  const keyed = { _key: block._key || uuid.uuid(), ...block };
+  return Array.isArray(keyed.children) && (keyed.children = keyed.children.map((child) => ({
+    _key: child._key || uuid.uuid(),
+    ...child
+  }))), keyed;
+}
+function sameValue(a, b) {
+  return stableString(a) === stableString(b);
+}
+function stableString(value) {
+  return Array.isArray(value) ? `[${value.map(stableString).join(",")}]` : value && typeof value == "object" ? `{${Object.entries(value).filter(([k]) => k !== "_key").sort(([a], [b]) => a < b ? -1 : a > b ? 1 : 0).map(([k, v]) => `${JSON.stringify(k)}:${stableString(v)}`).join(",")}}` : JSON.stringify(value) ?? "undefined";
+}
+function languageTitle(languages, id) {
+  return languages.find((l) => l.id === id)?.title || id;
+}
+function OpenVariantInStudio({ id, type }) {
+  const { onClick, href } = router.useIntentLink({ intent: "edit", params: { id, type } });
+  return /* @__PURE__ */ jsxRuntime.jsx(
+    ui.Button,
+    {
+      as: "a",
+      href,
+      onClick,
+      mode: "bleed",
+      icon: icons.LaunchIcon,
+      title: "Open this language version in Studio",
+      fontSize: 0,
+      padding: 1
+    }
+  );
+}
+function editorUrl(projectUrl, smartcatDocumentId) {
+  if (!projectUrl || !smartcatDocumentId) return null;
+  let origin;
+  try {
+    origin = new URL(projectUrl).origin;
+  } catch {
+    return null;
+  }
+  const sep = smartcatDocumentId.lastIndexOf("_");
+  if (sep < 0) return null;
+  const fileGuid = smartcatDocumentId.slice(0, sep), langNum = smartcatDocumentId.slice(sep + 1);
+  return `${origin}/open-editor/${fileGuid}?targetLanguageId=${langNum}`;
+}
+function ProgressBar({ percent, complete }) {
+  const { color } = ui.useTheme_v2(), pct = Math.max(0, Math.min(100, percent)), fill = (complete ? color.button.default.positive : color.button.default.primary).enabled.bg;
+  return /* @__PURE__ */ jsxRuntime.jsx(ui.Card, { tone: "transparent", border: !0, radius: 3, style: { height: 10, overflow: "hidden" }, children: /* @__PURE__ */ jsxRuntime.jsx(
+    "div",
+    {
+      style: {
+        width: `${pct}%`,
+        height: "100%",
+        background: fill,
+        borderRadius: "inherit",
+        transition: "width 0.3s ease"
+      }
+    }
+  ) });
+}
+function TargetRow({
+  target,
+  languages,
+  smartcatProjectUrl,
+  variants
+}) {
+  const percent = progress.targetPercent(target.stages), href = editorUrl(smartcatProjectUrl, target.smartcatDocumentId), label = languageTitle(languages, target.language), variantId = variants?.byLanguage[target.language];
+  return /* @__PURE__ */ jsxRuntime.jsxs(ui.Stack, { space: 2, children: [
+    /* @__PURE__ */ jsxRuntime.jsxs(ui.Flex, { align: "center", gap: 3, children: [
+      /* @__PURE__ */ jsxRuntime.jsx(ui.Box, { style: { width: 150, flex: "none" }, children: /* @__PURE__ */ jsxRuntime.jsxs(ui.Flex, { align: "center", gap: 1, children: [
+        /* @__PURE__ */ jsxRuntime.jsx(ui.Text, { size: 1, weight: "medium", children: href ? /* @__PURE__ */ jsxRuntime.jsx(
+          "a",
+          {
+            href,
+            target: "_blank",
+            rel: "noopener noreferrer",
+            title: "Open document in Smartcat editor",
+            children: label
+          }
+        ) : label }),
+        variantId && variants && /* @__PURE__ */ jsxRuntime.jsx(OpenVariantInStudio, { id: variantId, type: variants.type })
+      ] }) }),
+      /* @__PURE__ */ jsxRuntime.jsx(ui.Box, { flex: 1, children: /* @__PURE__ */ jsxRuntime.jsx(ProgressBar, { percent, complete: target.complete }) }),
+      /* @__PURE__ */ jsxRuntime.jsx(ui.Box, { style: { width: 38, flex: "none" }, children: /* @__PURE__ */ jsxRuntime.jsxs(ui.Text, { size: 1, muted: !0, align: "right", children: [
+        percent,
+        "%"
+      ] }) }),
+      /* @__PURE__ */ jsxRuntime.jsx(ui.Box, { style: { width: 72, flex: "none" }, children: target.imported ? /* @__PURE__ */ jsxRuntime.jsx(ui.Badge, { tone: "positive", fontSize: 0, padding: 2, children: "imported" }) : target.complete ? /* @__PURE__ */ jsxRuntime.jsx(ui.Badge, { tone: "primary", fontSize: 0, padding: 2, children: "ready" }) : null })
+    ] }),
+    target.stages.length > 0 && /* @__PURE__ */ jsxRuntime.jsx(ui.Inline, { space: 3, style: { paddingLeft: 162 }, children: target.stages.map((stage) => /* @__PURE__ */ jsxRuntime.jsxs(ui.Text, { size: 0, muted: !0, children: [
+      stage.name,
+      ": ",
+      stage.percent,
+      "%"
+    ] }, stage.name)) })
+  ] });
+}
+function ItemProgress({
+  doc,
+  languages,
+  smartcatProjectUrl,
+  variants
+}) {
+  return !doc.targets || doc.targets.length === 0 ? null : /* @__PURE__ */ jsxRuntime.jsx(ui.Stack, { space: 3, paddingTop: 1, children: doc.targets.map((target) => /* @__PURE__ */ jsxRuntime.jsx(
+    TargetRow,
+    {
+      target,
+      languages,
+      smartcatProjectUrl,
+      variants
+    },
+    target._key
+  )) });
+}
+function logsToText(logs) {
+  return logs.map((l) => {
+    const prefix = l.indent ? "  " : "", detail = [
+      l.before !== void 0 ? `before: ${l.before}` : null,
+      l.value !== void 0 ? `${l.before !== void 0 ? "after" : "value"}: ${l.value}` : null,
+      l.error !== void 0 ? `error: ${l.error}` : null
+    ].filter(Boolean).map((d) => `    ${d}`).join(`
+`);
+    return `${prefix}${l.message}${detail ? `
+${detail}` : ""}`;
+  }).join(`
+`);
+}
+const MONO = "var(--font-family-mono, monospace)", VALUE_BG = "var(--card-code-bg-color, rgba(127,127,127,0.12))", GLYPH = { info: "", success: "\u2713", skip: "\u2013", error: "\u2717", update: "" };
+function levelColor(theme, level) {
+  const muted = theme.sanity.color.muted;
+  if (level === "success") return muted.positive.enabled.fg;
+  if (level === "error") return muted.critical.enabled.fg;
+  if (level === "update") return muted.primary.enabled.fg;
+}
+function valueBg(theme, level) {
+  return level === "error" ? theme.sanity.color.muted.critical.enabled.bg : VALUE_BG;
+}
+function ValueBox({ label, text, bg }) {
+  return /* @__PURE__ */ jsxRuntime.jsx(ui.Box, { flex: 1, padding: 2, style: { background: bg, borderRadius: 3, minWidth: 0 }, children: /* @__PURE__ */ jsxRuntime.jsxs(ui.Stack, { space: 2, children: [
+    label && /* @__PURE__ */ jsxRuntime.jsx(ui.Text, { size: 0, muted: !0, weight: "semibold", children: label }),
+    /* @__PURE__ */ jsxRuntime.jsx(ui.Text, { size: 0, style: { fontFamily: MONO, whiteSpace: "pre-wrap" }, children: text })
+  ] }) });
+}
+function LogRow({ line }) {
+  const theme = ui.useTheme(), [open, setOpen] = react.useState(!1), hasDetail = line.value !== void 0 || line.before !== void 0 || line.error !== void 0, toggle = hasDetail ? () => setOpen((v) => !v) : void 0;
+  return /* @__PURE__ */ jsxRuntime.jsxs(ui.Box, { paddingLeft: line.indent ? 4 : 0, children: [
+    /* @__PURE__ */ jsxRuntime.jsxs(
+      ui.Text,
+      {
+        size: 1,
+        muted: line.level === "skip",
+        onClick: toggle,
+        style: {
+          fontFamily: MONO,
+          whiteSpace: "pre-wrap",
+          cursor: hasDetail ? "pointer" : "default",
+          color: levelColor(theme, line.level)
+        },
+        children: [
+          hasDetail && /* @__PURE__ */ jsxRuntime.jsxs("span", { style: { opacity: 0.6, userSelect: "none" }, children: [
+            open ? "\u25BE" : "\u25B8",
+            " "
+          ] }),
+          GLYPH[line.level] ? /* @__PURE__ */ jsxRuntime.jsxs("span", { style: { opacity: 0.7 }, children: [
+            GLYPH[line.level],
+            " "
+          ] }) : null,
+          line.message
+        ]
+      }
+    ),
+    hasDetail && open && /* @__PURE__ */ jsxRuntime.jsx(ui.Box, { marginTop: 1, children: /* @__PURE__ */ jsxRuntime.jsxs(ui.Stack, { space: 2, children: [
+      line.before !== void 0 ? (
+        // Before/after side by side, two boxes with a gap.
+        /* @__PURE__ */ jsxRuntime.jsxs(ui.Flex, { gap: 3, align: "stretch", children: [
+          /* @__PURE__ */ jsxRuntime.jsx(ValueBox, { label: "Before", text: line.before, bg: valueBg(theme, line.level) }),
+          /* @__PURE__ */ jsxRuntime.jsx(ValueBox, { label: "After", text: line.value ?? "", bg: valueBg(theme, line.level) })
+        ] })
+      ) : line.value !== void 0 ? /* @__PURE__ */ jsxRuntime.jsx(ValueBox, { text: line.value, bg: valueBg(theme, line.level) }) : null,
+      line.error !== void 0 && /* @__PURE__ */ jsxRuntime.jsx(ValueBox, { label: "JSON error", text: line.error, bg: valueBg(theme, line.level) })
+    ] }) })
+  ] });
+}
+function LogPanel({
+  logs,
+  expanded: expandedProp,
+  onExpandedChange
+}) {
+  const [internalExpanded, setInternalExpanded] = react.useState(!1), expanded = expandedProp ?? internalExpanded, setExpanded = (next) => {
+    onExpandedChange?.(next), expandedProp === void 0 && setInternalExpanded(next);
+  }, [copied, setCopied] = react.useState(!1), scrollRef = react.useRef(null), stickToBottom = react.useRef(!0), copyTimeout = react.useRef(null);
+  react.useEffect(() => () => {
+    copyTimeout.current && clearTimeout(copyTimeout.current);
+  }, []);
+  const handleCopy = () => {
+    navigator.clipboard?.writeText(logsToText(logs)), setCopied(!0), copyTimeout.current && clearTimeout(copyTimeout.current), copyTimeout.current = setTimeout(() => setCopied(!1), 1500);
+  }, handleScroll = () => {
+    const el = scrollRef.current;
+    el && (stickToBottom.current = el.scrollHeight - el.scrollTop - el.clientHeight < 8);
+  };
+  return react.useLayoutEffect(() => {
+    const el = scrollRef.current;
+    el && stickToBottom.current && (el.scrollTop = el.scrollHeight);
+  }, [logs, expanded]), /* @__PURE__ */ jsxRuntime.jsxs(ui.Stack, { space: 3, children: [
+    /* @__PURE__ */ jsxRuntime.jsx(
+      ui.Flex,
+      {
+        align: "center",
+        gap: 2,
+        onClick: () => setExpanded(!expanded),
+        style: { cursor: "pointer", userSelect: "none" },
+        children: /* @__PURE__ */ jsxRuntime.jsxs(ui.Heading, { size: 1, children: [
+          expanded ? "\u25BE" : "\u25B8",
+          " ",
+          logs.length > 0 ? `Log (${logs.length})` : "Log"
+        ] })
+      }
+    ),
+    expanded && /* @__PURE__ */ jsxRuntime.jsx(ui.Card, { radius: 2, border: !0, style: { position: "relative" }, children: logs.length === 0 ? /* @__PURE__ */ jsxRuntime.jsx(ui.Box, { padding: 3, children: /* @__PURE__ */ jsxRuntime.jsx(ui.Text, { size: 1, muted: !0, children: "The log is empty \u2014 it will show the status of any send or import operation." }) }) : /* @__PURE__ */ jsxRuntime.jsxs(jsxRuntime.Fragment, { children: [
+      /* @__PURE__ */ jsxRuntime.jsx(ui.Box, { style: { position: "absolute", top: 6, right: 6, zIndex: 1 }, children: /* @__PURE__ */ jsxRuntime.jsx(
+        ui.Button,
+        {
+          mode: "ghost",
+          padding: 2,
+          fontSize: 1,
+          icon: copied ? icons.CheckmarkIcon : icons.CopyIcon,
+          tone: copied ? "positive" : "default",
+          onClick: handleCopy,
+          title: copied ? "Copied" : "Copy log"
+        }
+      ) }),
+      /* @__PURE__ */ jsxRuntime.jsx(
+        "div",
+        {
+          ref: scrollRef,
+          onScroll: handleScroll,
+          style: { maxHeight: 320, overflowY: "auto", padding: 12 },
+          children: /* @__PURE__ */ jsxRuntime.jsx(ui.Stack, { space: 2, children: logs.map((line, i) => /* @__PURE__ */ jsxRuntime.jsx(LogRow, { line }, i)) })
+        }
+      )
+    ] }) })
+  ] });
+}
+function parseFunctionLog(raw) {
+  if (!raw) return [];
+  try {
+    const parsed = JSON.parse(raw);
+    return Array.isArray(parsed) ? parsed : [];
+  } catch {
+    return [];
+  }
+}
+function languageMappingLabel(language) {
+  const code = language.smartcatLanguage || language.id;
+  return code === language.id ? language.id : `${language.id} \u2192 ${code}`;
+}
+function DocTitle({ doc }) {
+  const schema = sanity.useSchema(), schemaType = doc ? schema.get(doc._type) : void 0, preview = sanity.useValuePreview({
+    enabled: !!(doc && schemaType),
+    schemaType,
+    value: doc ? { _id: doc._id, _type: doc._type } : void 0
+  }), title = typeof preview.value?.title == "string" ? preview.value.title : void 0;
+  return /* @__PURE__ */ jsxRuntime.jsx(jsxRuntime.Fragment, { children: title ?? (preview.isLoading ? "\u2026" : UNTITLED) });
+}
+const IN_FLIGHT = ["queued", "importing", "downloaded"], CAN_IMPORT = ["sent", "translating", "completed"], rotate = styled.keyframes`
+  to { transform: rotate(360deg); }
+`, SpinningSyncIcon = styled__default.default(icons.SyncIcon)`
+  ${({ $spinning }) => $spinning && styled.css`
+      animation: ${rotate} 0.8s linear infinite;
+    `}
+`;
+function LastUpdate({ date }) {
+  const relative = sanity.useRelativeTime(date, { useTemporalPhrase: !0 });
+  return /* @__PURE__ */ jsxRuntime.jsxs(ui.Text, { size: 1, muted: !0, title: new Date(date).toLocaleString(), children: [
+    "Last update: ",
+    relative
+  ] });
+}
+function OpenInStudioButton({ id, type }) {
+  const { onClick, href } = router.useIntentLink({ intent: "edit", params: { id, type } });
+  return /* @__PURE__ */ jsxRuntime.jsx(
+    ui.Button,
+    {
+      as: "a",
+      href,
+      onClick,
+      mode: "bleed",
+      icon: icons.LaunchIcon,
+      text: "Open in Studio",
+      fontSize: 0,
+      padding: 2
+    }
+  );
+}
+const CodeArea = styled__default.default.textarea`
+  width: 100%;
+  height: 70vh;
+  resize: none;
+  border: none;
+  outline: none;
+  padding: 0;
+  background: transparent;
+  color: inherit;
+  font-family: ui-monospace, SFMono-Regular, Menlo, Monaco, Consolas, monospace;
+  font-size: 12px;
+  line-height: 1.5;
+  white-space: pre;
+  tab-size: 2;
+`;
+function ViewLocjsonButton(props) {
+  const { docId, type, sourceIsPublished, client, schema, sourceLanguage, documentI18nLanguageField, fieldI18nLanguageField } = props, [open, setOpen] = react.useState(!1), [content, setContent] = react.useState(null), [filename, setFilename] = react.useState(null), [error, setError] = react.useState(null), build = react.useCallback(async () => {
+    setOpen(!0), setContent(null), setFilename(null), setError(null);
+    try {
+      const raw = await client.fetch(
+        sourceIsPublished ? "*[_id == $id][0]" : 'coalesce(*[_id == "drafts." + $id][0], *[_id == $id][0])',
+        { id: docId }
+      );
+      if (!raw) throw new Error(`Document not found: ${docId}`);
+      const isDraft = typeof raw._id == "string" && raw._id.startsWith("drafts."), doc = isDraft ? { ...raw, _id: docId } : raw, fields = locjson.getTranslatableFields(schema.get(type), { exclude: [documentI18nLanguageField] }), locjson$1 = locjson.serializeToLocjson(doc, fields, {
+        sourceLanguage,
+        fieldLanguageKey: fieldI18nLanguageField
+      }), smartcatName = locjson.buildLocjsonFilename(type, docId, resolveDocumentTitle(schema, doc), { draft: isDraft });
+      setFilename(smartcatName.split("/").pop() || smartcatName), setContent(JSON.stringify(locjson$1, null, 2));
+    } catch (err) {
+      setError(err instanceof Error ? err.message : String(err));
+    }
+  }, [client, schema, docId, type, sourceIsPublished, sourceLanguage, documentI18nLanguageField, fieldI18nLanguageField]), download = react.useCallback(() => {
+    if (content == null || !filename) return;
+    const url = URL.createObjectURL(new Blob([content], { type: "application/json" })), anchor = document.createElement("a");
+    anchor.href = url, anchor.download = filename, anchor.click(), URL.revokeObjectURL(url);
+  }, [content, filename]);
+  return /* @__PURE__ */ jsxRuntime.jsxs(jsxRuntime.Fragment, { children: [
+    /* @__PURE__ */ jsxRuntime.jsx(
+      ui.Button,
+      {
+        mode: "bleed",
+        icon: icons.JsonIcon,
+        title: "View LocJSON",
+        fontSize: 0,
+        padding: 2,
+        onClick: build
+      }
+    ),
+    open && /* @__PURE__ */ jsxRuntime.jsx(
+      ui.Dialog,
+      {
+        id: `locjson-${docId}`,
+        header: /* @__PURE__ */ jsxRuntime.jsxs(ui.Flex, { align: "center", gap: 3, children: [
+          /* @__PURE__ */ jsxRuntime.jsxs(ui.Text, { weight: "semibold", children: [
+            "LocJSON \xB7 ",
+            type
+          ] }),
+          /* @__PURE__ */ jsxRuntime.jsx(
+            ui.Button,
+            {
+              icon: icons.DownloadIcon,
+              text: "Download",
+              mode: "ghost",
+              fontSize: 1,
+              padding: 2,
+              disabled: content == null,
+              onClick: download
+            }
+          )
+        ] }),
+        onClose: () => setOpen(!1),
+        width: 3,
+        children: /* @__PURE__ */ jsxRuntime.jsx(ui.Box, { padding: 4, children: error ? /* @__PURE__ */ jsxRuntime.jsx(ui.Text, { size: 1, muted: !0, children: error }) : content === null ? /* @__PURE__ */ jsxRuntime.jsx(ui.Flex, { align: "center", justify: "center", padding: 5, children: /* @__PURE__ */ jsxRuntime.jsx(ui.Spinner, { muted: !0 }) }) : /* @__PURE__ */ jsxRuntime.jsx(
+          CodeArea,
+          {
+            readOnly: !0,
+            spellCheck: !1,
+            value: content,
+            onFocus: (e) => e.currentTarget.select()
+          }
+        ) })
+      }
+    )
+  ] });
+}
+function ProjectView({
+  projectId,
+  onBack,
+  languages,
+  sourceLanguage,
+  translatableTypes,
+  documentI18nLanguageField,
+  fieldI18nLanguageField
+}) {
+  const client = sanity.useClient({ apiVersion: constants.API_VERSION }), schema = sanity.useSchema(), toast = ui.useToast(), [project, setProject] = react.useState(void 0), [name, setName] = react.useState(""), [busy, setBusy] = react.useState(!1), [sending, setSending] = react.useState(!1), [importing, setImporting] = react.useState(!1), [cancelling, setCancelling] = react.useState(!1), [refreshing, setRefreshing] = react.useState(!1), [targets, setTargets] = react.useState([]), [confirmDelete, setConfirmDelete] = react.useState(!1), [markedForDeletion, setMarkedForDeletion] = react.useState(/* @__PURE__ */ new Set()), [logs, setLogs] = react.useState([]), [logExpanded, setLogExpanded] = react.useState(!1), appendLog = react.useCallback((line) => setLogs((prev) => [...prev, line]), []), appendServerLog = react.useCallback(
+    (raw, header) => {
+      const lines = parseFunctionLog(raw);
+      setLogs(
+        (prev) => lines.length === 0 ? [...prev, { level: "info", message: `${header}: no server log returned \u2014 deploy the latest Functions to see server-side steps` }] : [...prev, { level: "info", message: header }, ...lines.map((l) => ({ ...l, indent: !0 }))]
+      );
+    },
+    []
+  ), seeded = react.useRef(!1), toggleMark = react.useCallback((key) => {
+    setMarkedForDeletion((prev) => {
+      const next = new Set(prev);
+      return next.has(key) ? next.delete(key) : next.add(key), next;
+    });
+  }, []), load = react.useCallback(() => client.fetch(PROJECT_DETAIL_QUERY, { id: projectId }).then((res) => {
+    setProject(res), res && setName(res.name), res && !seeded.current && (setTargets(res.targetLanguages ?? []), seeded.current = !0);
+  }).catch((err) => toast.push({ status: "error", title: "Failed to load project", description: String(err) })), [client, projectId, toast]);
+  react.useEffect(() => {
+    load();
+    const sub = client.listen(PROJECT_DETAIL_QUERY, { id: projectId }, { visibility: "query" }).subscribe({ next: () => load(), error: () => {
+    } });
+    return () => sub.unsubscribe();
+  }, [client, projectId, load]);
+  const processingDownload = react.useRef(!1);
+  react.useEffect(() => {
+    if (project?.status === "importing" && (processingDownload.current = !1), project?.status !== "downloaded" || processingDownload.current) return;
+    processingDownload.current = !0;
+    const remaining = project.importRemaining ?? 0;
+    appendLog({ level: "info", message: "Translations downloaded \u2014 applying to documents" }), appendServerLog(project.functionLog, "Import function"), applyImportedTranslations({
+      client,
+      schema,
+      projectId,
+      documentLanguageField: documentI18nLanguageField,
+      fieldLanguageKey: fieldI18nLanguageField,
+      onLog: appendLog
+    }).then(async ({ imported, status }) => {
+      if (remaining > 0 && imported > 0) {
+        appendLog({ level: "success", message: `Imported ${imported} localized version(s)` }), appendLog({ level: "info", message: `${remaining} target(s) still on Smartcat \u2014 continuing import automatically` }), processingDownload.current = !1, await client.patch(projectId).set({ status: "importing", lastError: null }).commit();
+        return;
+      }
+      const description = status === "completed" ? "All targets are fully translated \u2014 project completed." : "Some targets are still translating \u2014 import again later to pull the rest.";
+      appendLog({ level: "success", message: `Imported ${imported} localized version(s)` }), appendLog({ level: status === "completed" ? "success" : "info", message: description }), toast.push({ status: "success", title: `Imported ${imported} localized version(s)`, description });
+    }).catch((err) => {
+      appendLog({ level: "error", message: `Failed to apply translations: ${String(err)}` }), toast.push({ status: "error", title: "Failed to apply translations", description: String(err) });
+    });
+  }, [project?.status, client, schema, projectId, toast, documentI18nLanguageField, fieldI18nLanguageField, appendLog, appendServerLog]);
+  const exportInFlight = react.useRef(!1);
+  react.useEffect(() => {
+    exportInFlight.current && (project?.status === "sent" ? (appendServerLog(project.functionLog, "Export function"), appendLog({ level: "success", message: "Sent to Smartcat" }), project.smartcatProjectUrl && appendLog({ level: "info", message: `Smartcat project: ${project.smartcatProjectUrl}` }), parseFunctionLog(project.functionLog).some((l) => l.level === "error") && (toast.push({ status: "warning", title: "There were errors sending content into Smartcat \u2014 check the log" }), setLogExpanded(!0)), exportInFlight.current = !1) : project?.status === "error" && (appendServerLog(project.functionLog, "Export function"), appendLog({ level: "error", message: `Export failed: ${project.lastError ?? "unknown error"}` }), exportInFlight.current = !1));
+  }, [project?.status, project?.smartcatProjectUrl, project?.lastError, project?.functionLog, appendLog, appendServerLog, toast]);
+  const requestProgress = react.useCallback(() => client.patch(projectId).set({ progressRequestedAt: (/* @__PURE__ */ new Date()).toISOString() }).commit(), [client, projectId]), syncedAtRef = react.useRef(void 0);
+  react.useEffect(() => {
+    syncedAtRef.current = project?.progressSyncedAt;
+  }, [project?.progressSyncedAt]);
+  const refreshBaseline = react.useRef(void 0), refreshTimeout = react.useRef(null);
+  react.useEffect(
+    () => () => {
+      refreshTimeout.current && clearTimeout(refreshTimeout.current);
+    },
+    []
+  );
+  const handleRefreshProgress = react.useCallback(async () => {
+    refreshBaseline.current = syncedAtRef.current, setRefreshing(!0), refreshTimeout.current && clearTimeout(refreshTimeout.current), refreshTimeout.current = setTimeout(() => setRefreshing(!1), 3e4);
+    try {
+      await requestProgress();
+    } catch (err) {
+      setRefreshing(!1), refreshTimeout.current && clearTimeout(refreshTimeout.current), toast.push({ status: "error", title: "Failed to refresh progress", description: String(err) });
+    }
+  }, [requestProgress, toast]);
+  react.useEffect(() => {
+    refreshing && project?.progressSyncedAt !== refreshBaseline.current && (setRefreshing(!1), refreshTimeout.current && clearTimeout(refreshTimeout.current), project?.lastError && (appendServerLog(project.functionLog, "Progress function"), appendLog({ level: "error", message: `Progress refresh failed: ${project.lastError}` }), toast.push({ status: "error", title: "Failed to refresh progress", description: project.lastError }), setLogExpanded(!0)));
+  }, [project?.progressSyncedAt, project?.lastError, project?.functionLog, refreshing, appendServerLog, appendLog, toast]);
+  const progressRequested = react.useRef(!1);
+  react.useEffect(() => {
+    progressRequested.current || !project?.smartcatProjectId || (progressRequested.current = !0, handleRefreshProgress());
+  }, [project?.smartcatProjectId, handleRefreshProgress]);
+  const handleRename = react.useCallback(async () => {
+    const trimmed = name.trim();
+    if (!(!trimmed || trimmed === project?.name)) {
+      setBusy(!0);
+      try {
+        await client.patch(projectId).set({ name: trimmed }).commit(), toast.push({ status: "success", title: "Renamed project" });
+      } catch (err) {
+        toast.push({ status: "error", title: "Failed to rename", description: String(err) });
+      } finally {
+        setBusy(!1);
+      }
+    }
+  }, [name, project, client, projectId, toast]), handleDelete = react.useCallback(async () => {
+    setBusy(!0);
+    try {
+      await client.delete(projectId), toast.push({ status: "success", title: "Deleted project" }), onBack();
+    } catch (err) {
+      toast.push({ status: "error", title: "Failed to delete", description: String(err) }), setBusy(!1);
+    }
+  }, [client, projectId, toast, onBack]), toggleTarget = react.useCallback((id) => {
+    setTargets((prev) => prev.includes(id) ? prev.filter((t) => t !== id) : [...prev, id]);
+  }, []), handleImport = react.useCallback(async () => {
+    setImporting(!0);
+    try {
+      processingDownload.current = !1, await client.patch(projectId).set({ status: "importing", lastError: null }).commit(), setLogs([]), appendLog({ level: "info", message: "Importing from Smartcat" }), appendLog({ level: "info", message: "The import function will download translations and create localized versions." }), toast.push({
+        status: "success",
+        title: "Importing from Smartcat",
+        description: "The import function will download translations and create localized versions."
+      });
+    } catch (err) {
+      toast.push({ status: "error", title: "Failed to start import", description: String(err) });
+    } finally {
+      setImporting(!1);
+    }
+  }, [client, projectId, toast, appendLog]), handleCancel = react.useCallback(async () => {
+    setCancelling(!0);
+    try {
+      await client.patch(projectId).set({ status: "draft" }).commit(), toast.push({ status: "success", title: "Cancelled \u2014 project reset to draft" });
+    } catch (err) {
+      toast.push({ status: "error", title: "Failed to cancel", description: String(err) });
+    } finally {
+      setCancelling(!1);
+    }
+  }, [client, projectId, toast]), handleSend = react.useCallback(async () => {
+    if (targets.length === 0) {
+      toast.push({ status: "warning", title: "Select at least one target language" });
+      return;
+    }
+    setSending(!0), setLogs([]);
+    try {
+      const deletions = [];
+      for (const item of project?.items ?? []) {
+        if (!markedForDeletion.has(item._key) || !item.doc?._id) continue;
+        const smartcatDocumentId = (project?.progress ?? []).find((p) => p.sourceDocId === item.doc._id)?.targets?.find((t) => t.smartcatDocumentId)?.smartcatDocumentId;
+        deletions.push({
+          itemKey: item._key,
+          sourceDocId: item.doc._id,
+          smartcatDocumentId
+        });
+      }
+      const { prepared, deleting } = await prepareExport({
+        client,
+        schema,
+        projectId,
+        targetLanguages: targets,
+        sourceLanguage,
+        languages,
+        translatableTypes,
+        exclude: [documentI18nLanguageField],
+        fieldLanguageKey: fieldI18nLanguageField,
+        deletions,
+        onLog: appendLog
+      });
+      setMarkedForDeletion(/* @__PURE__ */ new Set()), exportInFlight.current = !0, appendLog({ level: "info", message: "Uploading to Smartcat via the export function\u2026" }), toast.push({
+        status: "success",
+        title: "Queued for Smartcat",
+        description: `Prepared ${prepared} file(s)` + (deleting ? ` and ${deleting} for deletion` : "") + "; the export function will sync them."
+      });
+    } catch (err) {
+      appendLog({ level: "error", message: `Failed to queue: ${String(err)}` }), toast.push({ status: "error", title: "Failed to queue", description: String(err) });
+    } finally {
+      setSending(!1);
+    }
+  }, [targets, client, projectId, toast, schema, sourceLanguage, languages, documentI18nLanguageField, fieldI18nLanguageField, project, markedForDeletion, appendLog]), handleRemoveItem = react.useCallback(
+    async (item) => {
+      try {
+        await client.patch(projectId).unset([`items[_key=="${item._key}"]`]).commit(), toast.push({ status: "success", title: "Removed item" });
+      } catch (err) {
+        toast.push({ status: "error", title: "Failed to remove item", description: String(err) });
+      }
+    },
+    [client, projectId, toast]
+  );
+  if (project === void 0)
+    return /* @__PURE__ */ jsxRuntime.jsx(ui.Flex, { align: "center", justify: "center", padding: 5, children: /* @__PURE__ */ jsxRuntime.jsx(ui.Spinner, { muted: !0 }) });
+  if (project === null)
+    return /* @__PURE__ */ jsxRuntime.jsxs(ui.Stack, { space: 4, children: [
+      /* @__PURE__ */ jsxRuntime.jsx(ui.Button, { icon: icons.ArrowLeftIcon, text: "Back", mode: "bleed", onClick: onBack }),
+      /* @__PURE__ */ jsxRuntime.jsx(ui.Card, { padding: 5, radius: 2, tone: "critical", border: !0, children: /* @__PURE__ */ jsxRuntime.jsx(ui.Text, { children: "This project no longer exists." }) })
+    ] });
+  const items = project.items ?? [], nameChanged = name.trim() !== project.name && name.trim().length > 0, languagesLocked = !!project.smartcatProjectId, progress2 = project.progress ?? [], progressByDoc = /* @__PURE__ */ new Map();
+  for (const p of progress2)
+    p.sourceDocId && progressByDoc.set(p.sourceDocId, p);
+  const markedCount = items.filter((i) => markedForDeletion.has(i._key)).length, modeByType = /* @__PURE__ */ new Map();
+  for (const item of items) {
+    const t = item.doc?._type;
+    t && !modeByType.has(t) && modeByType.set(t, locjson.localizationMode(schema.get(t)));
+  }
+  return /* @__PURE__ */ jsxRuntime.jsxs(ui.Stack, { space: 5, children: [
+    /* @__PURE__ */ jsxRuntime.jsxs(ui.Flex, { align: "center", gap: 2, children: [
+      /* @__PURE__ */ jsxRuntime.jsx(ui.Button, { icon: icons.ArrowLeftIcon, text: "Projects", mode: "bleed", onClick: onBack }),
+      /* @__PURE__ */ jsxRuntime.jsx(ui.Box, { flex: 1 }),
+      /* @__PURE__ */ jsxRuntime.jsx(StatusBadge, { status: project.status }),
+      /* @__PURE__ */ jsxRuntime.jsx(
+        ui.Button,
+        {
+          icon: icons.TrashIcon,
+          title: "Delete project\u2026",
+          tone: "critical",
+          mode: "bleed",
+          fontSize: 1,
+          padding: 2,
+          onClick: () => setConfirmDelete(!0),
+          disabled: busy
+        }
+      )
+    ] }),
+    /* @__PURE__ */ jsxRuntime.jsx(ui.Card, { padding: 4, radius: 2, shadow: 1, children: /* @__PURE__ */ jsxRuntime.jsxs(ui.Stack, { space: 4, children: [
+      /* @__PURE__ */ jsxRuntime.jsxs(ui.Flex, { gap: 2, align: "flex-end", children: [
+        /* @__PURE__ */ jsxRuntime.jsx(ui.Box, { flex: 1, children: /* @__PURE__ */ jsxRuntime.jsxs(ui.Stack, { space: 2, children: [
+          /* @__PURE__ */ jsxRuntime.jsx(ui.Text, { size: 1, weight: "semibold", muted: !0, children: "Project name" }),
+          /* @__PURE__ */ jsxRuntime.jsx(
+            ui.TextInput,
+            {
+              value: name,
+              onChange: (e) => setName(e.currentTarget.value),
+              onKeyDown: (e) => {
+                e.key === "Enter" && handleRename();
+              },
+              disabled: busy
+            }
+          )
+        ] }) }),
+        /* @__PURE__ */ jsxRuntime.jsx(ui.Button, { text: "Save", onClick: handleRename, disabled: !nameChanged || busy, loading: busy })
+      ] }),
+      /* @__PURE__ */ jsxRuntime.jsxs(ui.Text, { size: 1, muted: !0, children: [
+        "Source: ",
+        /* @__PURE__ */ jsxRuntime.jsx("strong", { children: languageTitle(languages, project.sourceLanguage || sourceLanguage) })
+      ] }),
+      /* @__PURE__ */ jsxRuntime.jsxs(ui.Stack, { space: 2, children: [
+        /* @__PURE__ */ jsxRuntime.jsx(ui.Text, { size: 1, muted: !0, children: "Target languages" }),
+        /* @__PURE__ */ jsxRuntime.jsxs(ui.Flex, { gap: 6, align: "center", children: [
+          /* @__PURE__ */ jsxRuntime.jsx(ui.Stack, { space: 3, padding: 3, children: languages.filter((l) => l.id !== (project.sourceLanguage || sourceLanguage)).map((l) => {
+            const selected = targets.includes(l.id), disabled = sending || languagesLocked;
+            return /* @__PURE__ */ jsxRuntime.jsxs(ui.Flex, { align: "center", gap: 2, as: "label", style: { cursor: disabled ? "default" : "pointer" }, children: [
+              /* @__PURE__ */ jsxRuntime.jsx(
+                ui.Checkbox,
+                {
+                  checked: selected,
+                  disabled,
+                  onChange: () => toggleTarget(l.id)
+                }
+              ),
+              /* @__PURE__ */ jsxRuntime.jsxs(ui.Text, { size: 1, children: [
+                l.title,
+                /* @__PURE__ */ jsxRuntime.jsx(
+                  "span",
+                  {
+                    title: `Sanity language code: '${l.id}'
+Smartcat language code: '${l.smartcatLanguage || l.id}'`,
+                    style: { color: "var(--card-muted-fg-color)", opacity: 0.6, marginLeft: "1em" },
+                    children: languageMappingLabel(l)
+                  }
+                )
+              ] })
+            ] }, l.id);
+          }) }),
+          project.smartcatProjectUrl ? /* @__PURE__ */ jsxRuntime.jsx(ui.Box, { flex: 1, style: { maxWidth: 500 }, children: /* @__PURE__ */ jsxRuntime.jsxs(ui.Stack, { space: 4, children: [
+            /* @__PURE__ */ jsxRuntime.jsxs(ui.Text, { size: 1, muted: !0, children: [
+              "Smartcat project:",
+              " ",
+              /* @__PURE__ */ jsxRuntime.jsx(
+                "a",
+                {
+                  href: project.smartcatProjectUrl,
+                  target: "_blank",
+                  rel: "noopener noreferrer",
+                  title: "Open project in Smartcat",
+                  children: project.name
+                }
+              )
+            ] }),
+            languagesLocked && /* @__PURE__ */ jsxRuntime.jsx(ui.Text, { size: 1, muted: !0, children: "Target languages are locked once the project has been sent to Smartcat." })
+          ] }) }) : targets.length === 0 && /* @__PURE__ */ jsxRuntime.jsx(ui.Box, { flex: 1, style: { maxWidth: 500 }, children: /* @__PURE__ */ jsxRuntime.jsx(ui.Text, { size: 1, muted: !0, children: "Select one or more languages to translate your content into before you can send it to Smartcat for translation." }) })
+        ] })
+      ] })
+    ] }) }),
+    project.lastError && /* @__PURE__ */ jsxRuntime.jsx(ui.Card, { padding: 3, radius: 2, tone: "critical", border: !0, children: /* @__PURE__ */ jsxRuntime.jsx(ui.Text, { size: 1, children: project.lastError }) }),
+    /* @__PURE__ */ jsxRuntime.jsxs(ui.Flex, { align: "center", gap: 3, wrap: "wrap", children: [
+      /* @__PURE__ */ jsxRuntime.jsx(
+        ui.Button,
+        {
+          icon: icons.PublishIcon,
+          text: "Send to Smartcat",
+          mode: !languagesLocked && items.length > 0 ? void 0 : "ghost",
+          tone: !languagesLocked && items.length > 0 ? "primary" : void 0,
+          onClick: handleSend,
+          loading: sending,
+          disabled: sending || items.length === 0 || targets.length === 0 || IN_FLIGHT.includes(project.status)
+        }
+      ),
+      /* @__PURE__ */ jsxRuntime.jsx(
+        ui.Button,
+        {
+          icon: icons.DownloadIcon,
+          text: "Import translations",
+          mode: languagesLocked ? void 0 : "ghost",
+          tone: languagesLocked ? "primary" : void 0,
+          onClick: handleImport,
+          loading: importing,
+          disabled: importing || !project.smartcatProjectId || !CAN_IMPORT.includes(project.status)
+        }
+      ),
+      project.smartcatProjectId && /* @__PURE__ */ jsxRuntime.jsx(
+        ui.Button,
+        {
+          icon: /* @__PURE__ */ jsxRuntime.jsx(SpinningSyncIcon, { $spinning: refreshing }),
+          text: "Refresh progress",
+          mode: "bleed",
+          onClick: handleRefreshProgress,
+          disabled: refreshing
+        }
+      ),
+      project.progressSyncedAt && /* @__PURE__ */ jsxRuntime.jsx(LastUpdate, { date: project.progressSyncedAt }),
+      markedCount > 0 && /* @__PURE__ */ jsxRuntime.jsxs(ui.Text, { size: 1, muted: !0, children: [
+        markedCount,
+        " marked for deletion \u2014 applied on re-sync"
+      ] }),
+      IN_FLIGHT.includes(project.status) && /* @__PURE__ */ jsxRuntime.jsxs(ui.Inline, { space: 2, children: [
+        /* @__PURE__ */ jsxRuntime.jsxs(ui.Text, { size: 1, muted: !0, children: [
+          "Project is ",
+          /* @__PURE__ */ jsxRuntime.jsx("strong", { children: statusLabel(project.status) }),
+          " \u2014 wait for it to finish before re-sending."
+        ] }),
+        /* @__PURE__ */ jsxRuntime.jsx(
+          ui.Button,
+          {
+            icon: icons.CloseIcon,
+            text: "Cancel",
+            mode: "bleed",
+            tone: "critical",
+            fontSize: 1,
+            padding: 2,
+            onClick: handleCancel,
+            loading: cancelling,
+            disabled: cancelling
+          }
+        )
+      ] })
+    ] }),
+    /* @__PURE__ */ jsxRuntime.jsx(LogPanel, { logs, expanded: logExpanded, onExpandedChange: setLogExpanded }),
+    /* @__PURE__ */ jsxRuntime.jsxs(ui.Stack, { space: 3, children: [
+      /* @__PURE__ */ jsxRuntime.jsx(ui.Flex, { align: "center", gap: 2, children: /* @__PURE__ */ jsxRuntime.jsxs(ui.Heading, { size: 1, children: [
+        items.length,
+        " ",
+        items.length === 1 ? "Item" : "Items"
+      ] }) }),
+      items.length > 0 && /* @__PURE__ */ jsxRuntime.jsx(ui.Stack, { space: 2, children: items.map((item) => {
+        const docProgress = item.doc ? progressByDoc.get(item.doc._id) : void 0, isLinked = !!docProgress?.targets?.some((t) => t.smartcatDocumentId), isMarked = markedForDeletion.has(item._key);
+        return /* @__PURE__ */ jsxRuntime.jsx(
+          ui.Card,
+          {
+            padding: 3,
+            radius: 2,
+            shadow: 1,
+            tone: isMarked ? "critical" : void 0,
+            children: /* @__PURE__ */ jsxRuntime.jsxs(ui.Stack, { space: 3, children: [
+              /* @__PURE__ */ jsxRuntime.jsxs(ui.Flex, { align: "center", gap: 3, children: [
+                /* @__PURE__ */ jsxRuntime.jsxs(ui.Flex, { align: "center", gap: 2, children: [
+                  /* @__PURE__ */ jsxRuntime.jsx(
+                    ui.Badge,
+                    {
+                      tone: item.sourceIsPublished ? "positive" : "caution",
+                      paddingX: 2,
+                      title: item.sourceIsPublished ? "The published version is the translation source" : "The draft version is the translation source",
+                      children: item.sourceIsPublished ? "Published" : "Draft"
+                    }
+                  ),
+                  /* @__PURE__ */ jsxRuntime.jsx(ui.Text, { weight: "medium", children: /* @__PURE__ */ jsxRuntime.jsx("span", { style: isMarked ? { textDecoration: "line-through" } : void 0, children: /* @__PURE__ */ jsxRuntime.jsx(DocTitle, { doc: item.doc }) }) }),
+                  item.doc?._type && /* @__PURE__ */ jsxRuntime.jsx(ui.Badge, { tone: "primary", paddingX: 2, children: item.doc._type }),
+                  item.doc?._type && modeByType.has(item.doc._type) && /* @__PURE__ */ jsxRuntime.jsx(
+                    ui.Badge,
+                    {
+                      tone: "default",
+                      fontSize: 0,
+                      paddingX: 2,
+                      title: modeByType.get(item.doc._type) === "field" ? "This item is translated in field mode; translations will be stored as language variants of each field" : "This item is translated in document mode; translations will be stored as linked documents",
+                      children: modeByType.get(item.doc._type) === "field" ? "fields" : "document"
+                    }
+                  ),
+                  item.doc && /* @__PURE__ */ jsxRuntime.jsx(OpenInStudioButton, { id: item.doc._id, type: item.doc._type }),
+                  item.doc && /* @__PURE__ */ jsxRuntime.jsx(
+                    ViewLocjsonButton,
+                    {
+                      docId: item.doc._id,
+                      type: item.doc._type,
+                      sourceIsPublished: item.sourceIsPublished,
+                      client,
+                      schema,
+                      sourceLanguage,
+                      documentI18nLanguageField,
+                      fieldI18nLanguageField
+                    }
+                  )
+                ] }),
+                /* @__PURE__ */ jsxRuntime.jsx(ui.Box, { flex: 1 }),
+                isLinked ? /* @__PURE__ */ jsxRuntime.jsx(
+                  ui.Button,
+                  {
+                    mode: isMarked ? "default" : "bleed",
+                    tone: "critical",
+                    icon: icons.RemoveCircleIcon,
+                    title: isMarked ? "Unmark for deletion" : "Mark for deletion",
+                    padding: 2,
+                    onClick: () => toggleMark(item._key)
+                  }
+                ) : /* @__PURE__ */ jsxRuntime.jsx(
+                  ui.Button,
+                  {
+                    mode: "bleed",
+                    tone: "critical",
+                    icon: icons.TrashIcon,
+                    title: "Remove from project",
+                    onClick: () => handleRemoveItem(item)
+                  }
+                )
+              ] }),
+              docProgress && /* @__PURE__ */ jsxRuntime.jsx(
+                ItemProgress,
+                {
+                  doc: docProgress,
+                  languages,
+                  smartcatProjectUrl: project.smartcatProjectUrl,
+                  variants: item.doc ? {
+                    type: item.doc._type,
+                    byLanguage: Object.fromEntries(
+                      (item.translations ?? []).map((t) => [t.language, t.id])
+                    )
+                  } : void 0
+                }
+              )
+            ] })
+          },
+          item._key
+        );
+      }) }),
+      /* @__PURE__ */ jsxRuntime.jsx(ui.Card, { padding: 4, radius: 2, tone: "transparent", border: !0, children: /* @__PURE__ */ jsxRuntime.jsx(ui.Text, { muted: !0, align: "center", size: 1, children: "Add content from a document\u2019s \u201C\u22EF \u2192 Add to translation project\u201D menu." }) })
+    ] }),
+    confirmDelete && /* @__PURE__ */ jsxRuntime.jsx(
+      ui.Dialog,
+      {
+        id: "confirm-delete",
+        header: "Delete translation project?",
+        onClose: () => setConfirmDelete(!1),
+        width: 1,
+        children: /* @__PURE__ */ jsxRuntime.jsx(ui.Box, { padding: 4, children: /* @__PURE__ */ jsxRuntime.jsxs(ui.Stack, { space: 4, children: [
+          /* @__PURE__ */ jsxRuntime.jsxs(ui.Text, { children: [
+            "Delete ",
+            /* @__PURE__ */ jsxRuntime.jsx("strong", { children: project.name }),
+            "? This removes the project only \u2014 the referenced content documents are not deleted.",
+            project.smartcatProjectId && " The Smartcat project is not deleted either and will remain in your Smartcat workspace."
+          ] }),
+          /* @__PURE__ */ jsxRuntime.jsxs(ui.Flex, { justify: "flex-end", gap: 2, children: [
+            /* @__PURE__ */ jsxRuntime.jsx(ui.Button, { mode: "bleed", text: "Cancel", onClick: () => setConfirmDelete(!1), disabled: busy }),
+            /* @__PURE__ */ jsxRuntime.jsx(ui.Button, { tone: "critical", text: "Delete", icon: icons.TrashIcon, onClick: handleDelete, loading: busy })
+          ] })
+        ] }) })
+      }
+    )
+  ] });
+}
+function createDashboardComponent(config) {
+  const { sourceLanguage, languages, translatableTypes, documentI18nLanguageField, fieldI18nLanguageField } = config;
+  return function() {
+    const router$1 = router.useRouter(), projectId = router.useRouterState(
+      react.useCallback((state) => state.projectId ?? null, [])
+    ), openProject = react.useCallback((id) => router$1.navigate({ projectId: id }), [router$1]), goBack = react.useCallback(() => router$1.navigate({}), [router$1]);
+    return /* @__PURE__ */ jsxRuntime.jsx(ui.Box, { padding: 4, height: "fill", overflow: "auto", children: /* @__PURE__ */ jsxRuntime.jsx(ui.Container, { width: 2, children: projectId ? /* @__PURE__ */ jsxRuntime.jsx(
+      ProjectView,
+      {
+        projectId,
+        onBack: goBack,
+        languages,
+        sourceLanguage,
+        translatableTypes,
+        documentI18nLanguageField,
+        fieldI18nLanguageField
+      }
+    ) : /* @__PURE__ */ jsxRuntime.jsx(ProjectsView, { sourceLanguage, onOpenProject: openProject }) }) });
+  };
+}
+const TRANSLATION_TOOL_NAME = "translation-projects";
+function createTranslationsTool(config) {
+  return {
+    name: TRANSLATION_TOOL_NAME,
+    title: "Translation Projects",
+    icon: icons.TranslateIcon,
+    component: createDashboardComponent(config),
+    router: router.route.create("/", [router.route.create("/project/:projectId")])
+  };
+}
+const QUERY = `*[_type == "${constants.TRANSLATION_PROJECT_TYPE}" && count(items[
+  ${progress.ITEM_ID} in [$id] + *[_type == "translation.metadata" && references($id)].translations[].value._ref
+]) > 0] | order(_updatedAt desc){
+  _id,
+  name,
+  "isSource": count(items[${progress.ITEM_ID} == $id]) > 0,
+  "targetsThisLanguage": $language in targetLanguages
+}`;
+function ProjectLink({ basePath, project }) {
+  const router$1 = router.useRouter(), href = `${basePath.replace(/\/$/, "")}/${TRANSLATION_TOOL_NAME}/project/${project._id}`, onClick = react.useCallback(
+    (e) => {
+      e.metaKey || e.ctrlKey || e.shiftKey || e.altKey || (e.preventDefault(), router$1.navigateUrl({ path: href }));
+    },
+    [router$1, href]
+  );
+  return /* @__PURE__ */ jsxRuntime.jsx("a", { href, onClick, children: project.name || "Untitled project" });
+}
+function RoleCard({
+  lead,
+  tone = "primary",
+  warning,
+  basePath,
+  projects
+}) {
+  return /* @__PURE__ */ jsxRuntime.jsx(ui.Card, { tone, padding: 3, radius: 2, border: !0, children: /* @__PURE__ */ jsxRuntime.jsxs(ui.Stack, { space: 3, children: [
+    /* @__PURE__ */ jsxRuntime.jsxs(ui.Text, { size: 1, children: [
+      lead,
+      projects.map((p, i) => /* @__PURE__ */ jsxRuntime.jsxs(react.Fragment, { children: [
+        i > 0 && ", ",
+        /* @__PURE__ */ jsxRuntime.jsx(ProjectLink, { basePath, project: p })
+      ] }, p._id))
+    ] }),
+    warning && /* @__PURE__ */ jsxRuntime.jsx(ui.Text, { size: 1, weight: "semibold", children: warning })
+  ] }) });
+}
+function TranslationStatusLine({ mode }) {
+  const client = sanity.useClient({ apiVersion: constants.API_VERSION }), { basePath } = sanity.useWorkspace(), docId = sanity.useFormValue(["_id"])?.replace(/^drafts\./, ""), language = sanity.useFormValue(["language"]) ?? null, [projects, setProjects] = react.useState([]);
+  if (react.useEffect(() => {
+    if (!docId) return;
+    let cancelled = !1;
+    const params = { id: docId, language }, load = () => client.fetch(QUERY, params).then((res) => !cancelled && setProjects(res)).catch(() => !cancelled && setProjects([]));
+    load();
+    const sub = client.listen(QUERY, params, { visibility: "query" }).subscribe({ next: load, error: () => {
+    } });
+    return () => {
+      cancelled = !0, sub.unsubscribe();
+    };
+  }, [client, docId, language]), projects.length === 0) return null;
+  if (mode === "field")
+    return /* @__PURE__ */ jsxRuntime.jsx(ui.Stack, { space: 3, children: /* @__PURE__ */ jsxRuntime.jsx(
+      RoleCard,
+      {
+        lead: projects.length === 1 ? "This document is part of a translation project: " : "This document is part of multiple translation projects: ",
+        basePath,
+        projects
+      }
+    ) });
+  const asSource = projects.filter((p) => p.isSource), asTarget = projects.filter((p) => !p.isSource && p.targetsThisLanguage);
+  return /* @__PURE__ */ jsxRuntime.jsxs(ui.Stack, { space: 3, children: [
+    asSource.length > 0 && /* @__PURE__ */ jsxRuntime.jsx(
+      RoleCard,
+      {
+        lead: asSource.length === 1 ? "This source document is part of a translation project: " : "This source document is part of multiple translation projects: ",
+        basePath,
+        projects: asSource
+      }
+    ),
+    asTarget.length > 0 && /* @__PURE__ */ jsxRuntime.jsx(
+      RoleCard,
+      {
+        tone: asTarget.length > 1 ? "critical" : "primary",
+        lead: asTarget.length === 1 ? "This document variant is part of a translation project: " : "This document variant is part of multiple translation projects: ",
+        warning: asTarget.length > 1 ? "Importing translations from more than one project can overwrite each other on this document." : void 0,
+        basePath,
+        projects: asTarget
+      }
+    )
+  ] });
+}
+function createTranslationStatusInput(config) {
+  return function(props) {
+    return props.path.length === 0 && config.isTranslatableType(props.schemaType.name) ? /* @__PURE__ */ jsxRuntime.jsxs(ui.Stack, { space: 5, children: [
+      /* @__PURE__ */ jsxRuntime.jsx(TranslationStatusLine, { mode: locjson.localizationMode(props.schemaType) }),
+      props.renderDefault(props)
+    ] }) : props.renderDefault(props);
+  };
+}
+const INIT_QUERY = "*[_id == $id][0]{templatesRequestedAt, templatesSyncedAt}";
+function StudioInit(props) {
+  const client = sanity.useClient({ apiVersion: constants.API_VERSION }), didRun = react.useRef(!1);
+  return react.useEffect(() => {
+    didRun.current || (didRun.current = !0, client.fetch(INIT_QUERY, { id: constants.SETTINGS_DOC_ID }).then((s) => {
+      if (!(s?.templatesSyncedAt || isRefreshInFlight(s)))
+        return client.transaction().createIfNotExists({ _id: constants.SETTINGS_DOC_ID, _type: constants.SETTINGS_TYPE }).patch(constants.SETTINGS_DOC_ID, (p) => p.set({ templatesRequestedAt: (/* @__PURE__ */ new Date()).toISOString() })).commit({ visibility: "async" });
+    }).catch(() => {
+    }));
+  }, [client]), props.renderDefault(props);
+}
+const PLUGIN_TYPES = /* @__PURE__ */ new Set([constants.TRANSLATION_PROJECT_TYPE, constants.SETTINGS_TYPE]);
+function resolveConfig(config) {
+  const translatableTypes = config.translatableTypes;
+  return {
+    isTranslatableType: translatableTypes ? (type) => translatableTypes.includes(type) : (type) => !PLUGIN_TYPES.has(type),
+    translatableTypes,
+    // `rootTypes` inherits the *explicitly-configured* translatableTypes (not the
+    // resolved "everything") so an unconfigured Studio gets no crawl boundary
+    // rather than every type being a root (which would stop the crawl at once).
+    rootTypes: config.rootTypes ?? translatableTypes ?? [],
+    sourceLanguage: constants.requireSourceLanguage(config.sourceLanguage),
+    languages: config.languages ?? [],
+    documentI18nLanguageField: config.documentI18nPluginLanguageField ?? "language",
+    fieldI18nLanguageField: config.fieldI18nPluginLanguageField ?? "language"
+  };
+}
+const smartcatTranslation = sanity.definePlugin((config) => {
+  const resolved = resolveConfig(config), projectType = createTranslationProjectType(), settingsType = createSettingsType(), addToProjectAction = createAddToProjectAction(resolved), translationStatusInput = createTranslationStatusInput(resolved), translationsTool = createTranslationsTool(resolved), isTranslatable = resolved.isTranslatableType;
+  return {
+    name: "sanity-plugin-smartcat-translation",
+    schema: {
+      types: [projectType, settingsType]
+    },
+    studio: {
+      components: {
+        // Bootstraps the template cache on first Studio load.
+        layout: StudioInit
+      }
+    },
+    tools: [translationsTool],
+    document: {
+      actions: (prev, context) => isTranslatable(context.schemaType) ? [...prev, addToProjectAction] : prev
+    },
+    form: {
+      components: {
+        input: translationStatusInput
+      }
+    }
+  };
+});
+exports.TRANSLATION_PROJECT_TYPE = constants.TRANSLATION_PROJECT_TYPE;
+exports.smartcatTranslation = smartcatTranslation;
+//# sourceMappingURL=index.cjs.map