i18n-jsautotranslate 3.18.62 → 3.18.66
This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.
- package/ArcoDesign/Vue3/LanguageSelect.vue +17 -28
- package/index.js +569 -367
- package/package.json +3 -2
- package/vue/vue3/translate.ts +54 -0
- package/vue/vue3/translateVue3TS.ts +83 -0
package/index.js
CHANGED
|
@@ -14,7 +14,7 @@ var translate = {
|
|
|
14
14
|
* 格式：major.minor.patch.date
|
|
15
15
|
*/
|
|
16
16
|
// AUTO_VERSION_START
|
|
17
|
-
version: '3.18.
|
|
17
|
+
version: '3.18.66.20250930',
|
|
18
18
|
// AUTO_VERSION_END
|
|
19
19
|
/*
|
|
20
20
|
当前使用的版本，默认使用v2. 可使用 setUseVersion2();
|
|
@@ -24,7 +24,7 @@ var translate = {
|
|
|
24
24
|
/*js translate.setUseVersion2 start*/
|
|
25
25
|
setUseVersion2:function(){
|
|
26
26
|
translate.useVersion = 'v2';
|
|
27
|
-
|
|
27
|
+
translate.log('提示：自 v2.10 之后的版本默认就是使用V2版本（当前版本为:'+translate.version+'）， translate.setUseVersion2() 可以不用再加这一行了。当然加了也无所谓，只是加了跟不加是完全一样的。');
|
|
28
28
|
},
|
|
29
29
|
/*js translate.setUseVersion2 end*/
|
|
30
30
|
/*
|
|
@@ -49,6 +49,12 @@ var translate = {
|
|
|
49
49
|
resourcesUrl:'//res.zvo.cn/translate',
|
|
50
50
|
/*js translate.resourcesUrl end*/
|
|
51
51
|
|
|
52
|
+
/*js translate.log start*/
|
|
53
|
+
log: function(obj){
|
|
54
|
+
console.log(obj);
|
|
55
|
+
},
|
|
56
|
+
/*js translate.log end*/
|
|
57
|
+
|
|
52
58
|
/**
|
|
53
59
|
* 默认出现的选择语言的 select 选择框，可以通过这个选择切换语言。
|
|
54
60
|
*/
|
|
@@ -161,7 +167,7 @@ var translate = {
|
|
|
161
167
|
if(document.getElementById(translate.selectLanguageTag.documentId) == null){
|
|
162
168
|
var findBody = document.getElementsByTagName('body');
|
|
163
169
|
if(findBody.length == 0){
|
|
164
|
-
|
|
170
|
+
translate.log('body tag not find, translate.selectLanguageTag.render() is not show Select Language');
|
|
165
171
|
return;
|
|
166
172
|
}
|
|
167
173
|
var body_trans = findBody[0];
|
|
@@ -181,7 +187,7 @@ var translate = {
|
|
|
181
187
|
//从接口加载语种
|
|
182
188
|
translate.request.post(translate.request.api.language, {}, function(data){
|
|
183
189
|
if(data.result == 0){
|
|
184
|
-
|
|
190
|
+
translate.log('load language list error : '+data.info);
|
|
185
191
|
return;
|
|
186
192
|
}
|
|
187
193
|
//console.log(data.list);
|
|
@@ -263,8 +269,8 @@ var translate = {
|
|
|
263
269
|
* 已废弃，v1使用的
|
|
264
270
|
*/
|
|
265
271
|
execute_v1:function(){
|
|
266
|
-
|
|
267
|
-
|
|
272
|
+
translate.log('=====ERROR======');
|
|
273
|
+
translate.log('The v1 version has been discontinued since 2022. Please use the latest V3 version and refer to: http://translate.zvo.cn/41162.html');
|
|
268
274
|
},
|
|
269
275
|
/*js translate.execute_v1 end*/
|
|
270
276
|
|
|
@@ -328,7 +334,7 @@ var translate = {
|
|
|
328
334
|
var v1 = ',en,de,hi,lt,hr,lv,ht,hu,zh-CN,hy,uk,mg,id,ur,mk,ml,mn,af,mr,uz,ms,el,mt,is,it,my,es,et,eu,ar,pt-PT,ja,ne,az,fa,ro,nl,en-GB,no,be,fi,ru,bg,fr,bs,sd,se,si,sk,sl,ga,sn,so,gd,ca,sq,sr,kk,st,km,kn,sv,ko,sw,gl,zh-TW,pt-BR,co,ta,gu,ky,cs,pa,te,tg,th,la,cy,pl,da,tr,';
|
|
329
335
|
if(v1.indexOf(','+languageName+',') > -1){
|
|
330
336
|
//用的是v1.x
|
|
331
|
-
|
|
337
|
+
translate.log('您使用的是v1版本的切换语种方式，v1已在2021年就以废弃，请更换为v2，参考文档： http://translate.zvo.cn/41549.html');
|
|
332
338
|
translate.check();
|
|
333
339
|
|
|
334
340
|
var googtrans = '/'+translate.localLanguage+'/'+languageName;
|
|
@@ -380,7 +386,7 @@ var translate = {
|
|
|
380
386
|
}
|
|
381
387
|
}catch(e){
|
|
382
388
|
//增加try，避免异常导致无法用
|
|
383
|
-
|
|
389
|
+
translate.log(e);
|
|
384
390
|
}
|
|
385
391
|
|
|
386
392
|
translate.time.log('iframe 完成');
|
|
@@ -436,7 +442,7 @@ var translate = {
|
|
|
436
442
|
}
|
|
437
443
|
}catch(e){
|
|
438
444
|
//增加try，避免异常,比如跨域，中断导致无法用
|
|
439
|
-
|
|
445
|
+
translate.log(e);
|
|
440
446
|
}
|
|
441
447
|
}
|
|
442
448
|
}
|
|
@@ -460,7 +466,7 @@ var translate = {
|
|
|
460
466
|
/*js translate.check start*/
|
|
461
467
|
check:function(){
|
|
462
468
|
if(window.location.protocol == 'file:'){
|
|
463
|
-
|
|
469
|
+
translate.log('\r\n---WARNING----\r\ntranslate.js 主动翻译组件自检异常，当前协议是file协议，翻译组件要在正常的线上http、https协议下才能正常使用翻译功能\r\n------------');
|
|
464
470
|
}
|
|
465
471
|
},
|
|
466
472
|
/*js translate.check end*/
|
|
@@ -512,6 +518,12 @@ var translate = {
|
|
|
512
518
|
if(ele == null || typeof(ele) == 'undefined'){
|
|
513
519
|
return false;
|
|
514
520
|
}
|
|
521
|
+
if(ele.nodeType === 2){ //是属性，将其转为元素判断，因为当前忽略配置，是针对元素配置的
|
|
522
|
+
ele = ele.ownerElement;
|
|
523
|
+
}else if(ele.nodeType === 3){
|
|
524
|
+
//文本节点，转为元素
|
|
525
|
+
ele = ele.parentNode;
|
|
526
|
+
}
|
|
515
527
|
|
|
516
528
|
var parentNode = ele;
|
|
517
529
|
var maxnumber = 100; //最大循环次数，避免死循环
|
|
@@ -685,10 +697,10 @@ var translate = {
|
|
|
685
697
|
//如果from未传入，则自动识别当前页面的语种为from
|
|
686
698
|
//如果自动识别，也要确保是页面加载完后，免得放到了head里，那肯定啥也识别不出来
|
|
687
699
|
if(document.body == null){
|
|
688
|
-
|
|
700
|
+
translate.log('使用错误！你使用自定义术语 translate.nomenclature.append 时，from 未传值，此时 translate.js 会自动识别当前翻译区域的内容是什么语种，但是你当前吧 translate.nomenclature.append 放在了body之前就加载了，body都还没加载出来，翻译区域当前无内容，所以无法识别当前页面的语种。请将 translate.nomenclature.append 放在翻译内容加载完后再执行 （注意，要将 translate.nomenclature.append 放在 translate.execute() 的前面），建议将 translate.nomenclature.append 放在 </body> 跟 </html> 之间。');
|
|
689
701
|
}else{
|
|
690
702
|
if (document.readyState === 'loading') {
|
|
691
|
-
|
|
703
|
+
translate.log('使用异常告警：你使用的自定义术语 translate.nomenclature.append 时，from 未传值，此时 translate.js 会自动识别当前翻译区域的内容是什么语种，但页面Dom还未加载完毕时就触发了它，如果翻译区域当前无内容或者内容不是完整的，会造成识别当前页面的语种会有异常不准确，你需要仔细确认这个问题。建议将 translate.nomenclature.append 放在 </body> 跟 </html> 之间。');
|
|
692
704
|
}
|
|
693
705
|
}
|
|
694
706
|
|
|
@@ -759,8 +771,7 @@ var translate = {
|
|
|
759
771
|
* 如果传入 null，则不进行任何替换操作
|
|
760
772
|
* 如果传入具体的值，则是：
|
|
761
773
|
* {
|
|
762
|
-
* node: node节点
|
|
763
|
-
* attribute: 要替换的node的attribute名称。如果传入 null,则是直接对 nodeValue 生效
|
|
774
|
+
* node: node节点 ，要改动的文字所在的node节点。 如果改动的文字比如是 div 的title中，那么这里传入的node应该是 title 的node，而不是 div 的node
|
|
764
775
|
* }
|
|
765
776
|
*
|
|
766
777
|
* @returns {
|
|
@@ -893,8 +904,7 @@ var translate = {
|
|
|
893
904
|
如果传入 null，则不进行任何替换操作
|
|
894
905
|
如果传入具体的值，则是：
|
|
895
906
|
{
|
|
896
|
-
node: node节点
|
|
897
|
-
attribute: 要替换的node的attribute名称。如果传入 null,则是直接对 nodeValue 生效
|
|
907
|
+
node: node节点 ，要改动的文字所在的node节点。 如果改动的文字比如是 div 的title中，那么这里传入的node应该是 title 的node，而不是 div 的node
|
|
898
908
|
}
|
|
899
909
|
|
|
900
910
|
|
|
@@ -1084,7 +1094,7 @@ var translate = {
|
|
|
1084
1094
|
*/
|
|
1085
1095
|
set: async function(hash, originalText, toLanguage, translateText){
|
|
1086
1096
|
if(typeof(translate.storage.IndexedDB) == 'undefined'){
|
|
1087
|
-
|
|
1097
|
+
translate.log('ERROR: translate.storage.IndexedDB not find');
|
|
1088
1098
|
return;
|
|
1089
1099
|
}
|
|
1090
1100
|
var obj = await translate.storage.IndexedDB.get('hash_'+hash);
|
|
@@ -1104,11 +1114,11 @@ var translate = {
|
|
|
1104
1114
|
*/
|
|
1105
1115
|
export: async function(to){
|
|
1106
1116
|
if(typeof(translate.storage.IndexedDB) == 'undefined'){
|
|
1107
|
-
|
|
1117
|
+
translate.log('ERROR: translate.storage.IndexedDB not find');
|
|
1108
1118
|
return;
|
|
1109
1119
|
}
|
|
1110
1120
|
if(typeof(to) != 'string'){
|
|
1111
|
-
|
|
1121
|
+
translate.log('error : to param not find, example: "english"');
|
|
1112
1122
|
return;
|
|
1113
1123
|
}
|
|
1114
1124
|
var text = 'translate.office.append(\'';
|
|
@@ -1303,6 +1313,54 @@ var translate = {
|
|
|
1303
1313
|
//console.log('refresh ignore finish: '+Object.keys(translate.listener.ignoreNode).length);
|
|
1304
1314
|
},
|
|
1305
1315
|
|
|
1316
|
+
/*
|
|
1317
|
+
用于监听发生改变的这个 node 是否有正常需要翻译的内容、以及是否是非translate.js触发的需要被翻译。
|
|
1318
|
+
注意，传入进行判断的node中的文本必须是 node.nodeValue ，也就是这个必须是 node.nodeType == 2(某个元素的属性，比如 input 的 placeholder) 或 3(文本节点)， 这样他们才会有正常的 node.nodeValue，而且文本也存在于 node.nodeValue 中
|
|
1319
|
+
比如 div title="你好" ，要对 title 的 你好 这个值进行判定，传入的node必须是 title 的 node，而非 div 的 node
|
|
1320
|
+
它主要是为了给 translate.listener.addListener 中的动态监听node改变所服务的
|
|
1321
|
+
|
|
1322
|
+
@param node 要判断的这个是否需要触发翻译的node
|
|
1323
|
+
@return boolean true：需要触发 translate.execute(node) 进行翻译
|
|
1324
|
+
*/
|
|
1325
|
+
nodeValueChangeNeedTranslate: function(node){
|
|
1326
|
+
//是否是要加入翻译扫描触发执行，是则是true
|
|
1327
|
+
var addTranslateExecute = true;
|
|
1328
|
+
|
|
1329
|
+
/*
|
|
1330
|
+
不会进入翻译的情况 -
|
|
1331
|
+
1. 认为是有 translate.js 本身翻译导致的改变，不进行翻译
|
|
1332
|
+
取 translate.node.data 中的数据，当改变的node节点在其中找到了对应的数据后，进行判定
|
|
1333
|
+
1. 是整体翻译，且当前node改变后的内容，跟上次翻译后的结果一样，那说明当前node改变事件
|
|
1334
|
+
2. 不是整体翻译，可能是触发自定义术语、或直接没启用整体翻译能力，那就要根据最后翻译时间这个来判定了。如果这个node元素，已经被翻译过了，最后一次翻译渲染时间，距离当前时间不超过500毫秒
|
|
1335
|
+
2. 其他的情况如果后续发现有遗漏，再加入，当前没有这种考虑
|
|
1336
|
+
*/
|
|
1337
|
+
if(translate.node.get(node) != null){
|
|
1338
|
+
if(typeof(translate.node.get(node).whole) !== 'undefined' && translate.node.get(node).whole == true){
|
|
1339
|
+
//整体翻译
|
|
1340
|
+
if(typeof(translate.node.get(node).resultText) !== 'undefined' && translate.node.get(node).resultText === node.nodeValue){
|
|
1341
|
+
//当前改变后的内容，跟上次翻译后的结果一样，那说明当前node改变事件，是有translate.js 本身翻译导致的，不进行翻译
|
|
1342
|
+
addTranslateExecute = false;
|
|
1343
|
+
}
|
|
1344
|
+
}else{
|
|
1345
|
+
//不是整体翻译，可能是触发自定义术语、或直接没启用整体翻译能力
|
|
1346
|
+
//这就要根据最后翻译时间这个来判定了
|
|
1347
|
+
if(typeof(translate.node.get(node).lastTranslateRenderTime) == 'number' && translate.node.get(node).lastTranslateRenderTime + 500 > Date.now()){
|
|
1348
|
+
//如果这个node元素，已经被翻译过了，最后一次翻译渲染时间，距离当前时间不超过500毫秒，那认为这个元素动态改变，是有translate.js 本身引起的，将不做任何动作
|
|
1349
|
+
addTranslateExecute = false;
|
|
1350
|
+
}
|
|
1351
|
+
}
|
|
1352
|
+
}
|
|
1353
|
+
|
|
1354
|
+
//如果新的里面没有非空白字符的值，那也不再触发翻译
|
|
1355
|
+
if(addTranslateExecute === true){
|
|
1356
|
+
if(node.nodeValue.trim().length === 0){
|
|
1357
|
+
addTranslateExecute = false;
|
|
1358
|
+
}
|
|
1359
|
+
}
|
|
1360
|
+
|
|
1361
|
+
return addTranslateExecute;
|
|
1362
|
+
},
|
|
1363
|
+
|
|
1306
1364
|
|
|
1307
1365
|
//增加监听，开始监听。这个不要直接调用，需要使用上面的 start() 开启
|
|
1308
1366
|
addListener:function(){
|
|
@@ -1339,61 +1397,47 @@ var translate = {
|
|
|
1339
1397
|
}
|
|
1340
1398
|
}
|
|
1341
1399
|
}else if (mutation.type === 'attributes') {
|
|
1342
|
-
|
|
1343
|
-
|
|
1344
|
-
//如果是class，不做任何改变，直接跳出
|
|
1400
|
+
if(mutation.attributeName === 'class' || mutation.attributeName === 'style'){
|
|
1401
|
+
//如果是class/ style 这种常见的，不做任何改变，直接跳出
|
|
1345
1402
|
continue;
|
|
1346
1403
|
}
|
|
1347
|
-
//console.log('listener attributes change --> ' + mutation.target.nodeName+'['+ mutation.attributeName + '] oldValue :'+mutation.oldValue);
|
|
1348
1404
|
|
|
1349
|
-
|
|
1350
|
-
|
|
1351
|
-
|
|
1352
|
-
|
|
1405
|
+
/*
|
|
1406
|
+
这里要判断一些允许翻译的属性
|
|
1407
|
+
input 的 placeholder 属性 ,直接判断 placeholder 就行了，也就 input、textarea 有这个属性
|
|
1408
|
+
img 的 alt 属性
|
|
1409
|
+
所有标签的 title 属性
|
|
1410
|
+
*/
|
|
1411
|
+
|
|
1412
|
+
if(mutation.attributeName === 'placeholder' || mutation.attributeName === 'alt' || mutation.attributeName === 'title'){
|
|
1413
|
+
//允许翻译
|
|
1414
|
+
}else{
|
|
1415
|
+
//判断是否是 translate.element.tagAttribute 自定义翻译属性的
|
|
1416
|
+
var divTagAttribute = translate.element.tagAttribute[mutation.target.nodeName.toLowerCase()];
|
|
1417
|
+
if(typeof(divTagAttribute) !== 'undefined' && divTagAttribute.attribute.indexOf(mutation.attributeName) > -1 && divTagAttribute.condition(mutation.target)){
|
|
1418
|
+
//是自定义翻译这个属性的，以及判定是否达到翻译条件
|
|
1419
|
+
//条件满足，允许翻译
|
|
1353
1420
|
}else{
|
|
1354
|
-
|
|
1355
|
-
|
|
1356
|
-
//console.log(translate.node.get(mutation.target)[nodeAttribute.key])
|
|
1357
|
-
if(typeof(translate.node.get(mutation.target)[nodeAttribute.key]) != 'undefined'){
|
|
1358
|
-
//从翻译历史中删掉，使这个属性还能继续被翻译
|
|
1359
|
-
//console.log('delete translate.node.get(mutation.target)[nodeAttribute.key] -> '+mutation.attributeName);
|
|
1360
|
-
delete translate.node.get(mutation.target)[nodeAttribute.key];
|
|
1361
|
-
}
|
|
1421
|
+
//条件不满足，不在翻译的属性范围
|
|
1422
|
+
continue;
|
|
1362
1423
|
}
|
|
1363
1424
|
}
|
|
1364
1425
|
|
|
1365
|
-
|
|
1366
|
-
|
|
1426
|
+
//这里出现的 mutation.target 是定位到了元素上面，而不是变化的这个 attributes 属性上，需要用 mutation.attributeName 获取到这个属性的node
|
|
1427
|
+
var node = mutation.target.getAttributeNode(mutation.attributeName);
|
|
1428
|
+
|
|
1429
|
+
//是否是要加入翻译扫描触发执行，是则是true
|
|
1430
|
+
var addTranslateExecute = translate.listener.nodeValueChangeNeedTranslate(node);
|
|
1431
|
+
if(addTranslateExecute){ //不是 translate.js 翻译引起的改变，那么
|
|
1432
|
+
//console.log('listener attributes change ' + mutation.target.nodeName+'['+ mutation.attributeName + '] '+mutation.oldValue+' --> '+node.nodeValue);
|
|
1433
|
+
translate.node.delete(node);
|
|
1434
|
+
addNodes = [node]; //将这个属性转为的node加入待翻译
|
|
1435
|
+
}
|
|
1367
1436
|
}else if(mutation.type === 'characterData'){
|
|
1368
1437
|
//内容改变
|
|
1369
1438
|
|
|
1370
1439
|
//是否是要加入翻译扫描触发执行，是则是true
|
|
1371
|
-
var addTranslateExecute =
|
|
1372
|
-
|
|
1373
|
-
/*
|
|
1374
|
-
不会进入翻译的情况 -
|
|
1375
|
-
1. 认为是有 translate.js 本身翻译导致的改变，不进行翻译
|
|
1376
|
-
取 translate.node.data 中的数据，当改变的node节点在其中找到了对应的数据后，进行判定
|
|
1377
|
-
1. 是整体翻译，且当前node改变后的内容，跟上次翻译后的结果一样，那说明当前node改变事件
|
|
1378
|
-
2. 不是整体翻译，可能是触发自定义术语、或直接没启用整体翻译能力，那就要根据最后翻译时间这个来判定了。如果这个node元素，已经被翻译过了，最后一次翻译渲染时间，距离当前时间不超过500毫秒
|
|
1379
|
-
2. 其他的情况如果后续发现有遗漏，再加入，当前没有这种考虑
|
|
1380
|
-
*/
|
|
1381
|
-
if(translate.node.get(mutation.target) != null && typeof(translate.node.get(mutation.target).translate_default_value) != 'undefined'){
|
|
1382
|
-
if(typeof(translate.node.get(mutation.target).translate_default_value.whole) != 'undefined' && translate.node.get(mutation.target).translate_default_value.whole == true){
|
|
1383
|
-
//整体翻译
|
|
1384
|
-
if(typeof(translate.node.get(mutation.target).translate_default_value.resultText) != 'undefined' && translate.node.get(mutation.target).translate_default_value.resultText === mutation.target.nodeValue){
|
|
1385
|
-
//当前改变后的内容，跟上次翻译后的结果一样，那说明当前node改变事件，是有translate.js 本身翻译导致的，不进行翻译
|
|
1386
|
-
addTranslateExecute = false;
|
|
1387
|
-
}
|
|
1388
|
-
}else{
|
|
1389
|
-
//不是整体翻译，可能是触发自定义术语、或直接没启用整体翻译能力
|
|
1390
|
-
//这就要根据最后翻译时间这个来判定了
|
|
1391
|
-
if(typeof(translate.node.get(mutation.target).lastTranslateRenderTime) == 'number' && translate.node.get(mutation.target).lastTranslateRenderTime + 500 > Date.now()){
|
|
1392
|
-
//如果这个node元素，已经被翻译过了，最后一次翻译渲染时间，距离当前时间不超过500毫秒，那认为这个元素动态改变，是有translate.js 本身引起的，将不做任何动作
|
|
1393
|
-
addTranslateExecute = false;
|
|
1394
|
-
}
|
|
1395
|
-
}
|
|
1396
|
-
}
|
|
1440
|
+
var addTranslateExecute = translate.listener.nodeValueChangeNeedTranslate(mutation.target);
|
|
1397
1441
|
|
|
1398
1442
|
if(addTranslateExecute){ //不是 translate.js 翻译引起的改变，那么
|
|
1399
1443
|
translate.node.delete(mutation.target);
|
|
@@ -1422,10 +1466,8 @@ var translate = {
|
|
|
1422
1466
|
}
|
|
1423
1467
|
}
|
|
1424
1468
|
|
|
1425
|
-
//console.log(documents.length);
|
|
1426
1469
|
if(documents.length > 0){
|
|
1427
1470
|
//有变动，需要看看是否需要翻译，延迟10毫秒执行
|
|
1428
|
-
|
|
1429
1471
|
translate.time.log('监听到元素发生变化,'+documents.length+'个元素');
|
|
1430
1472
|
|
|
1431
1473
|
//判断是否属于在正在翻译的节点，重新组合出新的要翻译的node集合
|
|
@@ -1467,7 +1509,7 @@ var translate = {
|
|
|
1467
1509
|
//console.log('translateNodeslength: '+translateNodes.length);
|
|
1468
1510
|
|
|
1469
1511
|
translate.time.log('将监听到的发生变化的元素进行整理,得到'+translateNodes.length+'个元素，对其进行翻译');
|
|
1470
|
-
//console.log(translateNodes
|
|
1512
|
+
//console.log(translateNodes);
|
|
1471
1513
|
|
|
1472
1514
|
translate.execute(translateNodes);
|
|
1473
1515
|
//setTimeout(function() {
|
|
@@ -1514,7 +1556,7 @@ var translate = {
|
|
|
1514
1556
|
try{
|
|
1515
1557
|
translate.listener.execute.renderStartByApi[i](uuid, from, to);
|
|
1516
1558
|
}catch(e){
|
|
1517
|
-
|
|
1559
|
+
translate.log(e);
|
|
1518
1560
|
}
|
|
1519
1561
|
}
|
|
1520
1562
|
},
|
|
@@ -1533,7 +1575,7 @@ var translate = {
|
|
|
1533
1575
|
try{
|
|
1534
1576
|
translate.listener.execute.renderFinishByApi[i](uuid, from, to);
|
|
1535
1577
|
}catch(e){
|
|
1536
|
-
|
|
1578
|
+
translate.log(e);
|
|
1537
1579
|
}
|
|
1538
1580
|
}
|
|
1539
1581
|
}
|
|
@@ -1688,13 +1730,26 @@ var translate = {
|
|
|
1688
1730
|
|
|
1689
1731
|
|
|
1690
1732
|
// translate.node 记录
|
|
1691
|
-
|
|
1692
|
-
|
|
1733
|
+
|
|
1734
|
+
var translateNode; //当前操作的，要记录入 translate.node 中的，进行翻译的node
|
|
1735
|
+
var translateNode_attribute = ''; //当前操作的是node中的哪个attribute，如果没有是node本身则是空字符串
|
|
1736
|
+
if(typeof(task['attribute']) === 'string' && task['attribute'].length > 0){
|
|
1737
|
+
//当前渲染任务是针对的元素的某个属性，这是要取出这个元素的具体属性，作为一个目的 node 来进行加入 translate.node
|
|
1738
|
+
//是操作的元素的某个属性
|
|
1739
|
+
translateNode = this.nodes[hash][node_index].getAttributeNode(task['attribute']);
|
|
1740
|
+
translateNode_attribute = task['attribute'];
|
|
1741
|
+
}else{
|
|
1742
|
+
//操作的就是node本身
|
|
1743
|
+
translateNode = this.nodes[hash][node_index];
|
|
1744
|
+
}
|
|
1745
|
+
//console.log(translateNode)
|
|
1746
|
+
//var nodeAttribute = translate.node.getAttribute(task['attribute']);
|
|
1747
|
+
if(translate.node.data.get(translateNode) != null){
|
|
1693
1748
|
// 记录当前有 translate.js 所触发翻译之后渲染到dom界面显示的时间，13位时间戳
|
|
1694
|
-
translate.node.get(
|
|
1749
|
+
translate.node.get(translateNode).lastTranslateRenderTime = Date.now();
|
|
1695
1750
|
}else{
|
|
1696
|
-
|
|
1697
|
-
|
|
1751
|
+
translate.log('执行异常，渲染时，node 未在 translate.node 中找到, 这个理论上是不应该存在的，当前异常已被容错。 node：'+translateNode);
|
|
1752
|
+
translate.log(this.nodes[hash][task_index]);
|
|
1698
1753
|
}
|
|
1699
1754
|
|
|
1700
1755
|
//渲染页面进行翻译显示
|
|
@@ -1702,22 +1757,14 @@ var translate = {
|
|
|
1702
1757
|
var analyseSet = translate.element.nodeAnalyse.set(this.nodes[hash][task_index], task.originalText, task.resultText, task['attribute']);
|
|
1703
1758
|
//console.log(analyseSet);
|
|
1704
1759
|
|
|
1705
|
-
if(translate.node.data.get(
|
|
1706
|
-
|
|
1707
|
-
|
|
1708
|
-
|
|
1709
|
-
|
|
1710
|
-
//将具体通过文本翻译接口进行翻译的文本记录到 translate.node.data
|
|
1711
|
-
translate.node.get(this.nodes[hash][task_index])[nodeAttribute.key].translateTexts[task.originalText] = task.resultText;
|
|
1712
|
-
//将翻译完成后要显示出的文本进行记录
|
|
1713
|
-
translate.node.get(this.nodes[hash][task_index])[nodeAttribute.key].resultText = analyseSet.resultText;
|
|
1760
|
+
if(translate.node.data.get(translateNode) != null){
|
|
1761
|
+
//将具体通过文本翻译接口进行翻译的文本记录到 translate.node.data
|
|
1762
|
+
translate.node.get(translateNode).translateTexts[task.originalText] = task.resultText;
|
|
1763
|
+
//将翻译完成后要显示出的文本进行记录
|
|
1764
|
+
translate.node.get(translateNode).resultText = analyseSet.resultText;
|
|
1714
1765
|
|
|
1715
|
-
|
|
1716
|
-
|
|
1717
|
-
}
|
|
1718
|
-
}else{
|
|
1719
|
-
console.log('执行异常，渲染时，node未在 nodeHistory 中找到, 这个理论上是不应该存在的，当前异常已被容错。 node：'+this.nodes[hash][task_index]);
|
|
1720
|
-
console.log(this.nodes[hash][task_index]);
|
|
1766
|
+
//将其加入 translate.history.translateTexts
|
|
1767
|
+
translate.history.translateText.add(translate.node.get(translateNode).originalText ,analyseSet.resultText);
|
|
1721
1768
|
}
|
|
1722
1769
|
|
|
1723
1770
|
//加入 translate.listener.ignoreNode
|
|
@@ -1824,7 +1871,7 @@ var translate = {
|
|
|
1824
1871
|
if(translate.waitingExecute.queue.length > 0){
|
|
1825
1872
|
return translate.waitingExecute.queue.shift();
|
|
1826
1873
|
}else{
|
|
1827
|
-
|
|
1874
|
+
translate.log('警告， translate.waitingExecute.get 出现异常，quque已空，但还往外取。');
|
|
1828
1875
|
return null;
|
|
1829
1876
|
}
|
|
1830
1877
|
},
|
|
@@ -1850,12 +1897,14 @@ var translate = {
|
|
|
1850
1897
|
translate.listener.execute.renderFinishByApiRun(uuid, from, to);
|
|
1851
1898
|
|
|
1852
1899
|
//通过 uuid、from 取得本次翻译相关的 texts、nodes , 触发 translateNetworkAfter_Trigger 钩子
|
|
1900
|
+
//获取请求日志
|
|
1901
|
+
var requestData = translate.request.data[uuid].list[from][to];
|
|
1853
1902
|
translate.lifecycle.execute.translateNetworkAfter_Trigger({
|
|
1854
1903
|
uuid: uuid,
|
|
1855
1904
|
from: from,
|
|
1856
1905
|
to: to,
|
|
1857
|
-
texts:
|
|
1858
|
-
nodes:
|
|
1906
|
+
texts: requestData.texts,
|
|
1907
|
+
nodes: requestData.nodes,
|
|
1859
1908
|
result: result,
|
|
1860
1909
|
info: info
|
|
1861
1910
|
});
|
|
@@ -1904,7 +1953,7 @@ var translate = {
|
|
|
1904
1953
|
try{
|
|
1905
1954
|
translate.lifecycle.changeLanguage[i](to);
|
|
1906
1955
|
}catch(e){
|
|
1907
|
-
|
|
1956
|
+
translate.log(e);
|
|
1908
1957
|
}
|
|
1909
1958
|
}
|
|
1910
1959
|
},
|
|
@@ -1942,7 +1991,7 @@ var translate = {
|
|
|
1942
1991
|
isNextExecute = false;
|
|
1943
1992
|
}
|
|
1944
1993
|
}catch(e){
|
|
1945
|
-
|
|
1994
|
+
translate.log(e);
|
|
1946
1995
|
}
|
|
1947
1996
|
}
|
|
1948
1997
|
return isNextExecute;
|
|
@@ -1968,13 +2017,13 @@ var translate = {
|
|
|
1968
2017
|
try{
|
|
1969
2018
|
translate.lifecycle.execute.start[i](data.uuid, data.to);
|
|
1970
2019
|
}catch(e){
|
|
1971
|
-
|
|
2020
|
+
translate.log(e);
|
|
1972
2021
|
}
|
|
1973
2022
|
}else{
|
|
1974
2023
|
try{
|
|
1975
2024
|
translate.lifecycle.execute.start[i](data);
|
|
1976
2025
|
}catch(e){
|
|
1977
|
-
|
|
2026
|
+
translate.log(e);
|
|
1978
2027
|
}
|
|
1979
2028
|
}
|
|
1980
2029
|
|
|
@@ -1990,7 +2039,7 @@ var translate = {
|
|
|
1990
2039
|
try{
|
|
1991
2040
|
translate.listener.execute.renderStartByApi[i](uuid, from, to);
|
|
1992
2041
|
}catch(e){
|
|
1993
|
-
|
|
2042
|
+
translate.log(e);
|
|
1994
2043
|
}
|
|
1995
2044
|
}
|
|
1996
2045
|
},
|
|
@@ -2041,14 +2090,14 @@ var translate = {
|
|
|
2041
2090
|
try{
|
|
2042
2091
|
translate.lifecycle.execute.translateNetworkBefore[i](data.uuid, data.from, data.to, data.texts);
|
|
2043
2092
|
}catch(e){
|
|
2044
|
-
|
|
2093
|
+
translate.log(e);
|
|
2045
2094
|
}
|
|
2046
2095
|
}else{
|
|
2047
2096
|
//2025.9.15 之后的新的
|
|
2048
2097
|
try{
|
|
2049
2098
|
translate.lifecycle.execute.translateNetworkBefore[i](data);
|
|
2050
2099
|
}catch(e){
|
|
2051
|
-
|
|
2100
|
+
translate.log(e);
|
|
2052
2101
|
}
|
|
2053
2102
|
}
|
|
2054
2103
|
|
|
@@ -2073,7 +2122,7 @@ var translate = {
|
|
|
2073
2122
|
try{
|
|
2074
2123
|
translate.lifecycle.execute.translateNetworkAfter[i](data);
|
|
2075
2124
|
}catch(e){
|
|
2076
|
-
|
|
2125
|
+
translate.log(e);
|
|
2077
2126
|
}
|
|
2078
2127
|
}
|
|
2079
2128
|
},
|
|
@@ -2097,7 +2146,7 @@ var translate = {
|
|
|
2097
2146
|
try{
|
|
2098
2147
|
translate.lifecycle.execute.renderFinish[i](uuid, to);
|
|
2099
2148
|
}catch(e){
|
|
2100
|
-
|
|
2149
|
+
translate.log(e);
|
|
2101
2150
|
}
|
|
2102
2151
|
}
|
|
2103
2152
|
},
|
|
@@ -2128,7 +2177,7 @@ var translate = {
|
|
|
2128
2177
|
try{
|
|
2129
2178
|
translate.lifecycle.execute.finally[i](data);
|
|
2130
2179
|
}catch(e){
|
|
2131
|
-
|
|
2180
|
+
translate.log(e);
|
|
2132
2181
|
}
|
|
2133
2182
|
}
|
|
2134
2183
|
},
|
|
@@ -2223,8 +2272,8 @@ var translate = {
|
|
|
2223
2272
|
if(sliceDoc[di].getAttribute('class') != null && typeof(sliceDoc[di].getAttribute('class')) == 'string' && sliceDoc[di].getAttribute('class').length > 0){
|
|
2224
2273
|
sliceDocString = sliceDocString + " class="+sliceDoc[di].getAttribute('class');
|
|
2225
2274
|
}
|
|
2226
|
-
}else if(sliceDoc[di].nodeType === 3){
|
|
2227
|
-
//
|
|
2275
|
+
}else if(sliceDoc[di].nodeType === 2 || sliceDoc[di].nodeType === 3){
|
|
2276
|
+
//2属性 或 3文本节点
|
|
2228
2277
|
sliceDocString = sliceDocString + sliceDoc[di].nodeValue.replaceAll(/\r?\n/g, '[换行符]');
|
|
2229
2278
|
}
|
|
2230
2279
|
}
|
|
@@ -2232,8 +2281,7 @@ var translate = {
|
|
|
2232
2281
|
}
|
|
2233
2282
|
|
|
2234
2283
|
|
|
2235
|
-
|
|
2236
|
-
//console.log(docs);
|
|
2284
|
+
translate.log('当前翻译未完结，新翻译任务已加入等待翻译队列，待上个翻译任务结束后便会执行当前翻译任务'+sliceDocString);
|
|
2237
2285
|
translate.waitingExecute.add(docs);
|
|
2238
2286
|
|
|
2239
2287
|
//钩子
|
|
@@ -2267,7 +2315,7 @@ var translate = {
|
|
|
2267
2315
|
//translate.execute_v1();
|
|
2268
2316
|
//return;
|
|
2269
2317
|
//v2.5.1增加
|
|
2270
|
-
|
|
2318
|
+
translate.log('提示：https://github.com/xnx3/translate 在 v2.5 版本之后，由于谷歌翻译调整，免费翻译通道不再支持，所以v1版本的翻译接口不再被支持，v1全线下架。考虑到v1已不能使用，当前已自动切换到v2版本。如果您使用中发现什么异常，请针对v2版本进行适配。');
|
|
2271
2319
|
translate.useVersion = 'v2';
|
|
2272
2320
|
}
|
|
2273
2321
|
|
|
@@ -2296,7 +2344,7 @@ var translate = {
|
|
|
2296
2344
|
try{
|
|
2297
2345
|
translate.selectLanguageTag.render();
|
|
2298
2346
|
}catch(e){
|
|
2299
|
-
|
|
2347
|
+
translate.log(e);
|
|
2300
2348
|
}
|
|
2301
2349
|
|
|
2302
2350
|
translate.time.log('渲染出选择语言的select窗口-已完成');
|
|
@@ -2364,8 +2412,8 @@ var translate = {
|
|
|
2364
2412
|
//console.log(all)
|
|
2365
2413
|
|
|
2366
2414
|
if(all.length > 500){
|
|
2367
|
-
|
|
2368
|
-
|
|
2415
|
+
translate.log('------tip------');
|
|
2416
|
+
translate.log('translate.execute( docs ) 传入的docs.length 过大，超过500，这很不正常，当前 docs.length : '+all.length+' ,如果你感觉真的没问题，请联系作者 http://translate.zvo.cn/43006.html 说明情况，根据你的情况进行分析。 当前只取前500个元素进行翻译');
|
|
2369
2417
|
}
|
|
2370
2418
|
|
|
2371
2419
|
//初始化 translate.element.tagAttribute ，主要针对 v3.17.10 版本的适配调整，对 translate.element.tagAttribute 的设置做了改变，做旧版本的适配
|
|
@@ -2386,7 +2434,7 @@ var translate = {
|
|
|
2386
2434
|
}
|
|
2387
2435
|
}
|
|
2388
2436
|
}catch(e){
|
|
2389
|
-
|
|
2437
|
+
translate.log(e);
|
|
2390
2438
|
}
|
|
2391
2439
|
|
|
2392
2440
|
translate.time.log('开始扫描要翻译区域的元素');
|
|
@@ -2417,8 +2465,8 @@ var translate = {
|
|
|
2417
2465
|
if(typeof(translate.nodeQueue[uuid]) == 'undefined'){
|
|
2418
2466
|
translate.nodeQueue[uuid] = new Array();
|
|
2419
2467
|
translate.nodeQueue[uuid].list = [];
|
|
2420
|
-
|
|
2421
|
-
|
|
2468
|
+
translate.log('--- translate.js warn tip 警告！！ ---');
|
|
2469
|
+
translate.log('您使用translate.js时可能放的位置不对，不要吧 translate.js 放在网页最顶部，这样当 translate.js 进行执行，也就是 translate.execute() 执行时，因为网页是从上往下加载，它放在网页最顶部，那么它执行时网页后面的内容都还没加载出来，这个是不会获取到网页任何内容的，也就是它是不起任何作用的');
|
|
2422
2470
|
}
|
|
2423
2471
|
for(var lang in translate.nodeQueue[uuid].list){
|
|
2424
2472
|
if (!translate.nodeQueue[uuid].list.hasOwnProperty(lang)) {
|
|
@@ -2881,7 +2929,7 @@ var translate = {
|
|
|
2881
2929
|
//console.log(lang);
|
|
2882
2930
|
//console.log(translate.nodeQueue[uuid]['list'][lang][thhash].nodes);
|
|
2883
2931
|
if(typeof(translate.nodeQueue[uuid]['list'][lang][thhash].nodes) == 'undefined' || typeof(translate.nodeQueue[uuid]['list'][lang][thhash].nodes.length) == 'undefined'){
|
|
2884
|
-
|
|
2932
|
+
translate.log('translate.nodeQueue[\''+uuid+'\'][\'list\'][\''+lang+'\'][\''+thhash+'\'].nodes.length is null ，理论上不应该存在，进行异常报出，但不影响使用，已容错。');
|
|
2885
2933
|
continue;
|
|
2886
2934
|
}
|
|
2887
2935
|
|
|
@@ -2922,6 +2970,11 @@ var translate = {
|
|
|
2922
2970
|
将翻译请求的信息记录到 translate.js 本身中
|
|
2923
2971
|
uuid 每次 translate.execute() 触发生成的uuid
|
|
2924
2972
|
time: 触发后加入到 data 中的时间,13位时间戳
|
|
2973
|
+
list: 记录当前uuid下发起的网络请求
|
|
2974
|
+
from: 从什么语种进行的翻译，如： chinese_simplified
|
|
2975
|
+
to: 翻译为什么语种，如 ： english
|
|
2976
|
+
nodes: 当前网络请求有哪些node节点，值为 [node1, node2, ...]
|
|
2977
|
+
texts: 当前网络请求有哪些文本进行翻译，值为 [text1, text2, ...]
|
|
2925
2978
|
|
|
2926
2979
|
*/
|
|
2927
2980
|
translate.request.data[uuid] = {
|
|
@@ -2941,9 +2994,9 @@ var translate = {
|
|
|
2941
2994
|
}
|
|
2942
2995
|
|
|
2943
2996
|
if(typeof(translateTextArray[lang]) == 'undefined' || translateTextArray[lang].length < 1){
|
|
2944
|
-
|
|
2945
|
-
|
|
2946
|
-
|
|
2997
|
+
translate.log('异常,理论上不应该存在, lang:'+lang+', translateTextArray:');
|
|
2998
|
+
translate.log(translateTextArray);
|
|
2999
|
+
translate.log('你无需担心，这个只是个提示，它并不影响你翻译的正常进行，只是个异常提示而已，它会自动容错处理的，不会影响翻译的使用。');
|
|
2947
3000
|
|
|
2948
3001
|
translate.state = 0;
|
|
2949
3002
|
translate.executeNumber++;
|
|
@@ -2992,8 +3045,10 @@ var translate = {
|
|
|
2992
3045
|
});
|
|
2993
3046
|
|
|
2994
3047
|
//记入请求日志
|
|
2995
|
-
translate.request.data[uuid].list[lang]
|
|
2996
|
-
|
|
3048
|
+
if(typeof(translate.request.data[uuid].list[lang]) === 'undefined'){
|
|
3049
|
+
translate.request.data[uuid].list[lang] = {};
|
|
3050
|
+
}
|
|
3051
|
+
translate.request.data[uuid].list[lang][translate.to] = {
|
|
2997
3052
|
texts: translateTextArray[lang],
|
|
2998
3053
|
nodes: translateTextNodes,
|
|
2999
3054
|
};
|
|
@@ -3019,7 +3074,7 @@ var translate = {
|
|
|
3019
3074
|
translate.translateRequest[uuid][data.from].executeFinish = 1; //1是执行完毕
|
|
3020
3075
|
translate.translateRequest[uuid][data.from].stoptime = Math.floor(Date.now() / 1000);
|
|
3021
3076
|
}else{
|
|
3022
|
-
|
|
3077
|
+
translate.log('WARINNG!!! translate.translateRequest[uuid][data.from] is not object');
|
|
3023
3078
|
}
|
|
3024
3079
|
|
|
3025
3080
|
//为了兼容 v3.14以前的translate.service 版本，做了判断
|
|
@@ -3036,17 +3091,17 @@ var translate = {
|
|
|
3036
3091
|
translate.waitingExecute.isAllExecuteFinish(uuid, from, to, 0, data.info);
|
|
3037
3092
|
|
|
3038
3093
|
|
|
3039
|
-
|
|
3040
|
-
|
|
3094
|
+
translate.log('=======ERROR START=======');
|
|
3095
|
+
translate.log(translateTextArray[data.from]);
|
|
3041
3096
|
//console.log(encodeURIComponent(JSON.stringify(translateTextArray[data.from])));
|
|
3042
|
-
|
|
3043
|
-
|
|
3097
|
+
translate.log('response : '+data.info);
|
|
3098
|
+
translate.log('=======ERROR END =======');
|
|
3044
3099
|
//translate.temp_executeFinishNumber++; //记录执行完的次数
|
|
3045
3100
|
return;
|
|
3046
3101
|
}
|
|
3047
3102
|
|
|
3048
3103
|
if(typeof(translate.nodeQueue[uuid]) == 'undefined'){
|
|
3049
|
-
|
|
3104
|
+
translate.log('提示：你很可能多次引入了 translate.js 所以造成了翻译本身的数据错乱，这只是个提示，它还是会给你正常翻译的，但是你最好不要重复引入太多次 translate.js ，正常情况下只需要引入一次 translate.js 就可以了。太多的话很可能会导致你页面卡顿');
|
|
3050
3105
|
return;
|
|
3051
3106
|
}
|
|
3052
3107
|
|
|
@@ -3086,8 +3141,8 @@ var translate = {
|
|
|
3086
3141
|
originalWord = translate.nodeQueue[uuid]['list'][lang][hash]['original'];
|
|
3087
3142
|
//console.log('bef:'+translate.nodeQueue[uuid]['list'][lang][hash]['beforeText']);
|
|
3088
3143
|
}catch(e){
|
|
3089
|
-
|
|
3090
|
-
|
|
3144
|
+
translate.log('uuid:'+uuid+', originalWord:'+originalWord+', lang:'+lang+', hash:'+hash+', text:'+text+', queue:'+translate.nodeQueue[uuid]);
|
|
3145
|
+
translate.log(e);
|
|
3091
3146
|
continue;
|
|
3092
3147
|
}
|
|
3093
3148
|
|
|
@@ -3187,7 +3242,7 @@ var translate = {
|
|
|
3187
3242
|
将已扫描的节点进行记录，这里是只要进行扫描到了，也就是在加入 translate.nodeQueue 时就也要加入到这里。
|
|
3188
3243
|
这是一个map，为了兼容es5，这里设置为null，在 translate.execute 中在进行初始化
|
|
3189
3244
|
|
|
3190
|
-
key: node
|
|
3245
|
+
key: node ,进行翻译的文本的node， 如果是 div 的 title属性进行的翻译，那这个node是定位在 title 上的node，而不是 div 这个依附的元素
|
|
3191
3246
|
value: 这是一个对像
|
|
3192
3247
|
其中，key的取值有这几种：
|
|
3193
3248
|
translate_default_value: 如果当前翻译的是元素本身的值或node节点本身的值(nodeValue)，那么这里的key就是固定的 translate_default_value
|
|
@@ -3240,7 +3295,7 @@ var translate = {
|
|
|
3240
3295
|
key: translate.node 中 translate.node.get(node)[attribute] 所使用的 attribute 的字符串，如 attribute_title 、translate_default_value
|
|
3241
3296
|
attribute: 这里是attribute具体的内容，比如 key 是 attribute_title 那么这里就是 title , key 是 translate_default_value 这里就是 '' 空字符串
|
|
3242
3297
|
}
|
|
3243
|
-
|
|
3298
|
+
|
|
3244
3299
|
getAttribute:function(attribute){
|
|
3245
3300
|
var history_attribute;
|
|
3246
3301
|
if(typeof(attribute) != 'undefined' && attribute.length > 0){
|
|
@@ -3256,6 +3311,7 @@ var translate = {
|
|
|
3256
3311
|
attribute:attribute
|
|
3257
3312
|
}
|
|
3258
3313
|
},
|
|
3314
|
+
*/
|
|
3259
3315
|
/*
|
|
3260
3316
|
刷新 translate.node.data 中的数据，剔除过时的（node已经不存在于dom的）
|
|
3261
3317
|
*/
|
|
@@ -3354,6 +3410,147 @@ var translate = {
|
|
|
3354
3410
|
get:function(node, attribute){
|
|
3355
3411
|
return translate.element.nodeAnalyse.analyse(node,'','', attribute);
|
|
3356
3412
|
},
|
|
3413
|
+
/*
|
|
3414
|
+
同上，只不过这个是扫描 element/node 下的所有可翻译的子节点（下层节点），返回数组形态。
|
|
3415
|
+
这里面的数组，已经经过判断， text 必然是有不为空的值的。
|
|
3416
|
+
所以它的返回值，有可能是一个空的数组
|
|
3417
|
+
|
|
3418
|
+
[
|
|
3419
|
+
{
|
|
3420
|
+
node: 当前扫描出的node （传入的node、或下层node）
|
|
3421
|
+
attribute: 是否是下层属性，比如 alt、placeholder , 如果是传入的node本身，不是任何下层属性，则这里是空白字符串 ''
|
|
3422
|
+
text: 可进行翻译的文本，也就是当前数组中 node 的值的文本
|
|
3423
|
+
},
|
|
3424
|
+
...
|
|
3425
|
+
]
|
|
3426
|
+
*/
|
|
3427
|
+
gets:function(node){
|
|
3428
|
+
var resultArray = [];
|
|
3429
|
+
|
|
3430
|
+
var nodename = translate.element.getNodeName(node).toUpperCase();
|
|
3431
|
+
switch (nodename) {
|
|
3432
|
+
case 'META': //meta标签，如是关键词、描述等
|
|
3433
|
+
var nodeAttributeName = node.name.toLowerCase(); //取meta 标签的name 属性
|
|
3434
|
+
var nodeAttributePropertyOri = node.getAttribute('property'); //取 property的值
|
|
3435
|
+
var nodeAttributeProperty = '';
|
|
3436
|
+
if(typeof(nodeAttributePropertyOri) === 'string' && nodeAttributePropertyOri.length > 0){
|
|
3437
|
+
nodeAttributeProperty = nodeAttributePropertyOri.toLowerCase();
|
|
3438
|
+
}
|
|
3439
|
+
|
|
3440
|
+
if(nodeAttributeName == 'keywords' || nodeAttributeName == 'description' || nodeAttributeName == 'sharetitle' || nodeAttributeProperty == 'og:title' || nodeAttributeProperty == 'og:description' || nodeAttributeProperty == 'og:site_name' || nodeAttributeProperty == 'og:novel:latest_chapter_name'){
|
|
3441
|
+
if(typeof(node.content) === 'string' && node.content.trim().length > 0){
|
|
3442
|
+
resultArray.push({
|
|
3443
|
+
text: node.content,
|
|
3444
|
+
attribute: 'content',
|
|
3445
|
+
node: node.getAttributeNode('content')
|
|
3446
|
+
});
|
|
3447
|
+
}
|
|
3448
|
+
}
|
|
3449
|
+
break;
|
|
3450
|
+
case 'IMG':
|
|
3451
|
+
if(typeof(node.alt) === 'string' && node.alt.trim().length > 0){
|
|
3452
|
+
resultArray.push({
|
|
3453
|
+
text: node.alt,
|
|
3454
|
+
attribute: 'alt',
|
|
3455
|
+
node: node.getAttributeNode('alt')
|
|
3456
|
+
});
|
|
3457
|
+
}
|
|
3458
|
+
break;
|
|
3459
|
+
case 'INPUT':
|
|
3460
|
+
/*
|
|
3461
|
+
input，要对以下情况进行翻译
|
|
3462
|
+
placeholder
|
|
3463
|
+
type=button、submit 的情况下的 value
|
|
3464
|
+
*/
|
|
3465
|
+
|
|
3466
|
+
//针对 type=button、submit 的情况下的 value
|
|
3467
|
+
if(typeof(node.attributes.type) !== 'undefined' && node.attributes.type !== null && typeof(node.attributes.type.nodeValue) === 'string' && (node.attributes.type.nodeValue.toLowerCase() == 'button' || node.attributes.type.nodeValue.toLowerCase() == 'submit')){
|
|
3468
|
+
//取它的value
|
|
3469
|
+
var input_value_node = node.attributes.value;
|
|
3470
|
+
if(typeof(input_value_node) !== 'undefined' && input_value_node !== null && typeof(input_value_node.nodeValue) === 'string' && input_value_node.nodeValue.trim().length > 0){
|
|
3471
|
+
resultArray.push({
|
|
3472
|
+
text: input_value_node.nodeValue,
|
|
3473
|
+
attribute: 'value',
|
|
3474
|
+
node: input_value_node
|
|
3475
|
+
});
|
|
3476
|
+
}
|
|
3477
|
+
}
|
|
3478
|
+
|
|
3479
|
+
//针对 placeholder
|
|
3480
|
+
if(typeof(node.attributes['placeholder']) !== 'undefined' && typeof(node.attributes['placeholder'].nodeValue) === 'string' && node.attributes['placeholder'].nodeValue.trim().length > 0){
|
|
3481
|
+
resultArray.push({
|
|
3482
|
+
text: node.attributes['placeholder'].nodeValue,
|
|
3483
|
+
attribute: 'placeholder',
|
|
3484
|
+
node: node.attributes['placeholder']
|
|
3485
|
+
});
|
|
3486
|
+
}
|
|
3487
|
+
break;
|
|
3488
|
+
case 'TEXTAREA':
|
|
3489
|
+
//针对 placeholder
|
|
3490
|
+
if(typeof(node.attributes['placeholder']) !== 'undefined' && typeof(node.attributes['placeholder'].nodeValue) === 'string' && node.attributes['placeholder'].nodeValue.trim().length > 0){
|
|
3491
|
+
resultArray.push({
|
|
3492
|
+
text: node.attributes['placeholder'].nodeValue,
|
|
3493
|
+
attribute: 'placeholder',
|
|
3494
|
+
node: node.attributes['placeholder']
|
|
3495
|
+
});
|
|
3496
|
+
}
|
|
3497
|
+
break;
|
|
3498
|
+
}
|
|
3499
|
+
|
|
3500
|
+
//判断是否是 translate.element.tagAttribute 自定义翻译属性的
|
|
3501
|
+
var divTagAttribute = translate.element.tagAttribute[nodename.toLowerCase()];
|
|
3502
|
+
if(typeof(divTagAttribute) !== 'undefined'){
|
|
3503
|
+
//有这个标签的自定义翻译某个属性
|
|
3504
|
+
for(var ai = 0; ai<node.attributes.length; ai++){
|
|
3505
|
+
var arrtibuteNodeName = translate.element.getNodeName(node.attributes[ai]).toLowerCase();
|
|
3506
|
+
if(divTagAttribute.attribute.indexOf(arrtibuteNodeName) > -1 && divTagAttribute.condition(node)){
|
|
3507
|
+
//包含这个属性，且自定义判断条件满足，允许翻译
|
|
3508
|
+
//判定一下是否已经加入过了，如果没有加入过，才会加入。这里主要是针对input 标签进行判断，比如 input type="submit" 的，value值如果也被用户自定义翻译，那上面的value就已经加上了，不需要在加了
|
|
3509
|
+
var isAlreadyAdd = false; //true已经加入过了
|
|
3510
|
+
for(var ri = 0; ri < resultArray.length; ri++){
|
|
3511
|
+
if(resultArray[ri].node === node.attributes[ai]){
|
|
3512
|
+
//相同，则不在加入了
|
|
3513
|
+
isAlreadyAdd = true;
|
|
3514
|
+
}
|
|
3515
|
+
}
|
|
3516
|
+
if(!isAlreadyAdd){
|
|
3517
|
+
resultArray.push({
|
|
3518
|
+
text: node.attributes[ai].nodeValue,
|
|
3519
|
+
attribute: arrtibuteNodeName,
|
|
3520
|
+
node: node.attributes[ai]
|
|
3521
|
+
});
|
|
3522
|
+
}
|
|
3523
|
+
}
|
|
3524
|
+
}
|
|
3525
|
+
}else{
|
|
3526
|
+
//条件不满足，不在翻译的属性范围
|
|
3527
|
+
}
|
|
3528
|
+
|
|
3529
|
+
|
|
3530
|
+
//所有元素都要判定的属性 - title 属性
|
|
3531
|
+
if(typeof(node['title']) === 'string' && node['title'].trim().length > 0){
|
|
3532
|
+
var titleNode = node.getAttributeNode('title');
|
|
3533
|
+
resultArray.push({
|
|
3534
|
+
text: titleNode.nodeValue,
|
|
3535
|
+
attribute: 'title',
|
|
3536
|
+
node: titleNode
|
|
3537
|
+
});
|
|
3538
|
+
}
|
|
3539
|
+
|
|
3540
|
+
|
|
3541
|
+
//最后判定 node 本身
|
|
3542
|
+
if(typeof(node.nodeValue) === 'string' && node.nodeValue.trim().length > 0){
|
|
3543
|
+
//返回传入的node本身
|
|
3544
|
+
resultArray.push({
|
|
3545
|
+
text: node.nodeValue,
|
|
3546
|
+
attribute: '',
|
|
3547
|
+
node: node
|
|
3548
|
+
});
|
|
3549
|
+
}
|
|
3550
|
+
|
|
3551
|
+
|
|
3552
|
+
return resultArray;
|
|
3553
|
+
},
|
|
3357
3554
|
/*
|
|
3358
3555
|
进行翻译之后的渲染显示
|
|
3359
3556
|
注意，它会对node本身进行扫描的，需要进行通过文本翻译接口进行翻译的文本进行识别，比如 这个 node 其内容为：
|
|
@@ -3461,6 +3658,7 @@ var translate = {
|
|
|
3461
3658
|
|
|
3462
3659
|
//正常的node ，typeof 都是 object
|
|
3463
3660
|
|
|
3661
|
+
/* 这里是通用方法，不应该有限制
|
|
3464
3662
|
//console.log(typeof(node)+node);
|
|
3465
3663
|
if(nodename == '#text'){
|
|
3466
3664
|
//如果是普通文本，判断一下上层是否是包含在textarea标签中
|
|
@@ -3474,7 +3672,7 @@ var translate = {
|
|
|
3474
3672
|
}
|
|
3475
3673
|
}
|
|
3476
3674
|
}
|
|
3477
|
-
|
|
3675
|
+
*/
|
|
3478
3676
|
|
|
3479
3677
|
|
|
3480
3678
|
//console.log(nodename)
|
|
@@ -3633,11 +3831,23 @@ var translate = {
|
|
|
3633
3831
|
resultShowText: translate.element.nodeAnalyse.analyse 进行设置翻译后的文本渲染时，提前计算好这个node显示的所有文本，然后在赋予 dom，这里是计算好的node要整体显示的文本
|
|
3634
3832
|
*/
|
|
3635
3833
|
analyseReplaceBefore_DateToTranslateNode:function(node, attribute, resultShowText){
|
|
3636
|
-
|
|
3637
|
-
|
|
3638
|
-
|
|
3834
|
+
var translateNode; //当前操作的，要记录入 translate.node 中的，进行翻译的node
|
|
3835
|
+
var translateNode_attribute = ''; //当前操作的是node中的哪个attribute，如果没有是node本身则是空字符串
|
|
3836
|
+
|
|
3837
|
+
if(typeof(attribute) === 'string' && attribute.length > 0){
|
|
3838
|
+
//是操作的元素的某个属性
|
|
3839
|
+
translateNode = node.getAttributeNode(attribute);
|
|
3840
|
+
translateNode_attribute = attribute;
|
|
3841
|
+
}else{
|
|
3842
|
+
//操作的就是node本身
|
|
3843
|
+
translateNode = node;
|
|
3844
|
+
}
|
|
3845
|
+
|
|
3846
|
+
if(translate.node.find(translateNode)){
|
|
3847
|
+
if(typeof(translate.node.get(translateNode).translateResults) == 'undefined'){
|
|
3848
|
+
translate.node.get(translateNode).translateResults = {};
|
|
3639
3849
|
}
|
|
3640
|
-
translate.node.get(
|
|
3850
|
+
translate.node.get(translateNode).translateResults[resultShowText] = 1;
|
|
3641
3851
|
}else{
|
|
3642
3852
|
//翻译过程中，会有时间差，比如通过文本翻译api请求，这时node元素本身被其他js改变了，导致翻译完成后，原本的node不存在了
|
|
3643
3853
|
//console.log('[debug] 数据异常，analyse - set 中发现 translate.node 中的 node 不存在，理论上应该只要被扫描了，被翻译了，到这里就一定会存在的，不存在怎么会扫描到交给去翻译呢');
|
|
@@ -3661,8 +3871,8 @@ var translate = {
|
|
|
3661
3871
|
if(typeof(node.tagName) == 'string' && node.tagName.length > 0){
|
|
3662
3872
|
return node.tagName;
|
|
3663
3873
|
}else{
|
|
3664
|
-
|
|
3665
|
-
|
|
3874
|
+
translate.log('warn : get nodeName is null, this node ignore translate. node : ');
|
|
3875
|
+
translate.log(node);
|
|
3666
3876
|
return '';
|
|
3667
3877
|
}
|
|
3668
3878
|
}
|
|
@@ -3684,7 +3894,7 @@ var translate = {
|
|
|
3684
3894
|
|
|
3685
3895
|
//console.log('---'+typeof(node)+', ');
|
|
3686
3896
|
//判断是否是有title属性，title属性也要翻译
|
|
3687
|
-
if(typeof(node) == 'object' && typeof(node['title']) == 'string' && node['title'].length > 0){
|
|
3897
|
+
if(typeof(node) == 'object' && typeof(node['title']) == 'string' && node['title'].trim().length > 0){
|
|
3688
3898
|
//将title加入翻译队列
|
|
3689
3899
|
//console.log('---'+node.title+'\t'+node.tagName);
|
|
3690
3900
|
//console.log(node)
|
|
@@ -3693,7 +3903,8 @@ var translate = {
|
|
|
3693
3903
|
//判断当前元素是否在ignore忽略的tag、id、class name中
|
|
3694
3904
|
if(!translate.ignore.isIgnore(node)){
|
|
3695
3905
|
//不在忽略的里面，才会加入翻译
|
|
3696
|
-
translate.addNodeToQueue(uuid, node, node['title'], 'title');
|
|
3906
|
+
//translate.addNodeToQueue(uuid, node, node['title'], 'title');
|
|
3907
|
+
translate.addNodeToQueue(uuid, node.getAttributeNode('title'), node['title'], '');
|
|
3697
3908
|
}
|
|
3698
3909
|
}
|
|
3699
3910
|
|
|
@@ -3747,7 +3958,7 @@ var translate = {
|
|
|
3747
3958
|
//判断当前元素是否在ignore忽略的tag、id、class name中 v3.15.7 增加
|
|
3748
3959
|
if(!translate.ignore.isIgnore(node)){
|
|
3749
3960
|
//加入翻译
|
|
3750
|
-
translate.addNodeToQueue(uuid, node, attributeValue,
|
|
3961
|
+
translate.addNodeToQueue(uuid, node.getAttributeNode(attributeName), attributeValue, '');
|
|
3751
3962
|
}
|
|
3752
3963
|
}
|
|
3753
3964
|
}
|
|
@@ -3770,22 +3981,16 @@ var translate = {
|
|
|
3770
3981
|
if(node == null || typeof(node) == 'undefined'){
|
|
3771
3982
|
return;
|
|
3772
3983
|
}
|
|
3773
|
-
if(node.
|
|
3774
|
-
|
|
3775
|
-
|
|
3776
|
-
|
|
3777
|
-
|
|
3778
|
-
|
|
3779
|
-
|
|
3780
|
-
|
|
3781
|
-
return;
|
|
3782
|
-
}
|
|
3783
|
-
if(translate.ignore.tag.indexOf(parentNodeName.toLowerCase()) > -1){
|
|
3784
|
-
//忽略tag
|
|
3785
|
-
//console.log('忽略tag：'+parentNodeName);
|
|
3786
|
-
return;
|
|
3984
|
+
if(node.nodeType === 2){ //是属性node，比如 div 的 title 属性的 node
|
|
3985
|
+
if(node.ownerElement == null){
|
|
3986
|
+
return;
|
|
3987
|
+
}
|
|
3988
|
+
}else{ //是元素了
|
|
3989
|
+
if(node.parentNode == null){
|
|
3990
|
+
return;
|
|
3991
|
+
}
|
|
3787
3992
|
}
|
|
3788
|
-
|
|
3993
|
+
|
|
3789
3994
|
/****** 判断忽略的class ******/
|
|
3790
3995
|
/*
|
|
3791
3996
|
这段理论上不需要了，因为在 translate.ignore.isIgnore 判断了
|
|
@@ -3819,13 +4024,21 @@ var translate = {
|
|
|
3819
4024
|
return;
|
|
3820
4025
|
}
|
|
3821
4026
|
|
|
3822
|
-
//node
|
|
4027
|
+
//node分析，分析这个node的所有可翻译属性（包含自定义翻译属性 translate.element.tagAttribute ）
|
|
4028
|
+
var nodeAnalyChild = translate.element.nodeAnalyse.gets(node);
|
|
4029
|
+
//console.log(nodeAnalyChild);
|
|
4030
|
+
for(var nci = 0; nci < nodeAnalyChild.length; nci++){
|
|
4031
|
+
translate.addNodeToQueue(uuid, nodeAnalyChild[nci].node, nodeAnalyChild[nci].text, '');
|
|
4032
|
+
}
|
|
4033
|
+
/*
|
|
3823
4034
|
var nodeAnaly = translate.element.nodeAnalyse.get(node);
|
|
3824
4035
|
if(nodeAnaly['text'].length > 0){
|
|
3825
4036
|
//有要翻译的目标内容，加入翻译队列
|
|
3826
|
-
|
|
3827
|
-
|
|
4037
|
+
console.log(nodeAnaly)
|
|
4038
|
+
console.log('addNodeToQueue -- '+nodeAnaly['node']+', text:' + nodeAnaly['text']);
|
|
4039
|
+
translate.addNodeToQueue(uuid, nodeAnaly['node'], nodeAnaly['text'], '');
|
|
3828
4040
|
}
|
|
4041
|
+
*/
|
|
3829
4042
|
|
|
3830
4043
|
//console.log(nodeAnaly);
|
|
3831
4044
|
/*
|
|
@@ -3886,6 +4099,56 @@ var translate = {
|
|
|
3886
4099
|
*/
|
|
3887
4100
|
|
|
3888
4101
|
},
|
|
4102
|
+
/*
|
|
4103
|
+
将node转为element输出。
|
|
4104
|
+
如果node是文本元素，则转化为这个文本元素所在的element元素
|
|
4105
|
+
如果node是属性，则转化为这个属性所在的element元素
|
|
4106
|
+
如果node本身就是元素标签，那就还是这样返回。
|
|
4107
|
+
|
|
4108
|
+
|
|
4109
|
+
nodes: node数组，传入如 [node1,node2, ...] 它里面可能包含 node.nodeType 1\2\3 等值
|
|
4110
|
+
|
|
4111
|
+
返回这些node转化为所在元素后的数组，返回如 [element1, element2, ...]
|
|
4112
|
+
注意的是
|
|
4113
|
+
1. 输出的一定是 element 元素，也就是 node.nodeType 一定等于1
|
|
4114
|
+
2. 输出的元素数组不一定等于传入的nodes数组，也就是他们的数量跟下标并不是对应相等的
|
|
4115
|
+
|
|
4116
|
+
*/
|
|
4117
|
+
nodeToElement: function(nodes){
|
|
4118
|
+
var elements = new Array(); //要改动的元素
|
|
4119
|
+
|
|
4120
|
+
//遍历所有node组合到 nodes. 这个不单纯只是遍历组合，它会判断如果是文本节点，则取它的父级元素。它组合的结果是元素的集合
|
|
4121
|
+
for(var r = 0; r<nodes.length; r++){
|
|
4122
|
+
var node = nodes[r];
|
|
4123
|
+
if(typeof(node) == 'undefined' || typeof(node.parentNode) == 'undefined'){
|
|
4124
|
+
continue;
|
|
4125
|
+
}
|
|
4126
|
+
if(node.nodeType === 2){
|
|
4127
|
+
//是属性节点，可能是input、textarea 的 placeholder ，获取它的父元素
|
|
4128
|
+
var nodeParentElement = node.ownerElement;
|
|
4129
|
+
if(nodeParentElement == null){
|
|
4130
|
+
continue;
|
|
4131
|
+
}
|
|
4132
|
+
elements.push(nodeParentElement);
|
|
4133
|
+
}else if(node.nodeType === 3){
|
|
4134
|
+
//是文本节点
|
|
4135
|
+
var nodeParentElement = node.parentNode;
|
|
4136
|
+
if(nodeParentElement == null){
|
|
4137
|
+
continue;
|
|
4138
|
+
}
|
|
4139
|
+
elements.push(nodeParentElement);
|
|
4140
|
+
}else if(node.nodeType === 1){
|
|
4141
|
+
//元素节点了，直接加入
|
|
4142
|
+
elements.push(node);
|
|
4143
|
+
}else{
|
|
4144
|
+
//1\2\3 都不是，这不应该是 translate.js 中应该出现的
|
|
4145
|
+
translate.log('translate.element.nodeToElement 中，发现传入的node.nodeType 类型有异常，理论上不应该存在， node.nodeType:'+node.nodeType);
|
|
4146
|
+
translate.log(node);
|
|
4147
|
+
}
|
|
4148
|
+
}
|
|
4149
|
+
|
|
4150
|
+
return elements;
|
|
4151
|
+
}
|
|
3889
4152
|
},
|
|
3890
4153
|
|
|
3891
4154
|
|
|
@@ -3951,27 +4214,34 @@ var translate = {
|
|
|
3951
4214
|
|
|
3952
4215
|
|
|
3953
4216
|
/***** 记录这个node 到 translate.node.data，这也是node进入 translate.node.data 记录的第一入口 *****/
|
|
3954
|
-
|
|
3955
|
-
|
|
4217
|
+
var translateNode; //当前操作的，要记录入 translate.node 中的，进行翻译的node
|
|
4218
|
+
var translateNode_attribute = ''; //当前操作的是node中的哪个attribute，如果没有是node本身则是空字符串
|
|
4219
|
+
if(typeof(attribute) === 'string' && attribute.length > 0){
|
|
4220
|
+
//是操作的元素的某个属性
|
|
4221
|
+
translateNode = node.getAttributeNode(attribute);
|
|
4222
|
+
translateNode_attribute = attribute;
|
|
4223
|
+
}else{
|
|
4224
|
+
//操作的就是node本身
|
|
4225
|
+
translateNode = node;
|
|
3956
4226
|
}
|
|
3957
|
-
|
|
3958
|
-
|
|
3959
|
-
|
|
4227
|
+
if(translate.node.get(translateNode) == null){
|
|
4228
|
+
translate.node.set(translateNode, {});
|
|
4229
|
+
}
|
|
4230
|
+
|
|
4231
|
+
//var nodeAttribute = translate.node.getAttribute(attribute);
|
|
3960
4232
|
//console.log(text+'-----:');
|
|
3961
4233
|
//console.log(nodeAttribute);
|
|
3962
|
-
if(typeof(translate.node.get(
|
|
3963
|
-
|
|
3964
|
-
|
|
3965
|
-
|
|
3966
|
-
translate.node.get(
|
|
3967
|
-
if(typeof(translate.node.get(node)[nodeAttribute.key].originalText) == 'string'){
|
|
4234
|
+
//if(typeof(translate.node.get(translateNode)[nodeAttribute.key]) == 'undefined'){
|
|
4235
|
+
// translate.node.get(node)[nodeAttribute.key] = {};
|
|
4236
|
+
//}
|
|
4237
|
+
translate.node.get(translateNode).attribute = translateNode_attribute;
|
|
4238
|
+
if(typeof(translate.node.get(translateNode).originalText) === 'string'){
|
|
3968
4239
|
//这个节点有过记录原始显示的文本了，那么不再对其进行后续的扫描，除非它有被触发过动态监听元素改变， --- 至于它有被触发过动态监听元素改变--后续想怎么判定
|
|
3969
4240
|
//console.log(translate.node.get(node)[nodeAttribute.key].originalText+'\t又过了，不在翻译');
|
|
3970
4241
|
return;
|
|
3971
4242
|
}else{
|
|
3972
4243
|
//没有过，是第一次，那么赋予值
|
|
3973
|
-
translate.node.get(
|
|
3974
|
-
//console.log(translate.node.get(node));
|
|
4244
|
+
translate.node.get(translateNode).originalText = text;
|
|
3975
4245
|
}
|
|
3976
4246
|
//console.log(translate.node.get(node)[nodeAttribute.key]);
|
|
3977
4247
|
/*
|
|
@@ -4001,13 +4271,12 @@ var translate = {
|
|
|
4001
4271
|
return;
|
|
4002
4272
|
}
|
|
4003
4273
|
*/
|
|
4004
|
-
if(typeof(translate.node.get(
|
|
4005
|
-
translate.node.get(
|
|
4274
|
+
if(typeof(translate.node.get(translateNode).translateTexts) === 'undefined'){
|
|
4275
|
+
translate.node.get(translateNode).translateTexts = {};
|
|
4006
4276
|
}
|
|
4007
4277
|
/***** 自检完毕，准备进行翻译了 *****/
|
|
4008
4278
|
|
|
4009
4279
|
|
|
4010
|
-
|
|
4011
4280
|
//原本传入的text会被切割为多个小块
|
|
4012
4281
|
var textArray = new Array();
|
|
4013
4282
|
textArray.push(text); //先将主 text 赋予 ，后面如果对主text进行加工分割，分割后会将主text给删除掉
|
|
@@ -4047,8 +4316,8 @@ var translate = {
|
|
|
4047
4316
|
|
|
4048
4317
|
//console.log(textArray);
|
|
4049
4318
|
textArray = translate.nomenclature.dispose(textArray, temporaryIgnoreTexts[ti], temporaryIgnoreTexts[ti], {
|
|
4050
|
-
node:
|
|
4051
|
-
attribute:
|
|
4319
|
+
node:translateNode,
|
|
4320
|
+
attribute:''
|
|
4052
4321
|
}).texts;
|
|
4053
4322
|
//console.log(textArray);
|
|
4054
4323
|
}
|
|
@@ -4076,8 +4345,8 @@ var translate = {
|
|
|
4076
4345
|
//console.log('----translate.nomenclature.dispose---');
|
|
4077
4346
|
//console.log(textArray);
|
|
4078
4347
|
var nomenclatureDispose = translate.nomenclature.dispose(textArray, nomenclatureKey, nomenclatureValue, {
|
|
4079
|
-
node:
|
|
4080
|
-
attribute:
|
|
4348
|
+
node:translateNode,
|
|
4349
|
+
attribute:''
|
|
4081
4350
|
});
|
|
4082
4351
|
|
|
4083
4352
|
textArray = nomenclatureDispose.texts;
|
|
@@ -4101,10 +4370,10 @@ var translate = {
|
|
|
4101
4370
|
|
|
4102
4371
|
//记录 nodeHistory - 判断text是否已经被拆分了
|
|
4103
4372
|
if(textArray.length > 0 && textArray[0] != text){ //主要是后面的是否相等，前面的>0只是避免代码报错
|
|
4104
|
-
translate.node.get(
|
|
4373
|
+
translate.node.get(translateNode).whole = false; //已经被拆分了，不是整体翻译了
|
|
4105
4374
|
//这时，也默认给其赋值操作，将自定义术语匹配后的结果进行赋予
|
|
4106
4375
|
}else{
|
|
4107
|
-
translate.node.get(
|
|
4376
|
+
translate.node.get(translateNode).whole = true; //未拆分，是整体翻译
|
|
4108
4377
|
}
|
|
4109
4378
|
//成功加入到 nodeQueue 的对象。 如果长度为0，那就是还没有加入到 translate.nodeQueue 中，可能全被自定义术语命中了
|
|
4110
4379
|
var addQueueObjectArray = [];
|
|
@@ -4145,14 +4414,14 @@ var translate = {
|
|
|
4145
4414
|
// translate.node 记录
|
|
4146
4415
|
|
|
4147
4416
|
// 记录当前有 translate.js 所触发翻译之后渲染到dom界面显示的时间，13位时间戳
|
|
4148
|
-
translate.node.get(
|
|
4417
|
+
translate.node.get(translateNode).lastTranslateRenderTime = Date.now();
|
|
4149
4418
|
//将具体通过文本翻译接口进行翻译的文本记录到 translate.node.data
|
|
4150
|
-
translate.node.get(
|
|
4419
|
+
translate.node.get(translateNode).translateTexts = {}; //这里全部命中了，所以根本没有走翻译接口的文本
|
|
4151
4420
|
//将翻译完成后要显示出的文本进行记录
|
|
4152
|
-
translate.node.get(
|
|
4421
|
+
translate.node.get(translateNode).resultText = translate.element.nodeAnalyse.get(node, attribute).text; //直接获取当前node显示出来的文本作为最后的结果的文本
|
|
4153
4422
|
|
|
4154
4423
|
//将其加入 translate.history.translateTexts 中
|
|
4155
|
-
translate.history.translateText.add(translate.node.get(
|
|
4424
|
+
translate.history.translateText.add(translate.node.get(translateNode).originalText, translate.node.get(translateNode).resultText);
|
|
4156
4425
|
}
|
|
4157
4426
|
|
|
4158
4427
|
},
|
|
@@ -4422,11 +4691,11 @@ var translate = {
|
|
|
4422
4691
|
if(translate.whole.class.length == 0 && translate.whole.tag.length == 0 && translate.whole.id.length == 0){
|
|
4423
4692
|
|
|
4424
4693
|
}else{
|
|
4425
|
-
|
|
4694
|
+
translate.log('您开启了 translate.whole 此次行为避开了浏览器端的文本语种自动识别，而是暴力的直接对某个元素的整个文本进行翻译，很可能会产生非常大的翻译量，请谨慎！有关每日翻译字符的说明，可参考： http://translate.zvo.cn/42557.html ');
|
|
4426
4695
|
}
|
|
4427
4696
|
|
|
4428
4697
|
if(translate.whole.tag.indexOf('html') > -1){
|
|
4429
|
-
|
|
4698
|
+
translate.log('自检发现您设置了 translate.whole.tag 其中有 html ，这个是不生效的，最大只允许设置到 body ');
|
|
4430
4699
|
}
|
|
4431
4700
|
},
|
|
4432
4701
|
|
|
@@ -4690,10 +4959,10 @@ var translate = {
|
|
|
4690
4959
|
clearCacheLanguage:function(){
|
|
4691
4960
|
if(typeof(translate.language.setUrlParamControl_use) != 'undefined'){
|
|
4692
4961
|
if(translate.language.setUrlParamControl_use){
|
|
4693
|
-
|
|
4694
|
-
|
|
4695
|
-
|
|
4696
|
-
|
|
4962
|
+
translate.log('使用提示：')
|
|
4963
|
+
translate.log('translate.language.setUrlParamControl(...) 的作用是 可以通过URL传一个语种，来指定当前页面以什么语种显示。 参考文档： http://translate.zvo.cn/4075.html');
|
|
4964
|
+
translate.log('translate.language.clearCacheLanguage() 是清除历史翻译语种缓存，也就是清除之前指定翻译为什么语种。 参考文档：http://translate.zvo.cn/4080.html')
|
|
4965
|
+
translate.log('如果你执行了 translate.language.setUrlParamControl(...) 那么是要根据url传参来切换语种的，但是后面又出现了 translate.language.clearCacheLanguage() 它会阻止 translate.language.setUrlParamControl(...) 它的设置，即使有url传递翻译为什么语言，也会因为 translate.language.clearCacheLanguage() 给清除掉，使URL传参的语种不起任何作用。')
|
|
4697
4966
|
}
|
|
4698
4967
|
}
|
|
4699
4968
|
translate.to = '';
|
|
@@ -4995,7 +5264,7 @@ var translate = {
|
|
|
4995
5264
|
|
|
4996
5265
|
var romanceSentenceLanguage = translate.language.romanceSentenceAnaly(str);
|
|
4997
5266
|
if(romanceSentenceLanguage.length == 0){
|
|
4998
|
-
|
|
5267
|
+
translate.log('语种识别异常，应该是 法语、西班牙语、葡萄牙语、意大利语 中的一种才是，除非是除了这四种语种之外的别的 罗曼语族 中的语种，当前已将 '+ str +'识别为英语。 你可以联系我们求助 https://translate.zvo.cn/4030.html');
|
|
4999
5268
|
}else{
|
|
5000
5269
|
data.languageName = romanceSentenceLanguage;
|
|
5001
5270
|
}
|
|
@@ -5858,9 +6127,9 @@ var translate = {
|
|
|
5858
6127
|
translate.request.post(translate.request.api.ip, {}, function(data){
|
|
5859
6128
|
//console.log(data);
|
|
5860
6129
|
if(data.result == 0){
|
|
5861
|
-
|
|
5862
|
-
|
|
5863
|
-
|
|
6130
|
+
translate.log('==== ERROR 获取当前用户所在区域异常 ====');
|
|
6131
|
+
translate.log(data.info);
|
|
6132
|
+
translate.log('==== ERROR END ====');
|
|
5864
6133
|
}else{
|
|
5865
6134
|
translate.storage.set('to',data.language); //设置目标翻译语言
|
|
5866
6135
|
translate.to = data.language; //设置目标语言
|
|
@@ -6095,7 +6364,7 @@ var translate = {
|
|
|
6095
6364
|
let replaceResult = translate.util.replaceFromIndex(text, replaceIndex, replaceOriginalText, replaceResultText);
|
|
6096
6365
|
|
|
6097
6366
|
if(replaceResult.replaceEndIndex < 1){
|
|
6098
|
-
|
|
6367
|
+
translate.log('translate.util.findParticiple 中已经发现了，但是实际没有替换，出现异常了！理论上这是不应该出现的。 text:'+text+' , index:'+indexArray[i]+', translateOriginal:'+translateOriginal);
|
|
6099
6368
|
}else{
|
|
6100
6369
|
text = replaceResult.text;
|
|
6101
6370
|
}
|
|
@@ -6772,7 +7041,7 @@ var translate = {
|
|
|
6772
7041
|
var tLang = translate.util.browserLanguage[language];
|
|
6773
7042
|
if(typeof(tLang) == 'undefined'){
|
|
6774
7043
|
//没有在里面
|
|
6775
|
-
|
|
7044
|
+
translate.log('browser default language : '+language +', translate.js current translate channel not support this language ');
|
|
6776
7045
|
}else{
|
|
6777
7046
|
return tLang;
|
|
6778
7047
|
}
|
|
@@ -6931,7 +7200,7 @@ var translate = {
|
|
|
6931
7200
|
*/
|
|
6932
7201
|
use: function(serviceName){
|
|
6933
7202
|
if(typeof(translate.enterprise) != 'undefined' && translate.enterprise.isUse == true){
|
|
6934
|
-
|
|
7203
|
+
translate.log('您已启用了企业级翻译通道 translate.enterprise.use(); (文档：https://translate.zvo.cn/4087.html) , 所以您设置的 translate.service.use(\''+serviceName+'\'); (文档：https://translate.zvo.cn/4081.html) 将失效不起作用，有企业级翻译通道全部接管。');
|
|
6935
7204
|
return;
|
|
6936
7205
|
}
|
|
6937
7206
|
//console.log('--'+serviceName);
|
|
@@ -7055,8 +7324,8 @@ var translate = {
|
|
|
7055
7324
|
|
|
7056
7325
|
//进行对前后进行补齐数组
|
|
7057
7326
|
if(currentIndex < 0){
|
|
7058
|
-
|
|
7059
|
-
|
|
7327
|
+
translate.log('------ERROR--------');
|
|
7328
|
+
translate.log('翻译内容过多，进行拆分，但拆分判断出现异常，currentIndex：-1 请联系 http://translate.zvo.cn/43006.html 说明');
|
|
7060
7329
|
}
|
|
7061
7330
|
//前插入空数组填充
|
|
7062
7331
|
for(var addbeforei = 0; addbeforei<currentIndex; addbeforei++){
|
|
@@ -7086,8 +7355,8 @@ var translate = {
|
|
|
7086
7355
|
|
|
7087
7356
|
|
|
7088
7357
|
}, 'get', true, {'content-type':'application/x-www-form-urlencoded'}, function(xhr){
|
|
7089
|
-
|
|
7090
|
-
|
|
7358
|
+
translate.log('---------error--------');
|
|
7359
|
+
translate.log('edge translate service error, http code : '+xhr.status + ', response text : '+xhr.responseText);
|
|
7091
7360
|
}, true);
|
|
7092
7361
|
|
|
7093
7362
|
|
|
@@ -7196,7 +7465,7 @@ var translate = {
|
|
|
7196
7465
|
{},
|
|
7197
7466
|
function(data){
|
|
7198
7467
|
if (data.result == 0){
|
|
7199
|
-
|
|
7468
|
+
translate.log('translate.js init 初始化异常：'+data.info);
|
|
7200
7469
|
return;
|
|
7201
7470
|
}else if(data.result == 1){
|
|
7202
7471
|
//服务端返回的最新版本
|
|
@@ -7205,7 +7474,7 @@ var translate = {
|
|
|
7205
7474
|
var currentVersion = translate.util.versionStringToInt(translate.version.replace('v',''));
|
|
7206
7475
|
|
|
7207
7476
|
if(newVersion > currentVersion){
|
|
7208
|
-
|
|
7477
|
+
translate.log('Tip : translate.js find new version : '+data.version);
|
|
7209
7478
|
}
|
|
7210
7479
|
}
|
|
7211
7480
|
},
|
|
@@ -7481,7 +7750,7 @@ var translate = {
|
|
|
7481
7750
|
);
|
|
7482
7751
|
}catch(e){
|
|
7483
7752
|
//console.log('e0000');
|
|
7484
|
-
|
|
7753
|
+
translate.log(e);
|
|
7485
7754
|
//time = 300000; //无法连接的，那么赋予 300 秒吧
|
|
7486
7755
|
}
|
|
7487
7756
|
|
|
@@ -7516,7 +7785,7 @@ var translate = {
|
|
|
7516
7785
|
|
|
7517
7786
|
}else{
|
|
7518
7787
|
//异常，下标越界了！，固定返回最后一个
|
|
7519
|
-
|
|
7788
|
+
translate.log('异常，下标越界了！index：'+queueIndex);
|
|
7520
7789
|
queueIndex = queue.length-1;
|
|
7521
7790
|
}
|
|
7522
7791
|
//console.log(queueIndex);
|
|
@@ -7690,7 +7959,7 @@ var translate = {
|
|
|
7690
7959
|
try{
|
|
7691
7960
|
json = JSON.parse(xhr.responseText);
|
|
7692
7961
|
}catch(e){
|
|
7693
|
-
|
|
7962
|
+
translate.log(e);
|
|
7694
7963
|
}
|
|
7695
7964
|
}
|
|
7696
7965
|
}
|
|
@@ -7709,17 +7978,17 @@ var translate = {
|
|
|
7709
7978
|
//判断是否是v2版本的翻译，如果是 translate.service 模式并且没有使用企业级翻译，参会提示
|
|
7710
7979
|
//2024.3月底开始，翻译使用量增加的太快，开源的翻译服务器有点扛不住经常出故障，所以直接把这个提示加到这里
|
|
7711
7980
|
if(translate.service.name == 'translate.service'){
|
|
7712
|
-
|
|
7981
|
+
translate.log('----- translate.js 提示 -----\n翻译服务响应异常，解决这种情况可以有两种方案：\n【方案一】：使用采用最新版本 3.16.0及更高版本，js引用文件为 https://cdn.staticfile.net/translate.js/3.16.0/translate.js 并且使用 client.edge 模式 （增加一行设置代码就好，可参考 https://translate.zvo.cn/4081.html ），这样就不会再出现这种情况了，而且这个方案也是完全免费的。 \n【方案二】：采用企业级稳定翻译通道 ,但是这个相比于 方案一 来说，是有一定的收费的，大概一年600，这个就是专门为了高速及高稳定准备的，而相比于这个方案二，方案一则是全免费的。 因为方案二我们是部署了两个集群，而每个集群又下分了数个网络节点，包含中国大陆、香港、美国、欧洲、 等多个州，充分保障稳定、高效，同样也产生了不少成本，所以才需要付费。更多信息说明可以参考： http://translate.zvo.cn/4087.html \n【方案三】：私有部署你自己的翻译通道，并且启用内存级翻译缓存，毫秒级响应，但是需要依赖一台1核2G服务器，是最推荐的方式。具体参考：https://translate.zvo.cn/391129.html\n-------------');
|
|
7713
7982
|
}
|
|
7714
7983
|
|
|
7715
7984
|
//console.log(xhr);
|
|
7716
|
-
|
|
7717
|
-
|
|
7718
|
-
|
|
7719
|
-
|
|
7720
|
-
|
|
7721
|
-
|
|
7722
|
-
|
|
7985
|
+
translate.log('------- translate.js service api response error --------');
|
|
7986
|
+
translate.log(' http code : '+xhr.status);
|
|
7987
|
+
translate.log(' response : '+xhr.response);
|
|
7988
|
+
translate.log(' request url : '+url);
|
|
7989
|
+
translate.log(' request data : '+JSON.stringify(data));
|
|
7990
|
+
translate.log(' request method : '+method);
|
|
7991
|
+
translate.log('---------------------- end ----------------------');
|
|
7723
7992
|
}
|
|
7724
7993
|
|
|
7725
7994
|
}
|
|
@@ -7782,7 +8051,7 @@ var translate = {
|
|
|
7782
8051
|
}else if(type == '[object Object]'){
|
|
7783
8052
|
//案例三
|
|
7784
8053
|
if(typeof(obj.texts) == 'undefined'){
|
|
7785
|
-
|
|
8054
|
+
translate.log('translate.request.translateText 传入的值类型异常，因为你没有传入 obj.texts 要翻译的具体文本！ 请查阅文档： https://translate.zvo.cn/4077.html');
|
|
7786
8055
|
}
|
|
7787
8056
|
if(typeof(obj.texts) == 'string'){
|
|
7788
8057
|
//单个字符串
|
|
@@ -7798,7 +8067,7 @@ var translate = {
|
|
|
7798
8067
|
to = obj.to;
|
|
7799
8068
|
}
|
|
7800
8069
|
}else{
|
|
7801
|
-
|
|
8070
|
+
translate.log('translate.request.translateText 传入的值类型错误，请查阅文档： https://translate.zvo.cn/4077.html');
|
|
7802
8071
|
return;
|
|
7803
8072
|
}
|
|
7804
8073
|
}
|
|
@@ -7855,12 +8124,12 @@ var translate = {
|
|
|
7855
8124
|
//console.log(resultData);
|
|
7856
8125
|
//console.log(data);
|
|
7857
8126
|
if(resultData.result == 0){
|
|
7858
|
-
|
|
7859
|
-
|
|
7860
|
-
|
|
7861
|
-
|
|
7862
|
-
|
|
7863
|
-
|
|
8127
|
+
translate.log('=======ERROR START=======');
|
|
8128
|
+
translate.log('from : '+resultData.from);
|
|
8129
|
+
translate.log('to : '+resultData.to);
|
|
8130
|
+
translate.log('translate text array : '+texts);
|
|
8131
|
+
translate.log('response : '+resultData.info);
|
|
8132
|
+
translate.log('=======ERROR END =======');
|
|
7864
8133
|
//return;
|
|
7865
8134
|
}
|
|
7866
8135
|
|
|
@@ -7978,14 +8247,14 @@ var translate = {
|
|
|
7978
8247
|
//console.log('translate.request.listener.start ... 执行翻译 --'+currentTime);
|
|
7979
8248
|
translate.execute();
|
|
7980
8249
|
}catch(e){
|
|
7981
|
-
|
|
8250
|
+
translate.log(e);
|
|
7982
8251
|
}
|
|
7983
8252
|
}
|
|
7984
8253
|
}
|
|
7985
8254
|
}, 100);
|
|
7986
8255
|
|
|
7987
8256
|
if(typeof(PerformanceObserver) == 'undefined'){
|
|
7988
|
-
|
|
8257
|
+
translate.log('因浏览器版本较低， translate.request.listener.start() 中 PerformanceObserver 对象不存在，浏览器不支持，所以 translate.request.listener.start() 未生效。');
|
|
7989
8258
|
return;
|
|
7990
8259
|
}
|
|
7991
8260
|
|
|
@@ -8058,7 +8327,7 @@ var translate = {
|
|
|
8058
8327
|
observer.observe({ entryTypes: ["resource"] });
|
|
8059
8328
|
return;
|
|
8060
8329
|
} catch (e) {
|
|
8061
|
-
|
|
8330
|
+
translate.log("PerformanceObserver entryTypes 失败，尝试 type 参数");
|
|
8062
8331
|
}
|
|
8063
8332
|
}
|
|
8064
8333
|
}
|
|
@@ -8067,9 +8336,9 @@ var translate = {
|
|
|
8067
8336
|
// 回退到 type 参数
|
|
8068
8337
|
try {
|
|
8069
8338
|
observer.observe({ type: "resource", buffered: true });
|
|
8070
|
-
|
|
8339
|
+
translate.log("使用 PerformanceObserver type");
|
|
8071
8340
|
} catch (e) {
|
|
8072
|
-
|
|
8341
|
+
translate.log("当前浏览器不支持 PerformanceObserver 的任何参数, translate.request.listener.start() 未启动");
|
|
8073
8342
|
}
|
|
8074
8343
|
|
|
8075
8344
|
}
|
|
@@ -8335,24 +8604,7 @@ var translate = {
|
|
|
8335
8604
|
config.notTranslateTip = true;
|
|
8336
8605
|
}
|
|
8337
8606
|
|
|
8338
|
-
|
|
8339
|
-
|
|
8340
|
-
var lastUuid = ''; //最后一次的uuid
|
|
8341
|
-
for(var queue in translate.nodeQueue){
|
|
8342
|
-
if (!translate.nodeQueue.hasOwnProperty(queue)) {
|
|
8343
|
-
continue;
|
|
8344
|
-
}
|
|
8345
|
-
lastUuid = queue;
|
|
8346
|
-
}
|
|
8347
|
-
//console.log(queue);
|
|
8348
|
-
|
|
8349
|
-
if(lastUuid == ''){
|
|
8350
|
-
if(config.selectLanguageRefreshRender){
|
|
8351
|
-
console.log('提示，当前还未执行过翻译，所以 translate.reset(); 还原至翻译前的执行指令忽略');
|
|
8352
|
-
}
|
|
8353
|
-
return;
|
|
8354
|
-
}
|
|
8355
|
-
|
|
8607
|
+
|
|
8356
8608
|
/*
|
|
8357
8609
|
for(var lang in translate.nodeQueue[lastUuid].list){
|
|
8358
8610
|
if (!translate.nodeQueue[lastUuid].list.hasOwnProperty(lang)) {
|
|
@@ -8413,16 +8665,20 @@ var translate = {
|
|
|
8413
8665
|
if (!translate.node.get(key) == null) {
|
|
8414
8666
|
continue;
|
|
8415
8667
|
}
|
|
8416
|
-
for(var attr in translate.node.get(key)){
|
|
8417
|
-
if (!translate.node.get(key).hasOwnProperty(attr)) {
|
|
8418
|
-
|
|
8419
|
-
}
|
|
8420
|
-
|
|
8421
|
-
|
|
8668
|
+
//for(var attr in translate.node.get(key)){
|
|
8669
|
+
//if (!translate.node.get(key).hasOwnProperty(attr)) {
|
|
8670
|
+
// continue;
|
|
8671
|
+
//}
|
|
8672
|
+
|
|
8673
|
+
//var analyse = translate.element.nodeAnalyse.get(key,translate.node.get(key).attribute);
|
|
8674
|
+
if(typeof(translate.node.get(key).originalText) !== 'string'){
|
|
8422
8675
|
continue;
|
|
8423
8676
|
}
|
|
8424
|
-
translate.element.nodeAnalyse.analyse(key, analyse.text, translate.node.get(key)
|
|
8425
|
-
|
|
8677
|
+
//translate.element.nodeAnalyse.analyse(key, analyse.text, translate.node.get(key).originalText, translate.node.get(key).attribute);
|
|
8678
|
+
|
|
8679
|
+
//标注此次改动是有 translate.js 导致的 -- 这里就不用标记了，因为先已经移除了 translate.listener.observer 监听，所以不会再监听到还原的操作了
|
|
8680
|
+
key.nodeValue = translate.node.get(key).originalText;
|
|
8681
|
+
//}
|
|
8426
8682
|
}
|
|
8427
8683
|
|
|
8428
8684
|
|
|
@@ -8443,6 +8699,15 @@ var translate = {
|
|
|
8443
8699
|
translate.storage.set('to', '');
|
|
8444
8700
|
translate.to = null;
|
|
8445
8701
|
|
|
8702
|
+
//清除文本翻译记录
|
|
8703
|
+
if(translate.history.translateText.originalMap !== null){
|
|
8704
|
+
translate.history.translateText.originalMap.clear();
|
|
8705
|
+
}
|
|
8706
|
+
if(translate.history.translateText.resultMap !== null){
|
|
8707
|
+
translate.history.translateText.resultMap.clear();
|
|
8708
|
+
}
|
|
8709
|
+
|
|
8710
|
+
|
|
8446
8711
|
//重新绘制 select 选择语言
|
|
8447
8712
|
if(config.selectLanguageRefreshRender){
|
|
8448
8713
|
translate.selectLanguageTag.refreshRender();
|
|
@@ -8473,7 +8738,7 @@ var translate = {
|
|
|
8473
8738
|
//还有需要进行通过API接口进行翻译的文本，需要调用翻译接口
|
|
8474
8739
|
if(typeof(translate.request.api.translate) != 'string' || translate.request.api.translate == null || translate.request.api.translate.length < 1){
|
|
8475
8740
|
//用户已经设置了不掉翻译接口进行翻译
|
|
8476
|
-
|
|
8741
|
+
translate.log('已设置了不使用 translate 翻译接口，翻译请求被阻止');
|
|
8477
8742
|
return;
|
|
8478
8743
|
}
|
|
8479
8744
|
|
|
@@ -8529,7 +8794,7 @@ var translate = {
|
|
|
8529
8794
|
|
|
8530
8795
|
if(translate.service.name == 'client.edge'){
|
|
8531
8796
|
translate.service.name = 'translate.service';
|
|
8532
|
-
|
|
8797
|
+
translate.log('您已启用了企业级翻译通道 translate.enterprise.use(); (文档：https://translate.zvo.cn/4087.html) , 所以您设置的 translate.service.use(\'client.edge\'); (文档：https://translate.zvo.cn/4081.html) 将失效不起作用，有企业级翻译通道全部接管。');
|
|
8533
8798
|
return;
|
|
8534
8799
|
}
|
|
8535
8800
|
},
|
|
@@ -8671,7 +8936,7 @@ var translate = {
|
|
|
8671
8936
|
if(typeof(translatejsTextElementHidden) == 'undefined' || translatejsTextElementHidden == null){
|
|
8672
8937
|
const style = document.createElement('style');
|
|
8673
8938
|
// 设置 style 元素的文本内容为要添加的 CSS 规则
|
|
8674
|
-
style.textContent = ' .translatejs-text-element-hidden{color: transparent !important; text-shadow: none !important;}';
|
|
8939
|
+
style.textContent = ' .translatejs-text-element-hidden, .translatejs-text-element-hidden[type="text"]::placeholder{color: transparent !important; -webkit-text-fill-color: transparent !important; text-shadow: none !important;} ';
|
|
8675
8940
|
style.id = 'translatejs-text-element-hidden';
|
|
8676
8941
|
// 将 style 元素插入到 head 元素中
|
|
8677
8942
|
document.head.appendChild(style);
|
|
@@ -8692,38 +8957,16 @@ var translate = {
|
|
|
8692
8957
|
if(translate.progress.api.isTip){
|
|
8693
8958
|
//translate.listener.execute.renderStartByApi.push(function(uuid, from, to){
|
|
8694
8959
|
translate.lifecycle.execute.translateNetworkBefore.push(function(data){
|
|
8695
|
-
|
|
8696
|
-
|
|
8697
|
-
|
|
8698
|
-
for(var r = 0; r<data.nodes.length; r++){
|
|
8699
|
-
var node = data.nodes[r];
|
|
8700
|
-
if(typeof(node) == 'undefined' || typeof(node.parentNode) == 'undefined'){
|
|
8701
|
-
continue;
|
|
8702
|
-
}
|
|
8703
|
-
nodes.push(node);
|
|
8704
|
-
}
|
|
8960
|
+
//取出当前变动的node，对应的元素
|
|
8961
|
+
var elements = translate.element.nodeToElement(data.nodes);
|
|
8962
|
+
//console.log(elements)
|
|
8705
8963
|
|
|
8706
8964
|
//隐藏所有node的文本
|
|
8707
|
-
for(var r = 0; r<
|
|
8708
|
-
|
|
8709
|
-
nodes[r].className = nodes[r].className+' translatejs-text-element-hidden';
|
|
8710
|
-
}else{
|
|
8711
|
-
//不是元素，那么就取父级了 -- 这里即使翻译的属性，也要进行，比如 value 的 placeholder
|
|
8712
|
-
var nodeParent = nodes[r].parentNode;
|
|
8713
|
-
if(nodeParent == null){
|
|
8714
|
-
continue;
|
|
8715
|
-
}
|
|
8716
|
-
if(typeof(nodeParent.className) != 'undefined' && nodeParent.className != null && nodeParent.className.indexOf('translatejs-text-element-hidden') > -1){
|
|
8717
|
-
//父有了，那么子就不需要再加了
|
|
8718
|
-
continue;
|
|
8719
|
-
}else{
|
|
8720
|
-
//没有，添加
|
|
8721
|
-
nodeParent.className = nodeParent.className+' translatejs-text-element-hidden';
|
|
8722
|
-
}
|
|
8723
|
-
}
|
|
8965
|
+
for(var r = 0; r<elements.length; r++){
|
|
8966
|
+
elements[r].className = elements[r].className+' translatejs-text-element-hidden';
|
|
8724
8967
|
}
|
|
8725
8968
|
|
|
8726
|
-
var rects = translate.visual.getRects(
|
|
8969
|
+
var rects = translate.visual.getRects(elements);
|
|
8727
8970
|
//console.log(rects)
|
|
8728
8971
|
var rectsOneArray = translate.visual.rectsToOneArray(rects);
|
|
8729
8972
|
|
|
@@ -8737,70 +8980,29 @@ var translate = {
|
|
|
8737
8980
|
|
|
8738
8981
|
var rectLineSplit = translate.visual.filterRectsByLineInterval(rectsOneArray, 2);
|
|
8739
8982
|
for(var r = 0; r<rectLineSplit.length; r++){
|
|
8740
|
-
|
|
8741
|
-
|
|
8742
|
-
|
|
8743
|
-
|
|
8744
|
-
|
|
8745
|
-
if(nodeParent == null){
|
|
8746
|
-
continue;
|
|
8747
|
-
}
|
|
8748
|
-
if(typeof(nodeParent.className) != 'undefined' && nodeParent.className != null && nodeParent.className.indexOf('translate_api_in_progress') > -1){
|
|
8749
|
-
//父有了，那么子就不需要再加了
|
|
8750
|
-
continue;
|
|
8751
|
-
}else{
|
|
8752
|
-
//没有，添加
|
|
8753
|
-
nodeParent.className = nodeParent.className+' translate_api_in_progress';
|
|
8754
|
-
}
|
|
8755
|
-
}
|
|
8983
|
+
if(typeof(rectLineSplit[r].node.className) === 'string' && rectLineSplit[r].node.className.indexOf('translate_api_in_progress') > -1){
|
|
8984
|
+
//已经存在了，就不继续加了
|
|
8985
|
+
}else{
|
|
8986
|
+
rectLineSplit[r].node.className = rectLineSplit[r].node.className+' translate_api_in_progress';
|
|
8987
|
+
}
|
|
8756
8988
|
}
|
|
8757
|
-
|
|
8758
8989
|
});
|
|
8759
8990
|
|
|
8760
|
-
translate.
|
|
8761
|
-
|
|
8762
|
-
|
|
8763
|
-
|
|
8764
|
-
|
|
8765
|
-
|
|
8766
|
-
|
|
8767
|
-
|
|
8768
|
-
|
|
8769
|
-
|
|
8770
|
-
|
|
8771
|
-
|
|
8772
|
-
var node = translate.nodeQueue[uuid].list[from][hash].nodes[nodeindex].node;
|
|
8773
|
-
|
|
8774
|
-
var operationNode;
|
|
8775
|
-
if(node.nodeType === 1){
|
|
8776
|
-
//是元素
|
|
8777
|
-
operationNode = node;
|
|
8778
|
-
}else{
|
|
8779
|
-
//节点，如 #text
|
|
8780
|
-
operationNode = node.parentNode;
|
|
8781
|
-
if(operationNode == null){
|
|
8782
|
-
continue;
|
|
8783
|
-
}
|
|
8784
|
-
}
|
|
8785
|
-
|
|
8786
|
-
|
|
8787
|
-
|
|
8788
|
-
|
|
8789
|
-
if(typeof(operationNode.className) != 'undefined' && operationNode.className != null){
|
|
8790
|
-
|
|
8791
|
-
if(operationNode.className.indexOf('translatejs-text-element-hidden') > -1){
|
|
8792
|
-
operationNode.className = operationNode.className.replace(/translatejs-text-element-hidden/g, '');
|
|
8793
|
-
}
|
|
8794
|
-
if(operationNode.className.indexOf('translate_api_in_progress') > -1){
|
|
8795
|
-
operationNode.className = operationNode.className.replace(/translate_api_in_progress/g, '');
|
|
8796
|
-
}
|
|
8991
|
+
translate.lifecycle.execute.translateNetworkAfter.push(function(data){
|
|
8992
|
+
//取出当前变动的node，对应的元素
|
|
8993
|
+
var elements = translate.element.nodeToElement(data.nodes);
|
|
8994
|
+
|
|
8995
|
+
for(var r = 0; r<elements.length; r++){
|
|
8996
|
+
if(typeof(elements[r].className) === 'string'){
|
|
8997
|
+
if(elements[r].className.indexOf('translatejs-text-element-hidden') > -1){
|
|
8998
|
+
elements[r].className = elements[r].className.replace(/translatejs-text-element-hidden/g, '');
|
|
8999
|
+
}
|
|
9000
|
+
if(elements[r].className.indexOf('translate_api_in_progress') > -1){
|
|
9001
|
+
elements[r].className = elements[r].className.replace(/translate_api_in_progress/g, '');
|
|
8797
9002
|
}
|
|
8798
|
-
|
|
8799
|
-
|
|
8800
|
-
|
|
8801
|
-
|
|
8802
|
-
}
|
|
8803
|
-
}
|
|
9003
|
+
}
|
|
9004
|
+
}
|
|
9005
|
+
|
|
8804
9006
|
|
|
8805
9007
|
});
|
|
8806
9008
|
|
|
@@ -8845,7 +9047,7 @@ var translate = {
|
|
|
8845
9047
|
try{
|
|
8846
9048
|
jsObject = eval('(' + jsString + ')');
|
|
8847
9049
|
}catch(e){
|
|
8848
|
-
|
|
9050
|
+
translate.log(e)
|
|
8849
9051
|
failureFunction(e);
|
|
8850
9052
|
return;
|
|
8851
9053
|
}
|
|
@@ -9171,8 +9373,8 @@ var translate = {
|
|
|
9171
9373
|
|
|
9172
9374
|
// 检查 URL 是否匹配
|
|
9173
9375
|
if(typeof(rule.url) == 'undefined' && rule.url == ''){
|
|
9174
|
-
|
|
9175
|
-
|
|
9376
|
+
translate.log('WARINNG : translate.network.rule find url is null:');
|
|
9377
|
+
translate.log(rule);
|
|
9176
9378
|
continue;
|
|
9177
9379
|
}
|
|
9178
9380
|
//console.log(rule);
|
|
@@ -9264,8 +9466,8 @@ var translate = {
|
|
|
9264
9466
|
//console.log(url);
|
|
9265
9467
|
//console.log(rule);
|
|
9266
9468
|
if(typeof(rule.params) == 'undefined' && typeof(rule.params.length) == 'undefined' && rule.params.length < 1){
|
|
9267
|
-
|
|
9268
|
-
|
|
9469
|
+
translate.log('WARINNG: rule not find params , rule : ');
|
|
9470
|
+
translate.log(rule);
|
|
9269
9471
|
rule.params = [];
|
|
9270
9472
|
}
|
|
9271
9473
|
|
|
@@ -9284,11 +9486,11 @@ var translate = {
|
|
|
9284
9486
|
const translateResultData = await translate.network._translateText(original);
|
|
9285
9487
|
|
|
9286
9488
|
if(typeof(translateResultData) == 'undefined'){
|
|
9287
|
-
|
|
9489
|
+
translate.log('WARINNG: translateResultData is undefined');
|
|
9288
9490
|
}else if(typeof(translateResultData.result) == 'undefined'){
|
|
9289
|
-
|
|
9491
|
+
translate.log('WARINNG: translateResultData.result is undefined');
|
|
9290
9492
|
}else if(translateResultData.result != 1){
|
|
9291
|
-
|
|
9493
|
+
translate.log('WARINNG: translateResultData.result failure : '+translateResultData.info);
|
|
9292
9494
|
}else{
|
|
9293
9495
|
params.set(paramName, decodeURIComponent(translateResultData.text[0]));
|
|
9294
9496
|
}
|
|
@@ -10080,11 +10282,11 @@ var translate = {
|
|
|
10080
10282
|
//正常，body还没加载
|
|
10081
10283
|
}else{
|
|
10082
10284
|
if(config.inHeadTip){
|
|
10083
|
-
|
|
10285
|
+
translate.log('警告： translate.visual.webPageLoadTranslateBeforeHiddenText() 要在 head 标签中触发才能达到最好的效果！');
|
|
10084
10286
|
}
|
|
10085
10287
|
}
|
|
10086
10288
|
if(translate.language.local == ''){
|
|
10087
|
-
|
|
10289
|
+
translate.log('提醒：在使用 translate.visual.webPageLoadTranslateBeforeHiddenText() 之前，请先手动设置你的本地语种，参考： http://translate.zvo.cn/4066.html 如果你不设置本地语种，则不管你是否有切换语言，网页打开后都会先短暂的不显示文字');
|
|
10088
10290
|
}
|
|
10089
10291
|
|
|
10090
10292
|
if(translate.language.local == '' || translate.language.translateLocal == true || translate.language.local != translate.language.getCurrent()){
|
|
@@ -10223,7 +10425,7 @@ var translate = {
|
|
|
10223
10425
|
start:function(){
|
|
10224
10426
|
if(translate.time.execute.isUse){
|
|
10225
10427
|
//已经启动过了，不需要再启动了
|
|
10226
|
-
|
|
10428
|
+
translate.log('translate.time.execute.start() 已经启动过了，不需要再启动了');
|
|
10227
10429
|
}
|
|
10228
10430
|
|
|
10229
10431
|
translate.time.execute.data.isUse = true;
|
|
@@ -10287,7 +10489,7 @@ var translate = {
|
|
|
10287
10489
|
translate.time.execute.data[uuid].translateTexts = translateTexts;
|
|
10288
10490
|
|
|
10289
10491
|
|
|
10290
|
-
|
|
10492
|
+
translate.log('[time][translate.execute()] '+translate.time.execute.data[uuid].allTime+'ms '+(typeof(translate.time.execute.data[uuid].translateNetworkBeforeTime) != 'undefined'? '(search&cache '+(translate.time.execute.data[uuid].translateNetworkBeforeTime - translate.time.execute.data[uuid].startTime)+'ms)':'')+ (translateTexts.length > 0 ? (' , ['+translateLanguages+'] : ('+translateTexts.length+')['+translateTexts.slice(0, 3)+(translateTexts.length > 3 ? ', ...':'')+']'):''));
|
|
10291
10493
|
});
|
|
10292
10494
|
},
|
|
10293
10495
|
|
|
@@ -10339,11 +10541,11 @@ var translate = {
|
|
|
10339
10541
|
}
|
|
10340
10542
|
} catch (e) {
|
|
10341
10543
|
// 如果获取调用栈失败，使用原始log方法
|
|
10342
|
-
|
|
10544
|
+
translate.log(e);
|
|
10343
10545
|
}
|
|
10344
10546
|
|
|
10345
10547
|
functionName = functionName.replace('Object.','translate.');
|
|
10346
|
-
|
|
10548
|
+
translate.log(functionName+'() '+usetime+' -> '+remark);
|
|
10347
10549
|
}
|
|
10348
10550
|
|
|
10349
10551
|
},
|
|
@@ -10449,13 +10651,11 @@ var translate = {
|
|
|
10449
10651
|
});
|
|
10450
10652
|
//将其记录到 translate.node.data
|
|
10451
10653
|
translate.node.set(textNode,{
|
|
10452
|
-
|
|
10453
|
-
|
|
10454
|
-
|
|
10455
|
-
|
|
10456
|
-
|
|
10457
|
-
whole: true
|
|
10458
|
-
},
|
|
10654
|
+
attribute:"",
|
|
10655
|
+
originalText: originalText,
|
|
10656
|
+
resultText: text,
|
|
10657
|
+
translateTexts: {}, //这里因为直接从缓存中取的，没有走网络接口，所以这里直接空
|
|
10658
|
+
whole: true,
|
|
10459
10659
|
translateResults: {
|
|
10460
10660
|
[originalText]:1
|
|
10461
10661
|
},
|
|
@@ -10650,8 +10850,8 @@ var translate = {
|
|
|
10650
10850
|
|
|
10651
10851
|
//进行判断，DOM是否加载完成了，如果未加载完成就触发了 translate.execute 执行，那么弹出警告提示
|
|
10652
10852
|
if(document.readyState == 'loading'){
|
|
10653
|
-
|
|
10654
|
-
|
|
10853
|
+
translate.log('WARNING : The dom triggered translate.exece() before it was fully loaded, which does not comply with usage standards. The execution of translate.exece() should be done after the DOM is loaded');
|
|
10854
|
+
translate.log('警告：DOM 在完全加载之前触发了 translate.execute() ，这不符合使用规范，容易出现异常。你应该检查一下你的代码，translate.execute() 的执行应该在DOM加载完成后');
|
|
10655
10855
|
}
|
|
10656
10856
|
|
|
10657
10857
|
|
|
@@ -10734,8 +10934,10 @@ var nodeuuid = {
|
|
|
10734
10934
|
|
|
10735
10935
|
|
|
10736
10936
|
/*js copyright-notice start*/
|
|
10737
|
-
|
|
10738
|
-
|
|
10937
|
+
//延迟触发，方便拦截自定义
|
|
10938
|
+
setTimeout(function(){
|
|
10939
|
+
translate.log('------ translate.js ------\nTwo lines of js html automatic translation, page without change, no language configuration file, no API Key, SEO friendly! Open warehouse : https://github.com/xnx3/translate \n两行js实现html全自动翻译。 无需改动页面、无语言配置文件、无API Key、对SEO友好！完全开源，代码仓库：https://gitee.com/mail_osc/translate');
|
|
10940
|
+
}, 1000);
|
|
10739
10941
|
/*js copyright-notice end*/
|
|
10740
10942
|
|
|
10741
10943
|
//初始化
|