@focus-reactive/payload-plugin-translator 0.11.0 → 0.11.1

package/README.md

@@ -205,6 +205,45 @@ translatorPlugin({
 });
 ```
 
+### Drafts and publishing
+
+Applies to every way a translation is triggered — the admin controls, `POST /translate/enqueue`, and
+auto-translate. It matters most if your collections have `versions.drafts` enabled.
+
+**Without publish-on-translation**, the translation is written as a **draft version**. The document's
+published state is left alone: a live page stays live, an unpublished one stays unpublished, and the
+translated locale does not appear on the public site until someone publishes it.
+
+**With publish-on-translation**, the translation is written as a draft and the target locale is then
+published — a separate step, so it happens whether or not any field actually needed translating.
+Only the locale that was translated is published; other locales keep whatever state they were in.
+Translating a document that is not currently published does make the document live, with just that
+locale's content in it.
+
+A translation is taken from **the source locale's own current content** — the newer draft when one
+exists, else the published row, never a value Payload substitutes from another locale. Translating
+*from* a locale you have not filled in therefore translates nothing.
+
+Two consequences worth knowing before you rely on them:
+
+- **Publishing publishes the current draft, whatever is in it.** A translation is based on the
+  version the editor sees, and publishing puts that live — including pending edits nobody made for
+  the translation's sake, and including non-localized fields, which Payload stores once per document
+  and so cannot scope to a locale. That is what the flag asks for, but it is worth remembering
+  before running "translate and publish" over a long list of documents: every unpublished draft
+  among them goes live.
+- **`skip_existing` counts anything non-empty as translated.** A translation waiting unpublished in
+  a draft counts, so a reviewer's corrected text is published as it stands rather than
+  re-translated. It has no notion of *reviewed*, and it does not consult stale-detection — a locale
+  the admin marks out of date is still skipped
+  ([#118](https://github.com/focusreactive/payload-plugins/issues/118)).
+
+> **Changed in 0.11.1.** Before this, translating one locale as a draft unpublished the document in
+> every locale, and translating one locale with publishing pushed every other locale's unpublished
+> draft live ([#102](https://github.com/focusreactive/payload-plugins/issues/102)). The source was
+> also read from the published row with fallbacks, so translating from an empty locale translated
+> the default locale's text.
+
 ### Stale-translation detection
 
 _Since v0.8.0._
@@ -221,6 +260,10 @@ Dismiss acknowledges the drift without re-translating; the marker stays hidden u
 changes again. When `provenance` is disabled nothing is shown. Note the fingerprint is text-only, so
 formatting-only edits to rich text do not mark a locale stale.
 
+> **Upgrading to 0.11.1.** Records written earlier fingerprinted the source differently, so a locale
+> can read out of date once after upgrading with nothing actually needing re-translation. Dismissing
+> the marker or re-translating settles it.
+
 ### Auto-translate on source change
 
 _Since v0.9.0._
@@ -249,9 +292,12 @@ translatorPlugin({
 Behaviour: fires only on a **published** source save (draft/autosave saves are ignored; a collection
 without drafts treats every save as published); skips when no translatable content actually changed
 (same fingerprint as stale-detection); coalesces rapid edits via `debounceMs`; the translation is saved
-with the source document's status (published source → published translation); never re-triggers on its
+with the source document's status, scoped to **only the translated locale**; never re-triggers on its
 own translation writes; and never fails the editor's save (best-effort — failures are logged).
 
+> See [Drafts and publishing](#drafts-and-publishing) for what a translation does to a document's
+> published state.
+
 > **Requires a working job runner.** Auto-translate only **enqueues** jobs — they run via the task
 > runner (`createPayloadJobsRunner`) and its autorun loop. On serverless platforms such as **Vercel**,
 > cron-based autorun may not run automatically, so enqueued translations can sit unexecuted until

package/dist/client/widgets/bulk-translation-dashboard/ui/BulkTranslationDashboard.server.js

@@ -1,6 +1,6 @@
 import { jsx as _jsx } from "react/jsx-runtime";
 import { headers as getHeaders } from "next/headers";
-import { collectionHasDrafts } from "../../../../server/shared/guards";
+import { hasDraftsEnabled } from "payload/shared";
 import { resolveAutoTranslateSummary } from "../../../entities/translation/model/autoTranslateSummary";
 import BulkTranslationDashboard from "./BulkTranslationDashboard";
 const BulkTranslationDashboardServer = async (props)=>{
@@ -15,7 +15,7 @@ const BulkTranslationDashboardServer = async (props)=>{
     if (!hasAccess) return null;
     if (!props.collectionSlug) return null;
     const collection = props.payload.collections[props.collectionSlug]?.config;
-    const hasDrafts = collection ? collectionHasDrafts(collection) : false;
+    const hasDrafts = collection ? hasDraftsEnabled(collection) : false;
     const autoTranslate = resolveAutoTranslateSummary(collection, props.payload.config.localization ? props.payload.config.localization.defaultLocale : undefined);
     return /*#__PURE__*/ _jsx(BulkTranslationDashboard, {
         hasDrafts: hasDrafts,

package/dist/client/widgets/translate-document/ui/TranslateDocument.server.js

@@ -1,6 +1,6 @@
 import { jsx as _jsx } from "react/jsx-runtime";
 import { headers as getHeaders } from "next/headers";
-import { collectionHasDrafts } from "../../../../server/shared/guards";
+import { hasDraftsEnabled } from "payload/shared";
 import { resolveAutoTranslateSummary } from "../../../entities/translation/model/autoTranslateSummary";
 import TranslateDocument from "./TranslateDocument";
 async function TranslateDocumentServer(props) {
@@ -14,7 +14,7 @@ async function TranslateDocumentServer(props) {
     });
     if (!hasAccess) return null;
     if (!props.id) return null;
-    const hasDrafts = collectionHasDrafts(props.collection);
+    const hasDrafts = hasDraftsEnabled(props.collection);
     const autoTranslate = resolveAutoTranslateSummary(props.collection, props.payload.config.localization ? props.payload.config.localization.defaultLocale : undefined);
     return /*#__PURE__*/ _jsx(TranslateDocument, {
         hasDrafts: hasDrafts,

package/dist/client/widgets/translate-field-control/ui/TranslateFieldControl.js

@@ -47,8 +47,11 @@ import styles from "./styles.module.scss";
     const { mutateAsync, isPending } = useTranslateField();
     // `config.localization` is `false | {…}`, so the truthy check is load-bearing (not just a nil guard).
     const defaultLocale = config.localization ? config.localization.defaultLocale : undefined;
+    // `useLocale()` is typed `Locale` but actually returns `false | {} | Locale` until the admin's
+    // locale provider resolves (see the V4 TODO on the hook in @payloadcms/ui), so `code` can be absent.
+    const targetCode = locale?.code ?? "";
     const [isOpen, popup] = useToggle();
-    const [sourceLng, setSourceLng] = useState(()=>defaultLocale && defaultLocale !== locale.code ? defaultLocale : "");
+    const [sourceLng, setSourceLng] = useState(()=>defaultLocale && defaultLocale !== targetCode ? defaultLocale : "");
     // `null` = no undo available; an object wraps the value so a legitimately `undefined` field value
     // (a real pre-translation state) stays distinguishable from "nothing to undo".
     const [undo, setUndo] = useState(null);
@@ -57,7 +60,7 @@ import styles from "./styles.module.scss";
     // once translating the unsaved value in place is supported.) All hooks above run unconditionally.
     if (id === undefined || id === null) return null;
     // Source options: every locale except the one being edited (it's the fixed target).
-    const sourceLocaleOptions = localeOptions.filter((option)=>option.value !== locale.code);
+    const sourceLocaleOptions = localeOptions.filter((option)=>option.value !== targetCode);
     const canTranslate = sourceLng !== "" && !isPending;
     // One write path for every supported field type: a form UPDATE bumping value AND initialValue.
     // A Lexical (richText) editor re-mounts on the initialValue change so it shows the new content;
@@ -79,7 +82,7 @@ import styles from "./styles.module.scss";
             const { data } = await mutateAsync({
                 collectionSlug,
                 fieldPath: path,
-                targetLng: locale.code,
+                targetLng: targetCode,
                 sourceLng,
                 docId: id
             });
@@ -132,7 +135,7 @@ import styles from "./styles.module.scss";
                 className: styles.row,
                 children: [
                     /*#__PURE__*/ _jsxs("div", {
-                        "aria-label": `Translation direction: from ${sourceLng || "a source locale"} into ${locale.code}`,
+                        "aria-label": `Translation direction: from ${sourceLng || "a source locale"} into ${targetCode}`,
                         className: styles.direction,
                         role: "group",
                         children: [
@@ -161,9 +164,9 @@ import styles from "./styles.module.scss";
                                 children: "→"
                             }),
                             /*#__PURE__*/ _jsx("span", {
-                                "aria-label": `Target locale: ${locale.code} (the locale you're editing)`,
+                                "aria-label": `Target locale: ${targetCode} (the locale you're editing)`,
                                 className: styles.current,
-                                children: locale.code.toLowerCase()
+                                children: targetCode.toLowerCase()
                             })
                         ]
                     }),
