@immense/vue-pom-generator 1.0.38 → 1.0.40

package/dist/index.cjs

@@ -26,10 +26,10 @@ const path = require("node:path");
 const process = require("node:process");
 const node_url = require("node:url");
 const fs = require("node:fs");
+const parser = require("@babel/parser");
 const jsdom = require("jsdom");
 const compilerCore = require("@vue/compiler-core");
 const types = require("@babel/types");
-const parser = require("@babel/parser");
 const node_perf_hooks = require("node:perf_hooks");
 const compilerDom = require("@vue/compiler-dom");
 const compilerSfc = require("@vue/compiler-sfc");
@@ -2095,9 +2095,6 @@ Fix: either (1) include ${args.bestKeyPlaceholder} in your :${attrLabel} templat
   })();
   const tryMergeWithExistingPrimary = (candidateActionName) => {
     const mergeKey = (args.pomMergeKey ?? "").trim();
-    if (isKeyed) {
-      return false;
-    }
     const existingEntry = primaryByActionName.get(candidateActionName);
     const existingPom = existingEntry?.pom;
     if (!existingEntry || !existingPom) {
@@ -2108,6 +2105,9 @@ Fix: either (1) include ${args.bestKeyPlaceholder} in your :${attrLabel} templat
       ...existingPom.alternateFormattedDataTestIds ?? []
     ];
     const sharesSelectorIdentity = existingSelectors.includes(formattedDataTestIdForPom);
+    if (isKeyed && !sharesSelectorIdentity) {
+      return false;
+    }
     if (!mergeKey && !sharesSelectorIdentity) {
       return false;
     }
@@ -2154,6 +2154,11 @@ Fix: either (1) include ${args.bestKeyPlaceholder} in your :${attrLabel} templat
           conflicts = false;
         }
       }
+      if (conflicts && nameCollisionBehavior === "error" && tryMergeWithExistingPrimary(actionName)) {
+        methodName = candidate;
+        mergedIntoExisting = true;
+        break;
+      }
       if (conflicts && nameCollisionBehavior === "error") {
         const roleSuffix = upperFirst(normalizedRole || "Element");
         const baseNameUpper = upperFirst(baseWithSuffix);
@@ -2200,11 +2205,6 @@ Fix: either (1) include ${args.bestKeyPlaceholder} in your :${attrLabel} templat
         reservedMembers.add(actionName);
         break;
       }
