@yxw007/translate 0.0.4 → 0.0.6

package/dist/browser/index.umd.js

@@ -1,4 +1,4 @@
-// translate v0.0.4 Copyright (c) 2024 Potter<aa4790139@gmail.com> and contributors
+// translate v0.0.6 Copyright (c) 2024 Potter<aa4790139@gmail.com> and contributors
 (function (global, factory) {
     typeof exports === 'object' && typeof module !== 'undefined' ? factory(exports) :
     typeof define === 'function' && define.amd ? define(['exports'], factory) :
@@ -44,7 +44,7 @@
             name: "azure",
             async translate(text, opts) {
                 const { from, to } = opts;
-                const url = `${base}&to=${to}${from ? `&from=${from}` : ""}`;
+                const url = `${base}&to=${to}${from && from !== "auto" ? `&from=${from}` : ""}`;
                 if (!Array.isArray(text)) {
                     text = [text];
                 }
@@ -57,7 +57,11 @@
                     },
                     body: JSON.stringify(text.map((it) => ({ Text: it }))),
                 });
-                const body = await res.json();
+                const bodyRes = await res.json();
+                if (bodyRes.error) {
+                    throw new Error(`Translate fail ! code: ${bodyRes.error.code}, message: ${bodyRes.error.message}`);
+                }
+                const body = bodyRes;
                 if (!body || body.length === 0) {
                     throw new Error("Translate fail ! translate's result is null or empty");
                 }
@@ -331,6 +335,56 @@
         };
     }
 
+    class EndpointCache {
+        constructor({ size, params }) {
+            this.data = new Map();
+            this.parameters = [];
+            this.capacity = size ?? 50;
+            if (params) {
+                this.parameters = params;
+            }
+        }
+        get(endpointParams, resolver) {
+            const key = this.hash(endpointParams);
+            if (key === false) {
+                return resolver();
+            }
+            if (!this.data.has(key)) {
+                if (this.data.size > this.capacity + 10) {
+                    const keys = this.data.keys();
+                    let i = 0;
+                    while (true) {
+                        const { value, done } = keys.next();
+                        this.data.delete(value);
+                        if (done || ++i > 10) {
+                            break;
+                        }
+                    }
+                }
+                this.data.set(key, resolver());
+            }
+            return this.data.get(key);
+        }
+        size() {
+            return this.data.size;
+        }
+        hash(endpointParams) {
+            let buffer = "";
+            const { parameters } = this;
+            if (parameters.length === 0) {
+                return false;
+            }
+            for (const param of parameters) {
+                const val = String(endpointParams[param] ?? "");
+                if (val.includes("|;")) {
+                    return false;
+                }
+                buffer += val + "|;";
+            }
+            return buffer;
+        }
+    }
+
     const IP_V4_REGEX = new RegExp(`^(?:25[0-5]|2[0-4]\\d|1\\d\\d|[1-9]\\d|\\d)(?:\\.(?:25[0-5]|2[0-4]\\d|1\\d\\d|[1-9]\\d|\\d)){3}$`);
     const isIpAddress = (value) => IP_V4_REGEX.test(value) || (value.startsWith("[") && value.endsWith("]"));
 
@@ -2501,6 +2555,7 @@
                 headers: new Headers(request.headers),
                 method: method,
                 credentials,