@@ -176,7 +179,7 @@ import styles from "./styles.module.scss";
                             $isIconButton: true,
                             $isLoading: isPending,
                             disabled: !canTranslate,
-                            "aria-label": `Translate from ${sourceLng || "the selected locale"} into ${locale.code}`,
+                            "aria-label": `Translate from ${sourceLng || "the selected locale"} into ${targetCode}`,
                             onClick: handleTranslate,
                             children: /*#__PURE__*/ _jsx(SendIcon, {})
                         })

package/dist/core/translation-pipeline/stages/field-collector/FieldChunkCollector.js

@@ -30,9 +30,6 @@ const asObject = (value)=>isObject(value) ? value : {};
         this.strategy = strategy;
     }
     /** Collects translatable field chunks that need translation. */ collect() {
-        // The read walk SELECTS translatable leaves (via the shared selection core) and records, per
-        // selected leaf, the source value to translate plus its write target. The mutation is applied
-        // in a separate explicit pass below — read and write are no longer fused inside the walk.
         const selected = [];
         const chunks = [];
         const { strategy } = this;
@@ -119,8 +116,6 @@ const asObject = (value)=>isObject(value) ? value : {};
             target: this.targetData,
             path: []
         }, walker);
-        // Apply pass: write each selected leaf's source value into filteredData — this is what gets
-        // translated. Kept separate from the read walk above so selection stays read-only.
         for (const { dataRef, key, sourceValue } of selected){
             dataRef[key] = sourceValue;
         }

