webpack-gc-i18n-plugin 1.1.4 → 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');
 
@@ -382,6 +384,299 @@ const REGEX_MAP = {
   [OriginLangKeyEnum.RU]: /[йцукенгшщзхъфывапролджэячсмитьбюё .-]{1,}/ // 俄语字母
 };
 
+/*
+ * @Date: 2025-03-26 20:28:21
+ * @LastEditors: xiaoshan
+ * @LastEditTime: 2025-03-31 10:29:49
+ * @FilePath: /i18n_translation_vite/packages/autoI18nPluginCore/src/utils/split.ts
+ */
+// 插件核心文件
+// 字符串切割与转换函数
+// import generate from '@babel/generator'
+
+// todo 这个切割函数可以优化，性能可能很差
+/**
+ * 根据正则表达式分割字符串，并将符合正则的连续字符拼接起来。
+ * @param str - 要分割的字符串。
+ * @param separatorRegex - 用于分割字符串的正则表达式。
+ * @returns 分割并拼接后的字符串数组。
+ */
+/**
+ * 这个函数的主要功能是根据给定的正则表达式分割字符串，并对分割结果进行特殊处理。
+ * 处理过程分为三个主要步骤：
+ *
+ * 1. 首先根据分隔符正则和标点符号正则进行初步分割
+ * 2. 然后将连续的标点符号和符合分隔符正则的部分重新连接
+ * 3. 最后将不符合分隔符正则的相邻部分合并
+ *
+ * @param str - 需要分割的源字符串
+ * @param separatorRegex - 用于分割的正则表达式
+ * @returns 处理后的字符串数组
+ */
+function splitByRegex(str, separatorRegex) {
+  // 定义标点符号的正则表达式
+  const punctuationRegex = /[，。？！《》,.．：!?""''；'"、0-9\n\r\t\v\f]/;
+  // 创建一个新的正则表达式，用于分割字符串
+  const splitRegex = new RegExp(`(${separatorRegex.source}|${punctuationRegex.source})`, separatorRegex.flags);
+
+  // 使用正则表达式分割字符串，并过滤掉空字符串
+  const splitArr = str.split(splitRegex).filter(Boolean);
+  const result = [];
+  let currentMatch = '';
+
+  // 定义连接标点符号的正则表达式
+  const connectPunctuationRegex = /[，。？！《》,.．：!?；'"、0-9]/;
+  // 创建一个新的正则表达式，用于检测是否需要连接
+  const connectRegex = new RegExp(`(${separatorRegex.source}|${connectPunctuationRegex.source})`, separatorRegex.flags);
+
+  // 遍历分割后的数组
+  for (const item of splitArr) {
+    if (connectRegex.test(item)) {
+      // 如果当前项符合连接条件，则将其添加到当前匹配字符串中
+      currentMatch += item;
+    } else {
+      // 如果当前匹配字符串不为空，则将其添加到结果数组中
+      if (currentMatch) {
+        result.push(currentMatch);
+        currentMatch = '';
+      }
+      // 将当前项添加到结果数组中
+      result.push(item);
+    }
+  }
+
+  // 如果最后一个匹配字符串不为空，则将其添加到结果数组中
+  if (currentMatch) {
+    result.push(currentMatch);
+  }
+
+  // 再遍历一次，把不符合separatorRegex 这个正则的拼起来
+  const finalResult = [];
+  let tempStr = '';
+  for (let i = 0; i < result.length; i++) {
+    const item = result[i];
+    if (separatorRegex.test(item)) {
+      if (tempStr) {
+        finalResult.push(tempStr);
+        tempStr = '';
+      }
+      finalResult.push(item);
+    } else {
+      tempStr += item;
+      if (i === result.length - 1 || separatorRegex.test(result[i + 1])) {
+        finalResult.push(tempStr);
+        tempStr = '';
+      }
+    }
+  }
+  if (tempStr) {
+    finalResult.push(tempStr);
+  }
+  return finalResult;
+}
+
+/**
+ * 检查字符串是否需要切割。
+ * @param str - 要检查的字符串。
+ * @returns 如果字符串需要切割，则返回 true，否则返回 false。
+ */
+function checkNeedSplit(str) {
+  // 检查字符串中是否包含需要切割的特殊字符
+  return str.includes('\n') || str.includes('\\') || str.includes('\r') || str.includes('\t') || str.includes('\v') || str.includes('\f') || str.includes('>') || str.includes('<');
+}
+
+/**
+ * @description: 将字符串数组转换为babel的模板字符串节点
+ * @param {string[]} strArray - 字符串数组
+ * @return {types.CallExpression} - babel的深度扫描的表达式
+ */
+function convertToTemplateLiteral(strArray, option) {
+  const quasis = [];
+  const expressions = [];
+  strArray.forEach((str, index) => {
+    if (index === 0) {
+      if (getOriginRegex().test(str)) {
+        quasis.push(types__namespace.templateElement({
+          raw: '',
+          cooked: ''
+        }, false));
+        expressions.push(createI18nTranslator({
+          value: str,
+          isExpression: true,
+          insertOption: option
+        }));
+      } else {
+        quasis.push(types__namespace.templateElement({
+          raw: str,
+          cooked: str
+        }, false));
+      }
+    } else {
+      if (getOriginRegex().test(str)) {
+        expressions.push(createI18nTranslator({
+          value: str,
+          isExpression: true,
+          insertOption: option
+        }));
+      } else {
+        quasis.push(types__namespace.templateElement({
+          raw: str,
+          cooked: str
+        }, false));
+      }
+    }
+  });
+  if (quasis.length === expressions.length) {
+    quasis.push(types__namespace.templateElement({
+      raw: '',
+      cooked: ''
+    }, true));
+  } else if (quasis.length > expressions.length) {
+    quasis[quasis.length - 1].tail = true;
+  }
+  const templateLiteral = types__namespace.templateLiteral(quasis, expressions);
+  const deepScanCall = types__namespace.callExpression(types__namespace.identifier('$deepScan'), [templateLiteral]);
+  // 打印转换结果
+  // console.log('deepScanCall', (generate as any).default(deepScanCall).code)
+  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
+ * @LastEditTime: 2025-03-16 19:12:54
+ * @FilePath: /i18n_translation_vite/packages/autoI18nPluginCore/src/utils/translate.ts
+ */
+
+let langObj = {};
+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;
+}
+function isTemplateValue(value) {
+  return /\$\{[^}]+}/.test(value);
+}
+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) && getTemplateSemanticSplitSegments(oldValue).includes(value));
+}
+function removeTemplateStaticSegments(value) {
+  const segments = new Set(getTemplateSemanticSplitSegments(value));
+  Object.keys(langObj).forEach(key => {
+    if (segments.has(langObj[key])) {
+      delete langObj[key];
+    }
+  });
+}
+
+/**
+ * @description: 设置翻译对象属性
+ * @param {string} key
+ * @param {string} value
+ * @return {*}
+ */
+function setLangObj(key, value) {
+  if (isTemplateValue(value)) {
+    removeTemplateStaticSegments(value);
+  } else if (isTemplateStaticSegment(value)) {
+    return;
+  }
+  const existingKey = getLangKeyByValue(value);
+  if (existingKey && existingKey !== key) {
+    return;
+  }
+  if (!langObj[key]) {
+    langObj[key] = value;
+  }
+}
+
 /*
  * @Author: xiaoshanwen
  * @Date: 2023-10-11 10:01:43
@@ -503,7 +798,7 @@ function createI18nTranslator(createOption) {
     valStr
   } = normalizeTranslateValue(value);
   // 若 key 存在则使用 key，否则调用 generateId 函数根据 valStr 生成唯一的键
-  const generatedKey = key || generateId(valStr);
+  const generatedKey = key || resolveLangKey(generateId(valStr), trimmedValue);
   // 提取公共配置对象，避免重复代码
   const config = {
     option: option,
@@ -760,184 +1055,6 @@ let option = {
   ...DEFAULT_OPTION
 };
 
-/*
- * @Author: xiaoshanwen
- * @Date: 2023-10-30 18:23:03
- * @LastEditTime: 2025-03-16 19:12:54
- * @FilePath: /i18n_translation_vite/packages/autoI18nPluginCore/src/utils/translate.ts
- */
-
-let langObj = {};
-
-/**
- * @description: 设置翻译对象属性
- * @param {string} key
- * @param {string} value
- * @return {*}
- */
-function setLangObj(key, value) {
-  if (!langObj[key]) {
-    langObj[key] = value;
-  }
-}
-
-/*
- * @Date: 2025-03-26 20:28:21
- * @LastEditors: xiaoshan
- * @LastEditTime: 2025-03-31 10:29:49
- * @FilePath: /i18n_translation_vite/packages/autoI18nPluginCore/src/utils/split.ts
- */
-// 插件核心文件
-// 字符串切割与转换函数
-// import generate from '@babel/generator'
-
-// todo 这个切割函数可以优化，性能可能很差
-/**
- * 根据正则表达式分割字符串，并将符合正则的连续字符拼接起来。
- * @param str - 要分割的字符串。
- * @param separatorRegex - 用于分割字符串的正则表达式。
- * @returns 分割并拼接后的字符串数组。
- */
-/**
- * 这个函数的主要功能是根据给定的正则表达式分割字符串，并对分割结果进行特殊处理。
- * 处理过程分为三个主要步骤：
- *
- * 1. 首先根据分隔符正则和标点符号正则进行初步分割
- * 2. 然后将连续的标点符号和符合分隔符正则的部分重新连接
- * 3. 最后将不符合分隔符正则的相邻部分合并
- *
- * @param str - 需要分割的源字符串
- * @param separatorRegex - 用于分割的正则表达式
- * @returns 处理后的字符串数组
- */
-function splitByRegex(str, separatorRegex) {
-  // 定义标点符号的正则表达式
-  const punctuationRegex = /[，。？！《》,.．：!?""''；'"、0-9\n\r\t\v\f]/;
-  // 创建一个新的正则表达式，用于分割字符串
-  const splitRegex = new RegExp(`(${separatorRegex.source}|${punctuationRegex.source})`, separatorRegex.flags);
-
-  // 使用正则表达式分割字符串，并过滤掉空字符串
-  const splitArr = str.split(splitRegex).filter(Boolean);
-  const result = [];
-  let currentMatch = '';
-
-  // 定义连接标点符号的正则表达式
-  const connectPunctuationRegex = /[，。？！《》,.．：!?；'"、0-9]/;
-  // 创建一个新的正则表达式，用于检测是否需要连接
-  const connectRegex = new RegExp(`(${separatorRegex.source}|${connectPunctuationRegex.source})`, separatorRegex.flags);
-
-  // 遍历分割后的数组
-  for (const item of splitArr) {
-    if (connectRegex.test(item)) {
-      // 如果当前项符合连接条件，则将其添加到当前匹配字符串中
-      currentMatch += item;
-    } else {
-      // 如果当前匹配字符串不为空，则将其添加到结果数组中
-      if (currentMatch) {
-        result.push(currentMatch);
-        currentMatch = '';
-      }
-      // 将当前项添加到结果数组中
-      result.push(item);
-    }
-  }
-
-  // 如果最后一个匹配字符串不为空，则将其添加到结果数组中
-  if (currentMatch) {
-    result.push(currentMatch);
-  }
-
-  // 再遍历一次，把不符合separatorRegex 这个正则的拼起来
-  const finalResult = [];
-  let tempStr = '';
-  for (let i = 0; i < result.length; i++) {
-    const item = result[i];
-    if (separatorRegex.test(item)) {
-      if (tempStr) {
-        finalResult.push(tempStr);
-        tempStr = '';
-      }
-      finalResult.push(item);
-    } else {
-      tempStr += item;
-      if (i === result.length - 1 || separatorRegex.test(result[i + 1])) {
-        finalResult.push(tempStr);
-        tempStr = '';
-      }
-    }
-  }
-  if (tempStr) {
-    finalResult.push(tempStr);
-  }
-  return finalResult;
-}
-
-/**
- * 检查字符串是否需要切割。
- * @param str - 要检查的字符串。
- * @returns 如果字符串需要切割，则返回 true，否则返回 false。
- */
-function checkNeedSplit(str) {
-  // 检查字符串中是否包含需要切割的特殊字符
-  return str.includes('\n') || str.includes('\\') || str.includes('\r') || str.includes('\t') || str.includes('\v') || str.includes('\f') || str.includes('>') || str.includes('<');
-}
-
-/**
- * @description: 将字符串数组转换为babel的模板字符串节点
- * @param {string[]} strArray - 字符串数组
- * @return {types.CallExpression} - babel的深度扫描的表达式
- */
-function convertToTemplateLiteral(strArray, option) {
-  const quasis = [];
-  const expressions = [];
-  strArray.forEach((str, index) => {
-    if (index === 0) {
-      if (getOriginRegex().test(str)) {
-        quasis.push(types__namespace.templateElement({
-          raw: '',
-          cooked: ''
-        }, false));
-        expressions.push(createI18nTranslator({
-          value: str,
-          isExpression: true,
-          insertOption: option
-        }));
-      } else {
-        quasis.push(types__namespace.templateElement({
-          raw: str,
-          cooked: str
-        }, false));
-      }
-    } else {
-      if (getOriginRegex().test(str)) {
-        expressions.push(createI18nTranslator({
-          value: str,
-          isExpression: true,
-          insertOption: option
-        }));
-      } else {
-        quasis.push(types__namespace.templateElement({
-          raw: str,
-          cooked: str
-        }, false));
-      }
-    }
-  });
-  if (quasis.length === expressions.length) {
-    quasis.push(types__namespace.templateElement({
-      raw: '',
-      cooked: ''
-    }, true));
-  } else if (quasis.length > expressions.length) {
-    quasis[quasis.length - 1].tail = true;
-  }
-  const templateLiteral = types__namespace.templateLiteral(quasis, expressions);
-  const deepScanCall = types__namespace.callExpression(types__namespace.identifier('$deepScan'), [templateLiteral]);
-  // 打印转换结果
-  // console.log('deepScanCall', (generate as any).default(deepScanCall).code)
-  return deepScanCall;
-}
-
 /*
  * @Author: xiaoshanwen
  * @Date: 2023-11-01 16:35:38
@@ -1005,16 +1122,37 @@ function handleTemplateLiteralWithExpressions(node, path) {
     }
     return false;
   }
+  if (!hasExpressionInsideOriginContent(node)) {
+    return false;
+  }
   const {
     trimmedValue,
     valStr
   } = normalizeTranslateValue(fullValue);
-  const id = generateId(valStr);
+  const id = resolveLangKey(generateId(valStr), trimmedValue);
   const translateNode = createTranslateNode(path, id, valStr, expressionLabels, node.expressions);
   path.replaceWith(translateNode);
   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);
@@ -1079,7 +1217,7 @@ function createTrackedTranslateCall(value) {
     trimmedValue,
     valStr
   } = normalizeTranslateValue(value);
-  const id = generateId(valStr);
+  const id = resolveLangKey(generateId(valStr), trimmedValue);
   if (id && trimmedValue) {
     setLangObj(id, trimmedValue);
   }
@@ -1108,16 +1246,53 @@ 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
   } = normalizeTranslateValue(fullValue);
-  const id = generateId(valStr);
+  const id = resolveLangKey(generateId(valStr), trimmedValue);
   if (id && trimmedValue) {
     setLangObj(id, trimmedValue);
   }
   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)) {
@@ -1197,9 +1372,10 @@ function handleTemplateElement(node, insertOption) {
     // 替换为字符类型翻译节点
     node.value.raw = node.value.cooked = `\${${newNode}}`;
     const {
+      trimmedValue,
       valStr
     } = normalizeTranslateValue(value);
-    let id = generateId(valStr);
+    let id = resolveLangKey(generateId(valStr), trimmedValue);
     if (id && value) {
       setLangObj(id, value);
     }