generaltranslation 1.2.10 → 1.2.12

package/README.md

@@ -54,18 +54,7 @@ const codes = getLanguageCodes(['French', 'Spanish'])
 console.log(codes) // ['fr', 'es']
 ```
 
-## Get a user's language
-
-### getUserLanguage() 
-
-Returns a user's default browser language. Meant for use in a web browser (i.e. on the client side).
-
-```
-const userLanguage = getUserLanguage();
-console.log(userLanguage) // 'en'
-```
-
-## Prompt Internationalization API
+## Translation API
 
 For this function, you need to sign up for an API key at <a href='https://generaltranslation.com' target='_blank'>generaltranslation.com</a>.
 
@@ -81,23 +70,21 @@ const gt = new GT({
 });
 ```
 
-### async translatePrompt(prompt, language)
+### async translate(content, language)
 
-Translates prompt into the language represented by an ISO-639 language code. Designed for translating prompts into other languages, to internationalize responses from AI models.
-
-Just wrap `translatePrompt` around your prompt and go. 
+Translates content into the language represented by an ISO-639 language code. Caches by default. Just wrap `translate` around your content and go.
 
 All of the following are valid:
 
 ```
-const translatedPrompt = await gt.translatePrompt('Tell me a story', 'es');
+const translation = await gt.translate('Tell me a story', 'es'); // returns a string
 ```
 
 ```
-const first = 'Tell me a story ';
-const second = 'about a cat'
+const first = 'Tell me a story';
+const second = ' about a cat'
 
-const translatedPrompt = await gt.translatePrompt([
+const translated = await gt.translate([
     first, second
 ], 'es');
 ```
@@ -108,18 +95,18 @@ To mark text that shouldn't be translated, wrap it in `{ text: "", translate: fa
 const prompt = 'Tell me a story about ';
 const input = 'gatos con espadas'
 