+                cache: this.config.cache ?? "default",
             };
             if (body) {
                 requestOptions.duplex = "half";
@@ -2511,6 +2566,9 @@
             if (keepAliveSupport.supported) {
                 requestOptions.keepalive = keepAlive;
             }
+            if (typeof this.config.requestInit === "function") {
+                Object.assign(requestOptions, this.config.requestInit(request));
+            }
             let removeSignalEventListener = () => { };
             const fetchRequest = new Request(url, requestOptions);
             const raceOfPromises = [
@@ -4007,7 +4065,7 @@ ${toHex(hashedRequest)}`;
 
     var name = "@aws-sdk/client-translate";
     var description = "AWS SDK for JavaScript Translate Client for Node.js, Browser and React Native";
-    var version = "3.645.0";
+    var version = "3.651.1";
     var scripts = {
     	build: "concurrently 'yarn:build:cjs' 'yarn:build:es' 'yarn:build:types'",
     	"build:cjs": "node ../../scripts/compilation/inline client-translate",
@@ -4026,43 +4084,43 @@ ${toHex(hashedRequest)}`;
     var dependencies = {
     	"@aws-crypto/sha256-browser": "5.2.0",
     	"@aws-crypto/sha256-js": "5.2.0",
-    	"@aws-sdk/client-sso-oidc": "3.645.0",
-    	"@aws-sdk/client-sts": "3.645.0",
-    	"@aws-sdk/core": "3.635.0",
-    	"@aws-sdk/credential-provider-node": "3.645.0",
-    	"@aws-sdk/middleware-host-header": "3.620.0",
-    	"@aws-sdk/middleware-logger": "3.609.0",
-    	"@aws-sdk/middleware-recursion-detection": "3.620.0",
-    	"@aws-sdk/middleware-user-agent": "3.645.0",
-    	"@aws-sdk/region-config-resolver": "3.614.0",
-    	"@aws-sdk/types": "3.609.0",
-    	"@aws-sdk/util-endpoints": "3.645.0",
-    	"@aws-sdk/util-user-agent-browser": "3.609.0",
-    	"@aws-sdk/util-user-agent-node": "3.614.0",
-    	"@smithy/config-resolver": "^3.0.5",
-    	"@smithy/core": "^2.4.0",
-    	"@smithy/fetch-http-handler": "^3.2.4",
-    	"@smithy/hash-node": "^3.0.3",
-    	"@smithy/invalid-dependency": "^3.0.3",
-    	"@smithy/middleware-content-length": "^3.0.5",
-    	"@smithy/middleware-endpoint": "^3.1.0",
-    	"@smithy/middleware-retry": "^3.0.15",
-    	"@smithy/middleware-serde": "^3.0.3",
-    	"@smithy/middleware-stack": "^3.0.3",
-    	"@smithy/node-config-provider": "^3.1.4",
-    	"@smithy/node-http-handler": "^3.1.4",
-    	"@smithy/protocol-http": "^4.1.0",
-    	"@smithy/smithy-client": "^3.2.0",
-    	"@smithy/types": "^3.3.0",
-    	"@smithy/url-parser": "^3.0.3",
+    	"@aws-sdk/client-sso-oidc": "3.651.1",
+    	"@aws-sdk/client-sts": "3.651.1",
+    	"@aws-sdk/core": "3.651.1",
+    	"@aws-sdk/credential-provider-node": "3.651.1",
+    	"@aws-sdk/middleware-host-header": "3.649.0",
+    	"@aws-sdk/middleware-logger": "3.649.0",
+    	"@aws-sdk/middleware-recursion-detection": "3.649.0",
+    	"@aws-sdk/middleware-user-agent": "3.649.0",
+    	"@aws-sdk/region-config-resolver": "3.649.0",
+    	"@aws-sdk/types": "3.649.0",
+    	"@aws-sdk/util-endpoints": "3.649.0",
+    	"@aws-sdk/util-user-agent-browser": "3.649.0",
+    	"@aws-sdk/util-user-agent-node": "3.649.0",
+    	"@smithy/config-resolver": "^3.0.6",
+    	"@smithy/core": "^2.4.1",
+    	"@smithy/fetch-http-handler": "^3.2.5",
+    	"@smithy/hash-node": "^3.0.4",
+    	"@smithy/invalid-dependency": "^3.0.4",
+    	"@smithy/middleware-content-length": "^3.0.6",
+    	"@smithy/middleware-endpoint": "^3.1.1",
+    	"@smithy/middleware-retry": "^3.0.16",
+    	"@smithy/middleware-serde": "^3.0.4",
+    	"@smithy/middleware-stack": "^3.0.4",
+    	"@smithy/node-config-provider": "^3.1.5",
+    	"@smithy/node-http-handler": "^3.2.0",
+    	"@smithy/protocol-http": "^4.1.1",
+    	"@smithy/smithy-client": "^3.3.0",
+    	"@smithy/types": "^3.4.0",
+    	"@smithy/url-parser": "^3.0.4",
     	"@smithy/util-base64": "^3.0.0",
     	"@smithy/util-body-length-browser": "^3.0.0",
     	"@smithy/util-body-length-node": "^3.0.0",
-    	"@smithy/util-defaults-mode-browser": "^3.0.15",
-    	"@smithy/util-defaults-mode-node": "^3.0.15",
-    	"@smithy/util-endpoints": "^2.0.5",
-    	"@smithy/util-middleware": "^3.0.3",
-    	"@smithy/util-retry": "^3.0.3",
+    	"@smithy/util-defaults-mode-browser": "^3.0.16",
+    	"@smithy/util-defaults-mode-node": "^3.0.16",
+    	"@smithy/util-endpoints": "^2.1.0",
+    	"@smithy/util-middleware": "^3.0.4",
+    	"@smithy/util-retry": "^3.0.4",
     	"@smithy/util-utf8": "^3.0.0",
     	tslib: "^2.6.2",
     	uuid: "^9.0.1"
@@ -4719,11 +4777,15 @@ ${toHex(hashedRequest)}`;
     const _data = { version: "1.0", parameters: { Region: h, UseDualStack: i, UseFIPS: i, Endpoint: h }, rules: [{ conditions: [{ [t]: b, [u]: [j] }], rules: [{ conditions: p, error: "Invalid Configuration: FIPS and custom endpoint are not supported", type: d }, { conditions: q, error: "Invalid Configuration: Dualstack and custom endpoint are not supported", type: d }, { endpoint: { url: j, properties: m, headers: m }, type: e }], type: f }, { conditions: [{ [t]: b, [u]: r }], rules: [{ conditions: [{ [t]: "aws.partition", [u]: r, assign: g }], rules: [{ conditions: [k, l], rules: [{ conditions: [{ [t]: c, [u]: [a, n] }, o], rules: [{ endpoint: { url: "https://translate-fips.{Region}.{PartitionResult#dualStackDnsSuffix}", properties: m, headers: m }, type: e }], type: f }, { error: "FIPS and DualStack are enabled, but this partition does not support one or both", type: d }], type: f }, { conditions: p, rules: [{ conditions: [{ [t]: c, [u]: [n, a] }], rules: [{ endpoint: { url: "https://translate-fips.{Region}.{PartitionResult#dnsSuffix}", properties: m, headers: m }, type: e }], type: f }, { error: "FIPS is enabled but this partition does not support FIPS", type: d }], type: f }, { conditions: q, rules: [{ conditions: [o], rules: [{ endpoint: { url: "https://translate.{Region}.{PartitionResult#dualStackDnsSuffix}", properties: m, headers: m }, type: e }], type: f }, { error: "DualStack is enabled but this partition does not support DualStack", type: d }], type: f }, { endpoint: { url: "https://translate.{Region}.{PartitionResult#dnsSuffix}", properties: m, headers: m }, type: e }], type: f }], type: f }, { error: "Invalid Configuration: Missing Region", type: d }] };
     const ruleSet = _data;
 
+    const cache$1 = new EndpointCache({
+        size: 50,
+        params: ["Endpoint", "Region", "UseDualStack", "UseFIPS"],
+    });
     const defaultEndpointResolver = (endpointParams, context = {}) => {
-        return resolveEndpoint(ruleSet, {
+        return cache$1.get(endpointParams, () => resolveEndpoint(ruleSet, {
             endpointParams: endpointParams,
             logger: context.logger,
-        });
+        }));
     };
     customEndpointFunctions.aws = awsEndpointFunctions;
 
@@ -5370,9 +5432,7 @@ ${toHex(hashedRequest)}`;
 
     class TranslateTextCommand extends Command
         .classBuilder()
-        .ep({
-        ...commonParams,
-    })
+        .ep(commonParams)
         .m(function (Command, cs, config, o) {
         return [
             getSerdePlugin(config, this.serialize, this.deserialize),
@@ -6742,13 +6802,255 @@ ${toHex(hashedRequest)}`;
         zul: "zu",
     };
 
-    const isoKeys = Object.values(iso).sort();
-    function language(name) {
+    var languageNames = {
+        afar: "aa",
+        abkhazian: "ab",
+        afrikaans: "af",
+        akan: "ak",
+        albanian: "sq",
+        amharic: "am",
+        arabic: "ar",
+        aragonese: "an",
+        armenian: "hy",
+        assamese: "as",
+        avaric: "av",
+        avestan: "ae",
+        aymara: "ay",
+        azerbaijani: "az",
+        bashkir: "ba",
+        bambara: "bm",
+        basque: "eu",
+        belarusian: "be",
+        bengali: "bn",
+        "bihari languages": "bh",
+        bislama: "bi",
+        tibetan: "bo",
+        bosnian: "bs",
+        breton: "br",
+        bulgarian: "bg",
+        burmese: "my",
+        catalan: "ca",
+        valencian: "ca",
+        czech: "cs",
+        chamorro: "ch",
+        chechen: "ce",
+        chinese: "zh",
+        "church slavic": "cu",
+        "old slavonic": "cu",
+        "church slavonic": "cu",
+        "old bulgarian": "cu",
+        "old church slavonic": "cu",
+        chuvash: "cv",
+        cornish: "kw",
+        corsican: "co",
+        cree: "cr",
+        welsh: "cy",
+        danish: "da",
+        german: "de",
+        divehi: "dv",
+        dhivehi: "dv",
+        maldivian: "dv",
+        dutch: "nl",
+        flemish: "nl",
+        dzongkha: "dz",
+        greek: "el",
+        english: "en",
+        esperanto: "eo",
+        estonian: "et",
+        ewe: "ee",
+        faroese: "fo",
+        persian: "fa",
+        fijian: "fj",
+        finnish: "fi",
+        french: "fr",
+        "western frisian": "fy",
+        fulah: "ff",
+        georgian: "ka",
+        gaelic: "gd",
+        "scottish gaelic": "gd",
+        irish: "ga",
+        galician: "gl",
+        manx: "gv",
+        guarani: "gn",
+        gujarati: "gu",
+        haitian: "ht",
+        "haitian creole": "ht",
+        hausa: "ha",
+        hebrew: "he",
+        herero: "hz",
+        hindi: "hi",
+        "hiri motu": "ho",
+        croatian: "hr",
+        hungarian: "hu",
+        igbo: "ig",
+        icelandic: "is",
+        ido: "io",
+        "sichuan yi": "ii",
+        nuosu: "ii",
+        inuktitut: "iu",
+        interlingue: "ie",
+        occidental: "ie",
+        interlingua: "ia",
+        indonesian: "id",
+        inupiaq: "ik",
+        italian: "it",
+        javanese: "jv",
+        japanese: "ja",
+        kalaallisut: "kl",
+        greenlandic: "kl",
+        kannada: "kn",
+        kashmiri: "ks",
+        kanuri: "kr",
+        kazakh: "kk",
+        "central khmer": "km",
+        kikuyu: "ki",
+        gikuyu: "ki",
+        kinyarwanda: "rw",
+        kirghiz: "ky",
+        kyrgyz: "ky",
+        komi: "kv",
+        kongo: "kg",
+        korean: "ko",
+        kuanyama: "kj",
+        kwanyama: "kj",
+        kurdish: "ku",
+        lao: "lo",
+        latin: "la",
+        latvian: "lv",
+        limburgan: "li",
+        limburger: "li",
+        limburgish: "li",
+        lingala: "ln",
+        lithuanian: "lt",
+        luxembourgish: "lb",
+        letzeburgesch: "lb",
+        "luba-katanga": "lu",
+        ganda: "lg",
+        macedonian: "mk",
+        marshallese: "mh",
+        malayalam: "ml",
+        maori: "mi",
+        marathi: "mr",
+        malay: "ms",
+        malagasy: "mg",
+        maltese: "mt",
+        mongolian: "mn",
+        nauru: "na",
+        navajo: "nv",
+        navaho: "nv",
+        "ndebele, south": "nr",
+        "south ndebele": "nr",
+        "ndebele, north": "nd",
+        "north ndebele": "nd",
+        ndonga: "ng",
+        nepali: "ne",
+        "norwegian nynorsk": "nn",
+        "nynorsk, norwegian": "nn",
+        "norwegian bokmål": "nb",
+        "bokmål, norwegian": "nb",
+        norwegian: "no",
+        chichewa: "ny",
+        chewa: "ny",
+        nyanja: "ny",
+        occitan: "oc",
+        ojibwa: "oj",
+        oriya: "or",
+        oromo: "om",
+        ossetian: "os",
+        ossetic: "os",
+        panjabi: "pa",
+        punjabi: "pa",
+        pali: "pi",
+        polish: "pl",
+        portuguese: "pt",
+        pushto: "ps",
+        pashto: "ps",
+        quechua: "qu",
+        romansh: "rm",
+        romanian: "ro",
+        moldavian: "ro",
+        moldovan: "ro",
+        rundi: "rn",
+        russian: "ru",
+        sango: "sg",
+        sanskrit: "sa",
+        sinhala: "si",
+        sinhalese: "si",
+        slovak: "sk",
+        slovenian: "sl",
+        "northern sami": "se",
+        samoan: "sm",
+        shona: "sn",
+        sindhi: "sd",
+        somali: "so",
+        "sotho, southern": "st",
+        spanish: "es",
+        castilian: "es",
+        sardinian: "sc",
+        serbian: "sr",
+        swati: "ss",
+        sundanese: "su",
+        swahili: "sw",
+        swedish: "sv",
+        tahitian: "ty",
+        tamil: "ta",
+        tatar: "tt",
+        telugu: "te",
+        tajik: "tg",
+        tagalog: "tl",
+        thai: "th",
+        tigrinya: "ti",
+        tonga: "to",
+        tswana: "tn",
+        tsonga: "ts",
+        turkmen: "tk",
+        turkish: "tr",
+        twi: "tw",
+        uighur: "ug",
+        uyghur: "ug",
+        ukrainian: "uk",
+        urdu: "ur",
+        uzbek: "uz",
+        venda: "ve",
+        vietnamese: "vi",
+        volapük: "vo",
+        walloon: "wa",
+        wolof: "wo",
+        xhosa: "xh",
+        yiddish: "yi",
+        yoruba: "yo",
+        zhuang: "za",
+        chuang: "za",
+        zulu: "zu",
+    };
+
+    const nameKeys = Object.keys(languageNames).sort();
+    const isoKeys = Object.keys(iso).sort();
+    const iosValues = Object.values(iso);
+    function isValidLanguage(name) {
+        if (!name) {
+            return false;
+        }
+        if (name === "auto") {
+            return true;
+        }
         if (name.length > 100) {
             throw new Error(`The "language" is too long at ${name.length} characters`);
         }
-        if (!isoKeys.includes(name)) {
-            throw new Error(`The language "${name}" is not part of the ISO 639-1`);
+        return isoKeys.includes(name) || nameKeys.includes(name) || iosValues.includes(name);
+    }
+    function getISO(name) {
+        if (name === "auto") {
+            return name;
+        }
+        if (nameKeys.includes(name)) {
+            return languageNames[name];
+        }
+        if (isoKeys.includes(name)) {
+            return iso[name];
+        }
+        if (iosValues.includes(name)) {
+            return name;
         }
         return name;
     }
@@ -6845,19 +7147,25 @@ ${toHex(hashedRequest)}`;
             this.engines.set(engine.name, engine);
         }
         translate(text, options) {
-            const { from, to, engine = "google", cache_time = 60 * 1000 } = options;
+            const { engine = "google", cache_time = 60 * 1000 } = options;
+            let { from = "auto", to } = options;
+            from = options.from = getISO(from);
+            to = options.to = getISO(to);
             //1. Check if engine exists
             if (!this.engines.has(engine)) {
                 throw new Error(`Engine ${engine} not found`);
             }
             //2. Check if language exists
-            if (!language(to)) {
-                throw new Error(`Language ${to} not found`);
+            if (!isValidLanguage(to)) {
+                throw new Error(`The language "${to}" is not part of the ISO 639-1 or is not part of the language names`);
+            }
+            if (!isValidLanguage(from)) {
+                throw new Error(`The language "${from}" is not part of the ISO 639-1 or is not part of the language names`);
             }
             const key = `${from}:${to}:${engine}:${text}`;
             //3. If the cache is matched, the cache is used directly
             if (cache.get(key)) {
-                return cache.get(key)?.value;
+                return Promise.resolve(cache.get(key)?.value);
             }
             const engineInstance = this.engines.get(engine);
             if (!engineInstance) {
@@ -6873,11 +7181,14 @@ ${toHex(hashedRequest)}`;
     var index = {
         engines,
         translator,
+        Cache,
+        languageNames,
     };
 
     exports.Cache = Cache;
     exports.default = index;
     exports.engines = engines;
+    exports.languageNames = languageNames;
     exports.translator = translator;
 
     Object.defineProperty(exports, '__esModule', { value: true });