webpack-gc-i18n-plugin 1.1.3 → 1.1.4

package/dist/customLoader/index.cjs

@@ -811,8 +811,6 @@ function setLangObj(key, value) {
  * @returns 处理后的字符串数组
  */
 function splitByRegex(str, separatorRegex) {
-  if (str.includes('\n')) console.log(str, separatorRegex);
-
   // 定义标点符号的正则表达式
   const punctuationRegex = /[，。？！《》,.．：!?""''；'"、0-9\n\r\t\v\f]/;
   // 创建一个新的正则表达式，用于分割字符串
@@ -976,8 +974,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,9 +996,13 @@ 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 {
@@ -999,22 +1010,12 @@ function handleTemplateLiteralWithExpressions(node, path) {
     valStr
   } = normalizeTranslateValue(fullValue);
   const id = generateId(valStr);
-  const translateNode = createTranslateNode(path, id, valStr, placeholders, node.expressions);
+  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 +1026,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 = generateId(valStr);
+  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 = generateId(valStr);
+  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 +1175,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) {