webpack-gc-i18n-plugin 1.1.5 → 1.1.6

package/dist/customLoader/index.cjs

@@ -7,6 +7,8 @@ require('crypto-js');
 var OpenCC = require('opencc-js');
 var types = require('@babel/types');
 require('lodash');
+var path = require('node:path');
+var fs = require('node:fs');
 var babel = require('@babel/core');
 var generate = require('@babel/generator');
 
@@ -539,6 +541,49 @@ function convertToTemplateLiteral(strArray, option) {
   return deepScanCall;
 }
 
+/**
+ * @description: 读取国际化JSON文件
+ * @return {*}
+ */
+function getLangTranslateJSONFile() {
+  const filePath = path.join(option.globalPath, 'index.json');
+  try {
+    const content = fs.readFileSync(filePath, 'utf-8');
+    return content;
+  } catch (error) {
+    if (error.code === 'ENOENT') {
+      console.log('❌读取JSON配置文件异常，文件不存在');
+    } else {
+      console.log('❌读取JSON配置文件异常，无法读取文件');
+    }
+    return JSON.stringify({});
+  }
+}
+
+/**
+ * @description: 基于langKey获取JSON配置文件中对应语言对象
+ * @param {string} key
+ * @return {*}
+ */
+function getLangObjByJSONFileWithLangKey(key) {
+  let insertJSONObj = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : undefined;
+  // 获取翻译配置对象，优先使用传入的配置，否则从本地文件读取
+  const JSONObj = insertJSONObj || JSON.parse(getLangTranslateJSONFile());
+
+  // 初始化语言映射对象，用于存储不同语言的hash: value映射
+  const langObj = {};
+
+  // 遍历hash，提取hash对应语言key的值，并写入到langObj
+  Object.keys(JSONObj).forEach(langCode => {
+    langObj[langCode] = JSONObj[langCode][key];
+  });
+
+  // 返回当前语言的hash: value映射对象
+  // 例如: 'zh-cn' > {'hash1': '你好', 'hash2': '世界'}
+  // 'en' > {'hash1': 'hello', 'hash2': 'world'}
+  return langObj;
+}
+
 /*
  * @Author: xiaoshanwen
  * @Date: 2023-10-30 18:23:03
@@ -547,11 +592,32 @@ function convertToTemplateLiteral(strArray, option) {
  */
 
 let langObj = {};