package/dist/server/features/translate-document/handler.d.ts

@@ -16,4 +16,5 @@ export declare class TranslateDocumentHandler implements Handler<TranslateDocume
     constructor(translationProvider: TranslationProvider, schemaMap: CollectionSchemaMap, provenanceServiceFactory?: ProvenanceServiceFactory);
     handle(payload: Payload, input: TranslateDocumentInput): Promise<TranslateDocumentOutput>;
     private saveTranslatedDocument;
+    private publishTargetLocale;
 }

package/dist/server/features/translate-document/handler.js

@@ -2,6 +2,10 @@ import { APIError } from "payload";
 import { translateContent } from "../../../core/translation-pipeline";
 import { fetchSourceDocument } from "../../shared/payload/sourceDocument";
 import { AUTO_TRANSLATE_SKIP_CONTEXT_KEY } from "../../../types/AutoTranslateContext";
+import { resolveTargetLayer } from "./targetLayer";
+/** Loop guard: the auto-translate afterChange hook (#51) skips writes carrying this key. */ const translatorWriteContext = ()=>({
+        [AUTO_TRANSLATE_SKIP_CONTEXT_KEY]: true
+    });
 /**
  * Translates a single document from source language to target language. Provenance is delegated to
  * {@link ProvenanceService}: this handler only decides *when* to capture the source fingerprint
@@ -17,71 +21,76 @@ import { AUTO_TRANSLATE_SKIP_CONTEXT_KEY } from "../../../types/AutoTranslateCon
     }
     async handle(payload, input) {
         const { collection, collectionId, sourceLng, targetLng, strategy, publishOnTranslation } = input;
-        // Get original schema (preserves localized: true on nested fields)
         const schema = this.schemaMap.get(collection);
         if (!schema) throw new APIError(`Collection "${collection}" not found in schemaMap`, 400);
-        const sourceData = await fetchSourceDocument(payload, collection, collectionId, sourceLng);
-        // Capture the staleness baseline from the PRISTINE source NOW, before the pipeline runs — it
-        // translates in place and shares object-valued source leaves (e.g. richText nodes) by reference,
-        // so fingerprinting after `translateContent` would hash the target translation and make every
-        // fresh translation look instantly stale. The service is best-effort (a failure returns null).
+        const layer = resolveTargetLayer({
+            versions: payload.collections[collection].config.versions,
+            targetLng
+        });
+        // `draft: true` is unconditional: on a collection without drafts Payload has no version to
+        // substitute, so it returns the only row. The WRITE cannot be so relaxed — the `no-drafts`
+        // layer omits `draft` entirely, because that is the argument shape `main` sent.
+        const [sourceData, currentTargetVersion] = await Promise.all([
+            fetchSourceDocument(payload, collection, collectionId, sourceLng),
+            payload.findByID({
+                collection,
+                id: collectionId,
+                locale: targetLng,
+                fallbackLocale: false,
+                depth: 0,
+                draft: true
+            })
+        ]);
         const provenance = this.provenanceServiceFactory?.(payload);
         const sourceFingerprint = provenance?.captureFingerprint(collection, sourceData) ?? null;
-        const targetData = await payload.findByID({
-            collection,
-            id: collectionId,
-            locale: targetLng,
-            fallbackLocale: false,
-            depth: 0
-        });
         const translatedData = await translateContent({
             schema,
             sourceData,
-            targetData,
+            targetData: currentTargetVersion,
             sourceLng,
             targetLng,
             translationProvider: this.translationProvider,
             strategy
         });
-        if (!translatedData) return {
-            success: true
-        };
-        const collectionConfig = payload.collections[collection].config;
-        await this.saveTranslatedDocument(payload, collection, collectionId, translatedData, targetLng, sourceLng, collectionConfig, publishOnTranslation);
-        if (provenance && sourceFingerprint !== null) {
-            await provenance.record({
-                collectionSlug: collection,
-                documentId: String(collectionId),
-                targetLocale: targetLng,
-                sourceLocale: sourceLng
-            }, sourceFingerprint);
+        if (translatedData) {
+            await this.saveTranslatedDocument(payload, input, translatedData, layer.write);
+            if (provenance && sourceFingerprint !== null) {
+                await provenance.record({
+                    collectionSlug: collection,
+                    documentId: String(collectionId),
+                    targetLocale: targetLng,
+                    sourceLocale: sourceLng
+                }, sourceFingerprint);
+            }
+        }
+        if (publishOnTranslation && layer.kind === "drafts") {
+            await this.publishTargetLocale(payload, input, layer.publish);
         }
         return {
             success: true
         };
     }
-    async saveTranslatedDocument(payload, collection, collectionId, translatedData, targetLng, sourceLng, collectionConfig, publishOnTranslation) {
-        let isAutosaveEnabled = false;
-        const versions = collectionConfig.versions;
-        if (versions && versions.drafts) {
-            translatedData["_status"] = publishOnTranslation ? "published" : "draft";
-            const drafts = versions.drafts;
-            if (!publishOnTranslation && drafts.autosave) isAutosaveEnabled = true;
-        }
+    async saveTranslatedDocument(payload, input, translatedData, write) {
         await payload.update({
-            collection: collection,
-            id: collectionId,
+            collection: input.collection,
+            id: input.collectionId,
             data: translatedData,
-            autosave: isAutosaveEnabled,
-            locale: targetLng,
-            fallbackLocale: sourceLng,
-            // Mark this as a translator-authored write so the auto-translate afterChange hook (#51) skips it
-            // — the loop guard's second barrier, alongside the source-locale check. This write always targets
-            // the TARGET locale, so it is already exempt by locale; the flag also covers any future write
-            // path that could touch the source locale.
-            context: {
-                [AUTO_TRANSLATE_SKIP_CONTEXT_KEY]: true
-            }
+            ...write,
+            locale: input.targetLng,
+            fallbackLocale: input.sourceLng,
+            context: translatorWriteContext()
+        });
+    }
+    async publishTargetLocale(payload, input, publish) {
+        await payload.update({
+            collection: input.collection,
+            id: input.collectionId,
+            data: {
+                _status: publish.status
+            },
+            publishSpecificLocale: publish.publishSpecificLocale,
+            locale: publish.publishSpecificLocale,
+            context: translatorWriteContext()
         });
     }
 }

package/dist/server/features/translate-document/targetLayer.d.ts

@@ -0,0 +1,37 @@
+import type { CollectionConfig } from "payload";
+export type VersionsSlice = CollectionConfig["versions"];
+/** The arguments that publish one locale, once a collection is known to have a draft layer. */
+export type PublishScope = {
+    publishSpecificLocale: string;
+    /**
+     * Merged into the published write's data. Looks redundant beside `publishSpecificLocale`
+     * and is not: without it, any other locale holding a pending draft drags the whole
+     * document back to `draft` (#102).
+     */
+    status: "published";
+};
+/**
+ * Where a translation is written, and — separately — how the locale is published afterwards.
+ *
+ * A union, not one shape with optional fields: `publishSpecificLocale` on a collection with
+ * versions but no drafts drops every other locale from the live row (Payload 3.84.1, silent).
+ * `publish` exists only on the `drafts` variant, so that pair is unbuildable — see
+ * `targetLayer.contract.test.ts`.
+ */
+export type TargetLayer = {
+    kind: "no-drafts";
+    write: {
+        autosave: false;
+    };
+} | {
+    kind: "drafts";
+    write: {
+        draft: true;
+        autosave: boolean;
+    };
+    publish: PublishScope;
+};
+export declare function resolveTargetLayer(args: {
+    versions: VersionsSlice;
+    targetLng: string;
+}): TargetLayer;

