@smartcat/sanity-plugin 1.0.0 → 1.1.0

package/dist/_chunks-es/index.js

@@ -0,0 +1,175 @@
+function buildLanguageMappings(languages, ids) {
+  const byId = new Map(languages.map((l) => [l.id, l.smartcatLanguage || l.id]));
+  return ids.map((id) => ({ sanityId: id, smartcatLanguage: byId.get(id) || id }));
+}
+function toSmartcatLanguage(mappings, sanityId) {
+  return mappings?.find((m) => m.sanityId === sanityId)?.smartcatLanguage ?? sanityId;
+}
+function toSanityLanguage(mappings, smartcatLanguage) {
+  return mappings?.find((m) => m.smartcatLanguage === smartcatLanguage)?.sanityId ?? smartcatLanguage;
+}
+function findDuplicateSmartcatLanguages(mappings) {
+  const byCode = /* @__PURE__ */ new Map();
+  for (const m of mappings) {
+    const ids = byCode.get(m.smartcatLanguage) ?? [];
+    ids.push(m.sanityId), byCode.set(m.smartcatLanguage, ids);
+  }
+  return [...byCode.entries()].filter(([, ids]) => ids.length > 1).map(([smartcatLanguage, sanityIds]) => ({ smartcatLanguage, sanityIds }));
+}
+const ITEM_ID = "coalesce(docId, _ref)", ITEM_ID_FROM_SUBQUERY = "coalesce(^.docId, ^._ref)", itemDocDeref = (projection = "") => `*[_id == ${ITEM_ID_FROM_SUBQUERY}][0]${projection}`, itemDocDerefRespectingDraft = (projection = "") => `select(sourceIsPublished == true => *[_id == ${ITEM_ID_FROM_SUBQUERY}][0]${projection}, coalesce(*[_id == "drafts." + ${ITEM_ID_FROM_SUBQUERY}][0]${projection}, *[_id == ${ITEM_ID_FROM_SUBQUERY}][0]${projection}))`;
+function keyify(value) {
+  return value.replace(/[^a-zA-Z0-9_-]/g, "-") || "x";
+}
+function targetKey(sourceDocId, language) {
+  return keyify(`${sourceDocId}__${language}`);
+}
+function clampPercent(value) {
+  return typeof value != "number" || Number.isNaN(value) ? 0 : Math.max(0, Math.min(100, Math.round(value)));
+}
+function stripDraft(id) {
+  return id.replace(/^drafts\./, "");
+}
+function titleCase(value) {
+  return value && value.charAt(0).toUpperCase() + value.slice(1);
+}
+function buildStageNameMap(scProject) {
+  const map = /* @__PURE__ */ new Map();
+  return (scProject.workflowStages ?? []).forEach((stage, i) => {
+    stage.id && map.set(stage.id, titleCase(stage.stageType || stage.stageName || `Stage ${i + 1}`));
+  }), map;
+}
+function stagesFromDocument(doc, stageNames) {
+  return (doc.workflowStages ?? []).map((stage, i) => ({
+    _key: stage.id || `s${i}`,
+    name: stage.id && stageNames.get(stage.id) || titleCase(stage.stageType || stage.stageName || `Stage ${i + 1}`),
+    percent: clampPercent(stage.progress)
+  }));
+}
+function isTargetComplete(stages) {
+  return stages.length > 0 && stages.every((s) => s.percent >= 100);
+}
+function hasConfirmedContent(stages) {
+  return stages.some((s) => s.percent > 0);
+}
+function targetPercent(stages) {
+  return stages.length === 0 ? 0 : Math.round(stages.reduce((sum, s) => sum + s.percent, 0) / stages.length);
+}
+function sourceIdPrefix(doc) {
+  return ((doc.name || doc.filename || doc.fullPath || "").split("/").pop() ?? "").replace(/\.locjson$/i, "").replace(/-draft$/, "").slice(-8);
+}
+function buildProgress(items, scProject, previous, now, mappings) {
+  const stageNames = buildStageNameMap(scProject), importedSet = /* @__PURE__ */ new Set(), titleByDoc = /* @__PURE__ */ new Map();
+  for (const doc of previous ?? []) {
+    doc.title && titleByDoc.set(doc.sourceDocId, doc.title);
+    for (const target of doc.targets)
+      target.imported && importedSet.add(`${doc.sourceDocId}__${target.language}`);
+  }
+  const itemByPrefix = /* @__PURE__ */ new Map();
+  for (const item of items) itemByPrefix.set(stripDraft(item._id).slice(0, 8), item);
+  const byDoc = /* @__PURE__ */ new Map();
+  for (const scDoc of scProject.documents ?? []) {
+    if (!scDoc.targetLanguage) continue;
+    const item = itemByPrefix.get(sourceIdPrefix(scDoc));
+    if (!item) continue;
+    const language = toSanityLanguage(mappings, scDoc.targetLanguage);
+    let docProgress = byDoc.get(item._id);
+    if (!docProgress) {
+      const title = item.title || titleByDoc.get(item._id);
+      docProgress = { _key: targetKey(item._id, "doc"), sourceDocId: item._id, title, targets: [] }, byDoc.set(item._id, docProgress);
+    }
+    const stages = stagesFromDocument(scDoc, stageNames);
+    docProgress.targets.push({
+      _key: targetKey(item._id, language),
+      language,
+      smartcatDocumentId: scDoc.id,
+      stages,
+      complete: isTargetComplete(stages),
+      imported: importedSet.has(`${item._id}__${language}`),
+      syncedAt: now
+    });
+  }
+  const result = [];
+  for (const item of items) {
+    const docProgress = byDoc.get(item._id);
+    docProgress && (docProgress.targets.sort((a, b) => a.language.localeCompare(b.language)), result.push(docProgress));
+  }
+  return result;
+}
+function summarizeCompletion(progress) {
+  let total = 0, complete = 0, imported = 0, anyProgress = !1;
+  for (const doc of progress)
+    for (const target of doc.targets)
+      total++, target.complete && complete++, target.imported && imported++, target.stages.some((s) => s.percent > 0) && (anyProgress = !0);
+  return {
+    total,
+    complete,
+    imported,
+    allDone: total > 0 && complete === total && imported === total,
+    anyProgress
+  };
+}
+const PROGRESS_QUERY = `*[_id == $id][0]{
+  _id,
+  status,
+  smartcatProjectId,
+  smartcatLanguages[]{sanityId, smartcatLanguage},
+  "items": items[]{ "_id": ${ITEM_ID}, "title": ${itemDocDerefRespectingDraft(".title")} },
+  progress[]{_key, sourceDocId, title, targets[]{_key, language, smartcatDocumentId, stages, complete, imported, syncedAt}}
+}`;
+function itemsFromProject(project) {
+  const result = [];
+  for (const item of project.items ?? []) {
+    const _id = item?._id ?? item?.doc?._id;
+    _id && result.push({ _id, title: item?.title ?? item?.doc?.title ?? void 0 });
+  }
+  return result;
+}
+async function runProgressSync(options) {
+  const { sanity, smartcat, projectId, now = () => (/* @__PURE__ */ new Date()).toISOString() } = options, project = await sanity.fetch(PROGRESS_QUERY, { id: projectId });
+  if (!project) throw new Error(`Translation project ${projectId} not found`);
+  if (!project.smartcatProjectId)
+    throw new Error("Project has no smartcatProjectId \u2014 export it first");
+  const timestamp = now(), log = [];
+  smartcat.setRequestLogger?.(({ method, path, status, body }) => {
+    status >= 200 && status < 300 || (log.push({
+      level: "error",
+      message: status ? `Error ${status} while performing ${method} ${path}` : `${method} ${path} did not complete`
+    }), body && log.push({ level: "error", indent: !0, message: body }));
+  });
+  try {
+    const scProject = await smartcat.getProject(project.smartcatProjectId), progress = buildProgress(
+      itemsFromProject(project),
+      scProject,
+      project.progress,
+      timestamp,
+      project.smartcatLanguages
+    ), summary = summarizeCompletion(progress), patch = { progress, progressSyncedAt: timestamp, lastError: null };
+    return project.status === "sent" && summary.anyProgress && (patch.status = "translating"), await sanity.patch(projectId).set(patch).commit(), { summary };
+  } catch (err) {
+    const message = err instanceof Error ? err.message : String(err);
+    return log.some((l) => l.level === "error") || log.push({ level: "error", message }), await sanity.patch(projectId).set({ lastError: message, functionLog: JSON.stringify(log), progressSyncedAt: timestamp }).commit().catch(() => {
+    }), { summary: summarizeCompletion(project.progress ?? []), error: message };
+  }
+}
+export {
+  ITEM_ID,
+  ITEM_ID_FROM_SUBQUERY,
+  buildLanguageMappings,
+  buildProgress,
+  buildStageNameMap,
+  findDuplicateSmartcatLanguages,
+  hasConfirmedContent,
+  isTargetComplete,
+  itemDocDeref,
+  itemDocDerefRespectingDraft,
+  itemsFromProject,
+  keyify,
+  runProgressSync,
+  sourceIdPrefix,
+  stagesFromDocument,
+  summarizeCompletion,
+  targetKey,
+  targetPercent,
+  toSmartcatLanguage
+};
+//# sourceMappingURL=index.js.map

