@yxw007/translate 0.1.6 → 0.2.2

package/dist/browser/index.esm.js

@@ -1,4 +1,7 @@
-// translate v0.1.6 Copyright (c) 2024 Potter<aa4790139@gmail.com> and contributors
+// translate v0.2.2 Copyright (c) 2025 Potter<aa4790139@gmail.com> and contributors
+import 'fs/promises';
+import 'fs';
+import 'path';
 import { TranslateClient, TranslateTextCommand } from '@aws-sdk/client-translate';
 
 class TranslationError extends Error {
@@ -113,6 +116,9 @@ function useLogger(name = "") {
     };
 }
 
+function sleep(ms) {
+    return new Promise((resolve) => setTimeout(resolve, ms));
+}
 function getGapLine() {
     return "-".repeat(20);
 }
@@ -130,6 +136,66 @@ async function throwResponseError(name, res) {
     catch (e) { }
     return new TranslationError(name, `Translate fail ! ${res.status}: ${res.statusText} ${bodyRes?.message ?? ""}`);
 }
+function splitText(text, maxCharacterNum) {
+    const SPLIT_PRIORITY = [
+        /\n\n+/, // 段落分隔（优先保留空行）
+        /[.。！？?!\n]/, // 中日韩句子结束符+英文标点+换行
+        /[;；]/, // 分号（中英文）
+        /[,，]/g, // 逗号（中英文）
+        /\s/, // 空格（避免切分单词）
+    ];
+    const BEST_MATCH_RATIO = 0.7;
+    const chunks = [];
+    while (text.length > 0) {
+        const chunk = text.slice(0, maxCharacterNum);
+        // Scene 1：Prioritization of cases not subject to severance
+        if (text.length <= maxCharacterNum) {
+            chunks.push(text);
+            break;
+        }
+        // Scene 2：Finding Split Points by Priority
+        let splitPos = -1;
+        for (const delimiter of SPLIT_PRIORITY) {
+            const regex = new RegExp(delimiter.source + "(?=[^]*)", "g"); // back-to-front search
+            let m, longestMatch;
+            while ((m = regex.exec(chunk)) !== null) {
+                if (m.index === regex.lastIndex) {
+                    regex.lastIndex++;
+                }
+                if (longestMatch != null) {
+                    longestMatch = m.index > longestMatch.index ? m : longestMatch;
+                }
+                else {
+                    longestMatch = m;
+                }
+            }
+            if (longestMatch?.index !== undefined && longestMatch.index >= maxCharacterNum * BEST_MATCH_RATIO) {
+                splitPos = longestMatch.index;
+                break; // Finding Quality Split Points
+            }
+        }
+        // Scene 3：Conservative splitting in the absence of a suitable separator
+        if (splitPos === -1) {
+            splitPos = chunk.lastIndexOf(" ", maxCharacterNum); // look for the space
+            splitPos = splitPos === -1 ? maxCharacterNum : splitPos; // forcible division
+        }
+        if (splitPos == 0) {
+            text = text.slice(splitPos + 1);
+        }
+        else {
+            chunks.push(text.slice(0, splitPos));
+            text = text.slice(splitPos);
+        }
+    }
+    return chunks;
+}
+function isOverMaxCharacterNum(text, max_character_num) {
+    if (!text || text.length <= 0) {
+        return false;
+    }
+    const total = text.reduce((pre, cur) => pre + cur.length, 0);
+    return total > max_character_num;
+}
 
 function google(options) {
     const base = "https://translate.googleapis.com/translate_a/single";
@@ -2375,15 +2441,20 @@ function getLanguage(engine) {
 }
 
 const appName = "Translate";
+const defaultMaxCharacterNum = 1000;
 
 const logger = useLogger();
 const cache = new Cache();
 class Translator {
     engines;
     cache_time;
-    constructor(cache_time = 60 * 1000) {
+    concurrencyMax;
+    concurrencyDelay;
+    constructor(cache_time = 60 * 1000, concurrencyMax = 4, concurrencyDelay = 20) {
         this.engines = new Map();
         this.cache_time = cache_time;
+        this.concurrencyMax = concurrencyMax;
+        this.concurrencyDelay = concurrencyDelay;
     }
     /**
      * This method is obsolete, please use the addEngine method
@@ -2431,8 +2502,7 @@ class Translator {
         if (cache.get(key)) {
             return Promise.resolve(cache.get(key)?.value);
         }
-        return engineInstance
-            .translate(text, options)
+        return this.concurrencyHandle(engineInstance, text, options)
             .then((translated) => {
             cache.set(key, translated, cache_time ?? this.cache_time);
             return translated;
@@ -2447,6 +2517,55 @@ class Translator {
             }
         });
     }
+    async concurrencyHandle(engine, text, options) {
+        const { max_character_num = defaultMaxCharacterNum } = options;
+        const maxCharacterNum = max_character_num > 0 ? max_character_num : defaultMaxCharacterNum;
+        if (Array.isArray(text)) {
+            if (isOverMaxCharacterNum(text, max_character_num)) {
+                throw new TranslationError(appName, "String arrays do not support automatic character splitting, and the total number of characters in a string array exceeds the limit on the number of translated characters.");
+            }
+            return engine.translate(text, options);
+        }
+        else {
+            return this.concurrencyTranslate(engine, text, options, maxCharacterNum);
+        }
+    }
+    async concurrencyTranslate(engine, text, options, maxCharacterMum) {
+        const pendingTasks = splitText(text, maxCharacterMum).map((content, index) => ({ content, index }));
+        const result = [];
+        let activeTasks = 0;
+        const concurrencyDelay = this.concurrencyDelay;
+        const concurrencyMax = this.concurrencyMax;
+        return new Promise((resolve, reject) => {
+            function processTasks() {
+                while (activeTasks < concurrencyMax && pendingTasks.length > 0) {
+                    const { content, index } = pendingTasks.shift();
+                    activeTasks++;
+                    engine
+                        .translate(content, options)
+                        .then((res) => {
+                        result.push({
+                            translated: res,
+                            index,
+                        });
+                    })
+                        .catch((error) => reject(error))
+                        .finally(async () => {
+                        activeTasks--;
+                        if (activeTasks === 0 && pendingTasks.length <= 0) {
+                            result.sort((a, b) => a.index - b.index);
+                            const arr = result.reduce((pre, cur) => pre.concat(cur.translated), []);
+                            return resolve([arr.join("")]);
+                        }
+                        await sleep(concurrencyDelay);
+                        processTasks();
+                    });
+                }
+            }
+            processTasks();
+            return result;
+        });
+    }
 }
 const translator = new Translator();
 var index = {