webpack-gc-i18n-plugin 1.1.14 → 1.1.15

package/dist/customLoader/index.cjs

@@ -1069,6 +1069,8 @@ let TranslateTypeEnum = /*#__PURE__*/function (TranslateTypeEnum) {
  * @FilePath: /i18n_translation_vite/packages/autoI18nPluginCore/src/option.ts
  */
 
+const DEFAULT_ORIGIN_LANG = 'zh-cn';
+const DEFAULT_TARGET_LANG_LIST = ['zh-tw'];
 /**
  * 默认插件配置选项
  */
@@ -1092,10 +1094,10 @@ const DEFAULT_OPTION = {
   distPath: '',
   /** 打包后生成文件的主文件名称，默认是 'index' */
   distKey: 'index',
-  /** 来源语言，默认是中文 */
-  originLang: OriginLangKeyEnum.ZH,
-  /** 翻译目标语言列表，默认包含英文 */
-  targetLangList: ['en'],
+  /** 来源语言，由插件固定使用默认值 */
+  originLang: DEFAULT_ORIGIN_LANG,
+  /** 翻译目标语言列表，由插件固定使用默认值 */
+  targetLangList: [...DEFAULT_TARGET_LANG_LIST],
   /** 语言key，用于请求谷歌api和生成配置文件下对应语言的内容文件 */
   langKey: [],
   /** 命名空间，防止全局命名冲突 */
@@ -1613,7 +1615,7 @@ function StringLiteralFn (insertOption) {
 
       // 防止导入语句，只处理那些当前节点不是键值对的键的字符串字面量，调用语句判断当前调用语句是否包含需要过滤的调用语句
       if (isTranslateCall(parent) || types__namespace.isImportDeclaration(parent) || parent.key === node || types__namespace.isCallExpression(parent) && extractFnName && (option.excludedCall.includes(extractFnName) || extractFnName?.split('.')?.pop() && option.excludedCall.includes(extractFnName?.split('.')?.pop() || ''))) return;
-      const vueVNodeCallPath = getVueCompiledVNodeCallPath(path);
+      const vueVNodeInfo = getVueCompiledVNodeInfo(path);
       let replaceNode;
       if (option.deepScan && checkNeedSplit(value)) {
         replaceNode = convertToTemplateLiteral(splitByRegex(value, getOriginRegex()), insertOption);
@@ -1632,26 +1634,38 @@ function StringLiteralFn (insertOption) {
         });
       }
       path.replaceWith(replaceNode);
-      markVueCompiledVNodeDynamic(vueVNodeCallPath);
+      markVueCompiledVNodeDynamic(vueVNodeInfo?.callPath, vueVNodeInfo?.dynamicPropName);
     }
   };
 }
-function getVueCompiledVNodeCallPath(path) {
+function getVueCompiledVNodeInfo(path) {
   const callPath = path.parentPath;
-  if (!callPath || !types__namespace.isCallExpression(callPath.node)) return;
-  if (!isVueVNodeCreateCall(callPath.node)) return;
-  if (path.listKey !== 'arguments' || path.key !== 2) return;
-  return callPath;
+  if (callPath && types__namespace.isCallExpression(callPath.node) && isVueVNodeCreateCall(callPath.node) && path.listKey === 'arguments' && path.key === 2) {
+    return {
+      callPath
+    };
+  }
+  const propertyPath = path.parentPath;
+  const propsPath = propertyPath?.parentPath;
+  const vnodeCallPath = propsPath?.parentPath;
+  if (!propertyPath || !types__namespace.isObjectProperty(propertyPath.node) || propertyPath.node.value !== path.node || propertyPath.node.computed || !propsPath || !types__namespace.isObjectExpression(propsPath.node) || propsPath.listKey !== 'arguments' || propsPath.key !== 1 || !vnodeCallPath || !types__namespace.isCallExpression(vnodeCallPath.node) || !isVueVNodeCreateCall(vnodeCallPath.node)) return;
+  const key = propertyPath.node.key;
+  const dynamicPropName = types__namespace.isIdentifier(key) ? key.name : types__namespace.isStringLiteral(key) ? key.value : undefined;
+  if (!dynamicPropName) return;
+  return {
+    callPath: vnodeCallPath,
+    dynamicPropName
+  };
 }
-function markVueCompiledVNodeDynamic(callPath) {
+function markVueCompiledVNodeDynamic(callPath, dynamicPropName) {
   if (!callPath || !types__namespace.isCallExpression(callPath.node)) return;
-  const patchFlag = callPath.node.arguments[3];
-  if (isCachedPatchFlag(patchFlag)) {
-    const textPatchFlag = types__namespace.numericLiteral(1);
-    textPatchFlag.leadingComments = null;
-    textPatchFlag.innerComments = null;
-    textPatchFlag.trailingComments = null;
-    callPath.node.arguments[3] = textPatchFlag;
+  if (dynamicPropName) {
+    markVueCompiledPropDynamic(callPath.node, dynamicPropName);
+  } else {
+    const patchFlag = callPath.node.arguments[3];
+    if (isCachedPatchFlag(patchFlag)) {
+      callPath.node.arguments[3] = createPatchFlag(1);
+    }
   }
   const logicalPath = callPath.findParent(parentPath => {
     const node = parentPath.node;
@@ -1663,6 +1677,33 @@ function markVueCompiledVNodeDynamic(callPath) {
     logicalPath.replaceWith(callPath.node);
   }
 }
+function markVueCompiledPropDynamic(call, propName) {
+  while (call.arguments.length < 3) {
+    call.arguments.push(types__namespace.nullLiteral());
+  }
+  const patchFlag = call.arguments[3];
+  if (!patchFlag || isCachedPatchFlag(patchFlag)) {
+    call.arguments[3] = createPatchFlag(8);
+  } else if (types__namespace.isNumericLiteral(patchFlag) && (patchFlag.value & 8) !== 8) {
+    call.arguments[3] = createPatchFlag(patchFlag.value | 8);
+  }
+  const dynamicProps = call.arguments[4];
+  if (types__namespace.isArrayExpression(dynamicProps)) {
+    const hasProp = dynamicProps.elements.some(element => types__namespace.isStringLiteral(element) && element.value === propName);
+    if (!hasProp) {
+      dynamicProps.elements.push(types__namespace.stringLiteral(propName));
+    }
+  } else {
+    call.arguments[4] = types__namespace.arrayExpression([types__namespace.stringLiteral(propName)]);
+  }
+}
+function createPatchFlag(value) {
+  const patchFlag = types__namespace.numericLiteral(value);
+  patchFlag.leadingComments = null;
+  patchFlag.innerComments = null;
+  patchFlag.trailingComments = null;
+  return patchFlag;
+}
 function isCachedPatchFlag(node) {
   return types__namespace.isNumericLiteral(node) && node.value === -1 || types__namespace.isUnaryExpression(node) && node.operator === '-' && types__namespace.isNumericLiteral(node.argument) && node.argument.value === 1;
 }