@justanarthur/payload-plugin-translator 1.3.20 → 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 };