@autometa/playwright-loader 1.0.0-rc.0

package/dist/index.cjs

@@ -0,0 +1,636 @@
+'use strict';
+
+var fs = require('fs');
+var url = require('url');
+var path = require('path');
+var module$1 = require('module');
+var jiti = require('jiti');
+var fg = require('fast-glob');
+
+function _interopDefault (e) { return e && e.__esModule ? e : { default: e }; }
+
+var jiti__default = /*#__PURE__*/_interopDefault(jiti);
+var fg__default = /*#__PURE__*/_interopDefault(fg);
+
+// src/loader.ts
+var STEP_FALLBACK_GLOB = "**/*.{ts,tsx,js,jsx,mjs,cjs,mts,cts}";
+function resolvePackage(packageName, fromDir) {
+  try {
+    const require2 = module$1.createRequire(path.resolve(fromDir, "package.json"));
+    const resolved = require2.resolve(packageName);
+    if (resolved.endsWith(".js") || resolved.endsWith("/index.js")) {
+      const mjs = resolved.replace(/\.js$/, ".mjs");
+      if (fs.existsSync(mjs)) {
+        return mjs;
+      }
+      const indexMjs = resolved.replace(/index\.js$/, "index.mjs");
+      if (indexMjs !== mjs && fs.existsSync(indexMjs)) {
+        return indexMjs;
+      }
+    }
+    return resolved;
+  } catch {
+    return packageName;
+  }
+}
+function generateBridgeCode(featurePath, featureContent, runtimeProjectRoot) {
+  const projectRoot = runtimeProjectRoot ?? findProjectRoot(path.dirname(featurePath));
+  const { configPath, stepRoots, events } = loadConfigSync(projectRoot);
+  const configDir = configPath ? path.dirname(configPath) : projectRoot;
+  const stepPatterns = buildStepPatterns(stepRoots, {
+    configDir,
+    projectRoot
+  });
+  const eventPatterns = buildStepPatterns(events, {
+    configDir,
+    projectRoot
+  });
+  const eventImports = generateEventImports(eventPatterns);
+  const stepImports = generateStepImports(stepPatterns);
+  const playwrightPath = resolvePackage("@playwright/test", projectRoot);
+  const executorPath = resolvePackage("@autometa/playwright-executor", projectRoot);
+  const runnerPath = resolvePackage("@autometa/runner", projectRoot);
+  const gherkinPath = resolvePackage("@autometa/gherkin", projectRoot);
+  const debugInfo = JSON.stringify({
+    projectRoot,
+    configPath,
+    stepRoots,
+    stepPatterns
+  }, null, 2);
+  return `
+import { test } from ${JSON.stringify(playwrightPath)};
+import { execute } from ${JSON.stringify(executorPath)};
+import { coordinateRunnerFeature, CucumberRunner } from ${JSON.stringify(runnerPath)};
+import { parseGherkin } from ${JSON.stringify(gherkinPath)};
+
+const debugFlagValue = typeof process !== 'undefined'
+  ? (process.env.AUTOMETA_BRIDGE_DEBUG ?? process.env.AUTOMETA_DEBUG ?? '')
+  : '';
+const debugEnabled = (() => {
+  if (!debugFlagValue) {
+    return false;
+  }
+  const normalized = String(debugFlagValue).trim().toLowerCase();
+  return normalized === '1' || normalized === 'true' || normalized === 'yes' || normalized === 'on';
+})();
+const debugLog = (...args) => {
+  if (!debugEnabled) {
+    return;
+  }
+  console.log(...args);
+};
+
+// Debug: Step discovery configuration
+debugLog("[Autometa Bridge] Step discovery info:", ${JSON.stringify(debugInfo)});
+
+// Dynamic imports for event listener modules (side effects)
+${eventImports}
+
+// Dynamic imports for step definition modules
+${stepImports}
+
+function collectCandidateModules(imported) {
+  if (!imported || typeof imported !== 'object') {
+    return [];
+  }
+
+  const modules = new Set();
+  modules.add(imported);
+
+  const exportedModules = imported.modules;
+  if (Array.isArray(exportedModules)) {
+    for (const entry of exportedModules) {
+      if (entry && typeof entry === 'object') {
+        modules.add(entry);
+      }
+    }
+  }
+
+  const defaultExport = imported.default;
+  if (Array.isArray(defaultExport)) {
+    for (const entry of defaultExport) {
+      if (entry && typeof entry === 'object') {
+        modules.add(entry);
+      }
+    }
+  } else if (defaultExport && typeof defaultExport === 'object') {
+    modules.add(defaultExport);
+  }
+
+  return Array.from(modules);
+}
+
+function isStepsEnvironment(candidate) {
+  return Boolean(
+    candidate &&
+    typeof candidate === 'object' &&
+    typeof candidate.coordinateFeature === 'function' &&
+    typeof candidate.getPlan === 'function' &&
+    typeof candidate.Given === 'function' &&
+    typeof candidate.When === 'function' &&
+    typeof candidate.Then === 'function'
+  );
+}
+
+function extractStepsEnvironment(candidate) {
+  if (!candidate || typeof candidate !== 'object') {
+    return undefined;
+  }
+
+  if (isStepsEnvironment(candidate)) {
+    return candidate;
+  }
+
+  const stepsEnv = candidate.stepsEnvironment;
+  if (isStepsEnvironment(stepsEnv)) {
+    return stepsEnv;
+  }
+
+  const defaultExport = candidate.default;
+  if (isStepsEnvironment(defaultExport)) {
+    return defaultExport;
+  }
+
+  return undefined;
+}
+
+function resolveStepsEnvironment(modules) {
+  for (const moduleExports of Object.values(modules)) {
+    for (const candidate of collectCandidateModules(moduleExports)) {
+      const environment = extractStepsEnvironment(candidate);
+      if (environment) {
+        return environment;
+      }
+    }
+  }
+  return undefined;
+}
+
+function isScenario(element) {
+  return Boolean(
+    element &&
+    typeof element === 'object' &&
+    'steps' in element &&
+    !('exampleGroups' in element) &&
+    !('elements' in element)
+  );
+}
+
+function isScenarioOutline(element) {
+  return Boolean(
+    element &&
+    typeof element === 'object' &&
+    'steps' in element &&
+    'exampleGroups' in element
+  );
+}
+
+function isRule(element) {
+  return Boolean(
+    element &&
+    typeof element === 'object' &&
+    'elements' in element &&
+    Array.isArray(element.elements)
+  );
+}
+
+function createFeatureScopePlan(feature, basePlan) {
+  const allSteps = Array.from(basePlan.stepsById.values());
+  const featureChildren = [];
+  const scopesById = new Map(basePlan.scopesById);
+
+  for (const element of feature.elements ?? []) {
+    if (isScenario(element) || isScenarioOutline(element)) {
+      const scenarioScope = {
+        id: element.id ?? element.name,
+        kind: isScenarioOutline(element) ? 'scenarioOutline' : 'scenario',
+        name: element.name,
+        mode: 'default',
+        tags: element.tags ?? [],
+        steps: allSteps,
+        hooks: [],
+        children: [],
+        pending: false,
+      };
+      featureChildren.push(scenarioScope);
+      scopesById.set(scenarioScope.id, scenarioScope);
+      continue;
+    }
+
+    if (isRule(element)) {
+      const ruleChildren = [];
+      for (const ruleElement of element.elements ?? []) {
+        if (isScenario(ruleElement) || isScenarioOutline(ruleElement)) {
+          const scenarioScope = {
+            id: ruleElement.id ?? ruleElement.name,
+            kind: isScenarioOutline(ruleElement) ? 'scenarioOutline' : 'scenario',
+            name: ruleElement.name,
+            mode: 'default',
+            tags: ruleElement.tags ?? [],
+            steps: allSteps,
+            hooks: [],
+            children: [],
+            pending: false,
+          };
+          ruleChildren.push(scenarioScope);
+          scopesById.set(scenarioScope.id, scenarioScope);
+        }
+      }
+
+      const ruleScope = {
+        id: element.id ?? element.name,
+        kind: 'rule',
+        name: element.name,
+        mode: 'default',
+        tags: element.tags ?? [],
+        steps: allSteps,
+        hooks: [],
+        children: ruleChildren,
+        pending: false,
+      };
+      featureChildren.push(ruleScope);
+      scopesById.set(ruleScope.id, ruleScope);
+    }
+  }
+
+  const featureScope = {
+    id: feature.uri ?? feature.name,
+    kind: 'feature',
+    name: feature.name,
+    mode: 'default',
+    tags: feature.tags ?? [],
+    steps: allSteps,
+    hooks: [],
+    children: featureChildren,
+    pending: false,
+  };
+
+  const existingRoot = basePlan.root;
+  const updatedRoot = {
+    ...existingRoot,
+    children: [...existingRoot.children, featureScope],
+  };
+
+  scopesById.set(featureScope.id, featureScope);
+  scopesById.set(updatedRoot.id, updatedRoot);
+
+  const scopePlan = {
+    root: updatedRoot,
+    stepsById: basePlan.stepsById,
+    hooksById: basePlan.hooksById,
+    scopesById,
+  };
+
+  if (basePlan.worldFactory) {
+    scopePlan.worldFactory = basePlan.worldFactory;
+  }
+
+  if (basePlan.parameterRegistry) {
+    scopePlan.parameterRegistry = basePlan.parameterRegistry;
+  }
+
+  return scopePlan;
+}
+
+const gherkin = ${JSON.stringify(featureContent)};
+const feature = parseGherkin(gherkin);
+await loadEventModules();
+const stepModules = await loadStepModules();
+const steps = resolveStepsEnvironment(stepModules);
+
+if (!steps) {
+  throw new Error(
+    'Autometa could not find an exported steps environment for the configured step roots. ' +
+    'Export your runner environment as "stepsEnvironment" or default.'
+  );
+}
+
+// Debug: Check the steps environment
+debugLog("[Autometa Bridge] Steps environment found:", {
+  hasGiven: typeof steps.Given === 'function',
+  hasWhen: typeof steps.When === 'function', 
+  hasThen: typeof steps.Then === 'function',
+  hasGetPlan: typeof steps.getPlan === 'function',
+});
+
+CucumberRunner.setSteps(steps);
+
+const runtimeConfig = steps.getConfig?.() ?? {
+  test: {},
+  shim: {},
+  globals: {}
+};
+
+// Debug: Check the plan
+const basePlan = steps.getPlan();
+const paramRegistry = basePlan.parameterRegistry;
+const actualRegistry = paramRegistry?.registry ?? paramRegistry;
+const paramTypeNames = actualRegistry?.parameterTypes 
+  ? Array.from(actualRegistry.parameterTypes).map(pt => pt.name)
+  : [];
+debugLog("[Autometa Bridge] Base plan:", {
+  stepsCount: basePlan.stepsById?.size ?? 0,
+  hooksCount: basePlan.hooksById?.size ?? 0,
+  hasParameterRegistry: Boolean(paramRegistry),
+  parameterTypes: paramTypeNames,
+  hasHttpMethod: actualRegistry?.lookupByTypeName?.('httpMethod') !== undefined,
+  stepIds: Array.from(basePlan.stepsById?.keys() ?? []).slice(0, 5),
+});
+
+// Debug: Check step module contents
+debugLog("[Autometa Bridge] Step modules keys:", Object.keys(stepModules));
+const firstModKey = Object.keys(stepModules)[0];
+if (firstModKey) {
+  const firstMod = stepModules[firstModKey];
+  debugLog("[Autometa Bridge] First module exports:", Object.keys(firstMod ?? {}));
+}
+
+test.describe(feature.name, () => {
+  const scopedPlan = createFeatureScopePlan(feature, basePlan);
+  
+  // Debug: Check the scoped plan
+  const scopedRegistry = scopedPlan.parameterRegistry?.registry ?? scopedPlan.parameterRegistry;
+  debugLog("[Autometa Bridge] Scoped plan:", {
+    hasParameterRegistry: Boolean(scopedPlan.parameterRegistry),
+    hasHttpMethod: scopedRegistry?.lookupByTypeName?.('httpMethod') !== undefined,
+    rootChildren: scopedPlan.root?.children?.length ?? 0,
+    stepsCount: scopedPlan.stepsById?.size ?? 0,
+  });
+
+  // Debug: Feature name matching
+  debugLog("[Autometa Bridge] Feature matching:", {
+    gherkinName: feature.name,
+    featureScopeNames: scopedPlan.root?.children?.filter(c => c.kind === 'feature').map(c => c.name) ?? [],
+  });
+  
+  const { plan, adapter } = coordinateRunnerFeature({
+    feature,
+    environment: steps,
+    config: runtimeConfig,
+    plan: scopedPlan
+  });
+
+  // Debug: Check what adapter sees
+  const adapterRegistry = adapter.getParameterRegistry?.();
+  const actualAdapterReg = adapterRegistry?.registry ?? adapterRegistry;
+  debugLog("[Autometa Bridge] Adapter:", {
+    hasParameterRegistry: Boolean(adapterRegistry),
+    hasHttpMethod: actualAdapterReg?.lookupByTypeName?.('httpMethod') !== undefined,
+  });
+
+  execute({ plan, adapter, config: runtimeConfig });
+});
+`;
+}
+function findProjectRoot(startDir) {
+  let dir = startDir;
+  while (dir !== "/") {
+    if (fs.existsSync(path.resolve(dir, "package.json"))) {
+      return dir;
+    }
+    const parent = path.dirname(dir);
+    if (parent === dir)
+      break;
+    dir = parent;
+  }
+  return startDir;
+}
+function loadConfigSync(root) {
+  const candidates = [
+    "autometa.config.ts",
+    "autometa.config.js",
+    "autometa.config.mts",
+    "autometa.config.mjs",
+    "autometa.config.cts",
+    "autometa.config.cjs"
+  ];
+  const _jiti = jiti__default.default(root, { interopDefault: true });
+  for (const candidate of candidates) {
+    const configPath = path.resolve(root, candidate);
+    if (!fs.existsSync(configPath)) {
+      continue;
+    }
+    const mod = _jiti(configPath);
+    const config = mod && typeof mod === "object" && "default" in mod ? mod.default ?? mod : mod;
+    if (!isConfig(config)) {
+      throw new Error(
+        `Failed to load Autometa config from "${configPath}". Ensure the module exports a Config instance (e.g. export default defineConfig({...})).`
+      );
+    }
+    const resolved = config.resolve();
+    const stepRoots = resolved.config?.roots?.steps ?? [];
+    const events = resolved.config?.events ?? [];
+    return {
+      configPath,
+      stepRoots: Array.isArray(stepRoots) && stepRoots.length > 0 ? stepRoots : findDefaultStepRoots(root),
+      events: Array.isArray(events) ? events : []
+    };
+  }
+  return { configPath: void 0, stepRoots: findDefaultStepRoots(root), events: [] };
+}
+function isConfig(config) {
+  return typeof config === "object" && config !== null && "resolve" in config && typeof config.resolve === "function" && "current" in config && typeof config.current === "function";
+}
+function findDefaultStepRoots(root) {
+  const candidates = [
+    "src/steps",
+    "src/step-definitions",
+    "steps",
+    "step-definitions",
+    "src"
+  ];
+  const found = [];
+  for (const candidate of candidates) {
+    const path$1 = path.resolve(root, candidate);
+    if (fs.existsSync(path$1)) {
+      found.push(candidate);
+      break;
+    }
+  }
+  const stepDefFile = path.resolve(root, "src/step-definitions.ts");
+  if (fs.existsSync(stepDefFile)) {
+    found.push("src/step-definitions.ts");
+  }
+  return found.length > 0 ? found : ["src"];
+}
+function buildStepPatterns(entries, options) {
+  if (!entries || entries.length === 0) {
+    return [];
+  }
+  const patterns = /* @__PURE__ */ new Set();
+  for (const entry of entries) {
+    const normalized = entry.trim();
+    if (!normalized) {
+      continue;
+    }
+    for (const candidate of toPatterns(normalized, STEP_FALLBACK_GLOB)) {
+      const absolute = path.isAbsolute(candidate) ? normalizeSlashes(candidate) : normalizeSlashes(path.resolve(options.configDir, candidate));
+      const files = resolveGlobToFiles(absolute, options.projectRoot);
+      for (const file of files) {
+        patterns.add(file);
+      }
+    }
+  }
+  return Array.from(patterns);
+}
+function resolveGlobToFiles(pattern, projectRoot) {
+  const isSpecificFile = hasFileExtension(pattern) && !hasGlobMagic(pattern);
+  if (isSpecificFile) {
+    return fs.existsSync(pattern) ? [pattern] : [];
+  }
+  const matches = fg__default.default.sync(pattern, {
+    cwd: projectRoot,
+    absolute: true,
+    onlyFiles: true,
+    unique: true,
+    followSymbolicLinks: true,
+    ignore: [
+      "**/node_modules/**",
+      "**/*.test.*",
+      "**/*.spec.*"
+    ]
+  });
+  return matches.sort((a, b) => a.localeCompare(b));
+}
+function toPatterns(entry, fallbackGlob) {
+  if (hasGlobMagic(entry) || hasFileExtension(entry)) {
+    return [entry];
+  }
+  return [appendGlob(entry, fallbackGlob)];
+}
+function hasGlobMagic(input) {
+  return /[*?{}()[\]!,@+]/u.test(input);
+}
+function hasFileExtension(input) {
+  const normalized = normalizeSlashes(input);
+  const trimmed = normalized === "/" ? normalized : normalized.replace(/\/+$/u, "");
+  if (!trimmed || trimmed === "." || trimmed === "..") {
+    return false;
+  }
+  return Boolean(path.extname(trimmed));
+}
+function appendGlob(entry, glob) {
+  const normalized = normalizeSlashes(entry);
+  const trimmed = normalized === "/" ? normalized : normalized.replace(/\/+$/u, "");
+  if (!trimmed || trimmed === ".") {
+    return glob;
+  }
+  if (trimmed === "/") {
+    return `/${glob}`;
+  }
+  return `${trimmed}/${glob}`;
+}
+function normalizeSlashes(pathname) {
+  return pathname.replace(/\\/gu, "/");
+}
+function generateStepImports(stepPatterns, _projectRoot) {
+  if (stepPatterns.length === 0) {
+    return `
+async function loadStepModules() {
+  return {};
+}
+`;
+  }
+  const sortedPatterns = [...stepPatterns].sort((a, b) => {
+    const aName = a.toLowerCase();
+    const bName = b.toLowerCase();
+    const aIsMain = aName.includes("step-definitions.ts") || aName.includes("step-definitions.js");
+    const bIsMain = bName.includes("step-definitions.ts") || bName.includes("step-definitions.js");
+    if (aIsMain && !bIsMain)
+      return -1;
+    if (!aIsMain && bIsMain)
+      return 1;
+    const aIsIndex = aName.endsWith("/index.ts") || aName.endsWith("/index.js");
+    const bIsIndex = bName.endsWith("/index.ts") || bName.endsWith("/index.js");
+    if (aIsIndex && !bIsIndex)
+      return -1;
+    if (!aIsIndex && bIsIndex)
+      return 1;
+    return a.localeCompare(b);
+  });
+  const imports = sortedPatterns.map((file, index) => {
+    const importPath = normalizeSlashes(file);
+    return `  const mod${index} = await import(${JSON.stringify(importPath)});`;
+  }).join("\n");
+  const moduleMap = sortedPatterns.map((file, index) => {
+    const key = normalizeSlashes(file);
+    return `    ${JSON.stringify(key)}: mod${index},`;
+  }).join("\n");
+  return `
+async function loadStepModules() {
+${imports}
+  return {
+${moduleMap}
+  };
+}
+`;
+}
+function generateEventImports(eventPatterns) {
+  if (eventPatterns.length === 0) {
+    return `
+async function loadEventModules() {
+  return;
+}
+`;
+  }
+  const imports = eventPatterns.map((file) => {
+    const importPath = normalizeSlashes(file);
+    return `  await import(${JSON.stringify(importPath)});`;
+  }).join("\n");
+  return `
+async function loadEventModules() {
+${imports}
+}
+`;
+}
+
+// src/loader.ts
+async function resolve2(specifier, context, nextResolve) {
+  if (specifier.endsWith(".feature")) {
+    let resolvedPath;
+    if (specifier.startsWith("file://")) {
+      resolvedPath = url.fileURLToPath(specifier);
+    } else if (specifier.startsWith("/")) {
+      resolvedPath = specifier;
+    } else if (specifier.startsWith(".")) {
+      if (context.parentURL) {
+        const parentPath = url.fileURLToPath(context.parentURL);
+        const parentDir = path.dirname(parentPath);
+        resolvedPath = path.resolve(parentDir, specifier);
+      } else {
+        resolvedPath = path.resolve(process.cwd(), specifier);
+      }
+    } else {
+      resolvedPath = path.resolve(process.cwd(), specifier);
+    }
+    if (!fs.existsSync(resolvedPath)) {
+      throw new Error(`Cannot find .feature file: ${resolvedPath}`);
+    }
+    return {
+      url: url.pathToFileURL(resolvedPath).href,
+      format: "autometa-feature",
+      shortCircuit: true
+    };
+  }
+  return nextResolve(specifier, context);
+}
+async function load(url$1, context, nextLoad) {
+  if (context.format === "autometa-feature") {
+    const filePath = url.fileURLToPath(url$1);
+    const featureContent = fs.readFileSync(filePath, "utf-8");
+    const projectRoot = process.cwd();
+    const bridgeCode = generateBridgeCode(filePath, featureContent, projectRoot);
+    return {
+      format: "module",
+      shortCircuit: true,
+      source: bridgeCode
+    };
+  }
+  return nextLoad(url$1, context);
+}
+
+exports.generateBridgeCode = generateBridgeCode;
+exports.load = load;
+exports.resolve = resolve2;
+//# sourceMappingURL=out.js.map
+//# sourceMappingURL=index.cjs.map