@smartcat/sanity-plugin 1.0.1 → 1.1.0

package/dist/locjson.d.cts

@@ -5,12 +5,16 @@
  *
  * The type acts as a folder; the id prefix guarantees uniqueness. Identity on
  * import comes from the file's `x-sanity` metadata, not this name, so renames
- * are safe.
+ * are safe. When the exported content came from the document's draft, a `-draft`
+ * marker is appended so it's visible in Smartcat (`…-3f14f092-draft.locjson`).
  */
 export declare function buildLocjsonFilename(
   documentType: string,
   documentId: string,
   title?: string,
+  options?: {
+    draft?: boolean;
+  },
 ): string;
 
 export declare interface DeserializedDocument {

package/dist/locjson.d.ts

@@ -5,12 +5,16 @@
  *
  * The type acts as a folder; the id prefix guarantees uniqueness. Identity on
  * import comes from the file's `x-sanity` metadata, not this name, so renames
- * are safe.
+ * are safe. When the exported content came from the document's draft, a `-draft`
+ * marker is appended so it's visible in Smartcat (`…-3f14f092-draft.locjson`).
  */
 export declare function buildLocjsonFilename(
   documentType: string,
   documentId: string,
   title?: string,
+  options?: {
+    draft?: boolean;
+  },
 ): string;
 
 export declare interface DeserializedDocument {

package/dist/progress.d.cts

@@ -58,13 +58,14 @@ export declare function hasConfirmedContent(stages: StageProgress[]): boolean;
 /** A target is complete when it has stages and every one is at 100%. */
 export declare function isTargetComplete(stages: StageProgress[]): boolean;
 
-/** Resolves a project's referenced items into the lightweight shape we correlate on. */
+/**
+ * Resolves a project's items into the lightweight shape we correlate on. The id
+ * is the item's stored `docId` — NOT a dereferenced document — so an item whose
+ * document exists only as a draft (never published) still correlates instead of
+ * being silently dropped. Tolerates the legacy `{doc}` projection.
+ */
 export declare function itemsFromProject(project: {
-  items?: {
-    doc: {
-      _id: string;
-    } | null;
-  }[];
+  items?: ProjectItemRef[];
 }): ProjectItem[];
 
 /** Sanitizes an arbitrary string into a stable, Sanity-safe array `_key`. */
@@ -76,6 +77,17 @@ export declare interface ProjectItem {
   title?: string;
 }
 
+/** A project item as read for correlation: its stored id (always present) plus a
+ * best-effort title. `doc` is the legacy shape — some callers still project it. */
+declare interface ProjectItemRef {
+  _id?: string;
+  title?: string;
+  doc?: {
+    _id?: string;
+    title?: string;
+  } | null;
+}
+
 /** Sink for per-request tracing; attach with `SmartcatClient.setRequestLogger`. */
 declare type RequestLogger = (info: RequestLogInfo) => void;
 
@@ -193,11 +205,14 @@ declare interface SmartcatWorkflowStage {
 
 /**
  * Extracts the 8-char source-id prefix Smartcat preserves in a document's
- * filename (built as `<title>-<idPrefix>.locjson`). Used to correlate a Smartcat
+ * filename (built as `<title>-<idPrefix>.locjson`, or `<title>-<idPrefix>-draft.locjson`
+ * when the content came from the document's draft). Used to correlate a Smartcat
  * document back to a Sanity source document.
  *
- * The prefix is always the final 8 characters before the extension, so take the
- * tail rather than splitting on a dash — the title or the id prefix itself can
+ * A trailing `-draft` marker is stripped first, so a draft-sourced file resolves
+ * to the same id as its published counterpart. The prefix is then always the
+ * final 8 characters before the (marker and) extension, so take the tail rather
+ * than splitting on a dash — the title or the id prefix itself can
  * contain dashes (e.g. a custom id like `demo-pdpA` → prefix `demo-pdp`), which
  * would make a last-dash split return the wrong fragment.
  *

package/dist/progress.d.ts

@@ -58,13 +58,14 @@ export declare function hasConfirmedContent(stages: StageProgress[]): boolean;
 /** A target is complete when it has stages and every one is at 100%. */
 export declare function isTargetComplete(stages: StageProgress[]): boolean;
 
-/** Resolves a project's referenced items into the lightweight shape we correlate on. */
+/**
+ * Resolves a project's items into the lightweight shape we correlate on. The id
+ * is the item's stored `docId` — NOT a dereferenced document — so an item whose
+ * document exists only as a draft (never published) still correlates instead of
+ * being silently dropped. Tolerates the legacy `{doc}` projection.
+ */
 export declare function itemsFromProject(project: {
-  items?: {
-    doc: {
-      _id: string;
-    } | null;
-  }[];
+  items?: ProjectItemRef[];
 }): ProjectItem[];
 
 /** Sanitizes an arbitrary string into a stable, Sanity-safe array `_key`. */
@@ -76,6 +77,17 @@ export declare interface ProjectItem {
   title?: string;
 }
 
+/** A project item as read for correlation: its stored id (always present) plus a
+ * best-effort title. `doc` is the legacy shape — some callers still project it. */
+declare interface ProjectItemRef {
+  _id?: string;
+  title?: string;
+  doc?: {
+    _id?: string;
+    title?: string;
+  } | null;
+}
+
 /** Sink for per-request tracing; attach with `SmartcatClient.setRequestLogger`. */
 declare type RequestLogger = (info: RequestLogInfo) => void;
 
@@ -193,11 +205,14 @@ declare interface SmartcatWorkflowStage {
 
 /**
  * Extracts the 8-char source-id prefix Smartcat preserves in a document's
- * filename (built as `<title>-<idPrefix>.locjson`). Used to correlate a Smartcat
+ * filename (built as `<title>-<idPrefix>.locjson`, or `<title>-<idPrefix>-draft.locjson`
+ * when the content came from the document's draft). Used to correlate a Smartcat
  * document back to a Sanity source document.
  *
- * The prefix is always the final 8 characters before the extension, so take the
- * tail rather than splitting on a dash — the title or the id prefix itself can
+ * A trailing `-draft` marker is stripped first, so a draft-sourced file resolves
+ * to the same id as its published counterpart. The prefix is then always the
+ * final 8 characters before the (marker and) extension, so take the tail rather
+ * than splitting on a dash — the title or the id prefix itself can
  * contain dashes (e.g. a custom id like `demo-pdpA` → prefix `demo-pdp`), which
  * would make a last-dash split return the wrong fragment.
  *

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@smartcat/sanity-plugin",
-  "version": "1.0.1",
+  "version": "1.1.0",
   "publishConfig": {
     "access": "public",
     "registry": "https://registry.npmjs.org/"

package/src/actions/AddToProjectAction.tsx

@@ -1,6 +1,6 @@
 import {useCallback, useEffect, useMemo, useState} from 'react'
-import {useClient, useSchema, type DocumentActionComponent, type DocumentActionProps} from 'sanity'
-import {Box, Button, Card, Flex, Inline, Label, Select, Spinner, Stack, Switch, Text, TextInput, useToast} from '@sanity/ui'
+import {useClient, usePerspective, useSchema, type DocumentActionComponent, type DocumentActionProps} from 'sanity'
+import {Badge, Box, Button, Card, Flex, Inline, Label, Select, Spinner, Stack, Switch, Text, TextInput, useToast} from '@sanity/ui'
 import {AddIcon, TranslateIcon} from '@sanity/icons'
 import {uuid} from '@sanity/uuid'
 import {API_VERSION, TRANSLATION_PROJECT_TYPE} from '../lib/constants'
@@ -43,6 +43,12 @@ export function createAddToProjectAction(config: ResolvedSmartcatConfig): Docume
     const client = useClient({apiVersion: API_VERSION})
     const schema = useSchema()
     const toast = useToast()
+    // Which version is the translation source, decided here and stored on the
+    // item (the pill and the export both read it — no re-resolving later): the
+    // published document when the published perspective is selected or there is
+    // no draft; otherwise the draft, which is what the editor sees and edits.
+    const {selectedPerspectiveName} = usePerspective()
+    const sourceIsPublished = selectedPerspectiveName === 'published' || !draft
 
     const [open, setOpen] = useState(false)
     const [projects, setProjects] = useState<ProjectOption[] | null>(null)
@@ -96,6 +102,7 @@ export function createAddToProjectAction(config: ResolvedSmartcatConfig): Docume
           _key: uuid(),
           docId,
           docType,
+          sourceIsPublished,
         })
 
         // The root document plus, optionally, everything it links to — de-duped by id.
@@ -152,7 +159,7 @@ export function createAddToProjectAction(config: ResolvedSmartcatConfig): Docume
       } finally {
         setBusy(false)
       }
-    }, [selection, newName, workflow, publishedId, doc, includeLinked, schema, client, projects, close])
+    }, [selection, newName, workflow, publishedId, doc, includeLinked, sourceIsPublished, schema, client, projects, close])
 
     const content = useMemo(() => {
       if (projects === null) {
@@ -206,7 +213,16 @@ export function createAddToProjectAction(config: ResolvedSmartcatConfig): Docume
           <Card padding={3} radius={2} tone="transparent" border>
             <Stack space={4}>
               <Text size={1} muted>
-                Adding <strong>{docTitle}</strong> to the selected project.
+                Adding{' '}
+                <Badge
+                  tone={sourceIsPublished ? 'positive' : 'caution'}
+                  fontSize={1}
+                  paddingX={2}
+                  style={{verticalAlign: 'middle'}}
+                >
+                  {sourceIsPublished ? 'Published' : 'Draft'}
+                </Badge>{' '}
+                version of <strong>{docTitle}</strong> to the selected project.
               </Text>
               <Flex align="flex-start" gap={3}>
                 <Switch
@@ -239,7 +255,7 @@ export function createAddToProjectAction(config: ResolvedSmartcatConfig): Docume
           </Flex>
         </Stack>
       )
-    }, [projects, selection, newName, workflow, templates, busy, includeLinked, docTitle, close, handleConfirm])
+    }, [projects, selection, newName, workflow, templates, busy, includeLinked, docTitle, sourceIsPublished, close, handleConfirm])
 
     return {
       label: 'Add to translation project',

package/src/import/index.ts

@@ -1,6 +1,6 @@
 import type {SmartcatDocument, SmartcatProject} from '../smartcat/types'
 import {buildProgress, hasConfirmedContent, itemsFromProject, type DocProgress} from '../progress/core'
-import {itemDocDeref} from '../lib/projectItems'
+import {ITEM_ID, itemDocDerefRespectingDraft} from '../lib/projectItems'
 import type {SmartcatLanguageMapping} from '../lib/languageMap'
 import type {LogLine} from '../lib/log'
 
@@ -90,7 +90,7 @@ const PROJECT_QUERY = `*[_id == $id][0]{
   _id,
   smartcatProjectId,
   smartcatLanguages[]{sanityId, smartcatLanguage},
-  "items": items[]{ "doc": ${itemDocDeref('{_id, title}')} },
+  "items": items[]{ "_id": ${ITEM_ID}, "title": ${itemDocDerefRespectingDraft('.title')} },
   progress[]{_key, sourceDocId, title, targets[]{_key, language, smartcatDocumentId, stages, complete, imported, syncedAt}}
 }`
 
@@ -98,7 +98,7 @@ interface ProjectData {
   _id: string
   smartcatProjectId?: string
   smartcatLanguages?: SmartcatLanguageMapping[]
-  items?: {doc: {_id: string; title?: string} | null}[]
+  items?: {_id?: string; title?: string}[]
   progress?: DocProgress[]
 }
 

package/src/lib/locjson/filename.ts

@@ -5,13 +5,20 @@
  *
  * The type acts as a folder; the id prefix guarantees uniqueness. Identity on
  * import comes from the file's `x-sanity` metadata, not this name, so renames
- * are safe.
+ * are safe. When the exported content came from the document's draft, a `-draft`
+ * marker is appended so it's visible in Smartcat (`…-3f14f092-draft.locjson`).
  */
-export function buildLocjsonFilename(documentType: string, documentId: string, title?: string): string {
+export function buildLocjsonFilename(
+  documentType: string,
+  documentId: string,
+  title?: string,
+  options: {draft?: boolean} = {},
+): string {
   const idPrefix = stripDraft(documentId).slice(0, 8) || 'unknown'
   const safeTitle = sanitizeSegment(title || 'Untitled')
   const safeType = sanitizeSegment(documentType) || 'document'
-  return `${safeType}/${safeTitle}-${idPrefix}.locjson`
+  const draftMarker = options.draft ? '-draft' : ''
+  return `${safeType}/${safeTitle}-${idPrefix}${draftMarker}.locjson`
 }
 
 function stripDraft(id: string): string {

package/src/lib/locjson/locjson.test.ts

@@ -22,6 +22,9 @@ import type {LocJSON} from './types'
 const schema = Schema.compile({
   name: 'test',
   types: [
+    // @sanity/table shape: rows of plain-string cells, embedded in Portable Text.
+    {name: 'tableRow', type: 'object', fields: [{name: 'cells', type: 'array', of: [{type: 'string'}]}]},
+    {name: 'table', type: 'object', fields: [{name: 'rows', type: 'array', of: [{type: 'tableRow'}]}]},
     {
       name: 'page',
       type: 'document',
@@ -33,7 +36,7 @@ const schema = Schema.compile({
         {name: 'featured', type: 'boolean'},
         {name: 'tags', type: 'array', of: [{type: 'string'}]},
         {name: 'seo', type: 'object', fields: [{name: 'metaTitle', type: 'string'}]},
-        {name: 'body', type: 'array', of: [{type: 'block'}]},
+        {name: 'body', type: 'array', of: [{type: 'block'}, {type: 'table'}]},
       ],
     },
   ],
@@ -55,6 +58,14 @@ function makeBlock(text: string, marks: string[] = []) {
   }
 }
 
+function makeTable(rows: string[][]) {
+  return {
+    _type: 'table',
+    _key: 't1',
+    rows: rows.map((cells, i) => ({_type: 'tableRow', _key: `row${i}`, cells})),
+  }
+}
+
 describe('getTranslatableFields', () => {
   it('selects string/text/portable-text and excludes the rest', () => {
     const fields = getTranslatableFields(pageType)
@@ -176,26 +187,39 @@ describe('getTranslatableFields', () => {
 
 describe('portableTextToHtml', () => {
   it('renders unknown/custom block types as nothing, not a placeholder', () => {
-    // A custom `table` block (no to-html component). The default behavior emits a
-    // hidden `<div style="display:none">Unknown block type "table"…</div>`, whose
+    // A custom block with no to-html component. The default behavior emits a
+    // hidden `<div style="display:none">Unknown block type "…"</div>`, whose
     // English text would be translated into every locale and which Smartcat
     // rejects as unparseable HTML. It must be dropped entirely instead.
     const blocks = [
       makeBlock('Delivery info'),
-      {_type: 'table', _key: 't1', rows: [{_key: 'r1', _type: 'tableRow', cells: ['Region', 'Price']}]},
+      {_type: 'heroBanner', _key: 'h1', heading: 'Save 20%'},
     ]
     const html = portableTextToHtml(blocks)
     expect(html).not.toContain('Unknown block type')
     expect(html).not.toContain('display:none')
     expect(html).toContain('Delivery info')
   })
+
+  it('renders a table block to an HTML <table>, escaping cell text', () => {
+    const html = portableTextToHtml([makeTable([['Region', 'Price'], ['EU', '<10 & up']])])
+    expect(html).toContain('<table><tbody>')
+    expect(html).toContain('<tr><td>Region</td><td>Price</td></tr>')
+    // cells are HTML-escaped so markup-looking text survives Smartcat's parser
+    expect(html).toContain('<td>&lt;10 &amp; up</td>')
+  })
 })
 
 describe('findUnserializableBlockTypes', () => {
-  const table = {_type: 'table', _key: 't1', rows: [{_key: 'r1', _type: 'tableRow', cells: ['A', 'B']}]}
+  const table = makeTable([['A', 'B']])
 
   it('flags custom top-level block types', () => {
-    expect(findUnserializableBlockTypes([makeBlock('text'), table])).toEqual(['table'])
+    const embed = {_type: 'heroBanner', _key: 'h1', heading: 'x'}
+    expect(findUnserializableBlockTypes([makeBlock('text'), embed])).toEqual(['heroBanner'])
+  })
+
+  it('does NOT flag a table block (it round-trips through HTML)', () => {
+    expect(findUnserializableBlockTypes([makeBlock('text'), table])).toEqual([])
   })
 
   it('flags custom inline children (non-span)', () => {
@@ -295,7 +319,7 @@ describe('serializeToLocjson', () => {
         _id: 'x',
         _type: 'page',
         title: 'Delivery',
-        body: [makeBlock('How much is delivery?'), {_type: 'table', _key: 't1', rows: []}],
+        body: [makeBlock('How much is delivery?'), {_type: 'heroBanner', _key: 'h1', heading: 'x'}],
       },
       fields,
       {
@@ -306,7 +330,18 @@ describe('serializeToLocjson', () => {
     )
     // title still serialized; body left out entirely (not partially)
     expect(result.units.map((u) => u.key)).toEqual(['title'])
-    expect(skipped).toEqual([{fieldPath: 'body', types: ['table']}])
+    expect(skipped).toEqual([{fieldPath: 'body', types: ['heroBanner']}])
+  })
+
+  it('serializes a body containing a table (renders it into the HTML unit)', () => {
+    const result = serializeToLocjson(
+      {_id: 'x', _type: 'page', title: '', body: [makeTable([['Region', 'Price']])]},
+      fields,
+      {sourceLanguage: 'en', fieldLanguageKey: 'language'},
+    )
+    const body = result.units.find((u) => u.key === 'body')!
+    expect(body.properties?.['x-smartcat-format']).toBe('html')
+    expect(body.source[0]).toContain('<td>Region</td>')
   })
 
   it('skips empty fields', () => {
@@ -402,6 +437,35 @@ describe('round-trip', () => {
     const result = deserializeFromLocjson(translated, {parseHtml, getBlockContentType})
     expect(result.fields.title).toBe('À propos')
   })
+
+  it('round-trips a table block, translating its cells', () => {
+    const tableDoc = {
+      _id: 'abc12345-0000',
+      _type: 'page',
+      title: 'Pricing',
+      body: [makeBlock('Our plans:'), makeTable([['Region', 'Price'], ['EU', '€10']])],
+    }
+    const locjson = serializeToLocjson(tableDoc, fields, {sourceLanguage: 'en', fieldLanguageKey: 'language'})
+    // Translate the header cells by rewriting the HTML unit's target.
+    const translated: LocJSON = {
+      ...locjson,
+      units: locjson.units.map((u) =>
+        u.key === 'body'
+          ? {...u, target: [u.source[0].replace('Region', 'Région').replace('Price', 'Prix')]}
+          : {...u, target: [...u.source]},
+      ),
+    }
+    const result = deserializeFromLocjson(translated, {parseHtml, getBlockContentType})
+    const body = result.fields.body as Array<Record<string, unknown>>
+    const table = body.find((b) => b._type === 'table')!
+    const rows = table.rows as Array<{_type: string; _key: string; cells: string[]}>
+    expect(rows.map((r) => r.cells)).toEqual([
+      ['Région', 'Prix'],
+      ['EU', '€10'],
+    ])
+    // rows keep the tableRow type and carry a _key (required for array members)
+    expect(rows.every((r) => r._type === 'tableRow' && typeof r._key === 'string')).toBe(true)
+  })
 })
 
 // --- Field-level localization (sanity-plugin-internationalized-array) ---------
@@ -542,4 +606,10 @@ describe('buildLocjsonFilename', () => {
   it('falls back when title is missing', () => {
     expect(buildLocjsonFilename('page', 'abc12345-0000')).toBe('page/Untitled-abc12345.locjson')
   })
+
+  it('appends a -draft marker when the source was a draft', () => {
+    expect(buildLocjsonFilename('page', '3f14f092-3475', 'About Us', {draft: true})).toBe(
+      'page/About Us-3f14f092-draft.locjson',
+    )
+  })
 })

package/src/lib/locjson/portableText.ts

@@ -1,9 +1,51 @@
-import {toHTML} from '@portabletext/to-html'
-import {htmlToBlocks} from '@sanity/block-tools'
+import {escapeHTML, toHTML} from '@portabletext/to-html'
+import {htmlToBlocks, type DeserializerRule} from '@sanity/block-tools'
 
 /** A Portable Text block (loosely typed — shape varies by schema). */
 export type PortableTextBlock = Record<string, unknown>
 
+/**
+ * Custom (non-`block`) top-level Portable Text types that we *can* round-trip
+ * through HTML, and so must NOT treat as unserializable. Each needs both a
+ * `toHTML` component (below) and an `htmlToBlocks` rule (see {@link tableRule})
+ * so the block survives export → translation → import intact.
+ *
+ * Currently just `@sanity/table`: `{_type:'table', rows:[{_type:'tableRow',
+ * cells: string[]}]}` — plain-string cells, no header row, no col/row spans.
+ */
+const SERIALIZABLE_CUSTOM_TYPES = new Set(['table'])
+
+/** Renders a `@sanity/table` block to an HTML `<table>` for translation. */
+function tableToHtml(value: unknown): string {
+  const rows = Array.isArray((value as {rows?: unknown})?.rows) ? (value as {rows: unknown[]}).rows : []
+  const trs = rows
+    .map((row) => {
+      const cells = Array.isArray((row as {cells?: unknown})?.cells) ? (row as {cells: unknown[]}).cells : []
+      const tds = cells.map((cell) => `<td>${escapeHTML(typeof cell === 'string' ? cell : '')}</td>`).join('')
+      return `<tr>${tds}</tr>`
+    })
+    .join('')
+  return `<table><tbody>${trs}</tbody></table>`
+}
+
+/**
+ * An `htmlToBlocks` rule that turns a translated `<table>` back into a
+ * `@sanity/table` block. Rows get deterministic index-based `_key`s (the whole
+ * field value is replaced on import, so keys need only be unique within the
+ * table); cells are plain strings, matching the schema.
+ */
+const tableRule: DeserializerRule = {
+  deserialize(el, _next, createBlock) {
+    if ((el as Element).tagName?.toLowerCase() !== 'table') return undefined
+    const rows = Array.from((el as Element).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}) as never
+  },
+}
+
 /** Parses an HTML string into a DOM Document. Provided by the environment. */
 export type ParseHtml = (html: string) => Document
 
@@ -23,18 +65,24 @@ export function portableTextToHtml(blocks: PortableTextBlock[] | undefined | nul
     // (`onMissingComponent: false` only silences the warning; it does NOT stop the
     // placeholder — the `unknownType` override is what suppresses it.)
     onMissingComponent: false,
-    components: {unknownType: () => ''},
+    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)},
+    },
   })
 }
 
 /**
  * Distinct `_type`s in a Portable Text value that `@portabletext/to-html` cannot
- * serialize: any top-level member that isn't a standard `block`, or any inline
- * child that isn't a `span` (e.g. a custom `table` block or an inline object).
- * Such nodes render to nothing, so a field containing them can't survive the
- * HTML round-trip — the caller skips the whole field and warns rather than
- * silently drop or corrupt it. Marks/annotations are intentionally not included:
- * their text survives (only the annotation would be lost).
+ * serialize: any top-level member that isn't a standard `block` (and isn't in
+ * {@link SERIALIZABLE_CUSTOM_TYPES}, e.g. `table`, which we render explicitly),
+ * or any inline child that isn't a `span` (e.g. an inline object). Such nodes
+ * render to nothing, so a field containing them can't survive the HTML
+ * round-trip — the caller skips the whole field and warns rather than silently
+ * drop or corrupt it. Marks/annotations are intentionally not included: their
+ * text survives (only the annotation would be lost).
  */
 export function findUnserializableBlockTypes(
   blocks: PortableTextBlock[] | undefined | null,
@@ -45,7 +93,7 @@ export function findUnserializableBlockTypes(
     if (!block || typeof block !== 'object') continue
     const type = (block as {_type?: unknown})._type
     if (type !== 'block') {
-      if (typeof type === 'string') types.add(type)
+      if (typeof type === 'string' && !SERIALIZABLE_CUSTOM_TYPES.has(type)) types.add(type)
       continue
     }
     const children = (block as {children?: unknown}).children
@@ -73,9 +121,17 @@ export function portableTextToPlainText(blocks: PortableTextBlock[] | undefined
     if (Array.isArray(node)) {
       node.forEach(visit)
     } else if (node && typeof node === 'object') {
-      const value = node as {text?: unknown; children?: unknown}
+      const value = node as {text?: unknown; children?: unknown; rows?: unknown}
       if (typeof value.text === 'string') text += value.text
       if (Array.isArray(value.children)) visit(value.children)
+      // `table` blocks carry text in `rows[].cells[]` (plain strings), not spans;
+      // count it so a table-only field isn't judged empty and skipped on export.
+      if (Array.isArray(value.rows)) {
+        for (const row of value.rows) {
+          const cells = (row as {cells?: unknown})?.cells
+          if (Array.isArray(cells)) for (const cell of cells) if (typeof cell === 'string') text += cell
+        }
+      }
     }
   }
   visit(blocks)
@@ -94,5 +150,8 @@ export function htmlToPortableText(
   parseHtml: ParseHtml,
 ): PortableTextBlock[] {
   if (!html.trim()) return []
-  return htmlToBlocks(html, blockContentType as never, {parseHtml}) as unknown as PortableTextBlock[]
+  return htmlToBlocks(html, blockContentType as never, {
+    parseHtml,
+    rules: [tableRule],
+  }) as unknown as PortableTextBlock[]
 }

package/src/lib/projectItems.ts

@@ -15,3 +15,17 @@ export const ITEM_ID_FROM_SUBQUERY = 'coalesce(^.docId, ^._ref)'
 
 /** Dereference an item's document, with an optional projection e.g. `{_id, _type}`. */
 export const itemDocDeref = (projection = ''): string => `*[_id == ${ITEM_ID_FROM_SUBQUERY}][0]${projection}`
+
+/**
+ * Dereference an item's document, honoring where it was added from: items added
+ * in the **published** perspective (`sourceIsPublished == true`) resolve the
+ * published document only; every other item (including legacy items with no
+ * flag) prefers the **draft**, falling back to published. This makes the export
+ * translate the content the editor was actually viewing, and gives pre-existing
+ * projects the draft-preferring default for free.
+ */
+export const itemDocDerefRespectingDraft = (projection = ''): string =>
+  `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})` +
+  `)`

package/src/lib/resolveConfig.ts

@@ -17,6 +17,12 @@ export interface ResolvedSmartcatConfig {
    * plugin's own `smartcat.*` types; otherwise it's list membership.
    */
   isTranslatableType: (type: string) => boolean
+  /**
+   * The explicitly-configured translatable types, verbatim, for display/logging.
+   * `undefined` means none was configured — every non-plugin type is translatable
+   * (see {@link isTranslatableType}). Logic should use the predicate, not this.
+   */
+  translatableTypes?: string[]
   /** Root/standalone types where the linked-documents crawl stops. */
   rootTypes: string[]
   sourceLanguage: string
@@ -35,6 +41,7 @@ export function resolveConfig(config: SmartcatPluginConfig): ResolvedSmartcatCon
 
   return {
     isTranslatableType,
+    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).