@immense/vue-pom-generator 1.0.38 → 1.0.39

package/dist/index.mjs

@@ -2,10 +2,10 @@ import path from "node:path";
 import process from "node:process";
 import { pathToFileURL, fileURLToPath } from "node:url";
 import fs from "node:fs";
+import { parseExpression, parse } from "@babel/parser";
 import { JSDOM } from "jsdom";
 import { NodeTypes, stringifyExpression, ConstantTypes, createSimpleExpression } from "@vue/compiler-core";
 import { isArrayExpression, isStringLiteral, isTemplateLiteral, isAssignmentExpression, isIdentifier, isMemberExpression, isCallExpression, isExpressionStatement, isArrowFunctionExpression, isOptionalMemberExpression, isObjectExpression, isFile, isBlockStatement, isOptionalCallExpression, isLogicalExpression, isConditionalExpression, isSequenceExpression, isAssignmentPattern, isRestElement, isObjectPattern, isObjectProperty, isProgram, VISITOR_KEYS, isBooleanLiteral, isNumericLiteral, isNullLiteral } from "@babel/types";
-import { parseExpression, parse } from "@babel/parser";
 import { performance } from "node:perf_hooks";
 import * as compilerDom from "@vue/compiler-dom";
 import { parse as parse$2 } from "@vue/compiler-dom";
@@ -4017,6 +4017,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;
@@ -4027,7 +4028,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);
@@ -4068,6 +4071,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 });
@@ -4076,8 +4088,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;
@@ -4088,7 +4101,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) {
@@ -4102,7 +4115,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 });
@@ -4133,6 +4146,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 = 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)) {
@@ -4176,6 +4313,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;
@@ -4189,7 +4327,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) {
@@ -4211,8 +4352,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) {
@@ -4221,10 +4366,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) {
@@ -4378,6 +4528,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