i18n-jsautotranslate 3.13.0 → 3.13.6

package/README.md

@@ -275,8 +275,9 @@ tcdn是translate.js 的高级版本，它的能力是让你原本的网站可以
 如果您在使用过程中遇到任何异常情况，请详细说一下您遇到的问题。如果可以，请写下您的网站，以便我们可以更全面地测试，以便快速找到问题所在  
 作者微信：xnx3com（使用交流可加QQ群进行，我看微信很不及时）    
 Telegram : [untran](https://t.me/untran)  
+交流QQ群:240567964  
 交流QQ群:181781514  (已满)  
-交流QQ群:641047127  
+交流QQ群:641047127  (已满)  
 微信公众号：wangmarket  
 github: [https://github.com/xnx3/translate](https://github.com/xnx3/translate)  
 gitee:  [https://gitee.com/mail_osc/translate](https://gitee.com/mail_osc/translate)

package/index.js

@@ -3,8 +3,10 @@
 	国际化，网页自动翻译。
 	作者：管雷鸣
 	开原仓库：https://github.com/xnx3/translate
-
  */ 
+if(typeof(translate) == 'object' && typeof(translate.version) == 'string'){
+	throw new Error('translate.js 已经加载过一次了，当前是重复加载，避免你的翻译出现异常，已帮你拦截此次加载。本信息只是给你一个提示，你可以检查一下你的项目中是否出现了重复引入 translate.js ，当然，这个异常并不会影响到你的具体使用，它已经自动帮你处理拦截了这个异常，只不过提示出来是让你知道，你的代码里出现了重复引入的情况。');
+}
 var translate = {
 	/**
 	 * 当前的版本
@@ -12,7 +14,7 @@ var translate = {
 	 * 格式：major.minor.patch.date
 	 */
 	// AUTO_VERSION_START
-	version: '3.13.0.20250124',
+	version: '3.13.6.20250217',
 	// AUTO_VERSION_END
 	/*
 		当前使用的版本，默认使用v2. 可使用 setUseVersion2(); 
@@ -606,7 +608,7 @@ var translate = {
 							//console.log('beforeChar:'+beforeChar+', str:'+str)
 							var lang = translate.language.getCharLanguage(beforeChar);
 							//console.log(lang);
-							if(lang == 'english'){
+							if(lang == 'english' || lang == 'romance'){
 								//调出，不能强拆
 								continue;
 							}
@@ -621,7 +623,7 @@ var translate = {
 							//后面有别的字符,判断是什么字符，如果是英文，那么这个是不能被拆分的，要忽略
 							afterChar = str.substr(index+originalText.length,1);
 							var lang = translate.language.getCharLanguage(afterChar);
-							if(lang == 'english'){
+							if(lang == 'english' || lang == 'romance'){
 								//跳出，不能强拆
 								continue;
 							}
@@ -865,6 +867,18 @@ var translate = {
 				if(document.readyState == 'complete'){
 					//dom加载完成，进行启动
 					clearInterval(translate.temp_linstenerStartInterval);//停止
+
+					//如果不需要翻译的情况，是不需要进行监听的
+					if(translate.language.getCurrent() == translate.language.getLocal()){
+						if(translate.language.translateLocal){
+							//本地语种也要强制翻译跟本地语种不一致的语种
+						}else{
+							//console.log('本地语种跟目标语种一致，不进行翻译操作，无需监听。');
+							return;
+						}
+					}
+
+					//console.log('进行监听。。');
 					translate.listener.addListener();
 				}
 				
@@ -1757,7 +1771,7 @@ var translate = {
 			//console.log(translate.nodeQueue[uuid]['list'][lang]);
 			//console.log(firstScan);
 			for(var ti=0; ti<twoScan.length; ti++){
-				twoHash = twoScan[ti];
+				var twoHash = twoScan[ti];
 				//console.log(twoHash + '-- '+firstScan.indexOf(twoHash));
 				if(firstScan.indexOf(twoHash) == -1){
 					//需要追加了
@@ -1925,6 +1939,11 @@ var translate = {
 					return;
 				}
 				
+				if(typeof(translate.nodeQueue[uuid]) == 'undefined'){
+					console.log('提示：你很可能多次引入了 translate.js 所以造成了翻译本身的数据错乱，这只是个提示，它还是会给你正常翻译的，但是你最好不要重复引入太多次 translate.js ，正常情况下只需要引入一次 translate.js 就可以了。太多的话很可能会导致你页面卡顿');
+					return;
+				}
+
 				//console.log('-----待翻译3：----');
 				//console.log(translate.nodeQueue);
 				
@@ -3311,8 +3330,8 @@ var translate = {
 					]
 		 		]
 		 	}
-		 	languageName 是当前字符串是什么语种。它的识别有以下特点：
-		 		1. 如果出现英语跟中文、法语、德语等混合的情况，也就是不纯粹英语的情况，那么会以其他语种为准，而不是识别为英语。不论英语字符出现的比例占多少。
+		 	languageName 是当前字符串最终判定结果是什么语种。它的识别有以下特点：
+		 		1. 如果出现英语跟中文、罗曼语族、德语等混合的情况，也就是不纯粹英语的情况，那么会以其他语种为准，而不是识别为英语。不论英语字符出现的比例占多少。
 		 		2. 如果出现简体中文跟繁体中文混合的情况，那么识别为繁体中文。不论简体中文字符出现的比例占多少。
 				3. 除了以上两种规则外，如果出现了多个语种，那么会识别为出现字符数量最多的语种当做当前句子的语种。（注意是字符数，而不是语种的数组数）
 			languageArray 对传入字符串进行分析，识别出都有哪些语种，每个语种的字符是什么
@@ -3341,16 +3360,28 @@ var translate = {
 			//过滤 语种的字符数小于总字符数 百分之五的，低于这个数，将忽略
 			var langkeys = [];
 			for(var lang in langsNumber){
-				if(langsNumber[lang]/allNumber > 0.05){
+				if(langsNumber[lang]/allNumber > 0.01){
 					langkeys[langkeys.length] = lang+'';
 				}
 			}
 
-
 			if(langkeys.length > 1 && langkeys.indexOf('english') > -1){
-				//console.log('出现了english, 并且english跟其他语种一起出现，那么删除english，因为什么法语德语乱七八糟的都有英语。而且中文跟英文一起，如果认为是英文的话，有时候中文会不被翻译');
-				//langkeys.splice(langkeys.indexOf('english'), 1); 
-				langsNumber['english'] = 0;
+				//console.log('出现了english, 并且english跟其他语种一起出现那么删除english，因为什么法语德语乱七八糟的都有英语。而且中文跟英文一起，如果认为是英文的话，有时候中文会不被翻译');
+				//这里先判断一下是否有发现了 罗曼语族
+				if(langkeys.indexOf('romance') > -1){
+					//发现了，那么判断一下到底是 法语、西班牙语、葡萄牙语、意大利语 中的哪一种呢
+					var romanceSentenceLanguage = translate.language.romanceSentenceAnaly(str);
+					if(romanceSentenceLanguage.length == 0){
+						console.log('语种识别异常，应该是 法语、西班牙语、葡萄牙语、意大利语 中的一种才是，除非是除了这四种语种之外的别的 罗曼语族 中的语种，当前已将 '+ str +'识别为英语。 你可以联系我们求助 https://translate.zvo.cn/4030.html');
+					}else{
+						//console.log(langsNumber);
+						langsNumber[romanceSentenceLanguage] = langsNumber['romance']+langsNumber['english'];
+						//console.log('set romance to '+romanceSentenceLanguage+' : \t'+str);
+						langsNumber['english'] = 0;
+					}
+				}else{
+					langsNumber['english'] = 0;
+				}
 			}
 
 			if(langkeys.indexOf('chinese_simplified') > -1 && langkeys.indexOf('chinese_traditional') > -1){
@@ -3396,7 +3427,18 @@ var translate = {
 
 			return result;
 		},
-		// 传入一个char，返回这个char属于什么语种，返回如 chinese_simplified、english  如果返回空字符串，那么表示未获取到是什么语种
+		/*
+			传入一个char，返回这个char属于什么语种，返回如   如果返回空字符串，那么表示未获取到是什么语种
+			chinese_simplified 简体中文
+			chinese_traditional 繁体中文
+			russian 俄罗斯语
+			english 英语
+			romance 罗曼语族，它是 法语、西班牙语、意大利语、葡萄牙語 的集合，并不是单个语言
+			specialCharacter 特殊字符，符号
+			number 阿拉伯数字
+			japanese 日语
+			korean 韩语
+		*/
 		getCharLanguage:function(charstr){
 			if(charstr == null || typeof(charstr) == 'undefined'){
 				return '';
@@ -3408,6 +3450,9 @@ var translate = {
 			if(this.english(charstr)){
 				return 'english';
 			}
+			if(this.romance(charstr)){
+				return 'romance';
+			}
 			if(this.specialCharacter(charstr)){
 				return 'specialCharacter';
 			}
@@ -3735,16 +3780,6 @@ var translate = {
 				return '';
 			}
 		},
-		//是否包含英文，true:包含
-		english:function(str){
-			if(/.*[\u0041-\u005a]+.*$/.test(str)){ 
-				return true;
-			} else if(/.*[\u0061-\u007a]+.*$/.test(str)){
-				return true;
-			} else {
-				return false;
-			}
-		},
 		//是否包含日语，true:包含
 		japanese:function(str){
 			if(/.*[\u3040-\u309F\u30A0-\u30FF]+.*$/.test(str)){ 
@@ -3777,7 +3812,73 @@ var translate = {
 			}
 			return false;
 		},
-		
+		//是否包含英文，true:包含
+		english:function(str){
+			if(/.*[\u0041-\u005a]+.*$/.test(str)){ 
+				return true;
+			} else if(/.*[\u0061-\u007a]+.*$/.test(str)){
+				return true;
+			} else {
+				return false;
+			}
+		},
+		//是否包含 罗曼语族 的特殊字符，因为 法语、西班牙语、意大利语、葡萄牙語  都属于这个语族，单纯判断特殊字符已经不能判断出到底属于哪个语种了
+		romance_dict:['é','è','ê','à','ç','œ','ñ','á','ó','ò','ì','ã','õ'],
+		romance:function(str){
+			if(this.romance_dict.indexOf(str) > -1){ 
+				return true;
+			} else {
+				return false;
+			}
+		},
+		//对 罗曼语族 的句子进行分析，看它是属于 法语、西班牙语、意大利语、葡萄牙語 的哪个。注意这个是传入的整体的句子，不是传入的单个字符
+		//返回识别的语种：  french、spanish、italian、portuguese  如果都没有识别出来，则返回空字符串
+		romanceSentenceAnaly:function(text) {
+		    // 定义各语言的典型字母/符号权重 (可调整)
+		    const langFeatures = {
+		        'french': { score:0 , chars: ['é','è','ê','à','ç','œ'] },
+		        'spanish': { score:0 , chars: ['ñ','á','ó'], pairs: ['ll'] },
+		        'italian': { score:0 , chars: ['ò','ì'], pairs: ['cc', 'ss'] },
+		        'portuguese': { score:0 , chars: ['ã', 'õ'] }
+		    };
+
+		    // 逐字扫描 + 相邻配对检测
+		    for (let i=0; i<text.length; i++) {
+		        const char = text[i].toLowerCase(); 
+		        
+		        // 单字匹配
+		        Object.keys(langFeatures).forEach(lang => {
+		            if (langFeatures[lang].chars.includes(char)) {
+		                langFeatures[lang].score +=1;
+		            }
+		        });
+
+		        // 双字配对检测 (如 ll)
+		        if(i < text.length -1) {
+		            const pair = text.slice(i,i+2).toLowerCase();
+		            Object.keys(langFeatures).forEach(lang => {
+		            	const pairs = langFeatures[lang].pairs;
+				        if (pairs && pairs.includes(pair)) {
+				            langFeatures[lang].score += 2; // pair权重大于单字
+				        }
+		            });
+		         }
+		    }
+
+		    // 结果判定 （取最高分）
+		    let maxLang = '';
+		    let maxScore = -1;
+		    
+		    Object.keys(langFeatures).forEach(lang =>{
+		       if(langFeatures[lang].score > maxScore){
+		           maxScore = langFeatures[lang].score;
+		           maxLang = lang;
+		       } 
+		    });
+
+		    return maxLang || ''; 
+		},
+
 		//是否包含特殊字符，包含，则是true
 		specialCharacter:function(str){
 			//如：① ⑴ ⒈ 
@@ -4234,14 +4335,19 @@ var translate = {
 		},
 		/**
 		 * 将一个 JSONArray 数组，按照文字长度进行拆分。
-		 *  比如传入的 array 数组的文字长度是6200，传入的 size 是2000，那么就是将 array 数组拆分为多个长度不超出2000的数组返回。
+		 *  比如传入的 array 数组的文字长度是6200，传入的 stringLength 是2000，那么就是将 array 数组拆分为多个长度不超出2000的数组返回。
+		 * 		如果传入了 maxSize = 5 那么会对拆分后的数组的长度进行判断，如果数组内元素超过5，那么还要进行缩短，拆分后的数组不允许超过这个数
+		 * 		也就是拆分后的数组有两重限制，一是限制转化为文本形式的长度、再就是拆分后本身数组的大小。
+		 * 		
 		 *  注意，这个长度是指 array.toString() 后的长度，也就是包含了 [""] 这种符号的长度
 		 * @param array 要被拆分的数组，其内都是String类型，传入格式如 ["你好","世界"]
-		 * @param size 要被拆分的长度
+		 * @param stringLength 要被拆分的数组转化为字符串之后的长度
+		 * @param maxSize 被拆分的数组最大包含多少个，数组大小最大允许多大，要小于等于这个数。 如果设置为0则是不启用这个，不对拆分后的数组进行判断。
 		 * @return 被拆分后的数组列表
 		 * @author 刘晓腾
 		 */
-		 split:function(array, size) {
+		 split:function(array, size, maxSize) {
+		 	let orgsize = size;
 		    let list = [];
 		    // 数组长度小于size，直接进行返回
 		    if(JSON.stringify(array).length <= size) {
@@ -4299,10 +4405,10 @@ var translate = {
 		                        // 看看是否以引号开头，如果不是，需要拼两个引号
 		                        if (s.startsWith("\"")) {
 		                            // 拼一个引号，-1
-		                            endIndex = s.length() - 1;
+		                            endIndex = s.length - 1;
 		                        } else {
 		                            // 拼两个引号，-2
-		                            endIndex = s.length() - 2;
+		                            endIndex = s.length - 2;
 		                        }
 		                        if (!s.endsWith("\"")) {
 		                            // 开始不是逗号了，不能-1
@@ -4339,8 +4445,94 @@ var translate = {
 		            }
 		        }
 		    }
+			// 设置了maxSize，进行处理
+			if (maxSize && maxSize > 0) {
+				list = translate.util._splitMaxSize(list, orgsize, maxSize);
+			}
 		    return list;
 		},
+		/**
+		 * 针对split函数中maxSize的处理
+		 * 	private
+		 * @param array 已拆分的二维数组
+		 * @param size 拆分的长度
+		 * @param maxSize 元素数量
+		 * @author 刘晓腾
+		 */
+		_splitMaxSize:function(array, size, maxSize) {
+			// console.log("------ splitMaxSize run ------")
+
+			// 返回的数据
+			let list = [];
+			// 暂存的数组，用来存储每次遍历时超出的数据
+			let tmp = [];
+
+		 	// 遍历二维数组
+			array.forEach(function(arr, index) {
+				// 累加数组
+				arr = tmp.concat(arr);
+				// 计算元素数量
+				let length = arr.length;
+				// 数组中元素数量大于maxSize，对多余的元素进行移除
+				if (length > maxSize) {
+					// 第一个数组，包含前N个元素
+					let firstArray = arr.slice(0, maxSize);
+					// 第二个数组，包含剩下的元素
+					let secondArray = arr.slice(maxSize);
+
+					// 处理长度
+					let len = 1;
+					while (JSON.stringify(firstArray).length > size) {
+						// 长度超过限制，进行处理
+						firstArray = arr.slice(0, maxSize - len);
+						secondArray = arr.slice(maxSize - len);
+						len++;
+						if (len >= arr.length+1) {
+							break;
+						}
+					}
+
+					// 第一个数组记录
+					list.push(firstArray);
+					// 第二个数组暂存
+					tmp.length = 0;
+					tmp = secondArray;
+				} else {
+					// 没超，只处理长度
+					// 处理长度
+					let firstArray = arr;
+					let secondArray = [];
+					let len = 1;
+					while (JSON.stringify(firstArray).length > size) {
+						// 长度超过限制，进行处理
+						firstArray = arr.slice(0, maxSize - len);
+						secondArray = arr.slice(maxSize - len);
+						len++;
+						if (len >= arr.length+1) {
+							break;
+						}
+					}
+
+					// 第一个数组记录
+					list.push(firstArray);
+					// 第二个数组暂存
+					tmp.length = 0;
+					tmp = secondArray;
+				}
+
+			});
+
+			// 临时数组中还有元素，也要进行处理
+			if (tmp.length > 0) {
+				let tmpl = [];
+				tmpl.push(tmp);
+				// 递归处理
+				let l = translate.util._splitMaxSize(tmpl, size, maxSize);
+				list = list.concat(l);
+			}
+
+			return list;
+		},
 		/* 
 			浏览器的语种标识跟translate.js的语种标识的对应
 			key: 浏览器的语种标识
@@ -4358,6 +4550,7 @@ var translate = {
 			'nl':'dutch',
 			'yo':'yoruba',
 			'en':'english',
+			'en-US':'english',
 			'kok':'gongen',
 			'la':'latin',
 			'ne':'nepali',
@@ -4543,10 +4736,8 @@ var translate = {
 			 */
 			translate:function(path, data, func, abnormalFunc){
 				var textArray = JSON.parse(decodeURIComponent(data.text));
-				let translateTextArray = translate.util.split(textArray, 48000);
-				//console.log(translateTextArray);
+				let translateTextArray = translate.util.split(textArray, 40000, 900);
 				
-
 				translate.request.send(translate.service.edge.api.auth, {}, function(auth){
 					var from = translate.service.edge.language.getMap()[data.from];
 					var to = translate.service.edge.language.getMap()[data.to];
@@ -5112,7 +5303,7 @@ var translate = {
 
 			if(typeof(obj) == 'string'){
 				//案例一的场景，传入单个字符串
-				texts[0] = [obj];
+				texts[0] = obj;
 			}else{
 				//不是字符串了，而是对象了，判断是案例二还是案例三
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "i18n-jsautotranslate",
-  "version": "3.13.0",
+  "version": "3.13.6",
   "description": "Two lines of js realize automatic html translation. No need to change the page, no language configuration file, no API key, SEO friendly!",
   "main": "index.js",
   "scripts": {