torchv-translate 1.0.6 → 1.0.8

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "torchv-translate",
-  "version": "1.0.6",
+  "version": "1.0.8",
   "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",
   "exports": {

package/translate.js/translate.js

@@ -2184,27 +2184,37 @@ var translate = {
 			@param info 如果result为0，这里是失败信息
 		*/
 		isAllExecuteFinish:function(uuid, from, to, result, info){
-
-			translate.listener.execute.renderFinishByApiRun(uuid, from, to);
-
-			//通过 uuid、from 取得本次翻译相关的 texts、nodes , 触发 translateNetworkAfter_Trigger 钩子
-			//获取请求日志
-			var requestData = translate.request.data[uuid].list[from][to];
-			translate.lifecycle.execute.translateNetworkAfter_Trigger({
-				uuid: uuid,
-				from: from,
-				to: to,
-				texts: requestData.texts,
-				nodes: requestData.nodes,
-				result: result,
-				info: info
-			});
-
-			//console.log('uuid:'+uuid+', from:'+from+', to:'+to);
-			for(var lang in translate.translateRequest[uuid]){
-				if (!translate.translateRequest[uuid].hasOwnProperty(lang)) {
-		    		continue;
-		    	}
+
+			translate.listener.execute.renderFinishByApiRun(uuid, from, to);
+
+			//通过 uuid、from 取得本次翻译相关的 texts、nodes , 触发 translateNetworkAfter_Trigger 钩子
+			//获取请求日志
+			if(typeof(translate.request) === 'object'
+				&& typeof(translate.request.data) === 'object'
+				&& typeof(translate.request.data[uuid]) === 'object'
+				&& typeof(translate.request.data[uuid].list) === 'object'
+				&& typeof(translate.request.data[uuid].list[from]) === 'object'
+				&& typeof(translate.request.data[uuid].list[from][to]) === 'object'){
+				var requestData = translate.request.data[uuid].list[from][to];
+				translate.lifecycle.execute.translateNetworkAfter_Trigger({
+					uuid: uuid,
+					from: from,
+					to: to,
+					texts: requestData.texts,
+					nodes: requestData.nodes,
+					result: result,
+					info: info
+				});
+			}
+
+			//console.log('uuid:'+uuid+', from:'+from+', to:'+to);
+			if(typeof(translate.translateRequest) !== 'object' || typeof(translate.translateRequest[uuid]) !== 'object'){
+				return;
+			}
+			for(var lang in translate.translateRequest[uuid]){
+				if (!translate.translateRequest[uuid].hasOwnProperty(lang)) {
+		    		continue;
+		    	}
 				if(translate.translateRequest[uuid][lang].executeFinish == 0){
 					//这个还没执行完，那么直接退出，不在向后执行了
 					//console.log('uuid:'+uuid+'  lang:'+lang+'  executeFinish:0  time:'+translate.translateRequest[uuid][lang][i][addtime]);
@@ -2233,6 +2243,10 @@ var translate = {
 		translate.cancelVersion = translate.cancelVersion + 1;
 		//清空等待队列
 		translate.waitingExecute.clear();
+		//清空翻译请求去重缓存
+		if(typeof(translate.request) === 'object' && typeof(translate.request.pending) === 'object'){
+			translate.request.pending.clear();
+		}
 		//终止当前执行状态
 		translate.state = 0;
 		//中断未完成的翻译请求
@@ -2552,6 +2566,7 @@ var translate = {
 		var uuid = translate.util.uuid();
 		translate.time.log('创建uuid:'+uuid);
 		var executeCancelVersion = translate.cancelVersion;
+		var pendingKeysCreated = [];
 
 		//如果页面打开第一次使用，先判断缓存中有没有上次使用的语种，从缓存中取出
 		if(translate.to == null || translate.to == ''){
@@ -2967,12 +2982,12 @@ var translate = {
 				//console.log(originalWord);
 
 				//根据hash，判断本地是否有缓存了
-				var cacheHash = originalWord == translateText ? hash:translate.util.hash(translateText); //如果匹配到了自定义术语库，那翻译前的hash是被改变了
-				translate.nodeQueue[uuid]['list'][lang][hash]['cacheHash'] = cacheHash; //缓存的hash。 缓存时，其hash跟翻译的语言是完全对应的，缓存的hash就是翻译的语言转换来的
-				var cache = translate.storage.get('hash_'+translate.to+'_'+cacheHash);
-
-				//缓存是否有拿到具体缓存内容
-				if(cache != null && cache.length > 0){
+				var cacheHash = originalWord == translateText ? hash:translate.util.hash(translateText); //如果匹配到了自定义术语库，那翻译前的hash是被改变了
+				translate.nodeQueue[uuid]['list'][lang][hash]['cacheHash'] = cacheHash; //缓存的hash。 缓存时，其hash跟翻译的语言是完全对应的，缓存的hash就是翻译的语言转换来的
+				var cache = translate.storage.get('hash_'+translate.to+'_'+cacheHash);
+
+				//缓存是否有拿到具体缓存内容
+				if(cache != null && cache.length > 0){
 					for(var node_index = 0; node_index < translate.nodeQueue[uuid]['list'][lang][hash]['nodes'].length; node_index++){
 						//console.log(translate.nodeQueue[uuid]['list'][lang][hash]['nodes'][node_index]);
 
@@ -3055,14 +3070,27 @@ var translate = {
 					}
 
 
-
-					continue;	//跳出，不用在传入下面的翻译接口了
-				}
-				
-				/*
-				//取出数组
-				var queueNodes = this.nodeQueue[lang][hash];
-				if(queueNodes.length > 0){
+
+					continue;	//跳出，不用在传入下面的翻译接口了
+				}
+
+				//避免虚拟滚动等场景重复请求：如果同一文本正在翻译中，则加入等待队列
+				if(typeof(translate.request) === 'object' && typeof(translate.request.pending) === 'object'){
+					var pendingKey = translate.request.pending.key(lang, translate.to, cacheHash);
+					var pendingItem = translate.request.pending.get(pendingKey);
+					if(pendingItem != null){
+						translate.request.pending.add(pendingKey, {uuid:uuid, lang:lang, hash:hash});
+						continue;
+					}
+					//记录本次创建的pending，方便异常情况下清理
+					translate.request.pending.add(pendingKey, {uuid:uuid, lang:lang, hash:hash});
+					pendingKeysCreated.push(pendingKey);
+				}
+				
+				/*
+				//取出数组
+				var queueNodes = this.nodeQueue[lang][hash];
+				if(queueNodes.length > 0){
 					//因为在这个数组中的值都是一样的，那么只需要取出第一个就行了
 					var valueStr = queueNodes[0].nodeValue;
 					valueStr = this.util.charReplace(valueStr);
@@ -3090,13 +3118,20 @@ var translate = {
 		//console.log(translateTextArray);
 		//return;
 
-		if(typeof(translate.request.api.translate) != 'string' || translate.request.api.translate == null || translate.request.api.translate.length < 1){
-			//用户已经设置了不掉翻译接口进行翻译
-			translate.state = 0;
-			
-			//生命周期触发事件
-			translate.lifecycle.execute.renderFinish_Trigger(uuid, translate.to);
-			translate.executeNumber++;
+		if(typeof(translate.request.api.translate) != 'string' || translate.request.api.translate == null || translate.request.api.translate.length < 1){
+			//用户已经设置了不掉翻译接口进行翻译
+			translate.state = 0;
+
+			//清理本次创建的pending记录
+			if(pendingKeysCreated.length > 0 && typeof(translate.request) === 'object' && typeof(translate.request.pending) === 'object'){
+				for(var pk = 0; pk < pendingKeysCreated.length; pk++){
+					translate.request.pending.take(pendingKeysCreated[pk]);
+				}
+			}
+			
+			//生命周期触发事件
+			translate.lifecycle.execute.renderFinish_Trigger(uuid, translate.to);
+			translate.executeNumber++;
 
 			//钩子
 			translate.lifecycle.execute.finally_Trigger({
@@ -3476,14 +3511,19 @@ var translate = {
 						}
 
 
-						//翻译前的hash对应下标
-						var hash = splitHashes[i];	
-						var cacheHash = translate.nodeQueue[uuid]['list'][lang][hash]['cacheHash'];
+					//翻译前的hash对应下标
+					var hash = splitHashes[i];	
+					var cacheHash = translate.nodeQueue[uuid]['list'][lang][hash]['cacheHash'];
+					var pendingItem = null;
+					if(typeof(translate.request) === 'object' && typeof(translate.request.pending) === 'object'){
+						var pendingKey = translate.request.pending.key(lang, responseData.to, cacheHash);
+						pendingItem = translate.request.pending.take(pendingKey);
+					}
 
 
-						
-						//取原始的词，还未经过翻译的，需要进行翻译的词
-						var originalWord = '';
+					
+					//取原始的词，还未经过翻译的，需要进行翻译的词
+					var originalWord = '';
 						try{
 							originalWord = translate.nodeQueue[uuid]['list'][lang][hash]['original'];
 							//console.log('bef:'+translate.nodeQueue[uuid]['list'][lang][hash]['beforeText']);
@@ -3494,11 +3534,37 @@ var translate = {
 						}
 						
 						//for(var index = 0; index < translate.nodeQueue[lang][hash].length; index++){
-						for(var node_index = 0; node_index < translate.nodeQueue[uuid]['list'][lang][hash]['nodes'].length; node_index++){
-							//translate.nodeQueue[lang][hash]['nodes'][node_index].nodeValue = translate.nodeQueue[lang][hash]['nodes'][node_index].nodeValue.replace(new RegExp(originalWord,'g'), text);
-							//加入任务
-							task.add(translate.nodeQueue[uuid]['list'][lang][hash]['nodes'][node_index]['node'], originalWord, translate.nodeQueue[uuid]['list'][lang][hash]['nodes'][node_index]['beforeText']+text+translate.nodeQueue[uuid]['list'][lang][hash]['nodes'][node_index]['afterText'], translate.nodeQueue[uuid]['list'][lang][hash]['nodes'][node_index]['attribute']);
+					for(var node_index = 0; node_index < translate.nodeQueue[uuid]['list'][lang][hash]['nodes'].length; node_index++){
+						//translate.nodeQueue[lang][hash]['nodes'][node_index].nodeValue = translate.nodeQueue[lang][hash]['nodes'][node_index].nodeValue.replace(new RegExp(originalWord,'g'), text);
+						//加入任务
+						task.add(translate.nodeQueue[uuid]['list'][lang][hash]['nodes'][node_index]['node'], originalWord, translate.nodeQueue[uuid]['list'][lang][hash]['nodes'][node_index]['beforeText']+text+translate.nodeQueue[uuid]['list'][lang][hash]['nodes'][node_index]['afterText'], translate.nodeQueue[uuid]['list'][lang][hash]['nodes'][node_index]['attribute']);
+					}
+					//处理等待同一文本的其他节点
+					if(pendingItem != null && typeof(pendingItem.waits) === 'object'){
+						for(var wi = 0; wi < pendingItem.waits.length; wi++){
+							var waitItem = pendingItem.waits[wi];
+							if(waitItem.uuid === uuid && waitItem.lang === lang && waitItem.hash === hash){
+								continue;
+							}
+							if(typeof(translate.nodeQueue[waitItem.uuid]) === 'undefined'){
+								continue;
+							}
+							if(typeof(translate.nodeQueue[waitItem.uuid]['list'][waitItem.lang]) === 'undefined'){
+								continue;
+							}
+							if(typeof(translate.nodeQueue[waitItem.uuid]['list'][waitItem.lang][waitItem.hash]) === 'undefined'){
+								continue;
+							}
+							var waitQueue = translate.nodeQueue[waitItem.uuid]['list'][waitItem.lang][waitItem.hash];
+							if(typeof(waitQueue) === 'undefined' || typeof(waitQueue.nodes) === 'undefined'){
+								continue;
+							}
+							var waitOriginal = waitQueue.original;
+							for(var wni = 0; wni < waitQueue.nodes.length; wni++){
+								task.add(waitQueue.nodes[wni]['node'], waitOriginal, waitQueue.nodes[wni]['beforeText']+text+waitQueue.nodes[wni]['afterText'], waitQueue.nodes[wni]['attribute']);
+							}
 						}
+					}
 						//}
 						/*
 						for(var index = 0; index < translate.nodeQueue[data.from][hash].length; index++){
@@ -3521,6 +3587,23 @@ var translate = {
 					if(translate.cancelVersion != executeCancelVersion){
 						return;
 					}
+					//请求异常，清理pending，允许后续重试
+					if(typeof(translate.request) === 'object' && typeof(translate.request.pending) === 'object'){
+						for(var ph = 0; ph < splitHashes.length; ph++){
+							if(typeof(translate.nodeQueue[uuid]) === 'undefined'){
+								break;
+							}
+							if(typeof(translate.nodeQueue[uuid]['list'][lang]) === 'undefined'){
+								break;
+							}
+							if(typeof(translate.nodeQueue[uuid]['list'][lang][splitHashes[ph]]) === 'undefined'){
+								continue;
+							}
+							var cacheHash = translate.nodeQueue[uuid]['list'][lang][splitHashes[ph]]['cacheHash'];
+							var pendingKey = translate.request.pending.key(lang, translate.to, cacheHash);
+							translate.request.pending.take(pendingKey);
+						}
+					}
 					var info = '';
 					if(typeof(xhr.status) != 'undefined'){
 						if(xhr.status < 1){
@@ -8281,6 +8364,49 @@ var translate = {
 			//单条文本达到该长度后单独成组，避免与其它文本拼接，0则使用 size/2
 			singleTextMinSize:0
 		},
+		/*
+			翻译请求去重（处理中）
+		*/
+		pending:{
+			map:new Map(),
+			key:function(from, to, cacheHash){
+				return from+'|'+to+'|'+cacheHash;
+			},
+			get:function(key){
+				if(this.map == null){
+					this.map = new Map();
+				}
+				return this.map.get(key) || null;
+			},
+			add:function(key, waitItem){
+				if(this.map == null){
+					this.map = new Map();
+				}
+				var item = this.map.get(key);
+				if(item == null){
+					item = {waits:[]};
+					this.map.set(key, item);
+				}
+				if(waitItem != null){
+					item.waits.push(waitItem);
+				}
+				return item;
+			},
+			take:function(key){
+				if(this.map == null){
+					this.map = new Map();
+					return null;
+				}
+				var item = this.map.get(key) || null;
+				if(item != null){
+					this.map.delete(key);
+				}
+				return item;
+			},
+			clear:function(){
+				this.map = new Map();
+			}
+		},
 		/*
 			将翻译文本数组拆分为多个请求，避免一次请求过大导致超时
 			注意：不会拆分单条文本，避免破坏段落/语义