@justanarthur/payload-plugin-translator 1.3.19 → 1.3.21

package/dist/resolvers/copy.d.ts

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

package/dist/resolvers/copy.js

@@ -1,14 +1,20 @@
-export const copyResolver = ()=>{
-    return {
-        key: 'copy',
-        resolve: (args)=>{
-            const { texts } = args;
-            return {
-                success: true,
-                translatedTexts: texts
-            };
-        }
-    };
+// src/resolvers/copy.ts
+var copyResolver = () => {
+  return {
+    key: "copy",
+    resolve: (args) => {
+      const { texts } = args;
+      return {
+        success: true,
+        translatedTexts: texts
+      };
+    }
+  };
 };
 
-//# sourceMappingURL=copy.js.map
+// src/exports/resolvers/copy.ts
+var copy_default = copyResolver;
+export {
+  copy_default as default,
+  copyResolver
+};

package/dist/resolvers/google.d.ts

@@ -1,11 +1,29 @@
-import type { TranslateResolver } from './types';
-export type GoogleResolverConfig = {
-    apiKey: string;
-    /**
-     * How many texts to include into 1 request
-     * @default 100
-     */
-    chunkLength?: number;
-};
-export declare const googleResolver: ({ apiKey, chunkLength, }: GoogleResolverConfig) => TranslateResolver;
-//# sourceMappingURL=google.d.ts.map
+import { PayloadRequest } from "payload";
+type TranslateResolverArgs = {
+	/** Locale to translate from */
+	localeFrom: string;
+	/** Locale to translate to */
+	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 GoogleResolverConfig = {
+	apiKey: string;
+	/**
+	* How many texts to include into 1 request
+	* @default 100
+	*/
+	chunkLength?: number;
+};
+declare const googleResolver: ({ apiKey, chunkLength }: GoogleResolverConfig) => TranslateResolver;
+export { googleResolver, googleResolver as default, GoogleResolverConfig };

package/dist/resolvers/google.js

@@ -1,47 +1,61 @@
-import { chunkArray } from '../utils/chunkArray';
-const localeToCountryCodeMapper = {
-    ua: 'uk'
+// 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));
 };
-const mapLocale = (incoming)=>incoming in localeToCountryCodeMapper ? localeToCountryCodeMapper[incoming] : incoming;
-export const 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/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
+      };
+    }
+  };
 };
 
-//# sourceMappingURL=google.js.map
+// src/exports/resolvers/google.ts
+var google_default = googleResolver;
+export {
+  googleResolver,
+  google_default as default
+};

package/dist/resolvers/libreTranslate.d.ts

@@ -1,16 +1,34 @@
-import type { TranslateResolver } from './types';
-export 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;
+import { PayloadRequest } from "payload";
+type TranslateResolverArgs = {
+	/** Locale to translate from */
+	localeFrom: string;
+	/** Locale to translate to */
+	localeTo: string;
+	req: PayloadRequest;
+	texts: string[];
 };
-export declare const libreResolver: ({ apiKey, chunkLength, url, }: LibreResolverConfig) => TranslateResolver;
-//# sourceMappingURL=libreTranslate.d.ts.map
+type TranslateResolverResponse = {
+	success: false;
+} | {
+	success: true;
+	translatedTexts: string[];
+};
+type TranslateResolver = {
+	key: string;
+	resolve: (args: TranslateResolverArgs) => Promise<TranslateResolverResponse> | TranslateResolverResponse;
+};
+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;
+export { libreResolver, libreResolver as default, LibreResolverConfig };

package/dist/resolvers/libreTranslate.js

@@ -1,48 +1,63 @@
-import { chunkArray } from '../utils/chunkArray';
-const localeToCountryCodeMapper = {
-    ua: 'uk'
+// 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));
 };
-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
-            };
-        }
-    };
+
+// 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
+      };
+    }
+  };
 };
 
-//# 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,41 @@
-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 = {
+	/** Locale to translate from */
+	localeFrom: string;
+	/** Locale to translate to */
+	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 OpenAIMessageExchange = Record<string | number, string>;
+type OpenAIPrompt = (args: {
+	localeFrom: string;
+	localeTo: string;
+	texts: OpenAIMessageExchange;
 }) => 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;
+	/**
+	* How many texts to include into 1 request
+	* @default 100
+	*/
+	chunkLength?: number;
+	/**
+	* @default "gpt-3.5-turbo"
+	*/
+	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, OpenAIMessageExchange };

package/dist/resolvers/openAI.js

@@ -1,6 +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}.
+// 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**.
@@ -17,104 +22,111 @@ const defaultPrompt = ({ localeFrom, localeTo, texts })=>{
 **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`;
-            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,
-                                        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
-                    });
+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"
                 }
-                return {
-                    success: false
-                };
+              ],
+              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 };
+      }
+    }
+  };
 };
 
-//# sourceMappingURL=openAI.js.map
+// src/exports/resolvers/openAI.ts
+var openAI_default = openAIResolver;
+export {
+  openAIResolver,
+  openAI_default as default
+};