-      if (nameCollisionBehavior === "error" && tryMergeWithExistingPrimary(actionName)) {
-        methodName = candidate;
-        mergedIntoExisting = true;
-        break;
-      }
       if (!collisionDetails) {
         collisionDetails = { getterName: chosenGetterName, actionName };
         collisionHint = hint || (args.semanticNameHint ?? "").trim() || null;
@@ -3781,6 +3781,7 @@ function generateAggregatedCSharpFiles(componentHierarchyMap, outDir, options =
         chunks.push("    {");
         if (pom.formattedDataTestId.includes("${") || allTestIds.length <= 1) {
           chunks.push(`        await ${locatorName}${pom.formattedDataTestId.includes("${") ? `(${args})` : ""}.ClickAsync();`);
+          chunks.push(`        return new ${target}(Page);`);
         } else {
           chunks.push("        Exception? lastError = null;");
           chunks.push(`        foreach (var testId in new[] { ${allTestIds.map(toCSharpTestIdExpression).join(", ")} })`);
@@ -3801,7 +3802,6 @@ function generateAggregatedCSharpFiles(componentHierarchyMap, outDir, options =
           chunks.push("        }");
           chunks.push('        throw lastError ?? new System.Exception("[pom] Failed to navigate using any candidate test id.");');
         }
-        chunks.push(`        return new ${target}(Page);`);
         chunks.push("    }");
         chunks.push("");
         continue;
@@ -4058,6 +4058,7 @@ function generateViewObjectModelContent(componentName, dependencies, componentHi
   };
   const customPomClassIdentifierMap = options.customPomClassIdentifierMap ?? {};
   const customPomAvailableClassIdentifiers = options.customPomAvailableClassIdentifiers ?? /* @__PURE__ */ new Set();
+  const customPomMethodSignaturesByClass = options.customPomMethodSignaturesByClass ?? /* @__PURE__ */ new Map();
   const attachmentsForThisClass = customPomAttachments.filter((a) => {
     if (!Object.prototype.hasOwnProperty.call(customPomClassIdentifierMap, a.className))
       return false;
@@ -4068,7 +4069,9 @@ function generateViewObjectModelContent(componentName, dependencies, componentHi
     return a.attachWhenUsesComponents.some((c) => hasChildComponent(c));
   }).map((a) => ({
     className: customPomClassIdentifierMap[a.className],
-    propertyName: a.propertyName
+    propertyName: a.propertyName,
+    flatten: a.flatten ?? false,
+    methodSignatures: a.flatten ? customPomMethodSignaturesByClass.get(a.className) ?? /* @__PURE__ */ new Map() : /* @__PURE__ */ new Map()
   }));
   let content = "";
   const sourceRel = toPosixRelativePath(outputDir, filePath);
@@ -4109,6 +4112,15 @@ export class ${className} extends BasePage {
 `;
   const widgetInstances = isView ? getWidgetInstancesForView(componentName, dependencies.dataTestIdSet, customPomAvailableClassIdentifiers) : [];
   const componentRefsForInstances = isView ? usedComponentSet?.size ? usedComponentSet : childrenComponentSet : childrenComponentSet;
+  const childInstancePropertyNames = Array.from(componentRefsForInstances).filter((child) => componentHierarchyMap.has(child) && componentHierarchyMap.get(child)?.dataTestIdSet.size).map((child) => child.split(".vue")[0]);
+  const blockedViewPassthroughMethodNames = new Set(
+    attachmentsForThisClass.filter((a) => a.flatten).flatMap((a) => Array.from(a.methodSignatures.keys()))
+  );
+  const reservedAttachmentPassthroughNames = /* @__PURE__ */ new Set([
+    ...attachmentsForThisClass.map((a) => a.propertyName),
+    ...widgetInstances.map((w) => w.propertyName),
+    ...childInstancePropertyNames
+  ]);
   if (isView && (componentRefsForInstances.size > 0 || attachmentsForThisClass.length > 0 || widgetInstances.length > 0)) {
     content += getComponentInstances(componentRefsForInstances, componentHierarchyMap, attachmentsForThisClass, widgetInstances);
     content += getConstructor(componentRefsForInstances, componentHierarchyMap, attachmentsForThisClass, widgetInstances, { testIdAttribute });
@@ -4117,8 +4129,9 @@ export class ${className} extends BasePage {
     content += getComponentInstances(/* @__PURE__ */ new Set(), componentHierarchyMap, attachmentsForThisClass);
     content += getConstructor(/* @__PURE__ */ new Set(), componentHierarchyMap, attachmentsForThisClass, [], { testIdAttribute });
   }
+  content += getAttachmentPassthroughMethods(componentName, dependencies, attachmentsForThisClass, reservedAttachmentPassthroughNames);
   if (isView && componentRefsForInstances.size === 1) {
-    content += getViewPassthroughMethods(componentName, dependencies, componentRefsForInstances, componentHierarchyMap);
+    content += getViewPassthroughMethods(componentName, dependencies, componentRefsForInstances, componentHierarchyMap, blockedViewPassthroughMethodNames);
   }
   if (isView && options.vueRouterFluentChaining) {
     const routeMeta = options.routeMetaByComponent?.[componentName] ?? null;
@@ -4129,7 +4142,7 @@ export class ${className} extends BasePage {
   content += "}\n";
   return content;
 }
-function getViewPassthroughMethods(viewName, viewDependencies, childrenComponentSet, componentHierarchyMap) {
+function getViewPassthroughMethods(viewName, viewDependencies, childrenComponentSet, componentHierarchyMap, blockedMethodNames = /* @__PURE__ */ new Set()) {
   const existingOnView = viewDependencies.generatedMethods ?? /* @__PURE__ */ new Map();
   const methodToChildren = /* @__PURE__ */ new Map();
   for (const child of childrenComponentSet) {
@@ -4143,7 +4156,7 @@ function getViewPassthroughMethods(viewName, viewDependencies, childrenComponent
     for (const [name, sig] of methods.entries()) {
       if (!sig)
         continue;
-      if (existingOnView.has(name))
+      if (existingOnView.has(name) || blockedMethodNames.has(name))
         continue;
       const list = methodToChildren.get(name) ?? [];
       list.push({ childProp, params: sig.params, argNames: sig.argNames });
@@ -4174,6 +4187,130 @@ function getViewPassthroughMethods(viewName, viewDependencies, childrenComponent
     ""
   ].join("\n");
 }
+function getAttachmentPassthroughMethods(ownerName, ownerDependencies, attachmentsForThisClass, reservedMemberNames) {
+  if (!attachmentsForThisClass.some((a) => a.flatten && a.methodSignatures.size > 0)) {
+    return "";
+  }
+  const existingOnClass = ownerDependencies.generatedMethods ?? /* @__PURE__ */ new Map();
+  const methodToAttachments = /* @__PURE__ */ new Map();
+  for (const attachment of attachmentsForThisClass) {
+    if (!attachment.flatten) {
+      continue;
+    }
+    for (const [methodName, signature] of attachment.methodSignatures.entries()) {
+      if (methodName === "constructor" || existingOnClass.has(methodName) || reservedMemberNames.has(methodName)) {
+        continue;
+      }
+      const list = methodToAttachments.get(methodName) ?? [];
+      list.push({
+        propertyName: attachment.propertyName,
+        params: signature.params,
+        argNames: signature.argNames
+      });
+      methodToAttachments.set(methodName, list);
+    }
+  }
+  const sorted = Array.from(methodToAttachments.entries()).sort((a, b) => a[0].localeCompare(b[0]));
+  const lines = [];
+  for (const [methodName, candidates] of sorted) {
+    if (candidates.length !== 1) {
+      continue;
+    }
+    const { propertyName, params, argNames } = candidates[0];
+    const callArgs = argNames.join(", ");
+    const invocation = callArgs ? `this.${propertyName}.${methodName}(${callArgs})` : `this.${propertyName}.${methodName}()`;
+    lines.push(
+      "",
+      `    ${methodName}(${params}) {`,
+      `        return ${invocation};`,
+      "    }"
+    );
+  }
+  if (!lines.length) {
+    return "";
+  }
+  return [
+    "",
+    `    // Passthrough methods composed from custom helper attachments of ${ownerName}.`,
+    ...lines,
+    ""
+  ].join("\n");
+}
+function sliceNodeSource(source, node) {
+  if (node.start == null || node.end == null) {
+    return null;
+  }
+  const snippet = source.slice(node.start, node.end).trim();
+  return snippet.length ? snippet : null;
+}
+function getCustomPomCallArgumentName(param) {
+  if (param.type === "Identifier") {
+    return param.name;
+  }
+  if (param.type === "AssignmentPattern") {
+    return param.left.type === "Identifier" ? param.left.name : null;
+  }
+  if (param.type === "RestElement") {
+    return param.argument.type === "Identifier" ? `...${param.argument.name}` : null;
+  }
+  return null;
+}
+function extractCustomPomMethodSignatures(source, exportName) {
+  const signatures = /* @__PURE__ */ new Map();
+  let ast;
+  try {
+    ast = parser.parse(source, {
+      sourceType: "module",
+      plugins: ["typescript", "jsx"]
+    });
+  } catch {
+    return signatures;
+  }
+  for (const statement of ast.program.body) {
+    if (statement.type !== "ExportNamedDeclaration" || !statement.declaration || statement.declaration.type !== "ClassDeclaration") {
+      continue;
+    }
+    const declaration = statement.declaration;
+    if (declaration.id?.name !== exportName) {
+      continue;
+    }
+    for (const member of declaration.body.body) {
+      if (member.type !== "ClassMethod" || member.kind !== "method" || member.static || member.computed) {
+        continue;
+      }
+      if (member.accessibility === "private" || member.accessibility === "protected") {
+        continue;
+      }
+      if (member.key.type !== "Identifier") {
+        continue;
+      }
+      const params = [];
+      const argNames = [];
+      let supported = true;
+      member.params.forEach((param) => {
+        if (!supported) {
+          return;
+        }
+        const paramSource = sliceNodeSource(source, param);
+        const argName = getCustomPomCallArgumentName(param);
+        if (!paramSource || !argName) {
+          supported = false;
+          return;
+        }
+        params.push(paramSource);
+        argNames.push(argName);
+      });
+      if (!supported) {
+        continue;
+      }
+      signatures.set(member.key.name, {
+        params: params.join(", "),
+        argNames
+      });
+    }
+  }
+  return signatures;
+}
 function ensureDir(dir) {
   const normalized = dir.replace(/\\/g, "/");
   if (!fs.existsSync(normalized)) {
@@ -4217,6 +4354,7 @@ async function generateAggregatedFiles(componentHierarchyMap, vueFilesPathMap, b
       ]);
       const usedImportIdentifiers = /* @__PURE__ */ new Set();
       const customPomClassIdentifierMap2 = {};
+      const customPomMethodSignaturesByClass2 = /* @__PURE__ */ new Map();
       const ensureUniqueIdentifier = (base2) => {
         let candidate = base2;
         let i = 2;
@@ -4230,7 +4368,10 @@ async function generateAggregatedFiles(componentHierarchyMap, vueFilesPathMap, b
       const customDirRelOrAbs = options.customPomDir ?? "tests/playwright/pom/custom";
       const customDirAbs = path.isAbsolute(customDirRelOrAbs) ? customDirRelOrAbs : path.resolve(projectRoot, customDirRelOrAbs);
       if (!fs.existsSync(customDirAbs)) {
-        return;
+        return {
+          classIdentifierMap: customPomClassIdentifierMap2,
+          methodSignaturesByClass: customPomMethodSignaturesByClass2
+        };
       }
       const files = fs.readdirSync(customDirAbs).filter((f) => f.endsWith(".ts")).sort((a, b) => a.localeCompare(b));
       for (const file of files) {
@@ -4252,8 +4393,12 @@ Fix by setting generation.playwright.customPoms.importAliases["${exportName}"] t
         } else {
           localIdentifier = ensureUniqueIdentifier(requested);
         }
-        customPomClassIdentifierMap2[exportName] = localIdentifier;
         const customFileAbs = path.join(customDirAbs, file);
+        customPomClassIdentifierMap2[exportName] = localIdentifier;
+        const customPomMethodSignatures = extractCustomPomMethodSignatures(fs.readFileSync(customFileAbs, "utf8"), exportName);
+        if (customPomMethodSignatures.size > 0) {
+          customPomMethodSignaturesByClass2.set(exportName, customPomMethodSignatures);
+        }
         const fromOutputDir = outputDir;
         const importPath = stripExtension(toPosixRelativePath(fromOutputDir, customFileAbs));
         if (localIdentifier !== exportName) {
@@ -4262,10 +4407,15 @@ Fix by setting generation.playwright.customPoms.importAliases["${exportName}"] t
           imports.push(`import { ${exportName} } from "${importPath}";`);
         }
       }
-      return customPomClassIdentifierMap2;
+      return {
+        classIdentifierMap: customPomClassIdentifierMap2,
+        methodSignaturesByClass: customPomMethodSignaturesByClass2
+      };
     };
-    const customPomClassIdentifierMap = addCustomPomImports();
-    const customPomAvailableClassIdentifiers = new Set(Object.values(customPomClassIdentifierMap ?? {}));
+    const customPomImportResolution = addCustomPomImports();
+    const customPomClassIdentifierMap = customPomImportResolution?.classIdentifierMap ?? {};
+    const customPomMethodSignaturesByClass = customPomImportResolution?.methodSignaturesByClass ?? /* @__PURE__ */ new Map();
+    const customPomAvailableClassIdentifiers = new Set(Object.values(customPomClassIdentifierMap));
     const referencedTargets = /* @__PURE__ */ new Set();
     for (const [, deps] of items) {
       for (const dt of deps.dataTestIdSet) {
@@ -4419,6 +4569,7 @@ Fix by setting generation.playwright.customPoms.importAliases["${exportName}"] t
         customPomAttachments: options.customPomAttachments ?? [],
         customPomClassIdentifierMap,
         customPomAvailableClassIdentifiers,
+        customPomMethodSignaturesByClass,
         testIdAttribute: options.testIdAttribute,
         vueRouterFluentChaining: options.vueRouterFluentChaining,
         routeMetaByComponent: options.routeMetaByComponent