payload-translate 1.0.0

package/README.md

@@ -0,0 +1,62 @@
+# payload-translate
+
+AI-powered translation plugin for Payload CMS using Google Gemini.
+
+## Installation
+
+```bash
+pnpm add payload-translate
+# or
+npm install payload-translate
+```
+
+## Setup
+
+```ts
+import { buildConfig } from 'payload'
+import { payloadTranslate } from 'payload-translate'
+
+export default buildConfig({
+  plugins: [
+    payloadTranslate({
+      apiKey: process.env.GEMINI_API_KEY,
+      collections: ['posts', 'pages'],
+    }),
+  ],
+  localization: {
+    defaultLocale: 'en',
+    locales: ['en', 'es', 'fr'],
+  },
+})
+```
+
+## Options
+
+| Option | Type | Required | Description |
+|--------|------|----------|-------------|
+| `apiKey` | `string` | Yes | Google Gemini API key |
+| `collections` | `string[]` | Yes | Collection slugs to enable translation |
+| `disabled` | `boolean` | No | Disable the plugin |
+
+## How It Works
+
+1. Open any document in an enabled collection
+2. Click the **Translate** button
+3. Select target locale
+4. Content is translated via Gemini and saved
+
+## Supported Fields
+
+- Text fields
+- Textarea fields
+- Rich text (Lexical) - preserves formatting
+
+## Requirements
+
+- Payload 3.x
+- Localization enabled in Payload config
+- Google Gemini API key
+
+## License
+
+MIT

package/dist/components/TranslateButton/index.d.ts

@@ -0,0 +1,3 @@
+import React from 'react';
+import './index.scss';
+export declare const TranslateButton: React.FC;

package/dist/components/TranslateButton/index.js

@@ -0,0 +1,150 @@
+'use client';
+import { jsx as _jsx, jsxs as _jsxs, Fragment as _Fragment } from "react/jsx-runtime";
+import { Button, Modal, ReactSelect, useConfig, useDocumentInfo, useLocale, useModal } from '@payloadcms/ui';
+import React, { useCallback, useState } from 'react';
+import { toast } from 'sonner';
+import './index.scss';
+const MODAL_SLUG = 'translate-document-modal';
+export const TranslateButton = ()=>{
+    const { config } = useConfig();
+    const { id, collectionSlug } = useDocumentInfo();
+    const locale = useLocale();
+    const { closeModal, openModal } = useModal();
+    const [isTranslating, setIsTranslating] = useState(false);
+    const [selectedLocale, setSelectedLocale] = useState(null);
+    // Get available locales (exclude current locale)
+    const localization = config.localization;
+    const locales = localization ? localization.locales : [];
+    const availableTargetLocales = locales.filter((l)=>{
+        const code = typeof l === 'string' ? l : l.code;
+        return code !== locale?.code;
+    });
+    const handleTranslate = useCallback(async ()=>{
+        if (!collectionSlug || !id || !locale?.code || !selectedLocale) {
+            return;
+        }
+        setIsTranslating(true);
+        closeModal(MODAL_SLUG);
+        try {
+            const response = await fetch(`${config.serverURL}${config.routes.api}/translate`, {
+                body: JSON.stringify({
+                    collection: collectionSlug,
+                    documentId: id,
+                    sourceLocale: locale.code,
+                    targetLocale: selectedLocale.value
+                }),
+                credentials: 'include',
+                headers: {
+                    'Content-Type': 'application/json'
+                },
+                method: 'POST'
+            });
+            const result = await response.json();
+            if (result.success) {
+                toast.success(result.message || 'Translation complete');
+            } else {
+                toast.error(result.error || 'Translation failed');
+            }
+        } catch (error) {
+            toast.error('Translation request failed');
+            console.error('Translation error:', error);
+        } finally{
+            setIsTranslating(false);
+            setSelectedLocale(null);
+        }
+    }, [
+        closeModal,
+        collectionSlug,
+        config,
+        id,
+        locale,
+        selectedLocale
+    ]);
+    const handleCancel = useCallback(()=>{
+        setSelectedLocale(null);
+        closeModal(MODAL_SLUG);
+    }, [
+        closeModal
+    ]);
+    // Don't render if no localization, no other locales, or document not saved yet
+    if (!config.localization || availableTargetLocales.length === 0 || !id) {
+        return null;
+    }
+    const localeOptions = availableTargetLocales.map((l)=>{
+        if (typeof l === 'string') {
+            return {
+                label: l.toUpperCase(),
+                value: l
+            };
+        }
+        return {
+            label: typeof l.label === 'string' ? l.label : l.code.toUpperCase(),
+            value: l.code
+        };
+    });
+    return /*#__PURE__*/ _jsxs(_Fragment, {
+        children: [
+            /*#__PURE__*/ _jsx(Button, {
+                buttonStyle: "secondary",
+                disabled: isTranslating,
+                onClick: ()=>openModal(MODAL_SLUG),
+                children: isTranslating ? 'Translating...' : 'Translate'
+            }),
+            /*#__PURE__*/ _jsx(Modal, {
+                className: "translate-modal",
+                slug: MODAL_SLUG,
+                children: /*#__PURE__*/ _jsxs("div", {
+                    className: "translate-modal__wrapper",
+                    children: [
+                        /*#__PURE__*/ _jsxs("div", {
+                            className: "translate-modal__content",
+                            children: [
+                                /*#__PURE__*/ _jsx("h3", {
+                                    children: "Translate Document"
+                                }),
+                                /*#__PURE__*/ _jsxs("p", {
+                                    children: [
+                                        "Translate content from ",
+                                        /*#__PURE__*/ _jsx("strong", {
+                                            children: locale?.code?.toUpperCase()
+                                        }),
+                                        " to:"
+                                    ]
+                                }),
+                                /*#__PURE__*/ _jsx("div", {
+                                    className: "translate-modal__select",
+                                    children: /*#__PURE__*/ _jsx(ReactSelect, {
+                                        isClearable: true,
+                                        onChange: (option)=>setSelectedLocale(option),
+                                        options: localeOptions,
+                                        placeholder: "Select target locale...",
+                                        value: selectedLocale ?? undefined
+                                    })
+                                })
+                            ]
+                        }),
+                        /*#__PURE__*/ _jsxs("div", {
+                            className: "translate-modal__controls",
+                            children: [
+                                /*#__PURE__*/ _jsx(Button, {
+                                    buttonStyle: "secondary",
+                                    onClick: handleCancel,
+                                    size: "medium",
+                                    children: "Cancel"
+                                }),
+                                /*#__PURE__*/ _jsx(Button, {
+                                    disabled: !selectedLocale,
+                                    onClick: handleTranslate,
+                                    size: "medium",
+                                    children: "Translate"
+                                })
+                            ]
+                        })
+                    ]
+                })
+            })
+        ]
+    });
+};
+
+//# sourceMappingURL=index.js.map