package/dist/server/features/translate-document/targetLayer.js

@@ -0,0 +1,26 @@
+import { hasAutosaveEnabled, hasDraftsEnabled } from "payload/shared";
+export function resolveTargetLayer(args) {
+    const { versions, targetLng } = args;
+    const config = {
+        versions
+    };
+    if (!hasDraftsEnabled(config)) return {
+        kind: "no-drafts",
+        write: {
+            autosave: false
+        }
+    };
+    return {
+        kind: "drafts",
+        write: {
+            draft: true,
+            autosave: hasAutosaveEnabled(config)
+        },
+        publish: {
+            publishSpecificLocale: targetLng,
+            status: "published"
+        }
+    };
+}
+
+//# sourceMappingURL=targetLayer.js.map

package/dist/server/features/translate-field/handler.js

@@ -2,6 +2,7 @@ import { getByPath, ServerResponse } from "../../shared";
 import { translateContent } from "../../../core/translation-pipeline";
 import { FieldTranslationInputSchema, MAX_FIELD_VALUE_BYTES } from "./model";
 import { resolveFieldSubtree } from "./resolveFieldSubtree";
+import { fetchSourceDocument } from "../../shared/payload/sourceDocument";
 const byteLength = (value)=>new TextEncoder().encode(JSON.stringify(value) ?? "").length;
 const noop = (value, level, message)=>({
         status: "noop",
@@ -31,16 +32,9 @@ const noop = (value, level, message)=>({
         const { collection_slug, field_path, target_lng, source_lng, doc_id } = parsed.data;
         const fields = this.config.schemaMap.get(collection_slug);
         if (!fields) return ServerResponse.badRequest(`Collection "${collection_slug}" is not available for translation`);
-        // Read the source value from the saved document in `source_lng` (fallbackLocale: false so an
-        // empty source reads as empty → noop, not a fallback). The doc also lets the resolver
-        // disambiguate `blocks` — their `blockType` lives in the data.
-        const sourceDoc = await req.payload.findByID({
-            collection: collection_slug,
-            id: doc_id,
-            locale: source_lng,
-            fallbackLocale: false,
-            depth: 0
-        });
+        // The whole document, not just the field: the resolver needs it to disambiguate `blocks`, whose
+        // `blockType` lives in the data.
+        const sourceDoc = await fetchSourceDocument(req.payload, collection_slug, doc_id, source_lng);
         const sourceValue = getByPath(sourceDoc, field_path);
         // Guard the *translated* payload (held synchronously through the provider call), not the
         // request body, which now carries no field value.

package/dist/server/modules/auto-translate/AutoTranslateEnqueue.hook.js

@@ -1,3 +1,4 @@
+import { hasDraftsEnabled } from "payload/shared";
 import { hasSourceContentChanged } from "../../../core/domain/auto-translate";
 import { AUTO_TRANSLATE_CUSTOM_KEY } from "../../../core/domain/auto-translate";
 import { AUTO_TRANSLATE_SKIP_CONTEXT_KEY } from "../../../types/AutoTranslateContext";
@@ -31,7 +32,7 @@ import { buildAutoTranslateTasks, passesPublishGate } from "./AutoTranslate.poli
                 return doc;
             }
             if (req.locale !== sourceLocale) return doc;
-            const hasDrafts = Boolean(collection.versions && collection.versions.drafts);
+            const hasDrafts = hasDraftsEnabled(collection);
             if (!passesPublishGate(doc, hasDrafts)) return doc;
             const schema = schemaMap.get(collection.slug);
             if (schema && !hasSourceContentChanged(previousDoc, doc, schema)) return doc;

package/dist/server/shared/guards/index.d.ts

@@ -1,3 +1,2 @@
 export type { TranslatableField } from "./field-guards";
 export { isTranslatableField, isLocalizedField, isRelationshipField } from "./field-guards";
-export { collectionHasDrafts } from "./collection-guards";

package/dist/server/shared/guards/index.js

@@ -1,4 +1,3 @@
 export { isTranslatableField, isLocalizedField, isRelationshipField } from "./field-guards";
-export { collectionHasDrafts } from "./collection-guards";
 
 //# sourceMappingURL=index.js.map

package/dist/server/shared/payload/sourceDocument.d.ts

@@ -1,8 +1,6 @@
 import type { CollectionSlug, Payload } from "payload";
 /**
- * Fetch a document's source-locale data with the exact shape the provenance fingerprint depends on
- * (`depth: 0`, the given locale). Used by the translation **write** path (fingerprints the source it
- * just translated) and, through {@link ProvenanceService}, by the staleness **read** path
- * (re-fingerprints the live source), so the fingerprint baseline can never drift between the two.
+ * The single source read: what "translate from X" resolves to. Both translation write paths and
+ * the staleness recompute must go through here, or the fingerprints they compare drift apart.
  */
 export declare function fetchSourceDocument(payload: Payload, collection: CollectionSlug, id: string, locale: string): Promise<import("payload").JsonObject & import("payload").TypeWithID>;

package/dist/server/shared/payload/sourceDocument.js

@@ -1,14 +1,19 @@
 /**
- * Fetch a document's source-locale data with the exact shape the provenance fingerprint depends on
- * (`depth: 0`, the given locale). Used by the translation **write** path (fingerprints the source it
- * just translated) and, through {@link ProvenanceService}, by the staleness **read** path
- * (re-fingerprints the live source), so the fingerprint baseline can never drift between the two.
+ * The single source read: what "translate from X" resolves to. Both translation write paths and
+ * the staleness recompute must go through here, or the fingerprints they compare drift apart.
  */ export function fetchSourceDocument(payload, collection, id, locale) {
     return payload.findByID({
         collection,
         id,
         locale,
-        depth: 0
+        depth: 0,
+        // The current version, as the editor sees it. A published-row read is empty whenever the source
+        // locale is unpublished — which is exactly what a publish scoped to the target locale leaves
+        // behind — and then every fresh translation fingerprints as stale.
+        draft: true,
+        // Payload's locale fallback resolves an empty source locale to the default locale's text, so
+        // "translate from fr" would translate English and fingerprint English as the French source.
+        fallbackLocale: false
     });
 }
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@focus-reactive/payload-plugin-translator",
-  "version": "0.11.0",
+  "version": "0.11.1",
   "description": "Translation plugin for Payload CMS 3.x. Automatically translate your localized content using any translation provider.",
   "type": "module",
   "license": "MIT",

package/dist/server/shared/guards/collection-guards.d.ts

@@ -1,6 +0,0 @@
-import type { CollectionConfig, SanitizedCollectionConfig } from "payload";
-/**
- * Checks if a collection has drafts enabled.
- * Handles both CollectionConfig and SanitizedCollectionConfig.
- */
-export declare function collectionHasDrafts(collection: CollectionConfig | SanitizedCollectionConfig): boolean;

package/dist/server/shared/guards/collection-guards.js

@@ -1,16 +0,0 @@
-/**
- * Type guard: Checks if versions config is an object (not boolean).
- */ function isVersionsObject(versions) {
-    return typeof versions === "object" && versions !== null;
-}
-/**
- * Checks if a collection has drafts enabled.
- * Handles both CollectionConfig and SanitizedCollectionConfig.
- */ export function collectionHasDrafts(collection) {
-    const { versions } = collection;
-    if (!versions) return false;
-    if (!isVersionsObject(versions)) return false;
-    return "drafts" in versions && Boolean(versions.drafts);
-}
-
-//# sourceMappingURL=collection-guards.js.map