webpack-gc-i18n-plugin 1.1.4 → 1.1.5

package/dist/customLoader/index.cjs

@@ -382,6 +382,219 @@ 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;
+}
+
+/*
+ * @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 getLangKeyByValue(value) {
+  return Object.entries(langObj).find(_ref => {
+    let [, oldValue] = _ref;
+    return oldValue === value;
+  })?.[0];
+}
+function resolveLangKey(key, value) {
+  return getLangKeyByValue(value) || key;
+}
+function isTemplateValue(value) {
+  return /\$\{[^}]+}/.test(value);
+}
+function getTemplateStaticSegments(value) {
+  return value.split(/\$\{[^}]+}/g).filter(item => item);
+}
+function isTemplateStaticSegment(value) {
+  return Object.values(langObj).some(oldValue => isTemplateValue(oldValue) && getTemplateStaticSegments(oldValue).includes(value));
+}
+function removeTemplateStaticSegments(value) {
+  const segments = new Set(getTemplateStaticSegments(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 +716,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 +973,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
@@ -1009,7 +1044,7 @@ function handleTemplateLiteralWithExpressions(node, path) {
     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);
@@ -1079,7 +1114,7 @@ function createTrackedTranslateCall(value) {
     trimmedValue,
     valStr
   } = normalizeTranslateValue(value);
-  const id = generateId(valStr);
+  const id = resolveLangKey(generateId(valStr), trimmedValue);
   if (id && trimmedValue) {
     setLangObj(id, trimmedValue);
   }
@@ -1112,7 +1147,7 @@ function createTemplateLiteralTranslateCall(node) {
     trimmedValue,
     valStr
   } = normalizeTranslateValue(fullValue);
-  const id = generateId(valStr);
+  const id = resolveLangKey(generateId(valStr), trimmedValue);
   if (id && trimmedValue) {
     setLangObj(id, trimmedValue);
   }
@@ -1197,9 +1232,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);
     }