package/dist/components/TranslateButton/index.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../src/components/TranslateButton/index.tsx"],"sourcesContent":["'use client'\n\nimport type { Locale } from 'payload'\n\nimport {\n  Button,\n  Modal,\n  ReactSelect,\n  type ReactSelectOption,\n  useConfig,\n  useDocumentInfo,\n  useLocale,\n  useModal,\n} from '@payloadcms/ui'\nimport React, { useCallback, useState } from 'react'\nimport { toast } from 'sonner'\n\nimport './index.scss'\n\nconst MODAL_SLUG = 'translate-document-modal'\n\nexport const TranslateButton: React.FC = () => {\n  const { config } = useConfig()\n  const { id, collectionSlug } = useDocumentInfo()\n  const locale = useLocale()\n  const { closeModal, openModal } = useModal()\n  const [isTranslating, setIsTranslating] = useState(false)\n  const [selectedLocale, setSelectedLocale] = useState<null | ReactSelectOption>(null)\n\n  // Get available locales (exclude current locale)\n  const localization = config.localization\n  const locales = localization ? localization.locales : []\n  const availableTargetLocales = locales.filter((l: Locale | string) => {\n    const code = typeof l === 'string' ? l : l.code\n    return code !== locale?.code\n  })\n\n  const handleTranslate = useCallback(async () => {\n    if (!collectionSlug || !id || !locale?.code || !selectedLocale) {\n      return\n    }\n\n    setIsTranslating(true)\n    closeModal(MODAL_SLUG)\n\n    try {\n      const response = await fetch(`${config.serverURL}${config.routes.api}/translate`, {\n        body: JSON.stringify({\n          collection: collectionSlug,\n          documentId: id,\n          sourceLocale: locale.code,\n          targetLocale: selectedLocale.value,\n        }),\n        credentials: 'include',\n        headers: {\n          'Content-Type': 'application/json',\n        },\n        method: 'POST',\n      })\n\n      const result = await response.json()\n\n      if (result.success) {\n        toast.success(result.message || 'Translation complete')\n      } else {\n        toast.error(result.error || 'Translation failed')\n      }\n    } catch (error) {\n      toast.error('Translation request failed')\n      console.error('Translation error:', error)\n    } finally {\n      setIsTranslating(false)\n      setSelectedLocale(null)\n    }\n  }, [closeModal, collectionSlug, config, id, locale, selectedLocale])\n\n  const handleCancel = useCallback(() => {\n    setSelectedLocale(null)\n    closeModal(MODAL_SLUG)\n  }, [closeModal])\n\n  // Don't render if no localization, no other locales, or document not saved yet\n  if (!config.localization || availableTargetLocales.length === 0 || !id) {\n    return null\n  }\n\n  const localeOptions: ReactSelectOption[] = availableTargetLocales.map((l: Locale | string) => {\n    if (typeof l === 'string') {\n      return { label: l.toUpperCase(), value: l }\n    }\n    return {\n      label: typeof l.label === 'string' ? l.label : l.code.toUpperCase(),\n      value: l.code,\n    }\n  })\n\n  return (\n    <>\n      <Button\n        buttonStyle=\"secondary\"\n        disabled={isTranslating}\n        onClick={() => openModal(MODAL_SLUG)}\n      >\n        {isTranslating ? 'Translating...' : 'Translate'}\n      </Button>\n      <Modal className=\"translate-modal\" slug={MODAL_SLUG}>\n        <div className=\"translate-modal__wrapper\">\n          <div className=\"translate-modal__content\">\n            <h3>Translate Document</h3>\n            <p>\n              Translate content from <strong>{locale?.code?.toUpperCase()}</strong> to:\n            </p>\n            <div className=\"translate-modal__select\">\n              <ReactSelect\n                isClearable\n                onChange={(option) => setSelectedLocale(option as ReactSelectOption)}\n                options={localeOptions}\n                placeholder=\"Select target locale...\"\n                value={selectedLocale ?? undefined}\n              />\n            </div>\n          </div>\n          <div className=\"translate-modal__controls\">\n            <Button buttonStyle=\"secondary\" onClick={handleCancel} size=\"medium\">\n              Cancel\n            </Button>\n            <Button disabled={!selectedLocale} onClick={handleTranslate} size=\"medium\">\n              Translate\n            </Button>\n          </div>\n        </div>\n      </Modal>\n    </>\n  )\n}\n"],"names":["Button","Modal","ReactSelect","useConfig","useDocumentInfo","useLocale","useModal","React","useCallback","useState","toast","MODAL_SLUG","TranslateButton","config","id","collectionSlug","locale","closeModal","openModal","isTranslating","setIsTranslating","selectedLocale","setSelectedLocale","localization","locales","availableTargetLocales","filter","l","code","handleTranslate","response","fetch","serverURL","routes","api","body","JSON","stringify","collection","documentId","sourceLocale","targetLocale","value","credentials","headers","method","result","json","success","message","error","console","handleCancel","length","localeOptions","map","label","toUpperCase","buttonStyle","disabled","onClick","className","slug","div","h3","p","strong","isClearable","onChange","option","options","placeholder","undefined","size"],"mappings":"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"}

package/dist/components/TranslateButton/index.scss

@@ -0,0 +1,44 @@
+.translate-modal {
+  display: flex;
+  align-items: center;
+  justify-content: center;
+  position: fixed;
+  inset: 0;
+  z-index: 100;
+  background: rgba(0, 0, 0, 0.5);
+  backdrop-filter: blur(4px);
+
+  &__wrapper {
+    background: var(--theme-bg);
+    border-radius: 8px;
+    padding: 24px;
+    max-width: 400px;
+    width: 90%;
+    box-shadow: 0 4px 24px rgba(0, 0, 0, 0.2);
+  }
+
+  &__content {
+    margin-bottom: 24px;
+
+    h3 {
+      margin: 0 0 8px 0;
+      font-size: 1.25rem;
+      font-weight: 600;
+    }
+
+    p {
+      margin: 0 0 16px 0;
+      color: var(--theme-elevation-600);
+    }
+  }
+
+  &__select {
+    margin-top: 8px;
+  }
+
+  &__controls {
+    display: flex;
+    justify-content: flex-end;
+    gap: 12px;
+  }
+}

package/dist/endpoints/translateHandler.d.ts

@@ -0,0 +1,2 @@
+import type { PayloadHandler } from 'payload';
+export declare const translateHandler: PayloadHandler;

package/dist/endpoints/translateHandler.js

@@ -0,0 +1,114 @@
+import { translateWithGemini } from '../services/gemini.js';
+import { applyTranslations } from '../utils/applyTranslations.js';
+import { extractTranslatableFields } from '../utils/extractTranslatableFields.js';
+export const translateHandler = async (req)=>{
+    try {
+        const { payload, user } = req;
+        // Check authentication
+        if (!user) {
+            return Response.json({
+                error: 'Unauthorized',
+                success: false
+            }, {
+                status: 401
+            });
+        }
+        // Parse request body
+        const body = await req.json?.();
+        if (!body) {
+            return Response.json({
+                error: 'Invalid request body',
+                success: false
+            }, {
+                status: 400
+            });
+        }
+        const { collection, documentId, sourceLocale, targetLocale } = body;
+        // Validate request
+        if (!collection || !documentId || !sourceLocale || !targetLocale) {
+            return Response.json({
+                error: 'Missing required fields',
+                success: false
+            }, {
+                status: 400
+            });
+        }
+        // Get API key from config
+        const apiKey = payload.config.custom?.translateApiKey;
+        if (!apiKey) {
+            return Response.json({
+                error: 'Translation API key not configured',
+                success: false
+            }, {
+                status: 500
+            });
+        }
+        // Fetch document in source locale
+        const document = await payload.findByID({
+            id: documentId,
+            collection,
+            depth: 0,
+            locale: sourceLocale
+        });
+        if (!document) {
+            return Response.json({
+                error: 'Document not found',
+                success: false
+            }, {
+                status: 404
+            });
+        }
+        // Get collection config to find localized fields
+        const collectionConfig = payload.collections[collection]?.config;
+        if (!collectionConfig) {
+            return Response.json({
+                error: 'Collection not found',
+                success: false
+            }, {
+                status: 404
+            });
+        }
+        // Extract translatable fields
+        const translatableFields = extractTranslatableFields(document, collectionConfig.fields);
+        if (translatableFields.length === 0) {
+            return Response.json({
+                message: 'No translatable fields found',
+                success: true,
+                translatedFields: 0
+            });
+        }
+        // Prepare texts for translation
+        const texts = translatableFields.map((f)=>f.value);
+        // Translate with Gemini
+        const translations = await translateWithGemini({
+            apiKey,
+            sourceLocale,
+            targetLocale,
+            texts
+        });
+        // Apply translations to document
+        const updatedData = applyTranslations(document, translatableFields, translations);
+        // Update document in target locale
+        await payload.update({
+            id: documentId,
+            collection,
+            data: updatedData,
+            locale: targetLocale
+        });
+        return Response.json({
+            message: `Successfully translated ${translatableFields.length} field(s)`,
+            success: true,
+            translatedFields: translatableFields.length
+        });
+    } catch (error) {
+        console.error('Translation error:', error);
+        return Response.json({
+            error: error instanceof Error ? error.message : 'Translation failed',
+            success: false
+        }, {
+            status: 500
+        });
+    }
+};
+
+//# sourceMappingURL=translateHandler.js.map

package/dist/endpoints/translateHandler.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../src/endpoints/translateHandler.ts"],"sourcesContent":["import type { PayloadHandler } from 'payload'\n\nimport type { TranslateRequestBody, TranslateResponse } from '../types.js'\n\nimport { translateWithGemini } from '../services/gemini.js'\nimport { applyTranslations } from '../utils/applyTranslations.js'\nimport { extractTranslatableFields } from '../utils/extractTranslatableFields.js'\n\nexport const translateHandler: PayloadHandler = async (req) => {\n  try {\n    const { payload, user } = req\n\n    // Check authentication\n    if (!user) {\n      return Response.json({ error: 'Unauthorized', success: false } as TranslateResponse, {\n        status: 401,\n      })\n    }\n\n    // Parse request body\n    const body = (await req.json?.()) as TranslateRequestBody | undefined\n    if (!body) {\n      return Response.json(\n        { error: 'Invalid request body', success: false } as TranslateResponse,\n        { status: 400 },\n      )\n    }\n    const { collection, documentId, sourceLocale, targetLocale } = body\n\n    // Validate request\n    if (!collection || !documentId || !sourceLocale || !targetLocale) {\n      return Response.json(\n        { error: 'Missing required fields', success: false } as TranslateResponse,\n        { status: 400 },\n      )\n    }\n\n    // Get API key from config\n    const apiKey = (payload.config.custom as Record<string, unknown>)?.translateApiKey as\n      | string\n      | undefined\n    if (!apiKey) {\n      return Response.json(\n        { error: 'Translation API key not configured', success: false } as TranslateResponse,\n        { status: 500 },\n      )\n    }\n\n    // Fetch document in source locale\n    const document = await payload.findByID({\n      id: documentId,\n      collection,\n      depth: 0,\n      locale: sourceLocale,\n    })\n\n    if (!document) {\n      return Response.json({ error: 'Document not found', success: false } as TranslateResponse, {\n        status: 404,\n      })\n    }\n\n    // Get collection config to find localized fields\n    const collectionConfig = payload.collections[collection]?.config\n    if (!collectionConfig) {\n      return Response.json({ error: 'Collection not found', success: false } as TranslateResponse, {\n        status: 404,\n      })\n    }\n\n    // Extract translatable fields\n    const translatableFields = extractTranslatableFields(\n      document as Record<string, unknown>,\n      collectionConfig.fields,\n    )\n\n    if (translatableFields.length === 0) {\n      return Response.json({\n        message: 'No translatable fields found',\n        success: true,\n        translatedFields: 0,\n      } as TranslateResponse)\n    }\n\n    // Prepare texts for translation\n    const texts = translatableFields.map((f) => f.value)\n\n    // Translate with Gemini\n    const translations = await translateWithGemini({\n      apiKey,\n      sourceLocale,\n      targetLocale,\n      texts,\n    })\n\n    // Apply translations to document\n    const updatedData = applyTranslations(\n      document as Record<string, unknown>,\n      translatableFields,\n      translations,\n    )\n\n    // Update document in target locale\n    await payload.update({\n      id: documentId,\n      collection,\n      data: updatedData,\n      locale: targetLocale,\n    })\n\n    return Response.json({\n      message: `Successfully translated ${translatableFields.length} field(s)`,\n      success: true,\n      translatedFields: translatableFields.length,\n    } as TranslateResponse)\n  } catch (error) {\n    console.error('Translation error:', error)\n    return Response.json(\n      {\n        error: error instanceof Error ? error.message : 'Translation failed',\n        success: false,\n      } as TranslateResponse,\n      { status: 500 },\n    )\n  }\n}\n"],"names":["translateWithGemini","applyTranslations","extractTranslatableFields","translateHandler","req","payload","user","Response","json","error","success","status","body","collection","documentId","sourceLocale","targetLocale","apiKey","config","custom","translateApiKey","document","findByID","id","depth","locale","collectionConfig","collections","translatableFields","fields","length","message","translatedFields","texts","map","f","value","translations","updatedData","update","data","console","Error"],"mappings":"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"}

package/dist/exports/client.d.ts

@@ -0,0 +1 @@
+export { TranslateButton } from '../components/TranslateButton/index.js';

package/dist/exports/client.js

@@ -0,0 +1,3 @@
+export { TranslateButton } from '../components/TranslateButton/index.js';
+
+//# sourceMappingURL=client.js.map

package/dist/exports/client.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../src/exports/client.ts"],"sourcesContent":["export { TranslateButton } from '../components/TranslateButton/index.js'\n"],"names":["TranslateButton"],"mappings":"AAAA,SAASA,eAAe,QAAQ,yCAAwC"}

package/dist/exports/rsc.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/exports/rsc.js

@@ -0,0 +1,4 @@
+// RSC exports - currently not used by this plugin
+export { };
+
+//# sourceMappingURL=rsc.js.map

package/dist/exports/rsc.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../src/exports/rsc.ts"],"sourcesContent":["// RSC exports - currently not used by this plugin\nexport {}\n"],"names":[],"mappings":"AAAA,kDAAkD;AAClD,WAAS"}

package/dist/index.d.ts

@@ -0,0 +1,4 @@
+import type { Config } from 'payload';
+import type { PayloadTranslateConfig } from './types.js';
+export type { PayloadTranslateConfig };
+export declare const payloadTranslate: (pluginOptions: PayloadTranslateConfig) => (config: Config) => Config;

package/dist/index.js

@@ -0,0 +1,46 @@
+import { translateHandler } from './endpoints/translateHandler.js';
+export const payloadTranslate = (pluginOptions)=>(config)=>{
+        if (pluginOptions.disabled) {
+            return config;
+        }
+        // Store API key in custom config for endpoint access
+        if (!config.custom) {
+            config.custom = {};
+        }
+        ;
+        config.custom.translateApiKey = pluginOptions.apiKey;
+        // Add TranslateButton to specified collections
+        if (!config.collections) {
+            config.collections = [];
+        }
+        for (const collectionSlug of pluginOptions.collections){
+            const collection = config.collections.find((c)=>c.slug === collectionSlug);
+            if (collection) {
+                if (!collection.admin) {
+                    collection.admin = {};
+                }
+                if (!collection.admin.components) {
+                    collection.admin.components = {};
+                }
+                if (!collection.admin.components.edit) {
+                    collection.admin.components.edit = {};
+                }
+                if (!collection.admin.components.edit.beforeDocumentControls) {
+                    collection.admin.components.edit.beforeDocumentControls = [];
+                }
+                collection.admin.components.edit.beforeDocumentControls.push('payload-translate/client#TranslateButton');
+            }
+        }
+        // Register translation endpoint
+        if (!config.endpoints) {
+            config.endpoints = [];
+        }
+        config.endpoints.push({
+            handler: translateHandler,
+            method: 'post',
+            path: '/translate'
+        });
+        return config;
+    };
+
+//# sourceMappingURL=index.js.map

package/dist/index.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/index.ts"],"sourcesContent":["import type { Config } from 'payload'\n\nimport type { PayloadTranslateConfig } from './types.js'\n\nimport { translateHandler } from './endpoints/translateHandler.js'\n\nexport type { PayloadTranslateConfig }\n\nexport const payloadTranslate =\n  (pluginOptions: PayloadTranslateConfig) =>\n  (config: Config): Config => {\n    if (pluginOptions.disabled) {\n      return config\n    }\n\n    // Store API key in custom config for endpoint access\n    if (!config.custom) {\n      config.custom = {}\n    }\n    ;(config.custom as Record<string, unknown>).translateApiKey = pluginOptions.apiKey\n\n    // Add TranslateButton to specified collections\n    if (!config.collections) {\n      config.collections = []\n    }\n\n    for (const collectionSlug of pluginOptions.collections) {\n      const collection = config.collections.find((c) => c.slug === collectionSlug)\n\n      if (collection) {\n        if (!collection.admin) {\n          collection.admin = {}\n        }\n        if (!collection.admin.components) {\n          collection.admin.components = {}\n        }\n        if (!collection.admin.components.edit) {\n          collection.admin.components.edit = {}\n        }\n        if (!collection.admin.components.edit.beforeDocumentControls) {\n          collection.admin.components.edit.beforeDocumentControls = []\n        }\n\n        collection.admin.components.edit.beforeDocumentControls.push(\n          'payload-translate/client#TranslateButton',\n        )\n      }\n    }\n\n    // Register translation endpoint\n    if (!config.endpoints) {\n      config.endpoints = []\n    }\n\n    config.endpoints.push({\n      handler: translateHandler,\n      method: 'post',\n      path: '/translate',\n    })\n\n    return config\n  }\n"],"names":["translateHandler","payloadTranslate","pluginOptions","config","disabled","custom","translateApiKey","apiKey","collections","collectionSlug","collection","find","c","slug","admin","components","edit","beforeDocumentControls","push","endpoints","handler","method","path"],"mappings":"AAIA,SAASA,gBAAgB,QAAQ,kCAAiC;AAIlE,OAAO,MAAMC,mBACX,CAACC,gBACD,CAACC;QACC,IAAID,cAAcE,QAAQ,EAAE;YAC1B,OAAOD;QACT;QAEA,qDAAqD;QACrD,IAAI,CAACA,OAAOE,MAAM,EAAE;YAClBF,OAAOE,MAAM,GAAG,CAAC;QACnB;;QACEF,OAAOE,MAAM,CAA6BC,eAAe,GAAGJ,cAAcK,MAAM;QAElF,+CAA+C;QAC/C,IAAI,CAACJ,OAAOK,WAAW,EAAE;YACvBL,OAAOK,WAAW,GAAG,EAAE;QACzB;QAEA,KAAK,MAAMC,kBAAkBP,cAAcM,WAAW,CAAE;YACtD,MAAME,aAAaP,OAAOK,WAAW,CAACG,IAAI,CAAC,CAACC,IAAMA,EAAEC,IAAI,KAAKJ;YAE7D,IAAIC,YAAY;gBACd,IAAI,CAACA,WAAWI,KAAK,EAAE;oBACrBJ,WAAWI,KAAK,GAAG,CAAC;gBACtB;gBACA,IAAI,CAACJ,WAAWI,KAAK,CAACC,UAAU,EAAE;oBAChCL,WAAWI,KAAK,CAACC,UAAU,GAAG,CAAC;gBACjC;gBACA,IAAI,CAACL,WAAWI,KAAK,CAACC,UAAU,CAACC,IAAI,EAAE;oBACrCN,WAAWI,KAAK,CAACC,UAAU,CAACC,IAAI,GAAG,CAAC;gBACtC;gBACA,IAAI,CAACN,WAAWI,KAAK,CAACC,UAAU,CAACC,IAAI,CAACC,sBAAsB,EAAE;oBAC5DP,WAAWI,KAAK,CAACC,UAAU,CAACC,IAAI,CAACC,sBAAsB,GAAG,EAAE;gBAC9D;gBAEAP,WAAWI,KAAK,CAACC,UAAU,CAACC,IAAI,CAACC,sBAAsB,CAACC,IAAI,CAC1D;YAEJ;QACF;QAEA,gCAAgC;QAChC,IAAI,CAACf,OAAOgB,SAAS,EAAE;YACrBhB,OAAOgB,SAAS,GAAG,EAAE;QACvB;QAEAhB,OAAOgB,SAAS,CAACD,IAAI,CAAC;YACpBE,SAASpB;YACTqB,QAAQ;YACRC,MAAM;QACR;QAEA,OAAOnB;IACT,EAAC"}

package/dist/services/gemini.d.ts

@@ -0,0 +1,6 @@
+import type { GeminiTranslationRequest } from '../types.js';
+type TranslateWithGeminiArgs = {
+    apiKey: string;
+} & GeminiTranslationRequest;
+export declare function translateWithGemini({ apiKey, sourceLocale, targetLocale, texts, }: TranslateWithGeminiArgs): Promise<string[]>;
+export {};

package/dist/services/gemini.js

@@ -0,0 +1,84 @@
+const GEMINI_API_URL = 'https://generativelanguage.googleapis.com/v1beta/models/gemini-2.5-flash:generateContent';
+export async function translateWithGemini({ apiKey, sourceLocale, targetLocale, texts }) {
+    if (texts.length === 0) {
+        return [];
+    }
+    const prompt = buildTranslationPrompt(texts, sourceLocale, targetLocale);
+    const response = await fetch(`${GEMINI_API_URL}?key=${apiKey}`, {
+        body: JSON.stringify({
+            contents: [
+                {
+                    parts: [
+                        {
+                            text: prompt
+                        }
+                    ]
+                }
+            ],
+            generationConfig: {
+                maxOutputTokens: 8192,
+                temperature: 0.1,
+                thinkingConfig: {
+                    thinkingBudget: 0
+                },
+                topP: 0.95
+            }
+        }),
+        headers: {
+            'Content-Type': 'application/json'
+        },
+        method: 'POST'
+    });
+    if (!response.ok) {
+        const error = await response.text();
+        throw new Error(`Gemini API error: ${error}`);
+    }
+    const result = await response.json();
+    // Handle response - find the text part
+    const parts = result.candidates?.[0]?.content?.parts || [];
+    const textPart = parts.find((p)=>p.text !== undefined);
+    const generatedText = textPart?.text;
+    if (!generatedText) {
+        throw new Error(`No translation returned from Gemini. Response: ${JSON.stringify(result)}`);
+    }
+    return parseTranslationResponse(generatedText, texts.length);
+}
+function buildTranslationPrompt(texts, sourceLocale, targetLocale) {
+    const textsJson = JSON.stringify(texts);
+    return `You are a professional translator. Translate the following texts from ${sourceLocale} to ${targetLocale}.
+
+IMPORTANT RULES:
+1. Maintain the exact same formatting, including HTML tags, markdown, and special characters
+2. Do not translate proper nouns, brand names, or code/technical terms unless they have standard translations
+3. Preserve any placeholder variables like {{name}} or {0}
+4. Return ONLY a valid JSON array with the translations in the same order
+5. Each translation should correspond to the input at the same index
+
+Input texts (JSON array):
+${textsJson}
+
+Return ONLY the JSON array of translations, nothing else. Example format:
+["translated text 1", "translated text 2"]`;
+}
+function parseTranslationResponse(response, expectedCount) {
+    let jsonStr = response.trim();
+    // Handle code blocks if present
+    if (jsonStr.startsWith('```')) {
+        jsonStr = jsonStr.replace(/```json?\n?/g, '').replace(/```/g, '').trim();
+    }
+    try {
+        const translations = JSON.parse(jsonStr);
+        if (!Array.isArray(translations)) {
+            throw new Error('Response is not an array');
+        }
+        if (translations.length !== expectedCount) {
+            console.warn(`Expected ${expectedCount} translations, got ${translations.length}`);
+        }
+        return translations;
+    } catch (_error) {
+        console.error('Failed to parse translation response:', response);
+        throw new Error('Failed to parse translation response from Gemini');
+    }
+}
+
+//# sourceMappingURL=gemini.js.map

package/dist/services/gemini.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../src/services/gemini.ts"],"sourcesContent":["import type { GeminiTranslationRequest } from '../types.js'\n\ntype TranslateWithGeminiArgs = {\n  apiKey: string\n} & GeminiTranslationRequest\n\nconst GEMINI_API_URL =\n  'https://generativelanguage.googleapis.com/v1beta/models/gemini-2.5-flash:generateContent'\n\nexport async function translateWithGemini({\n  apiKey,\n  sourceLocale,\n  targetLocale,\n  texts,\n}: TranslateWithGeminiArgs): Promise<string[]> {\n  if (texts.length === 0) {\n    return []\n  }\n\n  const prompt = buildTranslationPrompt(texts, sourceLocale, targetLocale)\n\n  const response = await fetch(`${GEMINI_API_URL}?key=${apiKey}`, {\n    body: JSON.stringify({\n      contents: [\n        {\n          parts: [{ text: prompt }],\n        },\n      ],\n      generationConfig: {\n        maxOutputTokens: 8192,\n        temperature: 0.1,\n        thinkingConfig: {\n          thinkingBudget: 0,\n        },\n        topP: 0.95,\n      },\n    }),\n    headers: {\n      'Content-Type': 'application/json',\n    },\n    method: 'POST',\n  })\n\n  if (!response.ok) {\n    const error = await response.text()\n    throw new Error(`Gemini API error: ${error}`)\n  }\n\n  const result = await response.json()\n\n  // Handle response - find the text part\n  const parts = result.candidates?.[0]?.content?.parts || []\n  const textPart = parts.find((p: { text?: string }) => p.text !== undefined)\n  const generatedText = textPart?.text\n\n  if (!generatedText) {\n    throw new Error(`No translation returned from Gemini. Response: ${JSON.stringify(result)}`)\n  }\n\n  return parseTranslationResponse(generatedText, texts.length)\n}\n\nfunction buildTranslationPrompt(\n  texts: string[],\n  sourceLocale: string,\n  targetLocale: string,\n): string {\n  const textsJson = JSON.stringify(texts)\n\n  return `You are a professional translator. Translate the following texts from ${sourceLocale} to ${targetLocale}.\n\nIMPORTANT RULES:\n1. Maintain the exact same formatting, including HTML tags, markdown, and special characters\n2. Do not translate proper nouns, brand names, or code/technical terms unless they have standard translations\n3. Preserve any placeholder variables like {{name}} or {0}\n4. Return ONLY a valid JSON array with the translations in the same order\n5. Each translation should correspond to the input at the same index\n\nInput texts (JSON array):\n${textsJson}\n\nReturn ONLY the JSON array of translations, nothing else. Example format:\n[\"translated text 1\", \"translated text 2\"]`\n}\n\nfunction parseTranslationResponse(response: string, expectedCount: number): string[] {\n  let jsonStr = response.trim()\n\n  // Handle code blocks if present\n  if (jsonStr.startsWith('```')) {\n    jsonStr = jsonStr.replace(/```json?\\n?/g, '').replace(/```/g, '').trim()\n  }\n\n  try {\n    const translations = JSON.parse(jsonStr)\n\n    if (!Array.isArray(translations)) {\n      throw new Error('Response is not an array')\n    }\n\n    if (translations.length !== expectedCount) {\n      console.warn(`Expected ${expectedCount} translations, got ${translations.length}`)\n    }\n\n    return translations\n  } catch (_error) {\n    console.error('Failed to parse translation response:', response)\n    throw new Error('Failed to parse translation response from Gemini')\n  }\n}\n"],"names":["GEMINI_API_URL","translateWithGemini","apiKey","sourceLocale","targetLocale","texts","length","prompt","buildTranslationPrompt","response","fetch","body","JSON","stringify","contents","parts","text","generationConfig","maxOutputTokens","temperature","thinkingConfig","thinkingBudget","topP","headers","method","ok","error","Error","result","json","candidates","content","textPart","find","p","undefined","generatedText","parseTranslationResponse","textsJson","expectedCount","jsonStr","trim","startsWith","replace","translations","parse","Array","isArray","console","warn","_error"],"mappings":"AAMA,MAAMA,iBACJ;AAEF,OAAO,eAAeC,oBAAoB,EACxCC,MAAM,EACNC,YAAY,EACZC,YAAY,EACZC,KAAK,EACmB;IACxB,IAAIA,MAAMC,MAAM,KAAK,GAAG;QACtB,OAAO,EAAE;IACX;IAEA,MAAMC,SAASC,uBAAuBH,OAAOF,cAAcC;IAE3D,MAAMK,WAAW,MAAMC,MAAM,GAAGV,eAAe,KAAK,EAAEE,QAAQ,EAAE;QAC9DS,MAAMC,KAAKC,SAAS,CAAC;YACnBC,UAAU;gBACR;oBACEC,OAAO;wBAAC;4BAAEC,MAAMT;wBAAO;qBAAE;gBAC3B;aACD;YACDU,kBAAkB;gBAChBC,iBAAiB;gBACjBC,aAAa;gBACbC,gBAAgB;oBACdC,gBAAgB;gBAClB;gBACAC,MAAM;YACR;QACF;QACAC,SAAS;YACP,gBAAgB;QAClB;QACAC,QAAQ;IACV;IAEA,IAAI,CAACf,SAASgB,EAAE,EAAE;QAChB,MAAMC,QAAQ,MAAMjB,SAASO,IAAI;QACjC,MAAM,IAAIW,MAAM,CAAC,kBAAkB,EAAED,OAAO;IAC9C;IAEA,MAAME,SAAS,MAAMnB,SAASoB,IAAI;IAElC,uCAAuC;IACvC,MAAMd,QAAQa,OAAOE,UAAU,EAAE,CAAC,EAAE,EAAEC,SAAShB,SAAS,EAAE;IAC1D,MAAMiB,WAAWjB,MAAMkB,IAAI,CAAC,CAACC,IAAyBA,EAAElB,IAAI,KAAKmB;IACjE,MAAMC,gBAAgBJ,UAAUhB;IAEhC,IAAI,CAACoB,eAAe;QAClB,MAAM,IAAIT,MAAM,CAAC,+CAA+C,EAAEf,KAAKC,SAAS,CAACe,SAAS;IAC5F;IAEA,OAAOS,yBAAyBD,eAAe/B,MAAMC,MAAM;AAC7D;AAEA,SAASE,uBACPH,KAAe,EACfF,YAAoB,EACpBC,YAAoB;IAEpB,MAAMkC,YAAY1B,KAAKC,SAAS,CAACR;IAEjC,OAAO,CAAC,sEAAsE,EAAEF,aAAa,IAAI,EAAEC,aAAa;;;;;;;;;;AAUlH,EAAEkC,UAAU;;;0CAG8B,CAAC;AAC3C;AAEA,SAASD,yBAAyB5B,QAAgB,EAAE8B,aAAqB;IACvE,IAAIC,UAAU/B,SAASgC,IAAI;IAE3B,gCAAgC;IAChC,IAAID,QAAQE,UAAU,CAAC,QAAQ;QAC7BF,UAAUA,QAAQG,OAAO,CAAC,gBAAgB,IAAIA,OAAO,CAAC,QAAQ,IAAIF,IAAI;IACxE;IAEA,IAAI;QACF,MAAMG,eAAehC,KAAKiC,KAAK,CAACL;QAEhC,IAAI,CAACM,MAAMC,OAAO,CAACH,eAAe;YAChC,MAAM,IAAIjB,MAAM;QAClB;QAEA,IAAIiB,aAAatC,MAAM,KAAKiC,eAAe;YACzCS,QAAQC,IAAI,CAAC,CAAC,SAAS,EAAEV,cAAc,mBAAmB,EAAEK,aAAatC,MAAM,EAAE;QACnF;QAEA,OAAOsC;IACT,EAAE,OAAOM,QAAQ;QACfF,QAAQtB,KAAK,CAAC,yCAAyCjB;QACvD,MAAM,IAAIkB,MAAM;IAClB;AACF"}

package/dist/types.d.ts

@@ -0,0 +1,42 @@
+import type { CollectionSlug } from 'payload';
+export type PayloadTranslateConfig = {
+    /**
+     * Google Gemini API key for translations
+     */
+    apiKey: string;
+    /**
+     * List of collection slugs to enable translation for
+     */
+    collections: CollectionSlug[];
+    /**
+     * Whether the plugin is disabled
+     */
+    disabled?: boolean;
+};
+export type TranslateRequestBody = {
+    collection: string;
+    documentId: number | string;
+    sourceLocale: string;
+    targetLocale: string;
+};
+export type TranslateResponse = {
+    error?: string;
+    message?: string;
+    success: boolean;
+    translatedFields?: number;
+};
+export type TranslatableField = {
+    /**
+     * For richText fields, the path within the Lexical structure to the text node
+     * e.g., "root.children.0.children.1"
+     */
+    lexicalPath?: string;
+    path: string;
+    type: 'richText' | 'text' | 'textarea';
+    value: string;
+};
+export type GeminiTranslationRequest = {
+    sourceLocale: string;
+    targetLocale: string;
+    texts: string[];
+};

package/dist/types.js

@@ -0,0 +1,3 @@
+export { };
+
+//# sourceMappingURL=types.js.map

package/dist/types.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/types.ts"],"sourcesContent":["import type { CollectionSlug } from 'payload'\n\nexport type PayloadTranslateConfig = {\n  /**\n   * Google Gemini API key for translations\n   */\n  apiKey: string\n  /**\n   * List of collection slugs to enable translation for\n   */\n  collections: CollectionSlug[]\n  /**\n   * Whether the plugin is disabled\n   */\n  disabled?: boolean\n}\n\nexport type TranslateRequestBody = {\n  collection: string\n  documentId: number | string\n  sourceLocale: string\n  targetLocale: string\n}\n\nexport type TranslateResponse = {\n  error?: string\n  message?: string\n  success: boolean\n  translatedFields?: number\n}\n\nexport type TranslatableField = {\n  /**\n   * For richText fields, the path within the Lexical structure to the text node\n   * e.g., \"root.children.0.children.1\"\n   */\n  lexicalPath?: string\n  path: string\n  type: 'richText' | 'text' | 'textarea'\n  value: string\n}\n\nexport type GeminiTranslationRequest = {\n  sourceLocale: string\n  targetLocale: string\n  texts: string[]\n}\n"],"names":[],"mappings":"AA0CA,WAIC"}

package/dist/utils/applyTranslations.d.ts

@@ -0,0 +1,2 @@
+import type { TranslatableField } from '../types.js';
+export declare function applyTranslations(originalData: Record<string, unknown>, fields: TranslatableField[], translations: string[]): Record<string, unknown>;

package/dist/utils/applyTranslations.js

@@ -0,0 +1,80 @@
+export function applyTranslations(originalData, fields, translations) {
+    // Deep clone the original data
+    const result = JSON.parse(JSON.stringify(originalData));
+    fields.forEach((field, index)=>{
+        const translation = translations[index];
+        if (translation === undefined) {
+            return;
+        }
+        if (field.type === 'richText' && field.lexicalPath) {
+            // For rich text, apply translation to the specific text node in the Lexical structure
+            applyLexicalTranslation(result, field.path, field.lexicalPath, translation);
+        } else {
+            // For text/textarea, directly set the translation
+            setNestedValue(result, field.path, translation);
+        }
+    });
+    return result;
+}
+/**
+ * Apply a translation to a specific text node within a Lexical rich text field.
+ * @param data - The document data object
+ * @param fieldPath - Path to the rich text field (e.g., "content")
+ * @param lexicalPath - Path within the Lexical structure (e.g., "root.children.0.children.1")
+ * @param translation - The translated text
+ */ function applyLexicalTranslation(data, fieldPath, lexicalPath, translation) {
+    // Get the Lexical editor state object
+    const lexicalState = getNestedValue(data, fieldPath);
+    if (!lexicalState || typeof lexicalState !== 'object') {
+        return;
+    }
+    // Navigate to the text node and update its text property
+    const pathParts = lexicalPath.split('.');
+    let current = lexicalState;
+    for(let i = 0; i < pathParts.length; i++){
+        const key = pathParts[i];
+        if (current && typeof current === 'object' && key in current) {
+            if (i === pathParts.length - 1) {
+                // We're at the text node, update the text property
+                ;
+                current[key] = current[key];
+            }
+            current = current[key];
+        } else {
+            return; // Path not found
+        }
+    }
+    // current should now be the text node
+    if (current && typeof current === 'object' && 'text' in current) {
+        ;
+        current.text = translation;
+    }
+}
+function getNestedValue(obj, path) {
+    const keys = path.split('.');
+    let current = obj;
+    for (const key of keys){
+        if (current && typeof current === 'object' && key in current) {
+            current = current[key];
+        } else {
+            return undefined;
+        }
+    }
+    return current;
+}
+function setNestedValue(obj, path, value) {
+    const keys = path.split('.');
+    let current = obj;
+    for(let i = 0; i < keys.length - 1; i++){
+        const key = keys[i];
+        const nextKey = keys[i + 1];
+        if (!(key in current)) {
+            // Create array or object based on next key
+            current[key] = isNaN(Number(nextKey)) ? {} : [];
+        }
+        current = current[key];
+    }
+    current[keys[keys.length - 1]] = value;
+}
+
+//# sourceMappingURL=applyTranslations.js.map

package/dist/utils/applyTranslations.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../src/utils/applyTranslations.ts"],"sourcesContent":["import type { TranslatableField } from '../types.js'\n\nexport function applyTranslations(\n  originalData: Record<string, unknown>,\n  fields: TranslatableField[],\n  translations: string[],\n): Record<string, unknown> {\n  // Deep clone the original data\n  const result = JSON.parse(JSON.stringify(originalData)) as Record<string, unknown>\n\n  fields.forEach((field, index) => {\n    const translation = translations[index]\n    if (translation === undefined) {\n      return\n    }\n\n    if (field.type === 'richText' && field.lexicalPath) {\n      // For rich text, apply translation to the specific text node in the Lexical structure\n      applyLexicalTranslation(result, field.path, field.lexicalPath, translation)\n    } else {\n      // For text/textarea, directly set the translation\n      setNestedValue(result, field.path, translation)\n    }\n  })\n\n  return result\n}\n\n/**\n * Apply a translation to a specific text node within a Lexical rich text field.\n * @param data - The document data object\n * @param fieldPath - Path to the rich text field (e.g., \"content\")\n * @param lexicalPath - Path within the Lexical structure (e.g., \"root.children.0.children.1\")\n * @param translation - The translated text\n */\nfunction applyLexicalTranslation(\n  data: Record<string, unknown>,\n  fieldPath: string,\n  lexicalPath: string,\n  translation: string,\n): void {\n  // Get the Lexical editor state object\n  const lexicalState = getNestedValue(data, fieldPath)\n  if (!lexicalState || typeof lexicalState !== 'object') {\n    return\n  }\n\n  // Navigate to the text node and update its text property\n  const pathParts = lexicalPath.split('.')\n  let current: unknown = lexicalState\n\n  for (let i = 0; i < pathParts.length; i++) {\n    const key = pathParts[i]\n    if (current && typeof current === 'object' && key in current) {\n      if (i === pathParts.length - 1) {\n        // We're at the text node, update the text property\n        ;(current as Record<string, unknown>)[key] = current[key as keyof typeof current]\n      }\n      current = (current as Record<string, unknown>)[key]\n    } else {\n      return // Path not found\n    }\n  }\n\n  // current should now be the text node\n  if (current && typeof current === 'object' && 'text' in current) {\n    ;(current as Record<string, unknown>).text = translation\n  }\n}\n\nfunction getNestedValue(obj: Record<string, unknown>, path: string): unknown {\n  const keys = path.split('.')\n  let current: unknown = obj\n\n  for (const key of keys) {\n    if (current && typeof current === 'object' && key in current) {\n      current = (current as Record<string, unknown>)[key]\n    } else {\n      return undefined\n    }\n  }\n\n  return current\n}\n\nfunction setNestedValue(obj: Record<string, unknown>, path: string, value: unknown): void {\n  const keys = path.split('.')\n  let current: Record<string, unknown> = obj\n\n  for (let i = 0; i < keys.length - 1; i++) {\n    const key = keys[i]\n    const nextKey = keys[i + 1]\n\n    if (!(key in current)) {\n      // Create array or object based on next key\n      current[key] = isNaN(Number(nextKey)) ? {} : []\n    }\n\n    current = current[key] as Record<string, unknown>\n  }\n\n  current[keys[keys.length - 1]] = value\n}\n"],"names":["applyTranslations","originalData","fields","translations","result","JSON","parse","stringify","forEach","field","index","translation","undefined","type","lexicalPath","applyLexicalTranslation","path","setNestedValue","data","fieldPath","lexicalState","getNestedValue","pathParts","split","current","i","length","key","text","obj","keys","value","nextKey","isNaN","Number"],"mappings":"AAEA,OAAO,SAASA,kBACdC,YAAqC,EACrCC,MAA2B,EAC3BC,YAAsB;IAEtB,+BAA+B;IAC/B,MAAMC,SAASC,KAAKC,KAAK,CAACD,KAAKE,SAAS,CAACN;IAEzCC,OAAOM,OAAO,CAAC,CAACC,OAAOC;QACrB,MAAMC,cAAcR,YAAY,CAACO,MAAM;QACvC,IAAIC,gBAAgBC,WAAW;YAC7B;QACF;QAEA,IAAIH,MAAMI,IAAI,KAAK,cAAcJ,MAAMK,WAAW,EAAE;YAClD,sFAAsF;YACtFC,wBAAwBX,QAAQK,MAAMO,IAAI,EAAEP,MAAMK,WAAW,EAAEH;QACjE,OAAO;YACL,kDAAkD;YAClDM,eAAeb,QAAQK,MAAMO,IAAI,EAAEL;QACrC;IACF;IAEA,OAAOP;AACT;AAEA;;;;;;CAMC,GACD,SAASW,wBACPG,IAA6B,EAC7BC,SAAiB,EACjBL,WAAmB,EACnBH,WAAmB;IAEnB,sCAAsC;IACtC,MAAMS,eAAeC,eAAeH,MAAMC;IAC1C,IAAI,CAACC,gBAAgB,OAAOA,iBAAiB,UAAU;QACrD;IACF;IAEA,yDAAyD;IACzD,MAAME,YAAYR,YAAYS,KAAK,CAAC;IACpC,IAAIC,UAAmBJ;IAEvB,IAAK,IAAIK,IAAI,GAAGA,IAAIH,UAAUI,MAAM,EAAED,IAAK;QACzC,MAAME,MAAML,SAAS,CAACG,EAAE;QACxB,IAAID,WAAW,OAAOA,YAAY,YAAYG,OAAOH,SAAS;YAC5D,IAAIC,MAAMH,UAAUI,MAAM,GAAG,GAAG;gBAC9B,mDAAmD;;gBACjDF,OAAmC,CAACG,IAAI,GAAGH,OAAO,CAACG,IAA4B;YACnF;YACAH,UAAU,AAACA,OAAmC,CAACG,IAAI;QACrD,OAAO;YACL,QAAO,iBAAiB;QAC1B;IACF;IAEA,sCAAsC;IACtC,IAAIH,WAAW,OAAOA,YAAY,YAAY,UAAUA,SAAS;;QAC7DA,QAAoCI,IAAI,GAAGjB;IAC/C;AACF;AAEA,SAASU,eAAeQ,GAA4B,EAAEb,IAAY;IAChE,MAAMc,OAAOd,KAAKO,KAAK,CAAC;IACxB,IAAIC,UAAmBK;IAEvB,KAAK,MAAMF,OAAOG,KAAM;QACtB,IAAIN,WAAW,OAAOA,YAAY,YAAYG,OAAOH,SAAS;YAC5DA,UAAU,AAACA,OAAmC,CAACG,IAAI;QACrD,OAAO;YACL,OAAOf;QACT;IACF;IAEA,OAAOY;AACT;AAEA,SAASP,eAAeY,GAA4B,EAAEb,IAAY,EAAEe,KAAc;IAChF,MAAMD,OAAOd,KAAKO,KAAK,CAAC;IACxB,IAAIC,UAAmCK;IAEvC,IAAK,IAAIJ,IAAI,GAAGA,IAAIK,KAAKJ,MAAM,GAAG,GAAGD,IAAK;QACxC,MAAME,MAAMG,IAAI,CAACL,EAAE;QACnB,MAAMO,UAAUF,IAAI,CAACL,IAAI,EAAE;QAE3B,IAAI,CAAEE,CAAAA,OAAOH,OAAM,GAAI;YACrB,2CAA2C;YAC3CA,OAAO,CAACG,IAAI,GAAGM,MAAMC,OAAOF,YAAY,CAAC,IAAI,EAAE;QACjD;QAEAR,UAAUA,OAAO,CAACG,IAAI;IACxB;IAEAH,OAAO,CAACM,IAAI,CAACA,KAAKJ,MAAM,GAAG,EAAE,CAAC,GAAGK;AACnC"}

package/dist/utils/extractTranslatableFields.d.ts

@@ -0,0 +1,3 @@
+import type { Field } from 'payload';
+import type { TranslatableField } from '../types.js';
+export declare function extractTranslatableFields(data: Record<string, unknown>, fields: Field[], basePath?: string): TranslatableField[];

package/dist/utils/extractTranslatableFields.js

@@ -0,0 +1,149 @@
+export function extractTranslatableFields(data, fields, basePath = '') {
+    const translatableFields = [];
+    for (const field of fields){
+        // Skip fields without names (like row, collapsible without name)
+        if (!('name' in field)) {
+            // Handle layout fields that contain nested fields
+            if ('fields' in field) {
+                const nestedFields = extractTranslatableFields(data, field.fields, basePath);
+                translatableFields.push(...nestedFields);
+            }
+            // Handle tabs
+            if ('tabs' in field) {
+                for (const tab of field.tabs){
+                    if ('fields' in tab) {
+                        const tabFields = extractTranslatableFields(data, tab.fields, basePath);
+                        translatableFields.push(...tabFields);
+                    }
+                }
+            }
+            continue;
+        }
+        const fieldPath = basePath ? `${basePath}.${field.name}` : field.name;
+        const value = data[field.name];
+        // Skip if no value
+        if (value === undefined || value === null) {
+            continue;
+        }
+        // Only process localized fields (UIField doesn't have localized property)
+        const isLocalized = 'localized' in field && field.localized;
+        if (!isLocalized) {
+            // But still recurse into nested structures for localized children
+            if (field.type === 'group' && 'fields' in field && typeof value === 'object') {
+                const groupFields = extractTranslatableFields(value, field.fields, fieldPath);
+                translatableFields.push(...groupFields);
+            }
+            if (field.type === 'array' && 'fields' in field && Array.isArray(value)) {
+                value.forEach((item, index)=>{
+                    if (typeof item === 'object' && item !== null) {
+                        const itemFields = extractTranslatableFields(item, field.fields, `${fieldPath}.${index}`);
+                        translatableFields.push(...itemFields);
+                    }
+                });
+            }
+            if (field.type === 'blocks' && 'blocks' in field && Array.isArray(value)) {
+                value.forEach((block, index)=>{
+                    if (typeof block === 'object' && block !== null && 'blockType' in block) {
+                        const blockConfig = field.blocks.find((b)=>b.slug === block.blockType);
+                        if (blockConfig) {
+                            const blockFields = extractTranslatableFields(block, blockConfig.fields, `${fieldPath}.${index}`);
+                            translatableFields.push(...blockFields);
+                        }
+                    }
+                });
+            }
+            continue;
+        }
+        // Process localized fields
+        switch(field.type){
+            case 'array':
+                if ('fields' in field && Array.isArray(value)) {
+                    value.forEach((item, index)=>{
+                        if (typeof item === 'object' && item !== null) {
+                            const itemFields = extractTranslatableFields(item, field.fields, `${fieldPath}.${index}`);
+                            translatableFields.push(...itemFields);
+                        }
+                    });
+                }
+                break;
+            case 'blocks':
+                if ('blocks' in field && Array.isArray(value)) {
+                    value.forEach((block, index)=>{
+                        if (typeof block === 'object' && block !== null && 'blockType' in block) {
+                            const blockConfig = field.blocks.find((b)=>b.slug === block.blockType);
+                            if (blockConfig) {
+                                const blockFields = extractTranslatableFields(block, blockConfig.fields, `${fieldPath}.${index}`);
+                                translatableFields.push(...blockFields);
+                            }
+                        }
+                    });
+                }
+                break;
+            case 'group':
+                if ('fields' in field && typeof value === 'object') {
+                    const groupFields = extractTranslatableFields(value, field.fields, fieldPath);
+                    translatableFields.push(...groupFields);
+                }
+                break;
+            case 'richText':
+                if (value && typeof value === 'object') {
+                    // Extract each text node individually with its path in the Lexical tree
+                    const textNodes = extractLexicalTextNodes(value);
+                    for (const textNode of textNodes){
+                        if (textNode.text.trim()) {
+                            translatableFields.push({
+                                type: 'richText',
+                                lexicalPath: textNode.path,
+                                path: fieldPath,
+                                value: textNode.text
+                            });
+                        }
+                    }
+                }
+                break;
+            case 'text':
+            // falls through
+            case 'textarea':
+                if (typeof value === 'string' && value.trim()) {
+                    translatableFields.push({
+                        type: field.type,
+                        path: fieldPath,
+                        value
+                    });
+                }
+                break;
+        }
+    }
+    return translatableFields;
+}
+/**
+ * Extracts all text nodes from a Lexical editor state with their paths.
+ * This allows us to translate each text node individually and apply
+ * translations back to the exact same location.
+ */ function extractLexicalTextNodes(editorState) {
+    const textNodes = [];
+    if (!editorState || typeof editorState !== 'object') {
+        return textNodes;
+    }
+    const state = editorState;
+    if (!state.root) {
+        return textNodes;
+    }
+    function traverse(node, currentPath) {
+        if (node.type === 'text' && typeof node.text === 'string') {
+            textNodes.push({
+                path: currentPath,
+                text: node.text
+            });
+        }
+        if (node.children && Array.isArray(node.children)) {
+            node.children.forEach((child, index)=>{
+                traverse(child, `${currentPath}.children.${index}`);
+            });
+        }
+    }
+    traverse(state.root, 'root');
+    return textNodes;
+}
+
+//# sourceMappingURL=extractTranslatableFields.js.map

package/dist/utils/extractTranslatableFields.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../src/utils/extractTranslatableFields.ts"],"sourcesContent":["import type { Field } from 'payload'\n\nimport type { TranslatableField } from '../types.js'\n\nexport function extractTranslatableFields(\n  data: Record<string, unknown>,\n  fields: Field[],\n  basePath: string = '',\n): TranslatableField[] {\n  const translatableFields: TranslatableField[] = []\n\n  for (const field of fields) {\n    // Skip fields without names (like row, collapsible without name)\n    if (!('name' in field)) {\n      // Handle layout fields that contain nested fields\n      if ('fields' in field) {\n        const nestedFields = extractTranslatableFields(data, field.fields, basePath)\n        translatableFields.push(...nestedFields)\n      }\n      // Handle tabs\n      if ('tabs' in field) {\n        for (const tab of field.tabs) {\n          if ('fields' in tab) {\n            const tabFields = extractTranslatableFields(data, tab.fields, basePath)\n            translatableFields.push(...tabFields)\n          }\n        }\n      }\n      continue\n    }\n\n    const fieldPath = basePath ? `${basePath}.${field.name}` : field.name\n    const value = data[field.name]\n\n    // Skip if no value\n    if (value === undefined || value === null) {continue}\n\n    // Only process localized fields (UIField doesn't have localized property)\n    const isLocalized = 'localized' in field && field.localized\n    if (!isLocalized) {\n      // But still recurse into nested structures for localized children\n      if (field.type === 'group' && 'fields' in field && typeof value === 'object') {\n        const groupFields = extractTranslatableFields(\n          value as Record<string, unknown>,\n          field.fields,\n          fieldPath,\n        )\n        translatableFields.push(...groupFields)\n      }\n      if (field.type === 'array' && 'fields' in field && Array.isArray(value)) {\n        value.forEach((item, index) => {\n          if (typeof item === 'object' && item !== null) {\n            const itemFields = extractTranslatableFields(\n              item as Record<string, unknown>,\n              field.fields,\n              `${fieldPath}.${index}`,\n            )\n            translatableFields.push(...itemFields)\n          }\n        })\n      }\n      if (field.type === 'blocks' && 'blocks' in field && Array.isArray(value)) {\n        value.forEach((block, index) => {\n          if (typeof block === 'object' && block !== null && 'blockType' in block) {\n            const blockConfig = field.blocks.find((b) => b.slug === block.blockType)\n            if (blockConfig) {\n              const blockFields = extractTranslatableFields(\n                block as Record<string, unknown>,\n                blockConfig.fields,\n                `${fieldPath}.${index}`,\n              )\n              translatableFields.push(...blockFields)\n            }\n          }\n        })\n      }\n      continue\n    }\n\n    // Process localized fields\n    switch (field.type) {\n      case 'array':\n        if ('fields' in field && Array.isArray(value)) {\n          value.forEach((item, index) => {\n            if (typeof item === 'object' && item !== null) {\n              const itemFields = extractTranslatableFields(\n                item as Record<string, unknown>,\n                field.fields,\n                `${fieldPath}.${index}`,\n              )\n              translatableFields.push(...itemFields)\n            }\n          })\n        }\n        break\n      case 'blocks':\n        if ('blocks' in field && Array.isArray(value)) {\n          value.forEach((block, index) => {\n            if (typeof block === 'object' && block !== null && 'blockType' in block) {\n              const blockConfig = field.blocks.find((b) => b.slug === block.blockType)\n              if (blockConfig) {\n                const blockFields = extractTranslatableFields(\n                  block as Record<string, unknown>,\n                  blockConfig.fields,\n                  `${fieldPath}.${index}`,\n                )\n                translatableFields.push(...blockFields)\n              }\n            }\n          })\n        }\n        break\n\n      case 'group':\n        if ('fields' in field && typeof value === 'object') {\n          const groupFields = extractTranslatableFields(\n            value as Record<string, unknown>,\n            field.fields,\n            fieldPath,\n          )\n          translatableFields.push(...groupFields)\n        }\n        break\n\n      case 'richText':\n        if (value && typeof value === 'object') {\n          // Extract each text node individually with its path in the Lexical tree\n          const textNodes = extractLexicalTextNodes(value)\n          for (const textNode of textNodes) {\n            if (textNode.text.trim()) {\n              translatableFields.push({\n                type: 'richText',\n                lexicalPath: textNode.path,\n                path: fieldPath,\n                value: textNode.text,\n              })\n            }\n          }\n        }\n        break\n\n      case 'text':\n      // falls through\n      case 'textarea':\n        if (typeof value === 'string' && value.trim()) {\n          translatableFields.push({\n            type: field.type,\n            path: fieldPath,\n            value,\n          })\n        }\n        break\n    }\n  }\n\n  return translatableFields\n}\n\ninterface LexicalNode {\n  [key: string]: unknown\n  children?: LexicalNode[]\n  text?: string\n  type?: string\n}\n\ninterface LexicalTextNode {\n  path: string\n  text: string\n}\n\n/**\n * Extracts all text nodes from a Lexical editor state with their paths.\n * This allows us to translate each text node individually and apply\n * translations back to the exact same location.\n */\nfunction extractLexicalTextNodes(editorState: unknown): LexicalTextNode[] {\n  const textNodes: LexicalTextNode[] = []\n\n  if (!editorState || typeof editorState !== 'object') {\n    return textNodes\n  }\n\n  const state = editorState as { root?: LexicalNode }\n  if (!state.root) {\n    return textNodes\n  }\n\n  function traverse(node: LexicalNode, currentPath: string): void {\n    if (node.type === 'text' && typeof node.text === 'string') {\n      textNodes.push({\n        path: currentPath,\n        text: node.text,\n      })\n    }\n    if (node.children && Array.isArray(node.children)) {\n      node.children.forEach((child, index) => {\n        traverse(child, `${currentPath}.children.${index}`)\n      })\n    }\n  }\n\n  traverse(state.root, 'root')\n  return textNodes\n}\n"],"names":["extractTranslatableFields","data","fields","basePath","translatableFields","field","nestedFields","push","tab","tabs","tabFields","fieldPath","name","value","undefined","isLocalized","localized","type","groupFields","Array","isArray","forEach","item","index","itemFields","block","blockConfig","blocks","find","b","slug","blockType","blockFields","textNodes","extractLexicalTextNodes","textNode","text","trim","lexicalPath","path","editorState","state","root","traverse","node","currentPath","children","child"],"mappings":"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"}

package/package.json

@@ -0,0 +1,141 @@
+{
+  "name": "payload-translate",
+  "version": "1.0.0",
+  "description": "AI-powered translation plugin for Payload",
+  "license": "MIT",
+  "author": "Bridger Tower",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/brijr/payload-translate.git"
+  },
+  "homepage": "https://github.com/brijr/payload-translate#readme",
+  "bugs": {
+    "url": "https://github.com/brijr/payload-translate/issues"
+  },
+  "keywords": [
+    "payload",
+    "payloadcms",
+    "plugin",
+    "translation",
+    "i18n",
+    "localization",
+    "gemini",
+    "ai"
+  ],
+  "type": "module",
+  "exports": {
+    ".": {
+      "import": "./src/index.ts",
+      "types": "./src/index.ts",
+      "default": "./src/index.ts"
+    },
+    "./client": {
+      "import": "./src/exports/client.ts",
+      "types": "./src/exports/client.ts",
+      "default": "./src/exports/client.ts"
+    },
+    "./rsc": {
+      "import": "./src/exports/rsc.ts",
+      "types": "./src/exports/rsc.ts",
+      "default": "./src/exports/rsc.ts"
+    }
+  },
+  "main": "./src/index.ts",
+  "types": "./src/index.ts",
+  "files": [
+    "dist"
+  ],
+  "scripts": {
+    "build": "pnpm copyfiles && pnpm build:types && pnpm build:swc",
+    "build:swc": "swc ./src -d ./dist --config-file .swcrc --strip-leading-paths",
+    "build:types": "tsc --outDir dist --rootDir ./src",
+    "clean": "rimraf {dist,*.tsbuildinfo}",
+    "copyfiles": "copyfiles -u 1 \"src/**/*.{html,css,scss,ttf,woff,woff2,eot,svg,jpg,png,json}\" dist/",
+    "dev": "next dev dev --turbo",
+    "dev:generate-importmap": "pnpm dev:payload generate:importmap",
+    "dev:generate-types": "pnpm dev:payload generate:types",
+    "dev:payload": "cross-env PAYLOAD_CONFIG_PATH=./dev/payload.config.ts payload",
+    "generate:importmap": "pnpm dev:generate-importmap",
+    "generate:types": "pnpm dev:generate-types",
+    "lint": "eslint",
+    "lint:fix": "eslint ./src --fix",
+    "prepublishOnly": "pnpm clean && pnpm build",
+    "test": "pnpm test:int && pnpm test:e2e",
+    "test:e2e": "playwright test",
+    "test:int": "vitest"
+  },
+  "devDependencies": {
+    "@eslint/eslintrc": "^3.2.0",
+    "@payloadcms/db-mongodb": "3.37.0",
+    "@payloadcms/db-postgres": "3.37.0",
+    "@payloadcms/db-sqlite": "3.37.0",
+    "@payloadcms/eslint-config": "3.9.0",
+    "@payloadcms/next": "3.37.0",
+    "@payloadcms/richtext-lexical": "3.37.0",
+    "@payloadcms/ui": "3.37.0",
+    "@playwright/test": "1.56.1",
+    "@swc-node/register": "1.10.9",
+    "@swc/cli": "0.6.0",
+    "@types/node": "^22.5.4",
+    "@types/react": "19.2.1",
+    "@types/react-dom": "19.2.1",
+    "copyfiles": "2.4.1",
+    "cross-env": "^7.0.3",
+    "eslint": "^9.23.0",
+    "eslint-config-next": "15.4.7",
+    "graphql": "^16.8.1",
+    "mongodb-memory-server": "10.1.4",
+    "next": "15.5.7",
+    "open": "^10.1.0",
+    "payload": "3.37.0",
+    "prettier": "^3.4.2",
+    "qs-esm": "7.0.2",
+    "react": "19.2.1",
+    "react-dom": "19.2.1",
+    "rimraf": "3.0.2",
+    "sharp": "0.34.2",
+    "sort-package-json": "^2.10.0",
+    "typescript": "5.7.3",
+    "vite-tsconfig-paths": "^5.1.4",
+    "vitest": "^3.1.2"
+  },
+  "peerDependencies": {
+    "payload": "^3.37.0"
+  },
+  "engines": {
+    "node": "^18.20.2 || >=20.9.0",
+    "pnpm": "^9 || ^10"
+  },
+  "publishConfig": {
+    "exports": {
+      ".": {
+        "import": "./dist/index.js",
+        "types": "./dist/index.d.ts",
+        "default": "./dist/index.js"
+      },
+      "./client": {
+        "import": "./dist/exports/client.js",
+        "types": "./dist/exports/client.d.ts",
+        "default": "./dist/exports/client.js"
+      },
+      "./rsc": {
+        "import": "./dist/exports/rsc.js",
+        "types": "./dist/exports/rsc.d.ts",
+        "default": "./dist/exports/rsc.js"
+      }
+    },
+    "main": "./dist/index.js",
+    "types": "./dist/index.d.ts"
+  },
+  "pnpm": {
+    "onlyBuiltDependencies": [
+      "sharp",
+      "esbuild",
+      "unrs-resolver"
+    ]
+  },
+  "registry": "https://registry.npmjs.org/",
+  "dependencies": {
+    "sonner": "^2.0.7"
+  }
+}