generaltranslation 2.0.7 → 2.0.9

package/dist/codes/codes.d.ts

@@ -1,8 +1,8 @@
-interface LanguageObject {
+type LanguageObject = {
     language: string;
-    script: string;
-    region: string;
-}
+    script?: string;
+    region?: string;
+};
 /**
  * Returns a language object from an array of codes or a single code.
  * Returns null if there's no matching language.

package/dist/index.d.ts

@@ -1,7 +1,7 @@
 import { _getLanguageObject, _isSameLanguage } from './codes/codes';
 import { Content } from './translation/_translate';
 /**
- * Interface representing the constructor parameters for the GT class.
+ * Type representing the constructor parameters for the GT class.
  */
 type GTConstructorParams = {
     apiKey?: string;
@@ -27,26 +27,33 @@ declare class GT {
      * @param {string} [params.baseURL='https://prod.gtx.dev'] - The base URL for the translation service.
      */
     constructor({ apiKey, defaultLanguage, projectID, baseURL }?: GTConstructorParams);
-    translate({ content, targetLanguage, metadata }: {
-        content: Content;
-        targetLanguage: string;
-        metadata: {
-            [key: string]: any;
-        };
+    /**
+    * Translates a string, caching it for re-use.
+    * @param {Content} content - The content to translate.
+    * @param {string} targetLanguage - The target language for the translation.
+    * @param {{ [key: string]: any }} metadata - Additional metadata for the translation request.
+    * @returns {Promise<{ translation: string, error?: Error | unknown }>} - The translated content with optional error information.
+    */
+    translate(content: Content, targetLanguage: string, metadata?: {
+        [key: string]: any;
     }): Promise<{
         translation: string;
         error?: Error | unknown;
     }>;
-    translateMany({ contentArray, targetLanguage, metadata }: {
-        contentArray: Content[];
-        targetLanguage: string;
-        metadata: {
-            [key: string]: any;
-        };
-    }): Promise<Array<{
+    /**
+    * Translates a single piece of content and caches for use in a public project.
+    * @param {Content} content - The content to translate.
+    * @param {string} targetLanguage - The target language for the translation.
+    * @param {string} projectID - The ID of the project
+    * @param {{ [key: string]: any }} metadata - Additional metadata for the translation request.
+    * @returns {Promise<{ translation: string, error?: Error | unknown }>} The translated content with optional error information.
+    */
+    intl(content: Content, targetLanguage: string, projectID?: string, metadata?: {
+        [key: string]: any;
+    }): Promise<{
         translation: string;
         error?: Error | unknown;
-    }>>;
+    }>;
     /**
     * Translates the content of React children elements.
     *
@@ -57,16 +64,18 @@ declare class GT {
     *
     * @returns {Promise<any>} - A promise that resolves to the translated content.
     */
-    translateReactChildren({ content, targetLanguage, metadata }: {
-        content: any;
-        targetLanguage: string;
-        metadata: {
-            [key: string]: any;
-        };
+    translateReactChildren(content: any, targetLanguage: string, metadata?: {
+        [key: string]: any;
     }): Promise<{
         translation: any | null;
         error?: Error | unknown;
     }>;
+    /**
+    * Bundles multiple requests and sends them to the server.
+    * @param requests - Array of requests to be processed and sent.
+    * @returns A promise that resolves to an array of processed results.
+    */
+    bundleRequests(requests: any[]): Promise<Array<any | null>>;
 }
 export default GT;
 export declare const getLanguageObject: typeof _getLanguageObject;

package/dist/index.js

@@ -1,29 +1,6 @@
 "use strict";
 // `generaltranslation` language toolkit
 // © 2024, General Translation, Inc.
-var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
-    if (k2 === undefined) k2 = k;
-    var desc = Object.getOwnPropertyDescriptor(m, k);
-    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
-      desc = { enumerable: true, get: function() { return m[k]; } };
-    }
-    Object.defineProperty(o, k2, desc);
-}) : (function(o, m, k, k2) {
-    if (k2 === undefined) k2 = k;
-    o[k2] = m[k];
-}));
-var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
-    Object.defineProperty(o, "default", { enumerable: true, value: v });
-}) : function(o, v) {
-    o["default"] = v;
-});
-var __importStar = (this && this.__importStar) || function (mod) {
-    if (mod && mod.__esModule) return mod;
-    var result = {};
-    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
-    __setModuleDefault(result, mod);
-    return result;
-};
 var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
     function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
     return new (P || (P = Promise))(function (resolve, reject) {
@@ -40,10 +17,11 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.isSameLanguage = exports.getLanguageName = exports.getLanguageCode = exports.getLanguageObject = void 0;
 // ----- IMPORTS ----- //
 const codes_1 = require("./codes/codes");
-const _translate_1 = __importStar(require("./translation/_translate"));
+const _bundleRequests_1 = __importDefault(require("./translation/_bundleRequests"));
+const _intl_1 = __importDefault(require("./translation/_intl"));
+const _translate_1 = __importDefault(require("./translation/_translate"));
 const _translateReactChildren_1 = __importDefault(require("./translation/_translateReactChildren"));
 // TO DO
-// - Translation API
 // - Times/dates?
 // - Currency conversion?
 // ----- CORE CLASS ----- // 
@@ -72,14 +50,29 @@ class GT {
         this.defaultLanguage = defaultLanguage.toLowerCase();
         this.baseURL = baseURL;
     }
-    translate(_a) {
-        return __awaiter(this, arguments, void 0, function* ({ content, targetLanguage, metadata }) {
+    /**
+    * Translates a string, caching it for re-use.
+    * @param {Content} content - The content to translate.
+    * @param {string} targetLanguage - The target language for the translation.
+    * @param {{ [key: string]: any }} metadata - Additional metadata for the translation request.
+    * @returns {Promise<{ translation: string, error?: Error | unknown }>} - The translated content with optional error information.
+    */
+    translate(content, targetLanguage, metadata) {
+        return __awaiter(this, void 0, void 0, function* () {
             return yield (0, _translate_1.default)(this, content, targetLanguage, Object.assign({ projectID: this.projectID, defaultLanguage: this.defaultLanguage }, metadata));
         });
     }
-    translateMany(_a) {
-        return __awaiter(this, arguments, void 0, function* ({ contentArray, targetLanguage, metadata }) {
-            return yield (0, _translate_1._translateMany)(this, contentArray, targetLanguage, Object.assign({ projectID: this.projectID, defaultLanguage: this.defaultLanguage }, metadata));
+    /**
+    * Translates a single piece of content and caches for use in a public project.
+    * @param {Content} content - The content to translate.
+    * @param {string} targetLanguage - The target language for the translation.
+    * @param {string} projectID - The ID of the project
+    * @param {{ [key: string]: any }} metadata - Additional metadata for the translation request.
+    * @returns {Promise<{ translation: string, error?: Error | unknown }>} The translated content with optional error information.
+    */
+    intl(content, targetLanguage, projectID, metadata) {
+        return __awaiter(this, void 0, void 0, function* () {
+            return yield (0, _intl_1.default)(this, content, targetLanguage, projectID || this.projectID, Object.assign({ projectID: projectID || this.projectID, defaultLanguage: this.defaultLanguage }, metadata));
         });
     }
     /**
@@ -92,11 +85,21 @@ class GT {
     *
     * @returns {Promise<any>} - A promise that resolves to the translated content.
     */
-    translateReactChildren(_a) {
-        return __awaiter(this, arguments, void 0, function* ({ content, targetLanguage, metadata }) {
+    translateReactChildren(content, targetLanguage, metadata) {
+        return __awaiter(this, void 0, void 0, function* () {
             return yield (0, _translateReactChildren_1.default)(this, content, targetLanguage, Object.assign({ projectID: this.projectID, defaultLanguage: this.defaultLanguage }, metadata));
         });
     }
+    /**
+    * Bundles multiple requests and sends them to the server.
+    * @param requests - Array of requests to be processed and sent.
+    * @returns A promise that resolves to an array of processed results.
+    */
+    bundleRequests(requests) {
+        return __awaiter(this, void 0, void 0, function* () {
+            return (0, _bundleRequests_1.default)(this, requests);
+        });
+    }
 }
 // ----- EXPORTS ----- //
 // Export the class

package/dist/translation/_bundleRequests.d.ts

@@ -0,0 +1,15 @@
+type Request = {
+    type: 'translate' | 'intl' | 'react';
+    data: any;
+};
+/**
+ * Bundles multiple requests and sends them to the server.
+ * @param gt - Contains the baseURL and apiKey for the server request.
+ * @param requests - Array of requests to be processed and sent.
+ * @returns A promise that resolves to an array of processed results.
+ */
+export default function _bundleRequests(gt: {
+    baseURL: string;
+    apiKey: string;
+}, requests: Request[]): Promise<Array<any | null>>;
+export {};

package/dist/translation/_bundleRequests.js

@@ -0,0 +1,102 @@
+"use strict";
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.default = _bundleRequests;
+const _translate_1 = require("./_translate");
+/**
+ * Preprocesses the request based on its type.
+ * For 'intl' and 'translate' types, it processes the content and extracts arrays for further use.
+ * @param request - The request to be processed.
+ * @returns An object containing the processed request and any additional data.
+ */
+const _preprocess = (request) => {
+    const { type, data } = request;
+    let processedData = data;
+    let additional = {};
+    if (type === 'intl' || type === 'translate') {
+        const { array, excludedArray } = (0, _translate_1._process)(data.content);
+        processedData.content = array;
+        additional.excludedArray = excludedArray;
+        additional.type = type;
+    }
+    if (Object.keys(additional).length > 0) {
+        return {
+            processed: {
+                type: type,
+                data: processedData
+            },
+            additional: additional
+        };
+    }
+    return { processed: { type: type, data: processedData } };
+};
+/**
+ * Postprocesses the result based on additional data.
+ * If the type is 'translate' or 'intl', it recombines the excluded array with the translation.
+ * If there is an error, it attaches the error to the result.
+ * @param result - The result to be postprocessed.
+ * @param additional - Additional data from preprocessing.
+ * @returns The postprocessed result.
+ */
+const _postprocess = (result, additional) => {
+    if ((additional === null || additional === void 0 ? void 0 : additional.type) === "translate" || (additional === null || additional === void 0 ? void 0 : additional.type) === "intl") {
+        if (additional === null || additional === void 0 ? void 0 : additional.excludedArray) {
+            result.translation = (0, _translate_1._recombine)(result.translation, additional.excludedArray);
+        }
+    }
+    if (additional === null || additional === void 0 ? void 0 : additional.error) {
+        if (!additional)
+            return null;
+        result.error = additional.error;
+    }
+    return result;
+};
+/**
+ * Bundles multiple requests and sends them to the server.
+ * @param gt - Contains the baseURL and apiKey for the server request.
+ * @param requests - Array of requests to be processed and sent.
+ * @returns A promise that resolves to an array of processed results.
+ */
+function _bundleRequests(gt, requests) {
+    return __awaiter(this, void 0, void 0, function* () {
+        let processedArray = [];
+        let additionalArray = [];
+        // Preprocess each request and store the processed request and additional data.
+        requests.forEach(request => {
+            const { processed, additional } = _preprocess(request);
+            processedArray.push(processed);
+            additionalArray.push(additional || {});
+        });
+        try {
+            // Send the processed requests to the server as a bundled request.
+            const response = yield fetch(`${gt.baseURL}/bundle`, {
+                method: 'POST',
+                headers: {
+                    'Content-Type': 'application/json',
+                    'gtx-api-key': gt.apiKey,
+                },
+                body: JSON.stringify(processedArray)
+            });
+            // Check for response errors.
+            if (!response.ok) {
+                throw new Error(`${response.status}: ${yield response.text()}`);
+            }
+            // Parse the response and postprocess each result.
+            const resultArray = yield response.json();
+            return resultArray.map((item, index) => _postprocess(item, additionalArray[index]));
+        }
+        catch (error) {
+            console.error(error);
+            // If there is an error, postprocess each request with the error information.
+            return processedArray.map((item, index) => _postprocess(item, Object.assign({ error: error }, additionalArray[index])));
+        }
+    });
+}

package/dist/translation/_intl.d.ts

@@ -0,0 +1,19 @@
+import { Content } from "./_translate";
+/**
+   * Translates a single piece of content and caches for use in a public project.
+   * @param {{ baseURL: string, apiKey: string }} gt - The translation service configuration.
+   * @param {Content} content - The content to translate.
+   * @param {string} targetLanguage - The target language for the translation.
+   * @param {string} projectID - The ID of the project
+   * @param {{ [key: string]: any }} metadata - Additional metadata for the translation request.
+   * @returns {Promise<{ translation: string, error?: Error | unknown }>} - The translated content with optional error information.
+*/
+export default function _intl(gt: {
+    baseURL: string;
+    apiKey: string;
+}, content: Content, targetLanguage: string, projectID: string, metadata: {
+    [key: string]: any;
+}): Promise<{
+    translation: string;
+    error?: Error | unknown;
+}>;

package/dist/translation/_intl.js

@@ -0,0 +1,47 @@
+"use strict";
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.default = _intl;
+const _translate_1 = require("./_translate");
+/**
+   * Translates a single piece of content and caches for use in a public project.
+   * @param {{ baseURL: string, apiKey: string }} gt - The translation service configuration.
+   * @param {Content} content - The content to translate.
+   * @param {string} targetLanguage - The target language for the translation.
+   * @param {string} projectID - The ID of the project
+   * @param {{ [key: string]: any }} metadata - Additional metadata for the translation request.
+   * @returns {Promise<{ translation: string, error?: Error | unknown }>} - The translated content with optional error information.
+*/
+function _intl(gt, content, targetLanguage, projectID, metadata) {
+    return __awaiter(this, void 0, void 0, function* () {
+        const f = (array) => __awaiter(this, void 0, void 0, function* () {
+            const response = yield fetch(`${gt.baseURL}/intl`, {
+                method: 'POST',
+                headers: {
+                    'Content-Type': 'application/json',
+                    'gtx-api-key': gt.apiKey,
+                },
+                body: JSON.stringify({
+                    content: array,
+                    targetLanguage: targetLanguage,
+                    projectID: projectID,
+                    metadata: metadata
+                })
+            });
+            if (!response.ok) {
+                throw new Error(`${response.status}: ${yield response.text()}`);
+            }
+            const result = yield response.json();
+            return result.translation;
+        });
+        return (0, _translate_1._createTranslation)(content, f);
+    });
+}

package/dist/translation/_translate.d.ts

@@ -1,22 +1,30 @@
-type ContentObject = {
+export type ContentObject = {
     text: string;
     exclude?: boolean;
     cache?: boolean;
-    label?: string;
 };
-type ContentItem = string | ContentObject;
+type ContentItem = ContentObject | string;
 export type Content = ContentItem | ContentItem[];
-export declare function _translateMany(gt: {
-    baseURL: string;
-    apiKey: string;
-}, array: Content[], targetLanguage: string, metadata: {
-    [key: string]: any;
-}): Promise<{
+export declare const _process: (content: Content) => {
+    array: ContentObject[];
+    excludedArray: string[];
+};
+export declare const _recombine: (translatedContent: ContentObject[], excludedArray: string[]) => string;
+export declare const _createTranslation: (content: Content, f: Function) => Promise<{
     translation: string;
-    error: unknown;
-}[] | {
+    error?: undefined;
+} | {
     translation: string;
-}[]>;
+    error: unknown;
+}>;
+/**
+ * Translates a single piece of content.
+ * @param {{ baseURL: string, apiKey: string }} gt - The translation service configuration.
+ * @param {Content} content - The content to translate.
+ * @param {string} targetLanguage - The target language for the translation.
+ * @param {{ [key: string]: any }} metadata - Additional metadata for the translation request.
+ * @returns {Promise<{ translation: string, error?: Error | unknown }>} - The translated content with optional error information.
+ */
 export default function _translate(gt: {
     baseURL: string;
     apiKey: string;

package/dist/translation/_translate.js

@@ -1,4 +1,5 @@
 "use strict";
+// TYPE DEFINITIONS
 var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
     function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
     return new (P || (P = Promise))(function (resolve, reject) {
@@ -9,56 +10,73 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, ge
     });
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-exports._translateMany = _translateMany;
+exports._createTranslation = exports._recombine = exports._process = void 0;
 exports.default = _translate;
-// also handles errors
-const _combine = (contentArray, redactedArray) => {
-    let result = '';
-    const _handleItem = (contentItem) => {
-        if (typeof contentItem === 'string')
-            result += contentItem;
-        else if ((contentItem === null || contentItem === void 0 ? void 0 : contentItem.text) && typeof contentItem.text === 'string')
-            result += contentItem.text;
-        else if ((contentItem === null || contentItem === void 0 ? void 0 : contentItem.exclude) && redactedArray && redactedArray.length > 0) {
-            const redactedItem = redactedArray.shift();
-            if (redactedItem && (redactedItem === null || redactedItem === void 0 ? void 0 : redactedItem.text)) {
-                result += redactedItem.text;
-            }
+// PROCESSING
+const _process = (content) => {
+    let array = [];
+    let excludedArray = [];
+    const handleSingleItem = (contentItem) => {
+        if (typeof contentItem === 'string') {
+            array.push({ text: contentItem });
         }
-    };
-    contentArray.forEach(item => _handleItem(item));
-    return result;
-};
-const _redact = (content) => {
-    let contentArray = [];
-    let redactedArray = [];
-    const _handleItem = (contentItem) => {
-        if (typeof contentItem === 'string')
-            contentArray.push({
-                text: contentItem
-            });
-        else {
-            if (contentItem.exclude) {
-                contentArray.push(Object.assign(Object.assign({}, contentItem), { text: '', exclude: true }));
-                redactedArray.push(contentItem);
-            }
-            else {
-                contentArray.push(contentItem);
-            }
+        else if (typeof contentItem === 'object' && contentItem.exclude) {
+            array.push(Object.assign(Object.assign({}, contentItem), { text: '' }));
+            excludedArray.push(contentItem.text);
+        }
+        else if (typeof contentItem === 'object' && contentItem.text) {
+            array.push(contentItem);
         }
     };
     if (Array.isArray(content))
-        content.forEach(item => _handleItem(item));
+        content.map(handleSingleItem);
     else
-        _handleItem(content);
-    return {
-        contentArray, redactedArray
-    };
+        handleSingleItem(content);
+    return { array, excludedArray };
 };
-function _translateMany(gt, array, targetLanguage, metadata) {
+exports._process = _process;
+const _recombine = (translatedContent, excludedArray) => {
+    let result = '';
+    for (const object of translatedContent) {
+        if (object.exclude && excludedArray.length < 0) {
+            result += excludedArray.shift();
+        }
+        else if (object.text) {
+            result += object.text;
+        }
+    }
+    return result;
+};
+exports._recombine = _recombine;
+// REQUEST
+const _createTranslation = (content, f) => __awaiter(void 0, void 0, void 0, function* () {
+    const { array, excludedArray } = (0, exports._process)(content);
+    try {
+        const result = yield f(content);
+        return {
+            translation: (0, exports._recombine)(result, excludedArray)
+        };
+    }
+    catch (error) {
+        console.error(error);
+        return {
+            translation: (0, exports._recombine)(array, excludedArray),
+            error: error
+        };
+    }
+});
+exports._createTranslation = _createTranslation;
+/**
+ * Translates a single piece of content.
+ * @param {{ baseURL: string, apiKey: string }} gt - The translation service configuration.
+ * @param {Content} content - The content to translate.
+ * @param {string} targetLanguage - The target language for the translation.
+ * @param {{ [key: string]: any }} metadata - Additional metadata for the translation request.
+ * @returns {Promise<{ translation: string, error?: Error | unknown }>} - The translated content with optional error information.
+ */
+function _translate(gt, content, targetLanguage, metadata) {
     return __awaiter(this, void 0, void 0, function* () {
-        const processed = array.map(_redact);
-        try {
+        const f = (array) => __awaiter(this, void 0, void 0, function* () {
             const response = yield fetch(`${gt.baseURL}/text`, {
                 method: 'POST',
                 headers: {
@@ -66,7 +84,7 @@ function _translateMany(gt, array, targetLanguage, metadata) {
                     'gtx-api-key': gt.apiKey,
                 },
                 body: JSON.stringify({
-                    contentArray: processed.map(item => item.contentArray),
+                    content: array,
                     targetLanguage: targetLanguage,
                     metadata: metadata
                 })
@@ -74,27 +92,9 @@ function _translateMany(gt, array, targetLanguage, metadata) {
             if (!response.ok) {
                 throw new Error(`${response.status}: ${yield response.text()}`);
             }
-            const resultArray = yield response.json();
-            let finalArray = [];
-            for (const [index, item] of resultArray.entries()) {
-                finalArray.push({
-                    translation: _combine(item.translation, processed[index].redactedArray)
-                });
-            }
-            return finalArray;
-        }
-        catch (error) {
-            console.error(error);
-            return processed.map(item => ({
-                translation: _combine(item.contentArray, item.redactedArray),
-                error: error
-            }));
-        }
-    });
-}
-function _translate(gt, content, targetLanguage, metadata) {
-    return __awaiter(this, void 0, void 0, function* () {
-        const finalArray = yield _translateMany(gt, [content], targetLanguage, metadata);
-        return finalArray[0];
+            const result = yield response.json();
+            return result.translation;
+        });
+        return (0, exports._createTranslation)(content, f);
     });
 }

package/dist/translation/_translateReactChildren.d.ts

@@ -11,7 +11,7 @@
  * @throws {Error} - Throws an error if the response from the API is not ok (status code not in the range 200-299).
  *
 **/
-export default function translateReactChildren(gt: {
+export default function _translateReactChildren(gt: {
     baseURL: string;
     apiKey: string;
 }, content: any, targetLanguage: string, metadata: {

package/dist/translation/_translateReactChildren.js

@@ -9,7 +9,7 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, ge
     });
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.default = translateReactChildren;
+exports.default = _translateReactChildren;
 /**
  * Translates the given content into the target language using a specified API.
  *
@@ -23,7 +23,7 @@ exports.default = translateReactChildren;
  * @throws {Error} - Throws an error if the response from the API is not ok (status code not in the range 200-299).
  *
 **/
-function translateReactChildren(gt, content, targetLanguage, metadata) {
+function _translateReactChildren(gt, content, targetLanguage, metadata) {
     return __awaiter(this, void 0, void 0, function* () {
         try {
             const response = yield fetch(`${gt.baseURL}/react`, {

package/package.json

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