@immense/vue-pom-generator 1.0.61 → 1.0.62

package/dist/index.mjs

@@ -1761,11 +1761,12 @@ function nodeHandlerAttributeInfo(node) {
     return null;
   }
   const exp = handlerDirective.exp;
-  const source = getVueExpressionSource(exp, "content", "compiled");
-  if (!source) {
+  const transformedSource = getVueExpressionSource(exp, "content", "compiled");
+  const authorSource = getVueExpressionSource(exp, "loc", "content", "compiled");
+  if (!authorSource) {
     return null;
   }
-  const mergeKey = `handler:expr:${source}`;
+  const mergeKey = `handler:expr:${authorSource}`;
   const expr = tryGetDirectiveBabelAst(handlerDirective, {
     preferredViews: ["content", "compiled"],
     plugins: ["typescript", "jsx"],
@@ -1773,9 +1774,7 @@ function nodeHandlerAttributeInfo(node) {
     // That is fine for Vue codegen, but our semantic-name extraction needs a normal Babel parse tree.
     preferExistingAst: false
   });
-  if (!expr) {
-    return null;
-  }
+  const fallbackExpr = transformedSource !== authorSource ? tryParseBabelExpressionFromSource(authorSource, ["typescript", "jsx"]) : null;
   const isNodeType2 = (node2, type) => {
     return node2 !== null && node2.type === type;
   };
@@ -2011,59 +2010,73 @@ function nodeHandlerAttributeInfo(node) {
     const limited = parts.slice(0, 2);
     return limited.map((p) => `${toPascalCase(p.key)}${p.value}`).join("");
   };
-  const direct = getLastIdentifierFromMemberChain(expr);
-  if (direct) {
-    return { semanticNameHint: toPascalCase(direct), mergeKey };
-  }
-  if (isArrowFunctionExpressionNode(expr)) {
-    const body = expr.body;
-    const tryFromCallExpression = (call) => {
-      const resolvedCall = isAwaitExpressionNode(call) ? call.argument : call;
-      if (!isCallExpressionNode(resolvedCall)) {
-        return null;
-      }
-      const name = getLastIdentifierFromMemberChain(resolvedCall.callee);
-      if (!name) {
-        return null;
+  const tryFromCallExpression = (call) => {
+    const resolvedCall = isAwaitExpressionNode(call) ? call.argument : call;
+    if (!isCallExpressionNode(resolvedCall)) {
+      return null;
+    }
+    const name = getLastIdentifierFromMemberChain(resolvedCall.callee);
+    if (!name) {
+      return null;
+    }
+    const suffix = getStableSuffixFromCall(resolvedCall);
+    const semanticNameHint2 = suffix ? `${toPascalCase(name)}${suffix}` : toPascalCase(name);
+    return semanticNameHint2;
+  };
+  const resolveSemanticName = (candidateExpr) => {
+    if (!candidateExpr) {
+      return null;
+    }
+    const direct = getLastIdentifierFromMemberChain(candidateExpr);
+    if (direct) {
+      return toPascalCase(direct);
+    }
+    if (isArrowFunctionExpressionNode(candidateExpr)) {
+      const body = candidateExpr.body;
+      const directCall = tryFromCallExpression(body);
+      if (directCall) {
+        return directCall;
+      }
+      if (isAssignmentExpressionNode(body)) {
+        const lhs = getAssignmentTargetName(body.left);
+        if (lhs) {
+          const rhs = stableWordFromValue(body.right);
+          return `Set${toPascalCase(lhs)}${rhs ?? ""}`;
+        }
       }
-      const suffix = getStableSuffixFromCall(resolvedCall);
-      const semanticNameHint = suffix ? `${toPascalCase(name)}${suffix}` : toPascalCase(name);
-      return semanticNameHint;
-    };
-    const directCall = tryFromCallExpression(body);
-    if (directCall) {
-      return { semanticNameHint: directCall, mergeKey };
-    }
-    if (isAssignmentExpressionNode(body)) {
-      const lhs = getAssignmentTargetName(body.left);
-      if (lhs) {
-        const rhs = stableWordFromValue(body.right);
-        const semanticNameHint = `Set${toPascalCase(lhs)}${rhs ?? ""}`;
-        return { semanticNameHint, mergeKey };
-      }
-    }
-    if (isBlockStatementNode(body)) {
-      const stmts = body.body ?? [];
-      if (stmts.length > 0) {
-        const firstStmt = stmts[0];
-        if (isReturnStatementNode(firstStmt)) {
-          const fromReturn = tryFromCallExpression(firstStmt.argument ?? null);
-          if (fromReturn) {
-            return { semanticNameHint: fromReturn, mergeKey };
+      if (isBlockStatementNode(body)) {
+        const stmts = body.body ?? [];
+        if (stmts.length > 0) {
+          const firstStmt = stmts[0];
+          if (isReturnStatementNode(firstStmt)) {
+            const fromReturn = tryFromCallExpression(firstStmt.argument ?? null);
+            if (fromReturn) {
+              return fromReturn;
+            }
           }
-        }
-        if (isExpressionStatementNode(firstStmt)) {
-          const fromExpr = tryFromCallExpression(firstStmt.expression ?? null);
-          if (fromExpr) {
-            return { semanticNameHint: fromExpr, mergeKey };
+          if (isExpressionStatementNode(firstStmt)) {
+            const fromExpr = tryFromCallExpression(firstStmt.expression ?? null);
+            if (fromExpr) {
+              return fromExpr;
+            }
           }
         }
       }
+      const bodyName = getLastIdentifierFromMemberChain(body);
+      if (bodyName) {
+        return toPascalCase(bodyName);
+      }
     }
-    const bodyName = getLastIdentifierFromMemberChain(body);
-    if (bodyName) {
-      return { semanticNameHint: toPascalCase(bodyName), mergeKey };
-    }
+    return null;
+  };
+  const isVueRefValueAccess = (candidate) => {
+    return isMemberExpressionNode(candidate) && candidate.computed === false && isIdentifierNode2(candidate.property) && candidate.property.name === "value";
+  };
+  const transformedSemanticName = resolveSemanticName(expr);
+  const fallbackSemanticName = resolveSemanticName(fallbackExpr);
+  const semanticNameHint = fallbackSemanticName && transformedSource !== authorSource && isVueRefValueAccess(expr) ? fallbackSemanticName : transformedSemanticName ?? fallbackSemanticName;
+  if (semanticNameHint) {
+    return { semanticNameHint, mergeKey };
   }
   return null;
 }