@justanarthur/payload-plugin-translator 1.3.20 → 1.3.21

package/dist/index.js

@@ -1,87 +1,1301 @@
-import { deepMerge } from 'payload/shared';
-import { CustomButton } from './client/components/CustomButton';
-import { translations } from './i18n-translations';
-import { translateEndpoint } from './translate/endpoint';
-import { translateOperation } from './translate/operation';
-export { copyResolver } from './resolvers/copy';
-export { googleResolver } from './resolvers/google';
-export { libreResolver } from './resolvers/libreTranslate';
-export { openAIResolver } from './resolvers/openAI';
-export * from './resolvers/types';
-export { translateOperation };
-export const translator = (pluginConfig)=>{
-    return (config)=>{
-        if (pluginConfig.disabled || !config.localization || config.localization.locales.length < 2) return config;
-        const updatedConfig = {
-            ...config,
-            admin: {
-                ...config.admin ?? {},
-                custom: {
-                    ...config.admin?.custom ?? {},
-                    translator: {
-                        resolvers: pluginConfig.resolvers.map(({ key })=>({
-                                key
-                            }))
-                    }
-                }
-            },
-            collections: config.collections?.map((collection)=>{
-                if (!pluginConfig.collections.includes(collection.slug)) return collection;
-                return {
-                    ...collection,
-                    admin: {
-                        ...collection.admin ?? {},
-                        components: {
-                            ...collection.admin?.components ?? {},
-                            edit: {
-                                ...collection.admin?.components?.edit ?? {},
-                                PublishButton: CustomButton('publish'),
-                                SaveButton: CustomButton('save')
-                            }
-                        }
-                    }
-                };
-            }) ?? [],
-            custom: {
-                ...config.custom ?? {},
-                translator: {
-                    ...pluginConfig
-                }
-            },
-            endpoints: [
-                ...config.endpoints ?? [],
+// src/translate/operation.ts
+import he from "he";
+import { APIError as APIError3 } from "payload";
+
+// src/translate/findEntityWithConfig.ts
+import { APIError } from "payload";
+var findConfigBySlug = (slug, enities) => enities.find((entity) => entity.slug === slug);
+var findEntityWithConfig = async (args) => {
+  const { collectionSlug, globalSlug, id, locale, overrideAccess, req } = args;
+  if (!collectionSlug && !globalSlug)
+    throw new APIError("Bad Request", 400);
+  const { payload } = req;
+  const { config } = payload;
+  const isGlobal = !!globalSlug;
+  if (!isGlobal && !id)
+    throw new APIError("Bad Request", 400);
+  const entityConfig = isGlobal ? findConfigBySlug(globalSlug, config.globals) : findConfigBySlug(collectionSlug, config.collections);
+  if (!entityConfig)
+    throw new APIError("Bad Request", 400);
+  const docPromise = isGlobal ? payload.findGlobal({
+    depth: 0,
+    fallbackLocale: undefined,
+    locale,
+    overrideAccess,
+    req,
+    slug: args.globalSlug
+  }) : payload.findByID({
+    collection: collectionSlug,
+    depth: 0,
+    fallbackLocale: undefined,
+    id,
+    locale,
+    overrideAccess,
+    req
+  });
+  return {
+    config: entityConfig,
+    doc: await docPromise
+  };
+};
+
+// src/translate/traverseFields.ts
+import ObjectID from "bson-objectid";
+import { tabHasName } from "payload/shared";
+
+// src/utils/isEmpty.ts
+var isEmpty = (value) => {
+  if (Array.isArray(value))
+    return value.length === 0;
+  if (value === null || typeof value === "undefined")
+    return true;
+  if (typeof value === "object" && Object.keys(value).length === 0)
+    return true;
+  return false;
+};
+
+// src/translate/traverseRichText.ts
+var traverseRichText = ({
+  onText,
+  root,
+  siblingData,
+  additionalTraverseRichText
+}) => {
+  siblingData = siblingData ?? root;
+  if (siblingData.text) {
+    onText(siblingData);
+  }
+  if (Array.isArray(siblingData?.children)) {
+    for (const child of siblingData.children) {
+      traverseRichText({
+        onText,
+        root,
+        siblingData: child,
+        additionalTraverseRichText
+      });
+    }
+  } else {
+    additionalTraverseRichText?.({ onText, root, siblingData });
+  }
+};
+
+// src/translate/traverseFields.ts
+var traverseFields = ({
+  dataFrom,
+  emptyOnly,
+  fields,
+  localizedParent,
+  siblingDataFrom,
+  siblingDataTranslated,
+  translatedData,
+  valuesToTranslate,
+  _options
+}) => {
+  const { additionalTraverseRichText } = _options ?? {};
+  siblingDataFrom = siblingDataFrom ?? dataFrom;
+  siblingDataTranslated = siblingDataTranslated ?? translatedData;
+  for (const field of fields) {
+    switch (field.type) {
+      case "tabs":
+        for (const tab of field.tabs) {
+          const hasName = tabHasName(tab);
+          const tabDataFrom = hasName ? siblingDataFrom[tab.name] : siblingDataFrom;
+          if (!tabDataFrom)
+            return;
+          let tabDataTranslated;
+          if (hasName) {
+            if (!siblingDataTranslated[tab.name])
+              siblingDataTranslated[tab.name] = {};
+            tabDataTranslated = siblingDataTranslated[tab.name];
+          } else {
+            tabDataTranslated = siblingDataTranslated;
+          }
+          traverseFields({
+            dataFrom,
+            emptyOnly,
+            fields: tab.fields,
+            localizedParent: localizedParent ?? tab.localized,
+            siblingDataFrom: tabDataFrom,
+            siblingDataTranslated: tabDataTranslated,
+            translatedData,
+            valuesToTranslate,
+            _options
+          });
+        }
+        break;
+      case "group": {
+        if (!("name" in field))
+          break;
+        const groupDataFrom = siblingDataFrom[field.name];
+        if (!groupDataFrom)
+          break;
+        if (!siblingDataTranslated[field.name])
+          siblingDataTranslated[field.name] = {};
+        const groupDataTranslated = siblingDataTranslated[field.name];
+        traverseFields({
+          dataFrom,
+          emptyOnly,
+          fields: field.fields,
+          localizedParent: localizedParent ?? field.localized,
+          siblingDataFrom: groupDataFrom,
+          siblingDataTranslated: groupDataTranslated,
+          translatedData,
+          valuesToTranslate,
+          _options
+        });
+        break;
+      }
+      case "array": {
+        const arrayDataFrom = siblingDataFrom[field.name];
+        if (isEmpty(arrayDataFrom))
+          break;
+        if (!siblingDataTranslated[field.name])
+          siblingDataTranslated[field.name] = [];
+        let arrayDataTranslated = siblingDataTranslated[field.name];
+        if (field.localized || localizedParent) {
+          if (arrayDataTranslated.length > 0 && emptyOnly)
+            break;
+          arrayDataTranslated = arrayDataFrom.map(() => ({
+            id: ObjectID().toHexString()
+          }));
+        }
+        arrayDataTranslated.forEach((item, index) => {
+          traverseFields({
+            dataFrom,
+            emptyOnly,
+            fields: field.fields,
+            localizedParent: localizedParent ?? field.localized,
+            siblingDataFrom: arrayDataFrom[index],
+            siblingDataTranslated: item,
+            translatedData,
+            valuesToTranslate,
+            _options
+          });
+        });
+        siblingDataTranslated[field.name] = arrayDataTranslated;
+        break;
+      }
+      case "blocks": {
+        const blocksDataFrom = siblingDataFrom[field.name];
+        if (isEmpty(blocksDataFrom))
+          break;
+        if (!siblingDataTranslated[field.name])
+          siblingDataTranslated[field.name] = [];
+        let blocksDataTranslated = siblingDataTranslated[field.name];
+        if (field.localized || localizedParent) {
+          if (blocksDataTranslated.length > 0 && emptyOnly)
+            break;
+          blocksDataTranslated = blocksDataFrom.map(({ blockType }) => ({
+            blockType,
+            id: ObjectID().toHexString()
+          }));
+        }
+        blocksDataTranslated.forEach((item, index) => {
+          const block = field.blocks.find((each) => each.slug === item.blockType);
+          if (!block)
+            return;
+          traverseFields({
+            dataFrom,
+            emptyOnly,
+            fields: block.fields,
+            localizedParent: localizedParent ?? field.localized,
+            siblingDataFrom: blocksDataFrom[index],
+            siblingDataTranslated: item,
+            translatedData,
+            valuesToTranslate,
+            _options
+          });
+        });
+        siblingDataTranslated[field.name] = blocksDataTranslated;
+        break;
+      }
+      case "collapsible":
+      case "row":
+        traverseFields({
+          dataFrom,
+          emptyOnly,
+          fields: field.fields,
+          localizedParent,
+          siblingDataFrom,
+          siblingDataTranslated,
+          translatedData,
+          valuesToTranslate,
+          _options
+        });
+        break;
+      case "date":
+      case "checkbox":
+      case "code":
+      case "email":
+      case "number":
+      case "point":
+      case "radio":
+      case "relationship":
+      case "select":
+      case "upload":
+        siblingDataTranslated[field.name] = siblingDataFrom[field.name];
+        break;
+      case "json":
+        let traverseObject = function(obj) {
+          if (!obj || typeof obj !== "object")
+            return;
+          for (const key in obj) {
+            const value = obj[key];
+            if (typeof value === "string" && value.trim()) {
+              ((parentObj, parentKey, parentValue) => {
+                valuesToTranslate.push({
+                  onTranslate: (translated) => {
+                    parentObj[parentKey] = translated;
+                  },
+                  value: parentValue
+                });
+              })(obj, key, value);
+            } else if (typeof value === "object" && value !== null) {
+              traverseObject(value);
+            }
+          }
+        };
+        if (!(field.localized || localizedParent))
+          break;
+        if (isEmpty(siblingDataFrom[field.name]))
+          break;
+        if (emptyOnly && siblingDataTranslated[field.name])
+          break;
+        const jsonDataFrom = siblingDataFrom[field.name];
+        const jsonDataTranslated = JSON.parse(JSON.stringify(jsonDataFrom));
+        siblingDataTranslated[field.name] = jsonDataTranslated;
+        traverseObject(jsonDataTranslated);
+        break;
+      case "text":
+      case "textarea":
+        if (field.custom && typeof field.custom === "object" && field.custom.translatorSkip)
+          break;
+        if (!(field.localized || localizedParent) || isEmpty(siblingDataFrom[field.name]))
+          break;
+        if (emptyOnly && siblingDataTranslated[field.name])
+          break;
+        if (field.name === "blockName" || field.name === "id") {
+          break;
+        }
+        valuesToTranslate.push({
+          onTranslate: (translated) => {
+            siblingDataTranslated[field.name] = translated;
+          },
+          value: siblingDataFrom[field.name]
+        });
+        break;
+      case "richText": {
+        if (!(field.localized || localizedParent) || isEmpty(siblingDataFrom[field.name]))
+          break;
+        if (emptyOnly && siblingDataTranslated[field.name])
+          break;
+        const richTextDataFrom = siblingDataFrom[field.name];
+        siblingDataTranslated[field.name] = richTextDataFrom;
+        if (!richTextDataFrom)
+          break;
+        const isSlate = Array.isArray(richTextDataFrom);
+        const isLexical = "root" in richTextDataFrom;
+        if (!isSlate && !isLexical)
+          break;
+        if (isLexical) {
+          const root = siblingDataTranslated[field.name]?.root;
+          if (root)
+            traverseRichText({
+              onText: (siblingData, attribute = "text") => {
+                valuesToTranslate.push({
+                  onTranslate: (translated) => {
+                    siblingData[attribute] = translated;
+                  },
+                  value: siblingData[attribute]
+                });
+              },
+              root,
+              additionalTraverseRichText
+            });
+        } else {
+          for (const root of siblingDataTranslated[field.name]) {
+            traverseRichText({
+              onText: (siblingData, attribute = "text") => {
+                valuesToTranslate.push({
+                  onTranslate: (translated) => {
+                    siblingData[attribute] = translated;
+                  },
+                  value: siblingData[attribute]
+                });
+              },
+              root,
+              additionalTraverseRichText
+            });
+          }
+        }
+        break;
+      }
+      default:
+        break;
+    }
+  }
+};
+
+// src/translate/updateEntity.ts
+import { APIError as APIError2 } from "payload";
+var updateEntity = ({
+  collectionSlug,
+  data,
+  depth: incomingDepth,
+  globalSlug,
+  id,
+  locale,
+  overrideAccess,
+  req
+}) => {
+  if (!collectionSlug && !globalSlug)
+    throw new APIError2("Bad Request", 400);
+  const isGlobal = !!globalSlug;
+  if (!isGlobal && !id)
+    throw new APIError2("Bad Request", 400);
+  const depth = incomingDepth ?? req.payload.config.defaultDepth;
+  const promise = isGlobal ? req.payload.updateGlobal({
+    data,
+    depth,
+    locale,
+    overrideAccess,
+    req,
+    slug: globalSlug
+  }) : req.payload.update({
+    collection: collectionSlug,
+    data,
+    depth,
+    id,
+    locale,
+    overrideAccess,
+    req
+  });
+  return promise;
+};
+
+// src/translate/operation.ts
+var translateOperation = async (args) => {
+  const req = "req" in args ? args.req : {
+    payload: args.payload
+  };
+  const { collectionSlug, globalSlug, id, locale, localeFrom, overrideAccess } = args;
+  const { config, doc: dataFrom } = await findEntityWithConfig({
+    collectionSlug,
+    globalSlug,
+    id,
+    locale: localeFrom,
+    req
+  });
+  const resolver = (req.payload.config.custom?.translator?.resolvers ?? []).find((each) => each.key === args.resolver);
+  if (!resolver)
+    throw new APIError3(`Resolver with the key ${args.resolver} was not found`);
+  const valuesToTranslate = [];
+  let translatedData = args.data;
+  if (!translatedData) {
+    const { doc } = await findEntityWithConfig({
+      collectionSlug,
+      globalSlug,
+      id,
+      locale,
+      overrideAccess,
+      req
+    });
+    translatedData = doc;
+  }
+  traverseFields({
+    dataFrom,
+    emptyOnly: args.emptyOnly,
+    fields: config.fields,
+    translatedData,
+    valuesToTranslate,
+    _options: req.payload.config.custom?.translator?._options
+  });
+  const resolveResult = await resolver.resolve({
+    localeFrom: args.localeFrom,
+    localeTo: args.locale,
+    req,
+    texts: valuesToTranslate.map((each) => each.value)
+  });
+  let result;
+  if (!resolveResult.success) {
+    result = {
+      success: false
+    };
+  } else {
+    resolveResult.translatedTexts.forEach((translated, index) => {
+      const formattedValue = he.decode(translated);
+      valuesToTranslate[index].onTranslate(formattedValue);
+    });
+    if (args.update) {
+      await updateEntity({
+        collectionSlug,
+        data: translatedData,
+        depth: 0,
+        globalSlug,
+        id,
+        locale,
+        overrideAccess,
+        req
+      });
+    }
+    result = {
+      success: true,
+      translatedData,
+      dataFrom
+    };
+  }
+  return result;
+};
+
+// src/index.ts
+import { deepMerge } from "payload/shared";
+
+// src/client/components/CustomButton/index.tsx
+var CustomButton = (type) => {
+  return {
+    clientProps: {
+      type
+    },
+    path: "@justanarthur/payload-plugin-translator/client#CustomButtonWithTranslator"
+  };
+};
+
+// src/i18n-translations.ts
+var translations = {
+  en: {
+    "plugin-translator": {
+      resolver_copy_buttonLabel: "Copy from other locale",
+      resolver_copy_errorMessage: "An error occurred when trying to translate the data",
+      resolver_copy_modalTitle: "Choose the locale to copy from",
+      resolver_copy_submitButtonLabelEmpty: "Copy only empty fields",
+      resolver_copy_submitButtonLabelFull: "Copy all",
+      resolver_copy_successMessage: 'Successfully copied. Press "Save" to apply the changes.',
+      resolver_google_buttonLabel: "Google Translate",
+      resolver_google_errorMessage: "An error occurred when trying to translate the data",
+      resolver_google_modalTitle: "Choose the locale to translate from",
+      resolver_google_submitButtonLabelEmpty: "Translate only empty fields",
+      resolver_google_submitButtonLabelFull: "Translate all",
+      resolver_google_successMessage: 'Successfully translated. Press "Save" to apply the changes.',
+      resolver_libre_buttonLabel: "Libre Translate",
+      resolver_libre_errorMessage: "An error occurred when trying to translate the data",
+      resolver_libre_modalTitle: "Choose the locale to translate from",
+      resolver_libre_submitButtonLabelEmpty: "Translate only empty fields",
+      resolver_libre_submitButtonLabelFull: "Translate all",
+      resolver_libre_successMessage: 'Successfully translated. Press "Save" to apply the changes.',
+      resolver_openai_buttonLabel: "AI Translate",
+      resolver_openai_errorMessage: "An error occurred when trying to translate the data",
+      resolver_openai_modalTitle: "Choose the locale to translate from",
+      resolver_openai_submitButtonLabelEmpty: "Translate only empty fields",
+      resolver_openai_submitButtonLabelFull: "Translate all",
+      resolver_openai_successMessage: 'Successfully translated. Press "Save" to apply the changes.'
+    }
+  },
+  uk: {
+    "plugin-translator": {
+      resolver_copy_buttonLabel: "Копіювати з іншої локалі",
+      resolver_copy_errorMessage: "Сталася помилка під час спроби перекладу даних",
+      resolver_copy_modalTitle: "Виберіть локаль для копіювання",
+      resolver_copy_submitButtonLabelEmpty: "Копіювати лише порожні поля",
+      resolver_copy_submitButtonLabelFull: "Копіювати все",
+      resolver_copy_successMessage: 'Успішно скопійовано. Натисніть "Зберегти", щоб застосувати зміни.',
+      resolver_google_buttonLabel: "Переклад Google",
+      resolver_google_errorMessage: "Сталася помилка під час спроби перекладу даних",
+      resolver_google_modalTitle: "Виберіть локаль для перекладу",
+      resolver_google_submitButtonLabelEmpty: "Перекласти лише порожні поля",
+      resolver_google_submitButtonLabelFull: "Перекласти все",
+      resolver_google_successMessage: 'Успішно перекладено. Натисніть "Зберегти", щоб застосувати зміни.',
+      resolver_libre_buttonLabel: "Переклад Libre",
+      resolver_libre_errorMessage: "Сталася помилка під час спроби перекладу даних",
+      resolver_libre_modalTitle: "Виберіть локаль для перекладу",
+      resolver_libre_submitButtonLabelEmpty: "Перекласти лише порожні поля",
+      resolver_libre_submitButtonLabelFull: "Перекласти все",
+      resolver_libre_successMessage: 'Успішно перекладено. Натисніть "Зберегти", щоб застосувати зміни.',
+      resolver_openai_buttonLabel: "Переклад AI",
+      resolver_openai_errorMessage: "Сталася помилка під час спроби перекладу даних",
+      resolver_openai_modalTitle: "Виберіть локаль для перекладу",
+      resolver_openai_submitButtonLabelEmpty: "Перекласти лише порожні поля",
+      resolver_openai_submitButtonLabelFull: "Перекласти все",
+      resolver_openai_successMessage: 'Успішно перекладено. Натисніть "Зберегти", щоб застосувати зміни.'
+    }
+  },
+  zh: {
+    "plugin-translator": {
+      resolver_copy_buttonLabel: "从其他语言复制",
+      resolver_copy_errorMessage: "尝试翻译数据时发生错误",
+      resolver_copy_modalTitle: "选择要复制的语言",
+      resolver_copy_submitButtonLabelEmpty: "仅复制空字段",
+      resolver_copy_submitButtonLabelFull: "复制全部",
+      resolver_copy_successMessage: "复制成功。按下“保存”以应用更改。",
+      resolver_google_buttonLabel: "谷歌翻译",
+      resolver_google_errorMessage: "尝试翻译数据时发生错误",
+      resolver_google_modalTitle: "选择要翻译的语言",
+      resolver_google_submitButtonLabelEmpty: "仅翻译空字段",
+      resolver_google_submitButtonLabelFull: "翻译全部",
+      resolver_google_successMessage: "翻译成功。按下“保存”以应用更改。",
+      resolver_libre_buttonLabel: "自由翻译",
+      resolver_libre_errorMessage: "尝试翻译数据时发生错误",
+      resolver_libre_modalTitle: "选择要翻译的语言",
+      resolver_libre_submitButtonLabelEmpty: "仅翻译空字段",
+      resolver_libre_submitButtonLabelFull: "翻译全部",
+      resolver_libre_successMessage: "翻译成功。按下“保存”以应用更改。",
+      resolver_openai_buttonLabel: "AI翻译",
+      resolver_openai_errorMessage: "尝试翻译数据时发生错误",
+      resolver_openai_modalTitle: "选择要翻译的语言",
+      resolver_openai_submitButtonLabelEmpty: "仅翻译空字段",
+      resolver_openai_submitButtonLabelFull: "翻译全部",
+      resolver_openai_successMessage: "翻译成功。按下“保存”以应用更改。"
+    }
+  }
+};
+
+// src/jobs/constants.ts
+var TRANSLATE_TASK_SLUG = "translateEntityToLocale";
+var TRANSLATE_WORKFLOW_SLUG = "translateEntityToLocales";
+
+// src/jobs/createAutoTranslateCollectionHook.ts
+function createAutoTranslateCollectionHook(options) {
+  const {
+    collectionSlug,
+    defaultLocale: defaultLocaleOption,
+    targetLocales: targetLocalesOption,
+    onlyOnPublished = true,
+    workflowSlug = TRANSLATE_WORKFLOW_SLUG
+  } = options;
+  const afterChange = async ({ doc, req }) => {
+    if (shouldSkipAutoTranslate(req.context))
+      return doc;
+    const typed = doc;
+    const requestLocale = readRequestLocale(req);
+    const defaultLocale = defaultLocaleOption ?? readConfigDefaultLocale(req) ?? "";
+    if (!requestLocale || !defaultLocale || requestLocale !== defaultLocale)
+      return doc;
+    if (!req.user)
+      return doc;
+    if (onlyOnPublished && typed._status && typed._status !== "published")
+      return doc;
+    const targetLocales = targetLocalesOption ?? readTargetLocales(req, defaultLocale);
+    if (targetLocales.length === 0)
+      return doc;
+    const resolverKey = options.resolverKey ?? readFirstResolverKey(req);
+    if (!resolverKey) {
+      req.payload.logger.error({
+        msg: `auto-translate: no resolver key available for collection ${collectionSlug} — pass \`resolverKey\` to \`createAutoTranslateCollectionHook\` or configure \`translator.resolvers\` in \`translator({...})\``
+      });
+      return doc;
+    }
+    const updatedAt = typed.updatedAt ?? new Date().toISOString();
+    for (const toLocale of targetLocales) {
+      if (toLocale === defaultLocale)
+        continue;
+      try {
+        const job = await req.payload.jobs.queue({
+          workflow: workflowSlug,
+          input: {
+            id: typed.id,
+            updatedAt,
+            collection: collectionSlug,
+            fromLocale: defaultLocale,
+            resolver: resolverKey || undefined,
+            toLocale
+          }
+        });
+        req.payload.logger.info({
+          msg: `auto-translate: queued translation of ${collectionSlug}#${typed.id} → ${toLocale} (job ${job.id})`
+        });
+      } catch (error) {
+        req.payload.logger.error({
+          msg: `auto-translate: failed to queue ${collectionSlug}#${typed.id} → ${toLocale}: ${String(error)}`
+        });
+      }
+    }
+    return doc;
+  };
+  return { afterChange };
+}
+function shouldSkipAutoTranslate(context) {
+  return Boolean(context?.disableAutoTranslate);
+}
+function readRequestLocale(req) {
+  if (!req || typeof req !== "object")
+    return "";
+  const locale = req.locale;
+  return typeof locale === "string" && locale.length > 0 ? locale : "";
+}
+function readConfigDefaultLocale(req) {
+  if (!req || typeof req !== "object")
+    return "";
+  const config = req.payload?.config;
+  const def = config?.localization?.defaultLocale;
+  return typeof def === "string" && def.length > 0 ? def : "";
+}
+function readTargetLocales(req, defaultLocale) {
+  if (!req || typeof req !== "object")
+    return [];
+  const list = req.payload?.config?.localization?.locales;
+  if (!Array.isArray(list) || list.length === 0)
+    return [];
+  const out = [];
+  for (const entry of list) {
+    const code = typeof entry === "string" ? entry : entry?.code;
+    if (typeof code === "string" && code.length > 0 && code !== defaultLocale) {
+      out.push(code);
+    }
+  }
+  return out;
+}
+function readFirstResolverKey(req) {
+  if (!req || typeof req !== "object")
+    return "";
+  const custom = req.payload?.config?.custom?.translator?.resolvers;
+  if (!Array.isArray(custom) || custom.length === 0)
+    return "";
+  const first = custom[0];
+  return typeof first?.key === "string" ? first.key : "";
+}
+
+// src/jobs/createAutoTranslateGlobalHook.ts
+function createAutoTranslateGlobalHook(options) {
+  const {
+    globalSlug,
+    defaultLocale: defaultLocaleOption,
+    targetLocales: targetLocalesOption,
+    workflowSlug = TRANSLATE_WORKFLOW_SLUG
+  } = options;
+  return async ({ doc, req }) => {
+    if (shouldSkipAutoTranslate2(req.context))
+      return doc;
+    const typed = doc;
+    const requestLocale = readRequestLocale2(req);
+    const defaultLocale = defaultLocaleOption ?? readConfigDefaultLocale2(req) ?? "";
+    if (!requestLocale || !defaultLocale || requestLocale !== defaultLocale)
+      return doc;
+    if (!req.user)
+      return doc;
+    const targetLocales = targetLocalesOption ?? readTargetLocales2(req, defaultLocale);
+    if (targetLocales.length === 0)
+      return doc;
+    const resolverKey = options.resolverKey ?? readFirstResolverKey2(req);
+    if (!resolverKey) {
+      req.payload.logger.error({
+        msg: `auto-translate: no resolver key available for global ${globalSlug} — pass \`resolverKey\` to \`createAutoTranslateGlobalHook\` or configure \`translator.resolvers\` in \`translator({...})\``
+      });
+      return doc;
+    }
+    const updatedAt = typed.updatedAt ?? new Date().toISOString();
+    for (const toLocale of targetLocales) {
+      if (toLocale === defaultLocale)
+        continue;
+      try {
+        const job = await req.payload.jobs.queue({
+          workflow: workflowSlug,
+          input: {
+            updatedAt,
+            global: globalSlug,
+            fromLocale: defaultLocale,
+            resolver: resolverKey || undefined,
+            toLocale
+          }
+        });
+        req.payload.logger.info({
+          msg: `auto-translate: queued translation of ${globalSlug} → ${toLocale} (job ${job.id})`
+        });
+      } catch (error) {
+        req.payload.logger.error({
+          msg: `auto-translate: failed to queue ${globalSlug} → ${toLocale}: ${String(error)}`
+        });
+      }
+    }
+    return doc;
+  };
+}
+function shouldSkipAutoTranslate2(context) {
+  return Boolean(context?.disableAutoTranslate);
+}
+function readRequestLocale2(req) {
+  if (!req || typeof req !== "object")
+    return "";
+  const locale = req.locale;
+  return typeof locale === "string" && locale.length > 0 ? locale : "";
+}
+function readConfigDefaultLocale2(req) {
+  if (!req || typeof req !== "object")
+    return "";
+  const config = req.payload?.config;
+  const def = config?.localization?.defaultLocale;
+  return typeof def === "string" && def.length > 0 ? def : "";
+}
+function readTargetLocales2(req, defaultLocale) {
+  if (!req || typeof req !== "object")
+    return [];
+  const list = req.payload?.config?.localization?.locales;
+  if (!Array.isArray(list) || list.length === 0)
+    return [];
+  const out = [];
+  for (const entry of list) {
+    const code = typeof entry === "string" ? entry : entry?.code;
+    if (typeof code === "string" && code.length > 0 && code !== defaultLocale) {
+      out.push(code);
+    }
+  }
+  return out;
+}
+function readFirstResolverKey2(req) {
+  if (!req || typeof req !== "object")
+    return "";
+  const custom = req.payload?.config?.custom?.translator?.resolvers;
+  if (!Array.isArray(custom) || custom.length === 0)
+    return "";
+  const first = custom[0];
+  return typeof first?.key === "string" ? first.key : "";
+}
+
+// src/jobs/createTranslateTask.ts
+function createTranslateTask(options = {}) {
+  const { slug = "translateEntityToLocale" } = options;
+  return {
+    slug,
+    inputSchema: [
+      { name: "id", type: "number", required: false },
+      { name: "collection", type: "text", required: false },
+      { name: "global", type: "text", required: false },
+      { name: "fromLocale", type: "text", required: true },
+      { name: "toLocale", type: "text", required: true },
+      { name: "resolver", type: "text", required: false }
+    ],
+    outputSchema: [],
+    retries: 3,
+    handler: async (args) => {
+      const { input, job, req } = args;
+      const { id, collection, global, fromLocale, toLocale, resolver: inputResolver } = input;
+      if (!collection && !global) {
+        throw new Error("translateTask: either `collection` or `global` must be provided");
+      }
+      const resolverKey = options.resolverKey ?? inputResolver ?? readFirstResolverKey3(req);
+      if (!resolverKey) {
+        throw new Error(`translateTask: no resolver key available — pass \`resolverKey\` to \`createTranslateTask\` or queue the workflow with a \`resolver\` input. Did you forget to pass \`translator.resolvers\` to \`translator({...})\`?`);
+      }
+      const entityLabel = collection || global;
+      req.payload.logger.info({
+        jobId: job.id,
+        msg: `translating ${entityLabel} to locale ${toLocale}`
+      });
+      let result;
+      try {
+        result = await translateOperation({
+          req,
+          collectionSlug: collection,
+          globalSlug: global,
+          emptyOnly: false,
+          id,
+          locale: toLocale,
+          localeFrom: fromLocale,
+          overrideAccess: true,
+          resolver: resolverKey,
+          update: false
+        });
+      } catch (error) {
+        req.payload.logger.error({
+          jobId: job.id,
+          msg: `translateOperation threw for ${entityLabel} → ${toLocale}: ${String(error)}`
+        });
+        throw error;
+      }
+      if (!result.success) {
+        req.payload.logger.error({
+          jobId: job.id,
+          msg: `translation for ${entityLabel} to ${toLocale} failed (resolver returned success=false)`
+        });
+        throw new Error(`translateTask: resolver returned success=false for ${entityLabel} → ${toLocale}`);
+      }
+      const translated = result.translatedData ?? {};
+      const { _locale: _dropLocale, _parent_id: _dropParent, ...data } = translated;
+      req.payload.logger.info({
+        jobId: job.id,
+        msg: `persisting ${entityLabel} (id=${id ?? global}) at locale ${toLocale}`
+      });
+      try {
+        if (collection) {
+          await req.payload.update({
+            collection,
+            data,
+            id,
+            locale: toLocale,
+            overrideAccess: true,
+            req
+          });
+        } else {
+          await req.payload.updateGlobal({
+            slug: global,
+            data,
+            locale: toLocale,
+            overrideAccess: true,
+            req
+          });
+        }
+      } catch (error) {
+        req.payload.logger.error({
+          jobId: job.id,
+          msg: `persist failed for ${entityLabel} (id=${id ?? global}) at locale ${toLocale}: ${String(error)}`
+        });
+        throw error;
+      }
+      req.payload.logger.info({
+        jobId: job.id,
+        msg: `translation complete for ${entityLabel} → ${toLocale}`
+      });
+      return { output: { success: true } };
+    }
+  };
+}
+function readFirstResolverKey3(req) {
+  if (!req || typeof req !== "object")
+    return "";
+  const custom = req.payload?.config?.custom?.translator?.resolvers;
+  if (!Array.isArray(custom) || custom.length === 0)
+    return "";
+  const first = custom[0];
+  return typeof first?.key === "string" ? first.key : "";
+}
+
+// src/jobs/createTranslateWorkflow.ts
+function createTranslateWorkflow(options = {}) {
+  const { slug = "translateEntityToLocales", taskSlug = "translateEntityToLocale" } = options;
+  return {
+    slug,
+    inputSchema: [
+      { name: "id", type: "number", required: false },
+      { name: "updatedAt", type: "date", required: true },
+      { name: "collection", type: "text", required: false },
+      { name: "global", type: "text", required: false },
+      { name: "fromLocale", type: "text", required: true },
+      { name: "toLocale", type: "text", required: true },
+      { name: "resolver", type: "text", required: false }
+    ],
+    handler: async (args) => {
+      const { job, req, tasks } = args;
+      const { id, collection, global, fromLocale, toLocale, updatedAt, resolver } = job.input;
+      if (!collection && !global) {
+        throw new Error("translateWorkflow: either `collection` or `global` must be provided");
+      }
+      if (typeof req.payload.config.localization !== "object") {
+        req.payload.logger.error({
+          jobId: job.id,
+          msg: "localization is not enabled — skipping auto-translation workflow"
+        });
+        return;
+      }
+      const entityKey = collection ? `${collection}-${id}` : global;
+      const updatedAtIso = updatedAt instanceof Date ? updatedAt.toISOString() : String(updatedAt);
+      req.payload.logger.info({
+        jobId: job.id,
+        msg: `scheduling translation of ${entityKey} → ${toLocale}`
+      });
+      await tasks[taskSlug](`${entityKey}-${fromLocale}-${toLocale}-${updatedAtIso}`, {
+        input: {
+          id,
+          collection,
+          global,
+          fromLocale,
+          toLocale,
+          resolver
+        }
+      });
+    }
+  };
+}
+
+// src/translate/endpoint.ts
+import { APIError as APIError4 } from "payload";
+var translateEndpoint = async (req) => {
+  if (!req.json)
+    throw new APIError4("Content-Type should be json");
+  const args = await req.json();
+  const { collectionSlug, data, emptyOnly, globalSlug, id, locale, localeFrom, resolver } = args;
+  const result = await translateOperation({
+    collectionSlug,
+    data,
+    emptyOnly,
+    globalSlug,
+    id,
+    locale,
+    localeFrom,
+    overrideAccess: false,
+    req,
+    resolver,
+    update: false
+  });
+  return Response.json(result);
+};
+
+// src/resolvers/copy.ts
+var copyResolver = () => {
+  return {
+    key: "copy",
+    resolve: (args) => {
+      const { texts } = args;
+      return {
+        success: true,
+        translatedTexts: texts
+      };
+    }
+  };
+};
+// src/utils/chunkArray.ts
+var chunkArray = (array, length) => {
+  return Array.from({ length: Math.ceil(array.length / length) }, (_, i) => array.slice(i * length, i * length + length));
+};
+
+// src/resolvers/google.ts
+var localeToCountryCodeMapper = {
+  ua: "uk"
+};
+var mapLocale = (incoming) => (incoming in localeToCountryCodeMapper) ? localeToCountryCodeMapper[incoming] : incoming;
+var googleResolver = ({
+  apiKey,
+  chunkLength = 100
+}) => {
+  return {
+    key: "google",
+    resolve: async (args) => {
+      const { localeFrom, localeTo, req, texts } = args;
+      const apiUrl = `https://translation.googleapis.com/language/translate/v2?key=${apiKey}`;
+      const responses = await Promise.all(chunkArray(texts, chunkLength).map((q) => fetch(apiUrl, {
+        body: JSON.stringify({
+          q,
+          source: mapLocale(localeFrom),
+          target: mapLocale(localeTo)
+        }),
+        headers: {
+          "Content-Type": "application/json"
+        },
+        method: "POST"
+      }).then(async (res) => {
+        const data = await res.json();
+        if (!res.ok)
+          req.payload.logger.info({
+            googleResponse: data,
+            message: "An error occurred when trying to translate the data using Google API"
+          });
+        return {
+          data,
+          success: res.ok
+        };
+      })));
+      if (responses.some((res) => !res.success)) {
+        return {
+          success: false
+        };
+      }
+      const translatedTexts = responses.flatMap((chunk) => chunk.data.data.translations).map((translation) => translation.translatedText);
+      return {
+        success: true,
+        translatedTexts
+      };
+    }
+  };
+};
+// src/resolvers/libreTranslate.ts
+var localeToCountryCodeMapper2 = {
+  ua: "uk"
+};
+var mapLocale2 = (incoming) => (incoming in localeToCountryCodeMapper2) ? localeToCountryCodeMapper2[incoming] : incoming;
+var libreResolver = ({
+  apiKey,
+  chunkLength = 100,
+  url = "https://libretranslate.com/translate"
+}) => {
+  return {
+    key: "libre",
+    resolve: async (args) => {
+      const { localeFrom, localeTo, req, texts } = args;
+      const apiUrl = url;
+      const responses = await Promise.all(chunkArray(texts, chunkLength).map((q) => fetch(apiUrl, {
+        body: JSON.stringify({
+          api_key: apiKey,
+          q,
+          source: mapLocale2(localeFrom),
+          target: mapLocale2(localeTo)
+        }),
+        headers: {
+          "Content-Type": "application/json"
+        },
+        method: "POST"
+      }).then(async (res) => {
+        const data = await res.json();
+        if (!res.ok)
+          req.payload.logger.info({
+            libreResponse: data,
+            message: "An error occurred when trying to translate the data using LibreTranslate API"
+          });
+        return {
+          data,
+          success: res.ok
+        };
+      })));
+      if (responses.some((res) => !res.success)) {
+        return {
+          success: false
+        };
+      }
+      const translatedTexts = responses.flatMap((chunk) => chunk.data.translatedText);
+      return {
+        success: true,
+        translatedTexts
+      };
+    }
+  };
+};
+// src/resolvers/openAI.ts
+var defaultPrompt = ({ localeFrom, localeTo, texts }) => {
+  return `You are a machine translation service. Your task is to translate values in a strict JSON of key value pairs from ${localeFrom} to ${localeTo}.
+
+**INSTRUCTIONS:**
+1.  **Translate each value**.
+2.  The output **must valid JSON**.
+3.  The output array **must have the exact same number of elements** as the input.
+4.  Preserve the structure of the JSON array.
+5.  Preserve JSON keys without translation.
+6.  The **order of the elements must not change**.
+7.  **Do not include any text, explanations, or remarks outside of the JSON array.**
+8.  **Preserve any special characters, HTML tags, or formatting** present in the original strings.
+9.  **Preserve urls, hrefs, and email addresses** without translation.
+10. RETURN ONLY THE RAW JSON, DO NOT RESPOND WITH ANYTHING ELSE, AND NO FORMATTING.
+
+**INPUT JSON TO TRANSLATE:**
+${JSON.stringify(texts)}`;
+};
+var openAIResolver = ({
+  apiKey,
+  baseUrl,
+  chunkLength = 100,
+  model = "gpt-3.5-turbo",
+  prompt = defaultPrompt
+}) => {
+  return {
+    key: "openai",
+    resolve: async ({ localeFrom, localeTo, req, texts }) => {
+      const apiUrl = `${baseUrl || "https://api.openai.com"}/v1/chat/completions`;
+      try {
+        const response = await Promise.all(chunkArray(texts, chunkLength).map((texts2) => {
+          const structuredTexts = texts2.reduce((acc, curr, index) => {
+            acc[index + 1] = curr;
+            return acc;
+          }, {});
+          return fetch(apiUrl, {
+            body: JSON.stringify({
+              messages: [
                 {
-                    handler: translateEndpoint,
-                    method: 'post',
-                    path: '/translator/translate'
-                }
-            ],
-            globals: config.globals?.map((global)=>{
-                if (!pluginConfig.globals.includes(global.slug)) return global;
-                return {
-                    ...global,
-                    admin: {
-                        ...global.admin ?? {},
-                        components: {
-                            ...global.admin?.components ?? {},
-                            elements: {
-                                ...global.admin?.components?.elements ?? {},
-                                PublishButton: CustomButton('publish'),
-                                SaveButton: CustomButton('save')
-                            }
-                        }
-                    }
-                };
-            }) ?? [],
-            i18n: {
-                ...config.i18n,
-                translations: {
-                    ...deepMerge(config.i18n?.translations ?? {}, translations)
+                  content: prompt({ localeFrom, localeTo, texts: structuredTexts }),
+                  role: "user"
                 }
+              ],
+              model
+            }),
+            headers: {
+              Authorization: `Bearer ${apiKey}`,
+              "Content-Type": "application/json"
+            },
+            method: "post"
+          }).then(async (res) => {
+            const data = await res.json();
+            if (!res.ok)
+              req.payload.logger.info({
+                message: "An error occurred when trying to translate the data using OpenAI API",
+                openAIresponse: data
+              });
+            return {
+              data,
+              success: res.ok
+            };
+          });
+        }));
+        const translated = [];
+        for (const { data, success } of response) {
+          if (!success)
+            return {
+              success: false
+            };
+          const content = data?.choices?.[0]?.message?.content;
+          if (!content) {
+            req.payload.logger.error("An error occurred when trying to translate the data using OpenAI API - missing content in the response");
+            return {
+              success: false
+            };
+          }
+          const translatedStructuredTexts = JSON.parse(content);
+          const translatedChunk = Object.values(translatedStructuredTexts);
+          if (!Array.isArray(translatedChunk)) {
+            req.payload.logger.error({
+              data: translatedChunk,
+              fullContent: content,
+              message: "An error occurred when trying to translate the data using OpenAI API - parsed content is not an array"
+            });
+            return {
+              success: false
+            };
+          }
+          for (const text of translatedChunk) {
+            if (text && typeof text !== "string") {
+              req.payload.logger.error({
+                chunkData: translatedChunk,
+                data: text,
+                fullContent: content,
+                message: "An error occurred when trying to translate the data using OpenAI API - parsed content is not a string"
+              });
+              return {
+                success: false
+              };
+            }
+            translated.push(text);
+          }
+        }
+        return {
+          success: true,
+          translatedTexts: translated
+        };
+      } catch (e) {
+        if (e instanceof Error) {
+          req.payload.logger.info({
+            message: "An error occurred when trying to translate the data using OpenAI API",
+            originalErr: e.message
+          });
+        }
+        return { success: false };
+      }
+    }
+  };
+};
+// src/index.ts
+var AUTO_TRANSLATE_MARKER = Symbol.for("@justanarthur/payload-plugin-translator/auto-translate");
+var translator = (pluginConfig) => {
+  return (config) => {
+    if (pluginConfig.disabled || !config.localization || config.localization.locales.length < 2)
+      return config;
+    const updatedConfig = {
+      ...config,
+      admin: {
+        ...config.admin ?? {},
+        custom: {
+          ...config.admin?.custom ?? {},
+          translator: {
+            resolvers: pluginConfig.resolvers.map(({ key }) => ({ key }))
+          }
+        }
+      },
+      collections: config.collections?.map((collection) => {
+        if (!pluginConfig.collections.includes(collection.slug))
+          return collection;
+        return {
+          ...collection,
+          admin: {
+            ...collection.admin ?? {},
+            components: {
+              ...collection.admin?.components ?? {},
+              edit: {
+                ...collection.admin?.components?.edit ?? {},
+                PublishButton: CustomButton("publish"),
+                SaveButton: CustomButton("save")
+              }
             }
+          },
+          ...pluginConfig.autoTranslate ? {
+            hooks: attachCollectionHook(collection.hooks, createAutoTranslateCollectionHook({ collectionSlug: String(collection.slug) }).afterChange)
+          } : {}
         };
-        return updatedConfig;
+      }) ?? [],
+      custom: {
+        ...config.custom ?? {},
+        translator: {
+          ...pluginConfig
+        }
+      },
+      endpoints: [
+        ...config.endpoints ?? [],
+        {
+          handler: translateEndpoint,
+          method: "post",
+          path: "/translator/translate"
+        }
+      ],
+      globals: config.globals?.map((global) => {
+        if (!pluginConfig.globals.includes(global.slug))
+          return global;
+        return {
+          ...global,
+          admin: {
+            ...global.admin ?? {},
+            components: {
+              ...global.admin?.components ?? {},
+              elements: {
+                ...global.admin?.components?.elements ?? {},
+                PublishButton: CustomButton("publish"),
+                SaveButton: CustomButton("save")
+              }
+            }
+          },
+          ...pluginConfig.autoTranslate ? {
+            hooks: attachGlobalHook(global.hooks, createAutoTranslateGlobalHook({ globalSlug: String(global.slug) }))
+          } : {}
+        };
+      }) ?? [],
+      i18n: {
+        ...config.i18n,
+        translations: {
+          ...deepMerge(config.i18n?.translations ?? {}, translations)
+        }
+      },
+      ...pluginConfig.autoTranslate ? {
+        jobs: {
+          ...config.jobs ?? {},
+          tasks: ensureJobBySlug(config.jobs?.tasks, createTranslateTask()),
+          workflows: ensureJobBySlug(config.jobs?.workflows, createTranslateWorkflow())
+        }
+      } : {}
     };
+    return updatedConfig;
+  };
 };
+function ensureJobBySlug(existing, job) {
+  const list = existing ?? [];
+  if (list.some((entry) => entry.slug === job.slug))
+    return list;
+  return [...list, job];
+}
+function attachCollectionHook(existing, hookToAttach) {
+  const list = toHookArray(existing?.afterChange);
+  if (list.some(isMarkedAutoTranslate))
+    return existing ?? {};
+  return {
+    ...existing ?? {},
+    afterChange: [markAutoTranslate(hookToAttach), ...list]
+  };
+}
+function attachGlobalHook(existing, hookToAttach) {
+  const list = toHookArray(existing?.afterChange);
+  if (list.some(isMarkedAutoTranslate))
+    return existing ?? {};
+  return {
+    ...existing ?? {},
+    afterChange: [markAutoTranslate(hookToAttach), ...list]
+  };
+}
+function toHookArray(input) {
+  if (input === undefined)
+    return [];
+  return Array.isArray(input) ? input : [input];
+}
+function markAutoTranslate(hook) {
+  hook[AUTO_TRANSLATE_MARKER] = true;
+  return hook;
+}
+function isMarkedAutoTranslate(hook) {
+  return Boolean(hook?.[AUTO_TRANSLATE_MARKER]);
+}
 
-//# sourceMappingURL=index.js.map
+// src/exports/index.ts
+var exports_default = translator;
+export {
+  translator,
+  translateOperation,
+  exports_default as default
+};