webpack-gc-i18n-plugin 1.1.3 → 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,186 +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) {
-  if (str.includes('\n')) console.log(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
@@ -976,8 +1009,17 @@ function TemplateLiteral (insertOption) {
   };
 }
 function handleTemplateLiteralWithExpressions(node, path) {
-  const placeholders = node.expressions.map(expression => getExpressionPlaceholder(expression));
-  if (placeholders.some(placeholder => !placeholder)) {
+  let hasOptimizedExpression = false;
+  const expressionLabels = node.expressions.map((expression, index) => {
+    const optimizedExpression = optimizeConditionalExpression(expression);
+    if (optimizedExpression) {
+      hasOptimizedExpression = true;
+      node.expressions[index] = optimizedExpression.expression;
+      return optimizedExpression.label;
+    }
+    return getExpressionPlaceholder(expression);
+  });
+  if (expressionLabels.some(placeholder => placeholder === null)) {
     return false;
   }
   const fullValue = node.quasis.reduce((result, quasi, index) => {
@@ -989,32 +1031,26 @@ function handleTemplateLiteralWithExpressions(node, path) {
         console.log('转换异常');
       }
     }
-    return result + value + (index < node.expressions.length ? `\${${placeholders[index]}}` : '');
+    return result + value + (index < node.expressions.length ? formatExpressionPlaceholder(expressionLabels[index]) : '');
   }, '');
   if (!fullValue || !hasOriginSymbols(fullValue) || !option.excludedPattern.length || checkAgainstRegexArray(fullValue, [...option.excludedPattern])) {
+    if (hasOptimizedExpression) {
+      path.skip();
+      return true;
+    }
     return false;
   }
   const {
     trimmedValue,
     valStr
   } = normalizeTranslateValue(fullValue);
-  const id = generateId(valStr);
-  const translateNode = createTranslateNode(path, id, valStr, placeholders, node.expressions);
+  const id = resolveLangKey(generateId(valStr), trimmedValue);
+  const translateNode = createTranslateNode(path, id, valStr, expressionLabels, node.expressions);
   path.replaceWith(translateNode);
-  path.skip();
   setLangObj(id, trimmedValue);
   return true;
 }
 function getExpressionPlaceholder(expression) {
-  if (types.isIdentifier(expression)) {
-    return expression.name;
-  }
-  if (types.isMemberExpression(expression)) {
-    const objectName = getExpressionPlaceholder(expression.object);
-    const propertyName = expression.computed ? getExpressionPlaceholder(expression.property) : types.isIdentifier(expression.property) ? expression.property.name : '';
-    const value = [objectName, propertyName].filter(Boolean).join('.');
-    return cleanVueRuntimePrefix(value);
-  }
   if (types.isStringLiteral(expression) || types.isNumericLiteral(expression)) {
     return String(expression.value);
   }
@@ -1025,21 +1061,142 @@ function getExpressionPlaceholder(expression) {
     return getExpressionPlaceholder(expression.expression);
   }
   const generateCode = generate__namespace.default?.default || generate__namespace.default || generate__namespace;
-  return cleanVueRuntimePrefix(generateCode(expression).code);
+  return generateCode(expression, {
+    comments: false
+  }).code;
+}
+function optimizeConditionalExpression(expression) {
+  if (!types.isConditionalExpression(expression)) return null;
+  const consequent = translateConditionalStringBranch(expression.consequent);
+  const alternate = translateConditionalStringBranch(expression.alternate);
+  if (!consequent.changed && !alternate.changed) return null;
+  return {
+    label: getConditionalExpressionLabel(expression),
+    expression: types.conditionalExpression(types.cloneNode(expression.test), consequent.expression, alternate.expression)
+  };
+}
+function translateConditionalStringBranch(expression) {
+  if (types.isStringLiteral(expression) && hasOriginSymbols(expression.value)) {
+    return {
+      changed: true,
+      expression: createTrackedTranslateCall(expression.value)
+    };
+  }
+  if (types.isTemplateLiteral(expression)) {
+    const translateCall = createTemplateLiteralTranslateCall(expression);
+    if (translateCall) {
+      return {
+        changed: true,
+        expression: translateCall
+      };
+    }
+  }
+  if (types.isConditionalExpression(expression)) {
+    const optimizedExpression = optimizeConditionalExpression(expression);
+    if (optimizedExpression) {
+      return {
+        changed: true,
+        expression: optimizedExpression.expression
+      };
+    }
+  }
+  return {
+    changed: false,
+    expression: types.cloneNode(expression)
+  };
+}
+function createTrackedTranslateCall(value) {
+  const translateCall = createI18nTranslator({
+    value,
+    isExpression: true
+  });
+  const {
+    trimmedValue,
+    valStr
+  } = normalizeTranslateValue(value);
+  const id = resolveLangKey(generateId(valStr), trimmedValue);
+  if (id && trimmedValue) {
+    setLangObj(id, trimmedValue);
+  }
+  return translateCall;
+}
+function createTemplateLiteralTranslateCall(node) {
+  const expressions = node.expressions.map(expression => {
+    const optimizedExpression = optimizeConditionalExpression(expression);
+    return optimizedExpression ? optimizedExpression.expression : expression;
+  });
+  const expressionLabels = expressions.map(expression => getExpressionPlaceholder(expression));
+  if (expressionLabels.some(placeholder => placeholder === null)) {
+    return null;
+  }
+  const fullValue = node.quasis.reduce((result, quasi, index) => {
+    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 result + value + (index < expressions.length ? formatExpressionPlaceholder(expressionLabels[index]) : '');
+  }, '');
+  if (!fullValue || !hasOriginSymbols(fullValue) || !option.excludedPattern.length || checkAgainstRegexArray(fullValue, [...option.excludedPattern])) {
+    return null;
+  }
+  const {
+    trimmedValue,
+    valStr
+  } = normalizeTranslateValue(fullValue);
+  const id = resolveLangKey(generateId(valStr), trimmedValue);
+  if (id && trimmedValue) {
+    setLangObj(id, trimmedValue);
+  }
+  return createTranslateCall(id, valStr, expressionLabels, expressions);
+}
+function getConditionalExpressionLabel(expression) {
+  const test = expression.test;
+  if (types.isBinaryExpression(test) || types.isLogicalExpression(test)) {
+    return getExpressionPlaceholder(test.left);
+  }
+  return getExpressionPlaceholder(test);
+}
+function formatExpressionPlaceholder(placeholder) {
+  if (placeholder === null) return '';
+  return placeholder.trim() ? `\${${placeholder}}` : placeholder;
 }
 function createTranslateNode(path, id, valStr) {
   let placeholders = arguments.length > 3 && arguments[3] !== undefined ? arguments[3] : [];
   let expressions = arguments.length > 4 && arguments[4] !== undefined ? arguments[4] : [];
-  const args = [types.stringLiteral(id), types.stringLiteral(valStr)];
-  if (placeholders.length) {
-    args.push(types.objectExpression(placeholders.map((placeholder, index) => types.objectProperty(types.stringLiteral(placeholder), types.cloneNode(expressions[index])))));
-  }
-  const translateCall = types.callExpression(types.identifier(option.translateKey), args);
+  const translateCall = createTranslateCall(id, valStr, placeholders, expressions);
   if (!isVueTemplateRender(path)) {
     return translateCall;
   }
   return types.sequenceExpression([createVueTemplateLanguageDependency(), translateCall]);
 }
+function createTranslateCall(id, valStr) {
+  let placeholders = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : [];
+  let expressions = arguments.length > 3 && arguments[3] !== undefined ? arguments[3] : [];
+  const args = [types.stringLiteral(id), types.stringLiteral(valStr)];
+  if (placeholders.length) {
+    const placeholderEntries = placeholders.map((placeholder, index) => ({
+      placeholder,
+      expression: expressions[index]
+    })).filter(_ref => {
+      let {
+        placeholder
+      } = _ref;
+      return placeholder && placeholder.trim();
+    });
+    args.push(types.objectExpression(placeholderEntries.map(_ref2 => {
+      let {
+        placeholder,
+        expression
+      } = _ref2;
+      return types.objectProperty(types.stringLiteral(placeholder), types.cloneNode(expression));
+    })));
+  }
+  return types.callExpression(types.identifier(option.translateKey), args);
+}
 function isVueTemplateRender(path) {
   return Boolean(path.scope?.getBinding('_vm'));
 }
@@ -1053,9 +1210,6 @@ function createVueTemplateLanguageDependency() {
   const i18nLocale = types.logicalExpression('&&', types.cloneNode(i18n), types.memberExpression(types.cloneNode(i18n), types.identifier('locale')));
   return types.logicalExpression('||', storeLanguage, i18nLocale);
 }
-function cleanVueRuntimePrefix(value) {
-  return value.replace(/^(?:\$setup|_ctx|_vm|this)\./, '').replace(/([^\w$.])(?:\$setup|_ctx|_vm|this)\./g, '$1');
-}
 
 // 处理模板元素
 function handleTemplateElement(node, insertOption) {
@@ -1078,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);
     }