@justanarthur/payload-plugin-translator 1.3.20 → 3.0.3

package/dist/resolvers/libreTranslate.js

@@ -1,48 +1,11 @@
-import { chunkArray } from '../utils/chunkArray';
-const localeToCountryCodeMapper = {
-    ua: 'uk'
-};
-const mapLocale = (incoming)=>incoming in localeToCountryCodeMapper ? localeToCountryCodeMapper[incoming] : incoming;
-export const 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: 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({
-                        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
-            };
-        }
-    };
-};
+import {
+  libreResolver
+} from "../shared/chunk-zhrw0jnz.js";
+import"../shared/chunk-frnemj69.js";
 
-//# sourceMappingURL=libreTranslate.js.map
+// src/exports/resolvers/libreTranslate.ts
+var libreTranslate_default = libreResolver;
+export {
+  libreResolver,
+  libreTranslate_default as default
+};

package/dist/resolvers/openAI.d.ts

@@ -1,23 +1,31 @@
-import type { TranslateResolver } from './types';
-export type OpenAIMessageExchange = Record<string | number, string>;
-export type OpenAIPrompt = (args: {
-    localeFrom: string;
-    localeTo: string;
-    texts: OpenAIMessageExchange;
+import { PayloadRequest } from "payload";
+type TranslateResolverArgs = {
+	localeFrom: string;
+	localeTo: string;
+	req: PayloadRequest;
+	texts: string[];
+};
+type TranslateResolverResponse = {
+	success: false;
+} | {
+	success: true;
+	translatedTexts: string[];
+};
+type TranslateResolver = {
+	key: string;
+	resolve: (args: TranslateResolverArgs) => Promise<TranslateResolverResponse> | TranslateResolverResponse;
+};
+type OpenAIPrompt = (args: {
+	localeFrom: string;
+	localeTo: string;
+	texts: string[];
 }) => string;
-export type OpenAIResolverConfig = {
-    apiKey: string;
-    baseUrl?: string;
-    /**
-     * How many texts to include into 1 request
-     * @default 100
-     */
-    chunkLength?: number;
-    /**
-     * @default "gpt-3.5-turbo"
-     */
-    model?: string;
-    prompt?: OpenAIPrompt;
+type OpenAIResolverConfig = {
+	apiKey: string;
+	baseUrl?: string;
+	chunkLength?: number;
+	model?: string;
+	prompt?: OpenAIPrompt;
 };
-export declare const openAIResolver: ({ apiKey, baseUrl, chunkLength, model, prompt }: OpenAIResolverConfig) => TranslateResolver;
-//# sourceMappingURL=openAI.d.ts.map
+declare const openAIResolver: ({ apiKey, baseUrl, chunkLength, model, prompt }: OpenAIResolverConfig) => TranslateResolver;
+export { openAIResolver, openAIResolver as default, OpenAIResolverConfig, OpenAIPrompt };

package/dist/resolvers/openAI.js

@@ -1,136 +1,11 @@
-import { chunkArray } from '../utils/chunkArray';
-const 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}.
+import {
+  openAIResolver
+} from "../shared/chunk-ecnph6hw.js";
+import"../shared/chunk-frnemj69.js";
 
-**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)}`;
-};
-export const 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`;
-            const localizationConfig = req.payload.config.localization;
-            const resolveLocaleName = (code)=>{
-                if (localizationConfig && localizationConfig.locales) {
-                    const found = localizationConfig.locales.find((l)=>(typeof l === 'string' ? l : l.code) === code);
-                    if (found && typeof found !== 'string' && found.label) {
-                        return typeof found.label === 'string' ? found.label : found.label['en'] ?? code;
-                    }
-                }
-                return new Intl.DisplayNames([
-                    'en'
-                ], {
-                    type: 'language'
-                }).of(code) ?? code;
-            };
-            const localeFromName = resolveLocaleName(localeFrom);
-            const localeToName = resolveLocaleName(localeTo);
-            try {
-                const response = await Promise.all(chunkArray(texts, chunkLength).map((texts)=>{
-                    const structuredTexts = texts.reduce((acc, curr, index)=>{
-                        acc[index + 1] = curr;
-                        return acc;
-                    }, {});
-                    return fetch(apiUrl, {
-                        body: JSON.stringify({
-                            messages: [
-                                {
-                                    content: prompt({
-                                        localeFrom: localeFromName,
-                                        localeTo: localeToName,
-                                        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/exports/resolvers/openAI.ts
+var openAI_default = openAIResolver;
+export {
+  openAIResolver,
+  openAI_default as default
 };
-
-//# sourceMappingURL=openAI.js.map

package/dist/resolvers/types.d.ts

@@ -1,20 +1,18 @@
-import type { PayloadRequest } from 'payload';
-export type TranslateResolverArgs = {
-    /** Locale to translate from */
-    localeFrom: string;
-    /** Locale to translate to */
-    localeTo: string;
-    req: PayloadRequest;
-    texts: string[];
+import { PayloadRequest } from "payload";
+type TranslateResolverArgs = {
+	localeFrom: string;
+	localeTo: string;
+	req: PayloadRequest;
+	texts: string[];
 };
-export type TranslateResolverResponse = {
-    success: false;
+type TranslateResolverResponse = {
+	success: false;
 } | {
-    success: true;
-    translatedTexts: string[];
+	success: true;
+	translatedTexts: string[];
 };
-export type TranslateResolver = {
-    key: string;
-    resolve: (args: TranslateResolverArgs) => Promise<TranslateResolverResponse> | TranslateResolverResponse;
+type TranslateResolver = {
+	key: string;
+	resolve: (args: TranslateResolverArgs) => Promise<TranslateResolverResponse> | TranslateResolverResponse;
 };
-//# sourceMappingURL=types.d.ts.map
+export { TranslateResolverResponse, TranslateResolverArgs, TranslateResolver };

package/dist/resolvers/types.js

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

package/dist/shared/chunk-97ktc51q.js

@@ -0,0 +1,15 @@
+// src/resolvers/copy.ts
+var copyResolver = () => {
+  return {
+    key: "copy",
+    resolve: (args) => {
+      const { texts } = args;
+      return {
+        success: true,
+        translatedTexts: texts
+      };
+    }
+  };
+};
+
+export { copyResolver };

package/dist/shared/chunk-ecnph6hw.js

@@ -0,0 +1,205 @@
+import {
+  chunkArray
+} from "./chunk-frnemj69.js";
+
+// src/resolvers/openAI.ts
+var LOCALE_DISPLAY_NAME = {
+  en: "English",
+  sk: "Slovak",
+  cs: "Czech",
+  de: "German",
+  uk: "Ukrainian",
+  ua: "Ukrainian",
+  pl: "Polish",
+  hu: "Hungarian",
+  fr: "French",
+  es: "Spanish",
+  it: "Italian",
+  pt: "Portuguese",
+  nl: "Dutch",
+  ro: "Romanian"
+};
+var RETRY_DELAYS_MS = [500, 1000, 2000];
+var defaultPrompt = ({ localeFrom, localeTo, texts }) => {
+  const from = LOCALE_DISPLAY_NAME[localeFrom] ?? localeFrom;
+  const to = LOCALE_DISPLAY_NAME[localeTo] ?? localeTo;
+  return `You are a machine-translation engine. Translate each string in the input JSON array from ${from} (${localeFrom}) to ${to} (${localeTo}).
+
+Rules:
+1. The output must be a valid JSON array of strings, with the same length and order as the input.
+2. SLUGS: any input that looks like a URL slug (lowercase, contains only ASCII letters/digits/hyphens/underscores, no spaces, no punctuation) MUST be transliterated into the target language. Output the slug in the same format: lowercase ASCII only, using only letters a-z, digits 0-9, hyphens (-), and underscores (_). Never leave a slug unchanged. Never output accented characters, uppercase letters, spaces, or other symbols in a slug. Examples:
+   - "about-us-copy" (en) → "o-nas-kopia" (sk) → "uber-uns-kopie" (de) → "sobre-nos-copia" (pt) → "a-propos-copie" (fr)
+   - For Cyrillic source scripts, transliterate to Latin first, then translate.
+3. URLs (containing "://" or "www."), email addresses, hex strings, and other opaque identifiers: keep as-is.
+4. Apply locale-specific formatting for dates, currency, decimal separators in human-readable text.
+5. Return only the JSON array. No markdown fences, no prose, no trailing commentary.
+
+INPUT:
+${JSON.stringify(texts)}`;
+};
+var sleep = (ms) => new Promise((r) => setTimeout(r, ms));
+var isRetryableStatus = (status) => status === 429 || status >= 500;
+var isGpt5Family = (model) => /^gpt-5/.test(model);
+var isGpt54Plus = (model) => /^gpt-5\.[1-9]/.test(model);
+var usesMaxCompletionTokens = (model) => isGpt5Family(model) || /^o[1-9]/.test(model);
+var deriveMaxTokens = (chunkLength, model) => {
+  const base = Math.max(chunkLength * 100, 4000);
+  if (model && isGpt54Plus(model))
+    return Math.max(base * 4, 16000);
+  return base;
+};
+var parseContent = (raw) => {
+  const trimmed = raw.trim();
+  const m = trimmed.match(/^```(?:json)?\s*\n?([\s\S]*?)\n?\s*```$/);
+  const candidate = m ? m[1].trim() : trimmed;
+  const fenceStripped = m !== null;
+  let parsed;
+  try {
+    parsed = JSON.parse(candidate);
+  } catch (e) {
+    return {
+      error: e instanceof Error ? e.message : String(e),
+      fenceStripped,
+      ok: false
+    };
+  }
+  if (!Array.isArray(parsed)) {
+    return { error: "parsed value is not an array", fenceStripped, ok: false };
+  }
+  if (!parsed.every((v) => typeof v === "string")) {
+    return { error: "array contains non-string element", fenceStripped, ok: false };
+  }
+  return { fenceStripped, ok: true, translated: parsed };
+};
+var openAIResolver = ({
+  apiKey,
+  baseUrl,
+  chunkLength = 100,
+  model = "gpt-4o-mini",
+  prompt = defaultPrompt
+}) => {
+  return {
+    key: "openai",
+    resolve: async ({ localeFrom, localeTo, req, texts }) => {
+      const apiUrl = `${baseUrl || "https://api.openai.com"}/v1/chat/completions`;
+      const maxTokens = deriveMaxTokens(chunkLength, model);
+      const maxTokensKey = usesMaxCompletionTokens(model) ? "max_completion_tokens" : "max_tokens";
+      const supportsCustomTemperature = !isGpt5Family(model);
+      const reasoningEffort = isGpt54Plus(model) ? "low" : undefined;
+      const logger = req.payload.logger;
+      try {
+        const response = await Promise.all(chunkArray(texts, chunkLength).map(async (chunk) => {
+          for (let attempt = 0;attempt <= RETRY_DELAYS_MS.length; attempt++) {
+            let shouldRetry = false;
+            let httpStatus = 0;
+            try {
+              const res = await fetch(apiUrl, {
+                body: JSON.stringify({
+                  messages: [
+                    {
+                      content: prompt({ localeFrom, localeTo, texts: chunk }),
+                      role: "user"
+                    }
+                  ],
+                  model,
+                  ...supportsCustomTemperature ? { temperature: 0 } : {},
+                  ...reasoningEffort ? { reasoning_effort: reasoningEffort } : {},
+                  [maxTokensKey]: maxTokens
+                }),
+                headers: {
+                  Authorization: `Bearer ${apiKey}`,
+                  "Content-Type": "application/json"
+                },
+                method: "post"
+              });
+              httpStatus = res.status;
+              const data = await res.json();
+              if (res.ok) {
+                const content = data?.choices?.[0]?.message?.content;
+                if (!content) {
+                  logger.error({
+                    code: "OPENAI_BAD_JSON",
+                    message: "OpenAI response missing content",
+                    openAIResponse: data
+                  });
+                  shouldRetry = true;
+                } else {
+                  const result = parseContent(content);
+                  if (result.ok) {
+                    if (result.fenceStripped) {
+                      logger.info({
+                        code: "OPENAI_FENCE_STRIPPED",
+                        message: "OpenAI returned fenced JSON despite json_object mode"
+                      });
+                    }
+                    return { success: true, translated: result.translated };
+                  }
+                  logger.error({
+                    code: "OPENAI_BAD_JSON",
+                    error: result.error,
+                    fenceStripped: result.fenceStripped,
+                    message: "Failed to parse OpenAI response"
+                  });
+                  shouldRetry = true;
+                }
+              } else {
+                logger.error({
+                  code: "OPENAI_HTTP_ERROR",
+                  message: "OpenAI returned non-2xx status",
+                  openAIResponse: data,
+                  status: httpStatus
+                });
+                if (isRetryableStatus(httpStatus))
+                  shouldRetry = true;
+              }
+            } catch (e) {
+              logger.error({
+                code: "OPENAI_NETWORK_ERROR",
+                message: "OpenAI request threw",
+                originalErr: e instanceof Error ? e.message : String(e)
+              });
+              shouldRetry = true;
+            }
+            if (attempt < RETRY_DELAYS_MS.length && shouldRetry) {
+              logger.info({
+                attempt: attempt + 1,
+                code: "OPENAI_RETRY",
+                message: "Retrying OpenAI request after backoff",
+                nextBackoffMs: RETRY_DELAYS_MS[attempt],
+                status: httpStatus
+              });
+              await sleep(RETRY_DELAYS_MS[attempt]);
+              continue;
+            }
+            logger.error({
+              code: "OPENAI_GIVE_UP",
+              message: "OpenAI chunk failed after retries",
+              status: httpStatus
+            });
+            return { success: false };
+          }
+          return { success: false };
+        }));
+        const translated = [];
+        for (const result of response) {
+          if (!result.success)
+            return { success: false };
+          translated.push(...result.translated);
+        }
+        return {
+          success: true,
+          translatedTexts: translated
+        };
+      } catch (e) {
+        logger.error({
+          code: "OPENAI_UNEXPECTED",
+          message: "OpenAI resolve threw an unexpected error",
+          originalErr: e instanceof Error ? e.message : String(e)
+        });
+        return { success: false };
+      }
+    }
+  };
+};
+
+export { openAIResolver };

package/dist/shared/chunk-frnemj69.js

@@ -0,0 +1,6 @@
+// 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));
+};
+
+export { chunkArray };

package/dist/shared/chunk-fsveh29m.js

@@ -0,0 +1,55 @@
+import {
+  chunkArray
+} from "./chunk-frnemj69.js";
+
+// 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
+      };
+    }
+  };
+};
+
+export { googleResolver };