-function getLangKeyByValue(value) {
-  return Object.entries(langObj).find(_ref => {
+function normalizeValueForDedupe(value) {
+  return String(value || '').trim();
+}
+function findKeyByValue(valueMap, value) {
+  const exactKey = Object.entries(valueMap).find(_ref => {
     let [, oldValue] = _ref;
     return oldValue === value;
   })?.[0];
+  if (exactKey) return exactKey;
+  const normalizedValue = normalizeValueForDedupe(value);
+  return Object.entries(valueMap).find(_ref2 => {
+    let [, oldValue] = _ref2;
+    return normalizeValueForDedupe(oldValue) === normalizedValue;
+  })?.[0];
+}
+function getExistingOriginLangObj() {
+  try {
+    const filePath = path.join(option.globalPath, 'index.json');
+    if (!fs.existsSync(filePath)) return {};
+    return getLangObjByJSONFileWithLangKey(option.originLang);
+  } catch (error) {
+    return {};
+  }
+}
+function getLangKeyByValue(value) {
+  return findKeyByValue(langObj, value) || findKeyByValue(getExistingOriginLangObj(), value);
 }
 function resolveLangKey(key, value) {
   return getLangKeyByValue(value) || key;
@@ -559,14 +625,30 @@ function resolveLangKey(key, value) {
 function isTemplateValue(value) {
   return /\$\{[^}]+}/.test(value);
 }
-function getTemplateStaticSegments(value) {
-  return value.split(/\$\{[^}]+}/g).filter(item => item);
+function hasOriginSymbols$1(value) {
+  const originRegex = REGEX_MAP[option.originLang];
+  return originRegex ? originRegex.test(value) : false;
+}
+function getTemplateSemanticSplitSegments(value) {
+  const segments = value.split(/\$\{[^}]+}/g);
+  const result = new Set();
+  for (let index = 0; index < segments.length - 1; index++) {
+    const beforeValue = segments[index];
+    const afterValue = segments[index + 1];
+    if (!hasOriginSymbols$1(beforeValue) || !hasOriginSymbols$1(afterValue)) continue;
+    [beforeValue, afterValue].forEach(segment => {
+      if (segment.trim().length > 1) {
+        result.add(segment);
+      }
+    });
+  }
+  return [...result];
 }
 function isTemplateStaticSegment(value) {
-  return Object.values(langObj).some(oldValue => isTemplateValue(oldValue) && getTemplateStaticSegments(oldValue).includes(value));
+  return Object.values(langObj).some(oldValue => isTemplateValue(oldValue) && getTemplateSemanticSplitSegments(oldValue).includes(value));
 }
 function removeTemplateStaticSegments(value) {
-  const segments = new Set(getTemplateStaticSegments(value));
+  const segments = new Set(getTemplateSemanticSplitSegments(value));
   Object.keys(langObj).forEach(key => {
     if (segments.has(langObj[key])) {
       delete langObj[key];
@@ -1040,6 +1122,9 @@ function handleTemplateLiteralWithExpressions(node, path) {
     }
     return false;
   }
+  if (!hasExpressionInsideOriginContent(node)) {
+    return false;
+  }
   const {
     trimmedValue,
     valStr
@@ -1050,6 +1135,24 @@ function handleTemplateLiteralWithExpressions(node, path) {
   setLangObj(id, trimmedValue);
   return true;
 }
+function hasExpressionInsideOriginContent(node) {
+  return node.expressions.some((_, index) => {
+    const beforeValue = node.quasis.slice(0, index + 1).map(getTemplateElementValue).join('');
+    const afterValue = node.quasis.slice(index + 1).map(getTemplateElementValue).join('');
+    return hasOriginSymbols(beforeValue) && hasOriginSymbols(afterValue);
+  });
+}
+function getTemplateElementValue(quasi) {
+  let value = quasi.value.raw || quasi.value.cooked || '';
+  if (asianLangs.some(lang => option.originLang.includes(lang) || option.originLang === lang)) {
+    try {
+      value = unicodeToString(value);
+    } catch (error) {
+      console.log('转换异常');
+    }
+  }
+  return value;
+}
 function getExpressionPlaceholder(expression) {
   if (types.isStringLiteral(expression) || types.isNumericLiteral(expression)) {
     return String(expression.value);
@@ -1143,6 +1246,9 @@ function createTemplateLiteralTranslateCall(node) {
   if (!fullValue || !hasOriginSymbols(fullValue) || !option.excludedPattern.length || checkAgainstRegexArray(fullValue, [...option.excludedPattern])) {
     return null;
   }
+  if (!hasExpressionInsideOriginContent(node)) {
+    return createTemplateLiteralWithTranslatedQuasis(node, expressions);
+  }
   const {
     trimmedValue,
     valStr
@@ -1153,6 +1259,40 @@ function createTemplateLiteralTranslateCall(node) {
   }
   return createTranslateCall(id, valStr, expressionLabels, expressions);
 }
+function createTemplateLiteralWithTranslatedQuasis(node, expressions) {
+  const quasis = [];
+  const nextExpressions = [];
+  let pendingText = '';
+  let hasTranslatedQuasi = false;
+  node.quasis.forEach((quasi, index) => {
+    const value = getTemplateElementValue(quasi);
+    if (value && hasOriginSymbols(value) && option.excludedPattern.length && !checkAgainstRegexArray(value, [...option.excludedPattern])) {
+      quasis.push(types.templateElement({
+        raw: pendingText,
+        cooked: pendingText
+      }, false));
+      nextExpressions.push(createTrackedTranslateCall(value));
+      pendingText = '';
+      hasTranslatedQuasi = true;
+    } else {
+      pendingText += value;
+    }
+    if (index < expressions.length) {
+      quasis.push(types.templateElement({
+        raw: pendingText,
+        cooked: pendingText
+      }, false));
+      nextExpressions.push(types.cloneNode(expressions[index]));
+      pendingText = '';
+    }
+  });
+  if (!hasTranslatedQuasi) return null;
+  quasis.push(types.templateElement({
+    raw: pendingText,
+    cooked: pendingText
+  }, true));
+  return types.templateLiteral(quasis, nextExpressions);
+}
 function getConditionalExpressionLabel(expression) {
   const test = expression.test;
   if (types.isBinaryExpression(test) || types.isLogicalExpression(test)) {