-const translatedPrompt = await gt.translatePrompt([
+const translatedPrompt = await gt.translate([
     prompt, { text: input, translate: false }
 ], 'es');
 ```
 
-For type consistency, you can also make everything in the prompt parameter an object:
+For type consistency, you can also make everything in the content parameter an object:
 
 ```
 const prompt = 'Tell me a story about ';
 const input = 'gatos con espadas'
 
-const translatedPrompt = await gt.translatePrompt([
+const translatedPrompt = await gt.translate([
     { text: prompt }, 
     { text: input, translate: false }
 ], 'es');
@@ -128,5 +115,23 @@ const translatedPrompt = await gt.translatePrompt([
 This also works:
 
 ```
-const translatedPrompt = await gt.translatePrompt({ text: 'Tell me a story' }, 'es');
+const translatedPrompt = await gt.translate({ text: 'Tell me a story' }, 'es');
+```
+
+### async translateMany(contentArray, language)
+
+Translates multiple items of content into the language represented by an ISO-639 language code. Caches by default. Just wrap `translateMany` around an array of what you want to translate and specify a language. For example:
+
+```
+const requests = [
+    {
+        content: "You say goodbye",
+        language: "es"
+    },
+    {
+        content: "And I say hello.",
+        language: "de"
+    }
+];
+const translationArray = await gt.translateMany(requests) // returns an array
 ```

package/index.js

@@ -4,40 +4,63 @@
 // ----- IMPORTS ----- //
 
 const { _getLanguageCode, _getLanguageName } = require('./codes/codes.js');
-const _translatePrompt = require('./translate/prompts.js');
+const { _translate, _translateMany } = require('./translate/translate.js');
 const _translateHTML = require('./translate/html.js');
 
+// TO DO
+// - Times/dates?
+// - Currency conversion?
+// - Regions (e.g. en-GB)
+
 // ----- CORE CLASS ----- // 
 
+const getDefaultFromEnv = (VARIABLE) => {
+    if (typeof process !== 'undefined') {
+        if (process?.env?.[VARIABLE]) {
+            return process.env[VARIABLE];
+        }
+    }
+    return '';
+}
+
 class GT {
 
     constructor({
         apiKey = '', 
         defaultLanguage = 'en',
+        projectID = '',
         baseURL = 'https://translate.gtx.dev'
     } = {}) {
-        this.apiKey = apiKey || (typeof process !== 'undefined' ? process.env.GT_API_KEY : '');
+        this.apiKey = apiKey || getDefaultFromEnv('GT_API_KEY');
+        this.projectID = projectID || getDefaultFromEnv('GT_PROJECT_ID');
         this.defaultLanguage = defaultLanguage?.toLowerCase();
         this.baseURL = baseURL;
     }
 
-    // Prompt I18N
-    async translatePrompt(prompt, language) {
-        return await _translatePrompt({
-            content: prompt, language: language, config: this
+    // Site I18N
+    async translateHTML({ page, userLanguage, defaultLanguage, content, ...metadata }) {
+        return await _translateHTML({
+            page: page,
+            userLanguage: userLanguage,
+            defaultLanguage: defaultLanguage,
+            content: content,
+            config: this,
+            ...metadata
         });
     }
 
-    // Site I18N
-    async translateHTML({ projectID, page, userLanguage, defaultLanguage, content, ...metadata }) {
-        return await _translateHTML({
-           projectID: projectID,
-           page: page,
-           userLanguage: userLanguage,
-           defaultLanguage: defaultLanguage,
-           content: content,
-           config: this,
-           ...metadata
+    // String translation
+    async translate(content, language, { ... options }) {
+        return await _translate({
+            content: content, language: language, config: this, ...options,
+        });
+    }
+
+    // String translation, of an array of strings
+    // requestArray looks like { content: '', language: '' }
+    async translateMany(requestArray) {
+        return await _translateMany({
+            requestArray, config: this
         });
     }
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "generaltranslation",
-  "version": "1.2.10",
+  "version": "1.2.12",
   "description": "A language toolkit for AI developers",
   "main": "index.js",
   "scripts": {

package/translate/html.js

@@ -1,5 +1,4 @@
 const _translateHTML = async ({
-    projectID,
     page,
     userLanguage,
     defaultLanguage,
@@ -13,8 +12,9 @@ const _translateHTML = async ({
         throw new Error('Missing API Key!')
     };
 
+    const projectID = config?.projectID;
     if (!projectID) {
-        throw new Error('Missing project ID!')
+        throw new Error('Missing Project ID!')
     };
 
     try {

package/translate/{prompts.js → translate.js}

@@ -5,7 +5,7 @@ const _shouldTranslate = item => typeof item?.translate === 'boolean' ? item.tra
 
 // Pre-processes content to send to the API
 // Separates out text that shouldn't be translated.
-const _processPrompt = ({ content }) => {
+const _processContent = ({ content }) => {
     const processed = [];
     const untranslated = [];
     if (Array.isArray(content)) {
@@ -40,7 +40,7 @@ const _processPrompt = ({ content }) => {
 }
 
 // Build content string from array or single item
-const _constructPrompt = ({ content, untranslated = null}) => {
+const _constructContent = ({ content, untranslated = null}) => {
     if (Array.isArray(content)) {
         let final = '';
         for (const item of content) {
@@ -64,8 +64,8 @@ const _constructPrompt = ({ content, untranslated = null}) => {
 
 // Get a translation via General Translation API
 // Returns string
-const _translatePrompt = async ({
-    content, language, config
+const _translate = async ({
+    content, language, config, ...options
 }) => {
     
     const apiKey = config?.apiKey;
@@ -75,13 +75,13 @@ const _translatePrompt = async ({
 
     const defaultLanguage = config?.defaultLanguage;
     if (language === defaultLanguage) {
-        return _constructPrompt({ content: content });
+        return _constructContent({ content: content });
     };
 
-    const { processed, untranslated } = _processPrompt({ content });
+    const { processed, untranslated } = _processContent({ content });
     
     try {
-        const response = await fetch(`${config?.baseURL}/prompts`, {
+        const response = await fetch(`${config?.baseURL}`, {
             method: 'POST',
             headers: {
                 'Content-Type': 'application/json',
@@ -90,7 +90,8 @@ const _translatePrompt = async ({
             body: JSON.stringify({
                 content: processed,
                 targetLanguage: language,
-                defaultLanguage: defaultLanguage
+                defaultLanguage: defaultLanguage,
+                options: { ...options }
             })
         })
         if (!response.ok) {
@@ -98,13 +99,76 @@ const _translatePrompt = async ({
             throw new Error(`${result || response.status}`);
         } else {
             const result = await response.json();
-            return _constructPrompt({content: result, untranslated: untranslated });
+            return _constructContent({content: result, untranslated: untranslated });
         }
     } catch (error) {
         console.error(error)
-        return _constructPrompt({ content: content })
+        return _constructContent({ content: content })
     }
 
 }
 
-module.exports = _translatePrompt;
+const constructAll = (contentArray) => {
+    const returnArray = [];
+    for (const item of contentArray) {
+        returnArray.push(_constructContent({ content: item }))
+    }
+    return returnArray;
+}
+
+// Get a translation of multiple strings via General Translation API
+// Returns array of strings
+const _translateMany = async ({
+    requestArray, config
+}) => {
+    
+    const apiKey = config?.apiKey;
+    if (!apiKey) {
+        throw new Error('Missing API Key!')
+    };
+
+    const processedRequests = [];
+    const untranslatedArray = [];
+
+    for (const item of requestArray) {
+        const { processed, untranslated } = _processContent({ content: item?.content });
+        processedRequests.push({ content: processed, language: item.language, options: { ...item.options } });
+        untranslatedArray.push(untranslated);
+    };
+    
+    try {
+        const response = await fetch(`${config?.baseURL}/many`, {
+            method: 'POST',
+            headers: {
+                'Content-Type': 'application/json',
+                'gtx-api-key': apiKey,
+            },
+            body: JSON.stringify({
+                processedRequests: processedRequests,
+                targetLanguage: language,
+                defaultLanguage: defaultLanguage,
+                options: { ...options }
+            })
+        })
+        if (!response.ok) {
+            const result = await response.text();
+            throw new Error(`${result || response.status}`);
+        } else {
+            const result = await response.json();
+            if (!Array.isArray(result)) {
+                throw new Error(`${result || response.status}`);
+            }
+            const returnArray = []
+            for (const [index, item] of result.entries()) {
+                returnArray.push(_constructContent({content: item, untranslated: untranslatedArray[index] }));
+            }
+            return returnArray;
+        }
+    } catch (error) {
+        console.error(error)
+        return constructAll(requestArray.map(item => item.content));
+    }
+
+}
+
+module.exports = { _translate, _translateMany };