@immense/vue-pom-generator 1.0.64 → 1.0.65

package/RELEASE_NOTES.md

@@ -1,48 +1,31 @@
-● Based on the commit message and changes, here are the release notes:
+● ## v1.0.65
 
-  ---
+  ### Highlights
 
-  # v1.0.64
+  - Fixed parsing of guarded handler expressions (e.g., `@click="condition && handler"`)
+  - Improved semantic name resolution for wrapped and conditional event handlers
+  - Enhanced Vue compiler AST traversal to handle logical expressions (`&&` operators)
 
-  ## Highlights
+  ### Changes
 
-  - **TypeScript template expression support** – Compiler now parses TypeScript annotations in Vue
-   template expressions (e.g., `@row-click="(row: RowType) => ..."`), fixing crashes in Nuxt 4 +
-  TS codebases
-  - **Graceful submit-button fallback** – Submit buttons with dynamic labels now respect
-  `missingSemanticNameBehavior: "ignore"` and generate `SubmitButton` / `clickSubmit()` methods
-  instead of throwing
-  - **Improved TypeScript compatibility** – All three plugin compilation paths (dev-plugin,
-  build-plugin, vue-plugin) now support TypeScript expression syntax
+  **Parser Improvements**
+  - Added support for `LogicalExpression` nodes in handler attribute parsing
+  - Introduced `unwrapSemanticHelperCall` to handle Vue compiler helpers (`_unref`,
+  `_withModifiers`, etc.)
+  - Refactored `resolveSemanticName` to recursively unwrap nested expressions and guarded calls
+  - Handler names now correctly extracted from conditional expressions like `isValid &&
+  submitForm`
 
-  ## Changes
+  **Testing**
+  - Added test coverage for guarded handler scenarios
+  - Updated transform and utils test suites to validate new parsing logic
 
-  ### Parser Enhancements
-  - Added `expressionPlugins: ["typescript"]` to all `compilerDom.compile()` call sites
-  (dev-plugin, build-plugin, vue-plugin)
-  - Vue plugin merges expression plugins with user-supplied `userCompilerOptions` to preserve
-  custom configuration
+  ### Pull Requests Included
 
-  ### Submit Button Handling
-  - Submit buttons with dynamic inner text (e.g., ternary expressions like `{{ isNew ? 'Create' :
-  'Save' }}`) now honor `missingSemanticNameBehavior: "ignore"` option
-  - Falls back to literal `"submit"` identifier when semantic name cannot be derived, generating
-  `SubmitButton` / `clickSubmit()` POM surface
-  - Default behavior (throwing on missing semantic name) remains unchanged
+  No pull request was created for this fix; it was committed directly to `main`.
 
   ### Testing
-  - Added 3 regression tests for TypeScript expression parsing and submit-button fallback behavior
-  - Test suite: 163 → 166 tests passing
-  - All validation passes: typecheck, eslint, build
 
-  ## Pull Requests Included
-
-  - fix: parse TypeScript template expressions + allow submit-button fallback
-  [#20](https://github.com/immense/vue-pom-generator/pull/20)
-
-  ## Testing
-
-  Validated on Nuxt 4 + Vue 3 + TypeScript codebase. Three new regression tests added covering
-  TypeScript expression parsing and submit-button fallback scenarios. Full test suite passes (166
-  tests).
+  Validated with expanded unit test coverage in `tests/transform.test.ts` and
+  `tests/utils-coverage.test.ts`.
 

package/dist/index.cjs

@@ -1895,6 +1895,12 @@ function nodeHandlerAttributeInfo(node) {
     const n = node2;
     return typeof n.computed === "boolean" && typeof n.key === "object" && n.key !== null && typeof n.value === "object" && n.value !== null;
   };
+  const isLogicalExpressionNode = (node2) => {
+    if (!isNodeType2(node2, "LogicalExpression"))
+      return false;
+    const n = node2;
+    return typeof n.operator === "string" && typeof n.left === "object" && n.left !== null && typeof n.right === "object" && n.right !== null;
+  };
   const getLastIdentifierFromMemberChain = (node2) => {
     if (!node2)
       return null;
@@ -2065,48 +2071,66 @@ function nodeHandlerAttributeInfo(node) {
     const semanticNameHint2 = suffix ? `${toPascalCase(name)}${suffix}` : toPascalCase(name);
     return semanticNameHint2;
   };
+  const unwrapSemanticHelperCall = (candidateExpr) => {
+    if (!isCallExpressionNode(candidateExpr)) {
+      return null;
+    }
+    const calleeName = getLastIdentifierFromMemberChain(candidateExpr.callee);
+    if (calleeName !== "_unref" && calleeName !== "unref" && calleeName !== "_withModifiers" && calleeName !== "withModifiers") {
+      return null;
+    }
+    const firstArg = candidateExpr.arguments[0];
+    return typeof firstArg === "object" && firstArg !== null ? firstArg : null;
+  };
   const resolveSemanticName = (candidateExpr) => {
     if (!candidateExpr) {
       return null;
     }
+    const unwrappedHelperCandidate = unwrapSemanticHelperCall(candidateExpr);
+    if (unwrappedHelperCandidate) {
+      return resolveSemanticName(unwrappedHelperCandidate);
+    }
     const direct = getLastIdentifierFromMemberChain(candidateExpr);
     if (direct) {
       return toPascalCase(direct);
     }
+    const directCall = tryFromCallExpression(candidateExpr);
+    if (directCall) {
+      return directCall;
+    }
+    if (isAssignmentExpressionNode(candidateExpr)) {
+      const lhs = getAssignmentTargetName(candidateExpr.left);
+      if (lhs) {
+        const rhs = stableWordFromValue(candidateExpr.right);
+        return `Set${toPascalCase(lhs)}${rhs ?? ""}`;
+      }
+    }
+    if (isLogicalExpressionNode(candidateExpr) && candidateExpr.operator === "&&") {
+      return resolveSemanticName(candidateExpr.right);
+    }
     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 ?? ""}`;
-        }
-      }
       if (isBlockStatementNode(body)) {
         const stmts = body.body ?? [];
         if (stmts.length > 0) {
           const firstStmt = stmts[0];
           if (isReturnStatementNode(firstStmt)) {
-            const fromReturn = tryFromCallExpression(firstStmt.argument ?? null);
+            const fromReturn = resolveSemanticName(firstStmt.argument ?? null);
             if (fromReturn) {
               return fromReturn;
             }
           }
           if (isExpressionStatementNode(firstStmt)) {
-            const fromExpr = tryFromCallExpression(firstStmt.expression ?? null);
+            const fromExpr = resolveSemanticName(firstStmt.expression ?? null);
             if (fromExpr) {
               return fromExpr;
             }
           }
         }
       }
-      const bodyName = getLastIdentifierFromMemberChain(body);
+      const bodyName = resolveSemanticName(body);
       if (bodyName) {
-        return toPascalCase(bodyName);
+        return bodyName;
       }
     }
     return null;