@immense/vue-pom-generator 1.0.37 → 1.0.39

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");
@@ -3519,7 +3519,8 @@ async function generateFiles(componentHierarchyMap, vueFilesPathMap, basePageCla
     const fixtureRegistryFile = maybeGenerateFixtureRegistry(componentHierarchyMap, {
       generateFixtures,
       pomOutDir: outDir,
-      projectRoot
+      projectRoot,
+      customPomDir
     });
     if (fixtureRegistryFile) {
       writeGeneratedFile(fixtureRegistryFile);
@@ -3918,6 +3919,9 @@ function maybeGenerateFixtureRegistry(componentHierarchyMap, options) {
   const fixtureFileName = looksLikeFilePath ? path.basename(fixtureOutRel) : "fixtures.g.ts";
   const root = options.projectRoot ?? process.cwd();
   const fixtureOutDirAbs = path.isAbsolute(fixtureOutDirRel) ? fixtureOutDirRel : path.resolve(root, fixtureOutDirRel);
+  const customPomDirRel = options.customPomDir ?? "tests/playwright/pom/custom";
+  const customPomDirAbs = path.isAbsolute(customPomDirRel) ? customPomDirRel : path.resolve(root, customPomDirRel);
+  const overridePomDirAbs = path.resolve(path.dirname(customPomDirAbs), "overrides");
   const pomDirAbs = path.isAbsolute(pomOutDir) ? pomOutDir : path.resolve(root, pomOutDir);
   const pomImport = toPosixRelativePath(fixtureOutDirAbs, pomDirAbs);
   const viewClassNames = Array.from(componentHierarchyMap.entries()).filter(([, deps]) => !!deps.isView).map(([name]) => name).sort((a, b) => a.localeCompare(b));
@@ -3940,6 +3944,22 @@ function maybeGenerateFixtureRegistry(componentHierarchyMap, options) {
       return false;
     return true;
   }).sort((a, b) => a.localeCompare(b));
+  const fixtureClassNames = [...viewClassNames, ...componentClassNames];
+  const overrideCtorEntries = fixtureClassNames.map((name) => {
+    const overrideFilePath = path.join(overridePomDirAbs, `${name}.ts`);
+    if (!fs.existsSync(overrideFilePath))
+      return null;
+    return {
+      className: name,
+      localIdentifier: `${name}Override`,
+      importSpecifier: stripExtension(toPosixRelativePath(fixtureOutDirAbs, overrideFilePath))
+    };
+  }).filter((entry) => !!entry);
+  const overrideCtorByClassName = new Map(overrideCtorEntries.map((entry) => [entry.className, entry.localIdentifier]));
+  const overrideImports = overrideCtorEntries.length ? `${overrideCtorEntries.map((entry) => `import { ${entry.className} as ${entry.localIdentifier} } from "${entry.importSpecifier}";`).join("\n")}
+
+` : "";
+  const fixtureCtorExpression = (name) => overrideCtorByClassName.get(name) ?? `Pom.${name}`;
   const header = `${eslintSuppressionHeader}/**
  * DO NOT MODIFY BY HAND
  *
@@ -3948,8 +3968,8 @@ function maybeGenerateFixtureRegistry(componentHierarchyMap, options) {
  */
 
 `;
-  const fixturesTypeEntries = viewClassNames.map((name) => `  ${lowerFirst(name)}: Pom.${name},`).join("\n");
-  const componentFixturesTypeEntries = componentClassNames.map((name) => `  ${lowerFirst(name)}: Pom.${name},`).join("\n");
+  const fixturesTypeEntries = viewClassNames.map((name) => `  ${lowerFirst(name)}: ${fixtureCtorExpression(name)},`).join("\n");
+  const componentFixturesTypeEntries = componentClassNames.map((name) => `  ${lowerFirst(name)}: ${fixtureCtorExpression(name)},`).join("\n");
   const pomFactoryType = `export type PomConstructor<T> = new (page: PwPage) => T;
 
 export interface PomFactory {
@@ -3962,8 +3982,7 @@ export interface PomFactory {
 import { expect, test as base } from "@playwright/test";
 import type { Page as PwPage } from "@playwright/test";
 import * as Pom from "${pomImport}";
-
-export interface PlaywrightOptions {
+${overrideImports}export interface PlaywrightOptions {
   animation: Pom.PlaywrightAnimationOptions;
 }
 
@@ -4039,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;
@@ -4049,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);
@@ -4090,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 });
@@ -4098,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;
@@ -4110,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) {
@@ -4124,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 });
@@ -4155,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)) {
@@ -4198,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;
@@ -4211,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) {
@@ -4233,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) {
@@ -4243,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) {
@@ -4400,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