@justanarthur/payload-plugin-translator 1.3.21 → 3.0.3

package/dist/resolvers/copy.d.ts

@@ -1,8 +1,6 @@
 import { PayloadRequest } from "payload";
 type TranslateResolverArgs = {
-	/** Locale to translate from */
 	localeFrom: string;
-	/** Locale to translate to */
 	localeTo: string;
 	req: PayloadRequest;
 	texts: string[];

package/dist/resolvers/copy.js

@@ -1,16 +1,6 @@
-// src/resolvers/copy.ts
-var copyResolver = () => {
-  return {
-    key: "copy",
-    resolve: (args) => {
-      const { texts } = args;
-      return {
-        success: true,
-        translatedTexts: texts
-      };
-    }
-  };
-};
+import {
+  copyResolver
+} from "../shared/chunk-97ktc51q.js";
 
 // src/exports/resolvers/copy.ts
 var copy_default = copyResolver;

package/dist/resolvers/google.d.ts

@@ -1,8 +1,6 @@
 import { PayloadRequest } from "payload";
 type TranslateResolverArgs = {
-	/** Locale to translate from */
 	localeFrom: string;
-	/** Locale to translate to */
 	localeTo: string;
 	req: PayloadRequest;
 	texts: string[];
@@ -19,10 +17,6 @@ type TranslateResolver = {
 };
 type GoogleResolverConfig = {
 	apiKey: string;
-	/**
-	* How many texts to include into 1 request
-	* @default 100
-	*/
 	chunkLength?: number;
 };
 declare const googleResolver: ({ apiKey, chunkLength }: GoogleResolverConfig) => TranslateResolver;

package/dist/resolvers/google.js

@@ -1,57 +1,7 @@
-// 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
-      };
-    }
-  };
-};
+import {
+  googleResolver
+} from "../shared/chunk-fsveh29m.js";
+import"../shared/chunk-frnemj69.js";
 
 // src/exports/resolvers/google.ts
 var google_default = googleResolver;

package/dist/resolvers/libreTranslate.d.ts

@@ -1,8 +1,6 @@
 import { PayloadRequest } from "payload";
 type TranslateResolverArgs = {
-	/** Locale to translate from */
 	localeFrom: string;
-	/** Locale to translate to */
 	localeTo: string;
 	req: PayloadRequest;
 	texts: string[];
@@ -19,15 +17,7 @@ type TranslateResolver = {
 };
 type LibreResolverConfig = {
 	apiKey: string;
-	/**
-	* How many texts to include into 1 request
-	* @default 100
-	*/
 	chunkLength?: number;
-	/**
-	* Custom url for the libre translate instance
-	* @default "https://libretranslate.com/translate"
-	*/
 	url?: string;
 };
 declare const libreResolver: ({ apiKey, chunkLength, url }: LibreResolverConfig) => TranslateResolver;

package/dist/resolvers/libreTranslate.js

@@ -1,59 +1,7 @@
-// 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/libreTranslate.ts
-var localeToCountryCodeMapper = {
-  ua: "uk"
-};
-var mapLocale = (incoming) => (incoming in localeToCountryCodeMapper) ? localeToCountryCodeMapper[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: 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";
 
 // src/exports/resolvers/libreTranslate.ts
 var libreTranslate_default = libreResolver;

package/dist/resolvers/openAI.d.ts

@@ -1,8 +1,6 @@
 import { PayloadRequest } from "payload";
 type TranslateResolverArgs = {
-	/** Locale to translate from */
 	localeFrom: string;
-	/** Locale to translate to */
 	localeTo: string;
 	req: PayloadRequest;
 	texts: string[];
@@ -17,25 +15,17 @@ type TranslateResolver = {
 	key: string;
 	resolve: (args: TranslateResolverArgs) => Promise<TranslateResolverResponse> | TranslateResolverResponse;
 };
-type OpenAIMessageExchange = Record<string | number, string>;
 type OpenAIPrompt = (args: {
 	localeFrom: string;
 	localeTo: string;
-	texts: OpenAIMessageExchange;
+	texts: string[];
 }) => string;
 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;
 };
 declare const openAIResolver: ({ apiKey, baseUrl, chunkLength, model, prompt }: OpenAIResolverConfig) => TranslateResolver;
-export { openAIResolver, openAIResolver as default, OpenAIResolverConfig, OpenAIPrompt, OpenAIMessageExchange };
+export { openAIResolver, openAIResolver as default, OpenAIResolverConfig, OpenAIPrompt };

package/dist/resolvers/openAI.js

@@ -1,128 +1,7 @@
-// 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/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: [
-                {
-                  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 };
-      }
-    }
-  };
-};
+import {
+  openAIResolver
+} from "../shared/chunk-ecnph6hw.js";
+import"../shared/chunk-frnemj69.js";
 
 // src/exports/resolvers/openAI.ts
 var openAI_default = openAIResolver;

package/dist/resolvers/types.d.ts

@@ -1,8 +1,6 @@
 import { PayloadRequest } from "payload";
 type TranslateResolverArgs = {
-	/** Locale to translate from */
 	localeFrom: string;
-	/** Locale to translate to */
 	localeTo: string;
 	req: PayloadRequest;
 	texts: string[];

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 };