package/dist/_chunks-es/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","sources":["../../src/lib/languageMap.ts","../../src/lib/projectItems.ts","../../src/progress/core.ts"],"sourcesContent":["/**\n * Sanity ↔ Smartcat language-code mapping.\n *\n * Sanity locale tags (`id`) don't always match the codes Smartcat understands\n * (e.g. Sanity \"PL-PL\" vs Smartcat \"pl\"). The browser resolves the mapping from\n * plugin config and stamps the relevant pairs onto the project; the thin\n * Functions read them back. This module is dependency-free so it bundles into\n * both the Studio and the Functions.\n *\n * The invariant: everything stored in Sanity uses the Sanity `id`; only the\n * Smartcat HTTP calls use `smartcatLanguage`. So callers map forward (id → code)\n * when talking to Smartcat and invert (code → id) when storing what comes back.\n */\n\nexport interface SmartcatLanguageMapping {\n  sanityId: string\n  smartcatLanguage: string\n}\n\n/** Minimal language shape needed to build mappings (a subset of SmartcatLanguage). */\ninterface MappableLanguage {\n  id: string\n  smartcatLanguage?: string\n}\n\n/**\n * Builds the mapping pairs for the given Sanity ids, resolving each to its\n * configured `smartcatLanguage` (falling back to the id when not configured).\n */\nexport function buildLanguageMappings(\n  languages: MappableLanguage[],\n  ids: string[],\n): SmartcatLanguageMapping[] {\n  const byId = new Map(languages.map((l) => [l.id, l.smartcatLanguage || l.id]))\n  return ids.map((id) => ({sanityId: id, smartcatLanguage: byId.get(id) || id}))\n}\n\n/** Sanity id → Smartcat code. Identity when no mapping is found. */\nexport function toSmartcatLanguage(\n  mappings: SmartcatLanguageMapping[] | undefined,\n  sanityId: string,\n): string {\n  return mappings?.find((m) => m.sanityId === sanityId)?.smartcatLanguage ?? sanityId\n}\n\n/** Smartcat code → Sanity id. Identity when no mapping is found. */\nexport function toSanityLanguage(\n  mappings: SmartcatLanguageMapping[] | undefined,\n  smartcatLanguage: string,\n): string {\n  return mappings?.find((m) => m.smartcatLanguage === smartcatLanguage)?.sanityId ?? smartcatLanguage\n}\n\n/**\n * Finds Smartcat codes that more than one Sanity id maps to. A non-empty result\n * means the inverse (code → id) is ambiguous, so translations can't be routed\n * back — callers should reject such a configuration.\n */\nexport function findDuplicateSmartcatLanguages(\n  mappings: SmartcatLanguageMapping[],\n): {smartcatLanguage: string; sanityIds: string[]}[] {\n  const byCode = new Map<string, string[]>()\n  for (const m of mappings) {\n    const ids = byCode.get(m.smartcatLanguage) ?? []\n    ids.push(m.sanityId)\n    byCode.set(m.smartcatLanguage, ids)\n  }\n  return [...byCode.entries()]\n    .filter(([, ids]) => ids.length > 1)\n    .map(([smartcatLanguage, sanityIds]) => ({smartcatLanguage, sanityIds}))\n}\n","/**\n * GROQ fragments for reading a translation project's `items`.\n *\n * An item is either the current `smartcat.projectItem` shape (`{docId, docType}`)\n * or a legacy weak reference (`{_ref}`) from before the migration. These\n * fragments normalize across both so the old/new tolerance lives in one place —\n * interpolate them into item queries rather than re-writing `coalesce(...)`.\n */\n\n/** Normalized item id, evaluated in the item's own scope (inside `items[...]`). */\nexport const ITEM_ID = 'coalesce(docId, _ref)'\n\n/** Normalized item id, evaluated from a subquery nested under an item (via `^`). */\nexport const ITEM_ID_FROM_SUBQUERY = 'coalesce(^.docId, ^._ref)'\n\n/** Dereference an item's document, with an optional projection e.g. `{_id, _type}`. */\nexport const itemDocDeref = (projection = ''): string => `*[_id == ${ITEM_ID_FROM_SUBQUERY}][0]${projection}`\n\n/**\n * Dereference an item's document, honoring where it was added from: items added\n * in the **published** perspective (`sourceIsPublished == true`) resolve the\n * published document only; every other item (including legacy items with no\n * flag) prefers the **draft**, falling back to published. This makes the export\n * translate the content the editor was actually viewing, and gives pre-existing\n * projects the draft-preferring default for free.\n */\nexport const itemDocDerefRespectingDraft = (projection = ''): string =>\n  `select(` +\n  `sourceIsPublished == true => *[_id == ${ITEM_ID_FROM_SUBQUERY}][0]${projection}, ` +\n  `coalesce(*[_id == \"drafts.\" + ${ITEM_ID_FROM_SUBQUERY}][0]${projection}, *[_id == ${ITEM_ID_FROM_SUBQUERY}][0]${projection})` +\n  `)`\n","import type {SmartcatProject, SmartcatDocument, RequestLogger} from '../smartcat/types'\nimport {toSanityLanguage, type SmartcatLanguageMapping} from '../lib/languageMap'\nimport {ITEM_ID, itemDocDerefRespectingDraft} from '../lib/projectItems'\nimport type {LogLine} from '../lib/log'\n\n/**\n * Per-document, per-language, per-stage translation progress mirrored from\n * Smartcat onto a `smartcat.translationProject`.\n *\n * This module is intentionally **dependency-free** (no DOM, no @sanity/* runtime)\n * so it bundles cleanly into the thin `smartcat-progress` / `smartcat-import`\n * Functions. All keys are deterministic, so repeated refreshes patch the same\n * array members in place instead of churning `_key`s.\n */\n\nexport interface StageProgress {\n  /** Stable key for the Sanity array item (always set by `stagesFromDocument`). */\n  _key?: string\n  name: string\n  /** 0–100, rounded. */\n  percent: number\n}\n\nexport interface TargetProgress {\n  _key: string\n  language: string\n  /** Smartcat target document id (`<fileGuid>_<languageNumber>`). */\n  smartcatDocumentId?: string\n  stages: StageProgress[]\n  /** All stages at 100%. */\n  complete: boolean\n  /** A locale variant has been built from this target (set by the browser). */\n  imported: boolean\n  syncedAt?: string\n}\n\nexport interface DocProgress {\n  _key: string\n  sourceDocId: string\n  title?: string\n  targets: TargetProgress[]\n}\n\n/** Sanitizes an arbitrary string into a stable, Sanity-safe array `_key`. */\nexport function keyify(value: string): string {\n  return value.replace(/[^a-zA-Z0-9_-]/g, '-') || 'x'\n}\n\n/** Builds a progress target's `_key` from its document + language. */\nexport function targetKey(sourceDocId: string, language: string): string {\n  return keyify(`${sourceDocId}__${language}`)\n}\n\nfunction clampPercent(value: number | undefined): number {\n  if (typeof value !== 'number' || Number.isNaN(value)) return 0\n  return Math.max(0, Math.min(100, Math.round(value)))\n}\n\n/** Strips a `drafts.` prefix from a Sanity document id. */\nfunction stripDraft(id: string): string {\n  return id.replace(/^drafts\\./, '')\n}\n\nfunction titleCase(value: string): string {\n  return value ? value.charAt(0).toUpperCase() + value.slice(1) : value\n}\n\n/**\n * Builds a stage-id → display-name map from a project's `workflowStages`. On\n * Smartcat, document-level stages carry only `{id, progress}` — the human name\n * (`stageType`, e.g. \"translation\") lives on the project-level stages.\n */\nexport function buildStageNameMap(scProject: SmartcatProject): Map<string, string> {\n  const map = new Map<string, string>()\n  ;(scProject.workflowStages ?? []).forEach((stage, i) => {\n    if (stage.id) map.set(stage.id, titleCase(stage.stageType || stage.stageName || `Stage ${i + 1}`))\n  })\n  return map\n}\n\n/** Maps a Smartcat document's workflow stages to display-ready stage progress. */\nexport function stagesFromDocument(\n  doc: SmartcatDocument,\n  stageNames: Map<string, string>,\n): StageProgress[] {\n  const stages = doc.workflowStages ?? []\n  return stages.map((stage, i) => ({\n    _key: stage.id || `s${i}`,\n    name:\n      (stage.id && stageNames.get(stage.id)) ||\n      titleCase(stage.stageType || stage.stageName || `Stage ${i + 1}`),\n    percent: clampPercent(stage.progress),\n  }))\n}\n\n/** A target is complete when it has stages and every one is at 100%. */\nexport function isTargetComplete(stages: StageProgress[]): boolean {\n  return stages.length > 0 && stages.every((s) => s.percent >= 100)\n}\n\n/**\n * Whether a target has any content confirmed at any stage — i.e. there is\n * something worth importing. Used to gate `mode=confirmed` downloads so we skip\n * targets with nothing confirmed yet (which would otherwise come back as source).\n */\nexport function hasConfirmedContent(stages: StageProgress[]): boolean {\n  return stages.some((s) => s.percent > 0)\n}\n\n/** Average completion across a target's stages (0–100). */\nexport function targetPercent(stages: StageProgress[]): number {\n  if (stages.length === 0) return 0\n  return Math.round(stages.reduce((sum, s) => sum + s.percent, 0) / stages.length)\n}\n\n/** A project item we correlate Smartcat documents back to. */\nexport interface ProjectItem {\n  _id: string\n  title?: string\n}\n\n/**\n * Extracts the 8-char source-id prefix Smartcat preserves in a document's\n * filename (built as `<title>-<idPrefix>.locjson`, or `<title>-<idPrefix>-draft.locjson`\n * when the content came from the document's draft). Used to correlate a Smartcat\n * document back to a Sanity source document.\n *\n * A trailing `-draft` marker is stripped first, so a draft-sourced file resolves\n * to the same id as its published counterpart. The prefix is then always the\n * final 8 characters before the (marker and) extension, so take the tail rather\n * than splitting on a dash — the title or the id prefix itself can\n * contain dashes (e.g. a custom id like `demo-pdpA` → prefix `demo-pdp`), which\n * would make a last-dash split return the wrong fragment.\n *\n * Only a literal `.locjson` extension is stripped (Smartcat's API often returns\n * the name without it). A generic strip-after-last-dot would eat the tail of any\n * DOTTED title — e.g. micro-copy keys like `aiAssistantModal.resetChat-11AKrV8G`\n * — leaving the wrong 8 chars, so those documents silently never correlate,\n * never import, and re-syncs duplicate them instead of updating.\n */\nexport function sourceIdPrefix(doc: SmartcatDocument): string {\n  const base = doc.name || doc.filename || doc.fullPath || ''\n  const leaf = base.split('/').pop() ?? ''\n  const noExt = leaf.replace(/\\.locjson$/i, '')\n  // Draft-sourced files carry a trailing `-draft` marker (informational only, so\n  // a project never holds both a document's draft and its published version).\n  // Strip it before taking the tail so a draft file correlates to the same source\n  // id as its published counterpart — the id prefix is what identifies the item.\n  const noDraft = noExt.replace(/-draft$/, '')\n  return noDraft.slice(-8)\n}\n\n/**\n * Builds the full progress array from a freshly fetched Smartcat project and the\n * project's items — independent of any export-time skeleton, so it works for\n * projects exported before progress tracking existed.\n *\n * Documents are correlated to items by the 8-char id prefix in their filename;\n * `imported` flags are carried over from the previous progress (by source doc +\n * language) so importing isn't forgotten on refresh.\n *\n * `mappings` invert Smartcat's returned target codes back to Sanity ids, so all\n * stored progress uses Sanity locale tags. When omitted, codes pass through\n * unchanged (identity) — keeping legacy projects working.\n */\nexport function buildProgress(\n  items: ProjectItem[],\n  scProject: SmartcatProject,\n  previous: DocProgress[] | undefined,\n  now: string,\n  mappings?: SmartcatLanguageMapping[],\n): DocProgress[] {\n  const stageNames = buildStageNameMap(scProject)\n\n  const importedSet = new Set<string>()\n  // Titles are computed Sanity-native in the Studio and shipped on the outbox, so\n  // they may not be re-derivable server-side. Carry the previously-stored title\n  // forward so a progress sync (which only has the raw `doc.title`) can't clobber\n  // it with an \"Untitled\" for types that have no literal title field.\n  const titleByDoc = new Map<string, string>()\n  for (const doc of previous ?? []) {\n    if (doc.title) titleByDoc.set(doc.sourceDocId, doc.title)\n    for (const target of doc.targets) {\n      if (target.imported) importedSet.add(`${doc.sourceDocId}__${target.language}`)\n    }\n  }\n\n  const itemByPrefix = new Map<string, ProjectItem>()\n  for (const item of items) itemByPrefix.set(stripDraft(item._id).slice(0, 8), item)\n\n  const byDoc = new Map<string, DocProgress>()\n  for (const scDoc of scProject.documents ?? []) {\n    if (!scDoc.targetLanguage) continue\n    const item = itemByPrefix.get(sourceIdPrefix(scDoc))\n    if (!item) continue\n\n    // Store the Sanity locale tag, not Smartcat's code.\n    const language = toSanityLanguage(mappings, scDoc.targetLanguage)\n\n    let docProgress = byDoc.get(item._id)\n    if (!docProgress) {\n      const title = item.title || titleByDoc.get(item._id)\n      docProgress = {_key: targetKey(item._id, 'doc'), sourceDocId: item._id, title, targets: []}\n      byDoc.set(item._id, docProgress)\n    }\n    const stages = stagesFromDocument(scDoc, stageNames)\n    docProgress.targets.push({\n      _key: targetKey(item._id, language),\n      language,\n      smartcatDocumentId: scDoc.id,\n      stages,\n      complete: isTargetComplete(stages),\n      imported: importedSet.has(`${item._id}__${language}`),\n      syncedAt: now,\n    })\n  }\n\n  // Preserve item order; sort each doc's targets by language for stable display.\n  const result: DocProgress[] = []\n  for (const item of items) {\n    const docProgress = byDoc.get(item._id)\n    if (!docProgress) continue\n    docProgress.targets.sort((a, b) => a.language.localeCompare(b.language))\n    result.push(docProgress)\n  }\n  return result\n}\n\nexport interface CompletionSummary {\n  /** Total (document × language) targets. */\n  total: number\n  /** Targets whose stages are all at 100%. */\n  complete: number\n  /** Targets a variant has been built for. */\n  imported: number\n  /** True when every target is complete and imported (and there is ≥1 target). */\n  allDone: boolean\n  /** True when at least one stage shows any progress. */\n  anyProgress: boolean\n}\n\n/** Summarizes a progress array for status decisions and the dashboard. */\nexport function summarizeCompletion(progress: DocProgress[]): CompletionSummary {\n  let total = 0\n  let complete = 0\n  let imported = 0\n  let anyProgress = false\n  for (const doc of progress) {\n    for (const target of doc.targets) {\n      total++\n      if (target.complete) complete++\n      if (target.imported) imported++\n      if (target.stages.some((s) => s.percent > 0)) anyProgress = true\n    }\n  }\n  return {\n    total,\n    complete,\n    imported,\n    allDone: total > 0 && complete === total && imported === total,\n    anyProgress,\n  }\n}\n\n// ---------------------------------------------------------------------------\n// Function-side orchestration: refresh progress from Smartcat\n// ---------------------------------------------------------------------------\n\n/** Minimal structural subset of @sanity/client used by the progress refresh. */\nexport interface SanityLikeClient {\n  fetch<T = unknown>(query: string, params?: Record<string, unknown>): Promise<T>\n  patch(id: string): {\n    set(attrs: Record<string, unknown>): {commit(): Promise<unknown>}\n  }\n}\n\n/** Structural subset of SmartcatClient the progress refresh needs. */\nexport interface SmartcatProgressClient {\n  getProject(projectId: string): Promise<SmartcatProject>\n  /** Optional: trace every HTTP call so a timeout/error reaches the functionLog. */\n  setRequestLogger?(logger: RequestLogger): void\n}\n\nexport interface RunProgressSyncOptions {\n  sanity: SanityLikeClient\n  smartcat: SmartcatProgressClient\n  /** `_id` of the `smartcat.translationProject` to refresh. */\n  projectId: string\n  now?: () => string\n}\n\nexport interface RunProgressSyncResult {\n  summary: CompletionSummary\n  /** Set when the Smartcat fetch failed (e.g. timed out); the run was recorded, not thrown. */\n  error?: string\n}\n\nconst PROGRESS_QUERY = `*[_id == $id][0]{\n  _id,\n  status,\n  smartcatProjectId,\n  smartcatLanguages[]{sanityId, smartcatLanguage},\n  \"items\": items[]{ \"_id\": ${ITEM_ID}, \"title\": ${itemDocDerefRespectingDraft('.title')} },\n  progress[]{_key, sourceDocId, title, targets[]{_key, language, smartcatDocumentId, stages, complete, imported, syncedAt}}\n}`\n\ninterface ProgressProjectData {\n  _id: string\n  status?: string\n  smartcatProjectId?: string\n  smartcatLanguages?: SmartcatLanguageMapping[]\n  items?: ProjectItemRef[]\n  progress?: DocProgress[]\n}\n\n/** A project item as read for correlation: its stored id (always present) plus a\n * best-effort title. `doc` is the legacy shape — some callers still project it. */\ninterface ProjectItemRef {\n  _id?: string\n  title?: string\n  doc?: {_id?: string; title?: string} | null\n}\n\n/**\n * Resolves a project's items into the lightweight shape we correlate on. The id\n * is the item's stored `docId` — NOT a dereferenced document — so an item whose\n * document exists only as a draft (never published) still correlates instead of\n * being silently dropped. Tolerates the legacy `{doc}` projection.\n */\nexport function itemsFromProject(project: {items?: ProjectItemRef[]}): ProjectItem[] {\n  const result: ProjectItem[] = []\n  for (const item of project.items ?? []) {\n    const _id = item?._id ?? item?.doc?._id\n    if (!_id) continue\n    result.push({_id, title: item?.title ?? item?.doc?.title ?? undefined})\n  }\n  return result\n}\n\n/**\n * Thin progress step run by the `smartcat-progress` Function: fetches the\n * Smartcat project and mirrors its per-stage progress onto the project's\n * `progress` array. Read-only with respect to Smartcat — it never downloads or\n * creates variants, so it is cheap to run on every dashboard page load.\n */\nexport async function runProgressSync(\n  options: RunProgressSyncOptions,\n): Promise<RunProgressSyncResult> {\n  const {sanity, smartcat, projectId, now = () => new Date().toISOString()} = options\n\n  const project = await sanity.fetch<ProgressProjectData | null>(PROGRESS_QUERY, {id: projectId})\n  if (!project) throw new Error(`Translation project ${projectId} not found`)\n  if (!project.smartcatProjectId) {\n    throw new Error('Project has no smartcatProjectId — export it first')\n  }\n\n  const timestamp = now()\n\n  // Trace HTTP failures into a functionLog so a timeout/error surfaces in the UI.\n  // Successful calls are left unlogged: this Function runs on every page load, and\n  // functionLog is shared with export/import — writing it on every success would\n  // wipe a useful export/import log.\n  const log: LogLine[] = []\n  smartcat.setRequestLogger?.(({method, path, status, body}) => {\n    if (status >= 200 && status < 300) return\n    log.push({\n      level: 'error',\n      message: status ? `Error ${status} while performing ${method} ${path}` : `${method} ${path} did not complete`,\n    })\n    if (body) log.push({level: 'error', indent: true, message: body})\n  })\n\n  try {\n    const scProject = await smartcat.getProject(project.smartcatProjectId)\n    const progress = buildProgress(\n      itemsFromProject(project),\n      scProject,\n      project.progress,\n      timestamp,\n      project.smartcatLanguages,\n    )\n    const summary = summarizeCompletion(progress)\n\n    const patch: Record<string, unknown> = {progress, progressSyncedAt: timestamp, lastError: null}\n    // Gentle one-way nudge: once Smartcat reports any work, reflect it in the badge.\n    // Completion remains owned by the import flow.\n    if (project.status === 'sent' && summary.anyProgress) {\n      patch.status = 'translating'\n    }\n\n    await sanity.patch(projectId).set(patch).commit()\n\n    return {summary}\n  } catch (err) {\n    // Record the failure and return instead of throwing: a throw would let the\n    // platform retry, and a timed-out fetch has nothing transient to gain. Leave\n    // the existing `progress` untouched (no zeroing-out) and only stamp the error\n    // plus a fresh `progressSyncedAt`, which releases the UI refresh spinner and\n    // makes the log land where the dashboard reads it.\n    const message = err instanceof Error ? err.message : String(err)\n    if (!log.some((l) => l.level === 'error')) log.push({level: 'error', message})\n    await sanity\n      .patch(projectId)\n      .set({lastError: message, functionLog: JSON.stringify(log), progressSyncedAt: timestamp})\n      .commit()\n      .catch(() => {})\n    return {summary: summarizeCompletion(project.progress ?? []), error: message}\n  }\n}\n"],"names":[],"mappings":"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"}

package/dist/_chunks-es/index2.js

@@ -0,0 +1,340 @@
+import { toHTML, escapeHTML } from "@portabletext/to-html";
+import { htmlToBlocks } from "@sanity/block-tools";
+function isExcludedByDocumentI18n(field) {
+  return field.type?.options?.documentInternationalization?.exclude === !0;
+}
+function isSystemType(typeName) {
+  return typeof typeName == "string" && typeName.startsWith("sanity.");
+}
+function isInternationalizedArrayType(type) {
+  return type?.jsonType === "array" && typeof type.name == "string" && type.name.startsWith("internationalizedArray");
+}
+function isInternationalizedArrayMemberType(typeName) {
+  return typeof typeName == "string" && /^internationalizedArray.+Value$/.test(typeName);
+}
+function innerValueType(arrayType) {
+  return arrayType?.of?.[0]?.fields?.find((f) => f.name === "value")?.type;
+}
+function localizationMode(compiledType) {
+  const fields = compiledType?.fields;
+  return Array.isArray(fields) && fields.some((f) => isInternationalizedArrayType(f.type)) ? "field" : "document";
+}
+function getTranslatableFields(compiledType, options = {}) {
+  const rootType = compiledType;
+  if (isSystemType(rootType?.name)) return [];
+  if (!Array.isArray(rootType?.fields)) return [];
+  const result = [];
+  return walkFields(rootType, "", localizationMode(rootType), new Set(options.exclude ?? []), result), result;
+}
+function walkFields(compiledType, prefix, mode, exclude, out) {
+  for (const field of compiledType?.fields ?? []) {
+    if (!field?.name || field.name.startsWith("_") || prefix === "" && exclude.has(field.name)) continue;
+    const forceInclude = field.type?.options?.smartcatTranslation?.include === !0;
+    if (isExcludedByDocumentI18n(field) && !forceInclude) continue;
+    const path = prefix ? `${prefix}.${field.name}` : field.name, title = field.type?.title || titleCase(field.name);
+    if (mode === "field")
+      if (isInternationalizedArrayType(field.type)) {
+        const inner = innerValueType(field.type), shape = classifyValueShape(inner) ?? (forceInclude ? classifyValueShapeByJsonType(inner) : null);
+        shape ? out.push({ path, localization: "field", kind: shape.container === "scalar" ? shape.kind : "plain", title, value: shape }) : forceInclude && warnUntranslatableInclude(field.name, inner);
+      } else isPlainObject(field.type) && walkFields(field.type, path, mode, exclude, out);
+    else {
+      const kind = classifyField(field.type) ?? (forceInclude ? classifyByJsonType(field.type) : null);
+      kind ? out.push({ path, localization: "document", kind, title, value: { container: "scalar", kind } }) : forceInclude && warnUntranslatableInclude(field.name, field.type);
+    }
+  }
+}
+function enumerateLeaves(field, sourceValue) {
+  const base = field.path, shape = field.value ?? { container: "scalar", kind: field.kind };
+  if (shape.container === "scalar")
+    return [{ fullKey: base, valuePath: "", kind: shape.kind, title: field.title }];
+  if (shape.container === "arrayOfScalar")
+    return (Array.isArray(sourceValue) ? sourceValue : []).map((_, i) => ({ fullKey: `${base}[${i}]`, valuePath: `[${i}]`, kind: shape.kind, title: field.title }));
+  if (shape.container === "object")
+    return shape.leaves.map((l) => ({ fullKey: `${base}.${l.subPath}`, valuePath: l.subPath, kind: l.kind, title: l.title ?? field.title }));
+  const arr = Array.isArray(sourceValue) ? sourceValue : [], out = [];
+  for (const item of arr) {
+    const key = item?._key;
+    if (typeof key == "string")
+      for (const l of shape.leaves) {
+        const valuePath = l.subPath ? `[${key}].${l.subPath}` : `[${key}]`;
+        out.push({ fullKey: `${base}${valuePath}`, valuePath, kind: l.kind, title: l.title ?? field.title });
+      }
+  }
+  return out;
+}
+function isPlainObject(type) {
+  return type?.jsonType !== "object" || !Array.isArray(type.fields) || type.fields.some((f) => f.name === "_ref") ? !1 : !["reference", "image", "file", "slug", "geopoint"].includes(type.name ?? "");
+}
+function classifyValueShape(inner) {
+  if (!inner) return null;
+  const scalar = classifyField(inner);
+  if (scalar) return { container: "scalar", kind: scalar };
+  if (inner.jsonType === "array" && Array.isArray(inner.of)) {
+    const member = inner.of[0];
+    if (member?.jsonType === "string" && (member.name === "string" || member.name === "text"))
+      return { container: "arrayOfScalar", kind: "plain" };
+    if (isPlainObject(member)) {
+      const leaves = collectLeaves(member, "");
+      if (leaves.length) return { container: "arrayOfObject", leaves };
+    }
+    return null;
+  }
+  if (isPlainObject(inner)) {
+    const leaves = collectLeaves(inner, "");
+    if (leaves.length) return { container: "object", leaves };
+  }
+  return null;
+}
+function classifyValueShapeByJsonType(inner) {
+  const kind = classifyByJsonType(inner);
+  return kind ? { container: "scalar", kind } : null;
+}
+function collectLeaves(objType, prefix) {
+  const leaves = [];
+  for (const f of objType?.fields ?? []) {
+    if (!f?.name || f.name.startsWith("_") || isExcludedByDocumentI18n(f) && f.type?.options?.smartcatTranslation?.include !== !0) continue;
+    const subPath = prefix ? `${prefix}.${f.name}` : f.name, kind = classifyField(f.type);
+    kind ? leaves.push({ subPath, kind, title: f.type?.title || titleCase(f.name) }) : isPlainObject(f.type) && leaves.push(...collectLeaves(f.type, subPath));
+  }
+  return leaves;
+}
+function isPortableTextArray(type) {
+  return type.jsonType === "array" && Array.isArray(type.of) && type.of.some((member) => member?.name === "block" || member?.jsonType === "block");
+}
+function classifyField(type) {
+  return type ? type.jsonType === "string" && (type.name === "string" || type.name === "text") ? "plain" : isPortableTextArray(type) ? "portableText" : null : null;
+}
+function classifyByJsonType(type) {
+  return type ? type.jsonType === "string" ? "plain" : isPortableTextArray(type) ? "portableText" : null : null;
+}
+function warnUntranslatableInclude(fieldName, type) {
+  console.warn(
+    `[smartcat-translation] Field "${fieldName}" is marked smartcatTranslation.include but its type (name: ${JSON.stringify(type?.name)}, jsonType: ${JSON.stringify(type?.jsonType)}) has no translatable representation; skipping.`
+  );
+}
+function titleCase(name) {
+  return name.replace(/([A-Z])/g, " $1").replace(/^./, (c) => c.toUpperCase());
+}
+function inferTranslatableFields(doc, options = {}) {
+  if (isSystemType(doc._type)) return [];
+  const exclude = new Set(options.exclude ?? []), isI18nArray = (value) => Array.isArray(value) && value.some((m) => m && typeof m == "object" && isInternationalizedArrayMemberType(m._type)), entries = Object.entries(doc).filter(([key]) => !key.startsWith("_") && !exclude.has(key)), fieldMode = entries.some(([, value]) => isI18nArray(value)), result = [];
+  for (const [key, value] of entries)
+    if (fieldMode) {
+      if (!isI18nArray(value)) continue;
+      const sample = value.find((m) => m && typeof m == "object")?.value, kind = sampleKind(sample);
+      kind && result.push({ path: key, kind, localization: "field", title: titleCase(key) });
+    } else typeof value == "string" ? value.length > 0 && result.push({ path: key, kind: "plain", localization: "document", title: titleCase(key) }) : Array.isArray(value) && value.some(isPortableTextBlock) && result.push({ path: key, kind: "portableText", localization: "document", title: titleCase(key) });
+  return result;
+}
+function sampleKind(value) {
+  return typeof value == "string" ? "plain" : Array.isArray(value) && value.some(isPortableTextBlock) ? "portableText" : null;
+}
+function isPortableTextBlock(value) {
+  return !!(value && typeof value == "object" && value._type === "block");
+}
+function orderFieldsBy(fields, orderedPaths) {
+  if (!orderedPaths || orderedPaths.length === 0) return fields;
+  const rank = new Map(orderedPaths.map((path, i) => [path, i])), at = (path) => rank.has(path) ? rank.get(path) : Number.MAX_SAFE_INTEGER;
+  return fields.map((field, i) => ({ field, i })).sort((a, b) => at(a.field.path) - at(b.field.path) || a.i - b.i).map((x) => x.field);
+}
+function parsePath(path) {
+  const segs = [], re = /\.?([^.[\]]+)|\[([^\]]+)\]/g;
+  let m;
+  for (; (m = re.exec(path)) !== null; )
+    m[1] !== void 0 ? segs.push({ field: m[1] }) : /^\d+$/.test(m[2]) ? segs.push({ index: Number(m[2]) }) : segs.push({ key: m[2] });
+  return segs;
+}
+function child(container, seg) {
+  if (!(container == null || typeof container != "object"))
+    return "field" in seg ? container[seg.field] : "index" in seg ? Array.isArray(container) ? container[seg.index] : void 0 : Array.isArray(container) ? container.find((m) => m && typeof m == "object" && m._key === seg.key) : void 0;
+}
+function getAtPath(root, path) {
+  let cur = root;
+  for (const seg of parsePath(path))
+    if (cur = child(cur, seg), cur === void 0) return;
+  return cur;
+}
+function setAtPath(root, path, value) {
+  const segs = parsePath(path);
+  if (segs.length === 0) return value;
+  const clone = structuredClone(root);
+  let cur = clone;
+  for (let i = 0; i < segs.length - 1; i++)
+    if (cur = child(cur, segs[i]), cur == null || typeof cur != "object") return clone;
+  const last = segs[segs.length - 1];
+  if ("field" in last) cur[last.field] = value;
+  else if ("index" in last && Array.isArray(cur)) cur[last.index] = value;
+  else if ("key" in last && Array.isArray(cur)) {
+    const idx = cur.findIndex((m) => m && typeof m == "object" && m._key === last.key);
+    idx >= 0 && (cur[idx] = value);
+  }
+  return clone;
+}
+const SERIALIZABLE_CUSTOM_TYPES = /* @__PURE__ */ new Set(["table"]);
+function tableToHtml(value) {
+  return `<table><tbody>${(Array.isArray(value?.rows) ? value.rows : []).map((row) => `<tr>${(Array.isArray(row?.cells) ? row.cells : []).map((cell) => `<td>${escapeHTML(typeof cell == "string" ? cell : "")}</td>`).join("")}</tr>`).join("")}</tbody></table>`;
+}
+const tableRule = {
+  deserialize(el, _next, createBlock) {
+    if (el.tagName?.toLowerCase() !== "table") return;
+    const rows = Array.from(el.querySelectorAll("tr")).map((tr, i) => ({
+      _type: "tableRow",
+      _key: `row${i}`,
+      cells: Array.from(tr.querySelectorAll("td, th")).map((cell) => cell.textContent ?? "")
+    }));
+    return createBlock({ _type: "table", rows });
+  }
+};
+function portableTextToHtml(blocks) {
+  return !blocks || blocks.length === 0 ? "" : toHTML(blocks, {
+    // Fallback only. Serialization skips any field containing an unserializable
+    // block up front (see findUnserializableBlockTypes), so to-html should never
+    // meet an unknown type here. If one slips through, render it as empty rather
+    // than let @portabletext/to-html emit its default placeholder — a hidden
+    // `<div style="display:none">Unknown block type "…"</div>` whose English text
+    // would otherwise be sent to Smartcat and translated into every locale.
+    // (`onMissingComponent: false` only silences the warning; it does NOT stop the
+    // placeholder — the `unknownType` override is what suppresses it.)
+    onMissingComponent: !1,
+    components: {
+      unknownType: () => "",
+      // Serializable custom block types get real markup so their text is
+      // translatable and can be parsed back (see SERIALIZABLE_CUSTOM_TYPES).
+      types: { table: ({ value }) => tableToHtml(value) }
+    }
+  });
+}
+function findUnserializableBlockTypes(blocks) {
+  if (!Array.isArray(blocks)) return [];
+  const types = /* @__PURE__ */ new Set();
+  for (const block of blocks) {
+    if (!block || typeof block != "object") continue;
+    const type = block._type;
+    if (type !== "block") {
+      typeof type == "string" && !SERIALIZABLE_CUSTOM_TYPES.has(type) && types.add(type);
+      continue;
+    }
+    const children = block.children;
+    if (Array.isArray(children))
+      for (const child2 of children) {
+        const childType = child2?._type;
+        typeof childType == "string" && childType !== "span" && types.add(childType);
+      }
+  }
+  return [...types].sort();
+}
+function portableTextToPlainText(blocks) {
+  if (!Array.isArray(blocks)) return "";
+  let text = "";
+  const visit = (node) => {
+    if (Array.isArray(node))
+      node.forEach(visit);
+    else if (node && typeof node == "object") {
+      const value = node;
+      if (typeof value.text == "string" && (text += value.text), Array.isArray(value.children) && visit(value.children), Array.isArray(value.rows))
+        for (const row of value.rows) {
+          const cells = row?.cells;
+          if (Array.isArray(cells)) for (const cell of cells) typeof cell == "string" && (text += cell);
+        }
+    }
+  };
+  return visit(blocks), text;
+}
+function htmlToPortableText(html, blockContentType, parseHtml) {
+  return html.trim() ? htmlToBlocks(html, blockContentType, {
+    parseHtml,
+    rules: [tableRule]
+  }) : [];
+}
+function serializeToLocjson(doc, fields, options) {
+  const units = [];
+  for (const field of fields) {
+    const source = field.localization === "field" ? memberValue(getAtPath(doc, field.path), options.sourceLanguage, options.fieldLanguageKey) : getAtPath(doc, field.path);
+    for (const leaf of enumerateLeaves(field, source)) {
+      const value = leaf.valuePath ? getAtPath(source, leaf.valuePath) : source, comments = leaf.title ? [leaf.title] : void 0;
+      if (leaf.kind === "plain") {
+        if (typeof value != "string" || value.trim().length === 0) continue;
+        units.push({
+          key: leaf.fullKey,
+          properties: { comments, "x-smartcat-split": "full", "x-sanity": { fieldPath: leaf.fullKey } },
+          // Split into line segments but keep the trailing newline on each, so
+          // concatenating the segments (LocJSON's '' join) reconstructs the original.
+          source: value.split(new RegExp("(?<=\\n)")),
+          target: []
+        });
+      } else {
+        const blocks = value, unserializable = findUnserializableBlockTypes(blocks);
+        if (unserializable.length > 0) {
+          options.onSkippedField?.({ fieldPath: field.path, title: field.title, types: unserializable });
+          continue;
+        }
+        const html = portableTextToHtml(blocks);
+        if (!html || portableTextToPlainText(blocks).trim().length === 0) continue;
+        units.push({
+          key: leaf.fullKey,
+          properties: { comments, "x-smartcat-format": "html", "x-smartcat-split": "full", "x-sanity": { fieldPath: leaf.fullKey } },
+          source: [html],
+          target: []
+        });
+      }
+    }
+  }
+  return {
+    properties: {
+      version: 1,
+      "x-sanity": {
+        documentId: doc._id,
+        documentType: doc._type,
+        rev: doc._rev,
+        sourceLanguage: options.sourceLanguage
+      }
+    },
+    units
+  };
+}
+function memberValue(field, language, languageKey) {
+  return Array.isArray(field) ? field.find(
+    (m) => m && typeof m == "object" && m[languageKey] === language
+  )?.value : void 0;
+}
+function buildLocjsonFilename(documentType, documentId, title, options = {}) {
+  const idPrefix = stripDraft(documentId).slice(0, 8) || "unknown", safeTitle = sanitizeSegment(title || "Untitled"), safeType = sanitizeSegment(documentType) || "document", draftMarker = options.draft ? "-draft" : "";
+  return `${safeType}/${safeTitle}-${idPrefix}${draftMarker}.locjson`;
+}
+function stripDraft(id) {
+  return id.replace(/^drafts\./, "");
+}
+function sanitizeSegment(value) {
+  return value.replace(/[/\\?%*:|"<>]/g, " ").replace(/\s+/g, " ").trim();
+}
+function deserializeFromLocjson(locjson, options) {
+  const fileMeta = locjson.properties?.["x-sanity"], fields = {}, sources = {};
+  for (const unit of locjson.units ?? []) {
+    const fieldPath = unit.properties?.["x-sanity"]?.fieldPath ?? unit.key, value = ((unit.target?.length ? unit.target : unit.source) ?? []).join("");
+    sources[fieldPath] = (unit.source ?? []).join(""), unit.properties?.["x-smartcat-format"] === "html" ? fields[fieldPath] = htmlToPortableText(value, options.getBlockContentType(fieldPath), options.parseHtml) : fields[fieldPath] = value;
+  }
+  return {
+    documentId: fileMeta?.documentId,
+    documentType: fileMeta?.documentType,
+    sourceLanguage: fileMeta?.sourceLanguage,
+    fields,
+    sources
+  };
+}
+export {
+  buildLocjsonFilename,
+  deserializeFromLocjson,
+  enumerateLeaves,
+  getAtPath,
+  getTranslatableFields,
+  htmlToPortableText,
+  inferTranslatableFields,
+  innerValueType,
+  isInternationalizedArrayType,
+  localizationMode,
+  orderFieldsBy,
+  portableTextToHtml,
+  serializeToLocjson,
+  setAtPath
+};
+//# sourceMappingURL=index2.js.map