@step-forge/step-forge 0.0.20 → 0.0.22

package/dist/engine-vqA-eL_T.cjs

@@ -0,0 +1,186 @@
+const require_hooks = require("./hooks-Be0cjULN.cjs");
+let _cucumber_cucumber_expressions = require("@cucumber/cucumber-expressions");
+//#region src/runtime/engine.ts
+const keywordToStepType = {
+	Given: "given",
+	When: "when",
+	Then: "then"
+};
+var UndefinedStepError = class extends Error {
+	step;
+	constructor(step) {
+		super(`Undefined step: ${step.effectiveKeyword} ${step.text}`);
+		this.step = step;
+		this.name = "UndefinedStepError";
+	}
+};
+var AmbiguousStepError = class extends Error {
+	step;
+	matches;
+	constructor(step, matches) {
+		super(`Ambiguous step: "${step.text}" matched ${matches.length} definitions:\n` + matches.map((m) => `  - ${m.expression}`).join("\n"));
+		this.step = step;
+		this.matches = matches;
+		this.name = "AmbiguousStepError";
+	}
+};
+/**
+* Compile a registry's steps into matchable Cucumber expressions **once** per
+* run. The result is reused for every scenario — compilation is pure and depends
+* only on the registry, so recompiling per scenario (as an earlier version did)
+* was wasted work proportional to scenarios × steps.
+*/
+function compileRegistry(registry) {
+	return registry.all().map((step) => {
+		const paramRegistry = new _cucumber_cucumber_expressions.ParameterTypeRegistry();
+		for (const parser of step.parsers) {
+			if (paramRegistry.lookupByTypeName(parser.name)) continue;
+			const regexps = Array.isArray(parser.regexp) ? parser.regexp : [parser.regexp];
+			paramRegistry.defineParameterType(new _cucumber_cucumber_expressions.ParameterType(parser.name, regexps, null, (value) => parser.parse(value)));
+		}
+		return {
+			step,
+			expression: new _cucumber_cucumber_expressions.CucumberExpression(step.expression, paramRegistry)
+		};
+	});
+}
+/**
+* Find the single step definition matching a Gherkin step. Matching is
+* opinionated and strict: the keyword must line up with the step type, exactly
+* one definition must match, and undefined/ambiguous both throw rather than
+* silently skipping (unlike Cucumber's pending/undefined dance).
+*/
+function matchStep(step, compiled) {
+	const expectedType = keywordToStepType[step.effectiveKeyword];
+	const matches = [];
+	for (const { step: def, expression } of compiled) {
+		if (def.stepType !== expectedType) continue;
+		const result = expression.match(step.text);
+		if (result) matches.push({
+			step: def,
+			args: result.map((a) => a.getValue(null))
+		});
+	}
+	if (matches.length === 0) throw new UndefinedStepError(step);
+	if (matches.length > 1) throw new AmbiguousStepError(step, matches.map((m) => m.step));
+	return matches[0];
+}
+/**
+* Run one scenario against a pre-compiled step table. A fresh world is created
+* per scenario (state never leaks between scenarios). On the first failing step
+* the remaining steps are marked skipped, matching Cucumber's execution
+* semantics.
+*
+* Never throws for step or hook failures: it always resolves to a
+* `ScenarioResult` carrying the per-step breakdown and (on failure) the first
+* `error` with a synthetic `.feature` stack frame attached. Callers decide what
+* to do with a failure — the CLI runner reports it, a test-runner adapter can
+* re-throw `result.error`. It still rejects for truly exceptional conditions
+* (e.g. a bug in the engine itself), never for a normal test failure.
+*
+* Pass the compiled table from {@link compileRegistry} once and reuse it across
+* every scenario in the run.
+*/
+async function runScenario(scenario, compiled, makeWorld, hooks = require_hooks.globalHookRegistry) {
+	const start = now();
+	const world = makeWorld();
+	const scenarioInfo = {
+		name: scenario.name,
+		file: scenario.file
+	};
+	const steps = [];
+	let failed = false;
+	let firstError;
+	const fail = (err) => {
+		if (failed) return;
+		failed = true;
+		firstError = err instanceof Error ? err : new Error(String(err));
+	};
+	try {
+		for (const hook of hooks.for("scenario", "before")) await hook.fn({
+			world,
+			scenario: scenarioInfo
+		});
+	} catch (err) {
+		fail(err);
+	}
+	for (const step of scenario.steps) {
+		if (failed) {
+			steps.push({
+				step,
+				status: "skipped"
+			});
+			continue;
+		}
+		let source;
+		try {
+			const { step: def, args } = matchStep(step, compiled);
+			source = def.source;
+			await def.execute(world, args);
+			steps.push({
+				step,
+				status: "passed",
+				source
+			});
+		} catch (err) {
+			const error = err instanceof Error ? err : new Error(String(err));
+			steps.push({
+				step,
+				status: "failed",
+				error,
+				source
+			});
+			fail(error);
+		}
+	}
+	for (const hook of hooks.for("scenario", "after")) try {
+		await hook.fn({
+			world,
+			scenario: scenarioInfo
+		});
+	} catch (err) {
+		fail(err);
+	}
+	return {
+		scenario,
+		status: failed ? "failed" : "passed",
+		steps,
+		error: firstError,
+		durationMs: now() - start
+	};
+}
+/**
+* Monotonic-ish millisecond clock. `performance.now()` where available (Node &
+* Bun both expose it globally), falling back to `Date.now()`. Kept in one place
+* so timing is consistent across scenarios.
+*/
+function now() {
+	return typeof performance !== "undefined" ? performance.now() : Date.now();
+}
+//#endregion
+Object.defineProperty(exports, "AmbiguousStepError", {
+	enumerable: true,
+	get: function() {
+		return AmbiguousStepError;
+	}
+});
+Object.defineProperty(exports, "UndefinedStepError", {
+	enumerable: true,
+	get: function() {
+		return UndefinedStepError;
+	}
+});
+Object.defineProperty(exports, "compileRegistry", {
+	enumerable: true,
+	get: function() {
+		return compileRegistry;
+	}
+});
+Object.defineProperty(exports, "runScenario", {
+	enumerable: true,
+	get: function() {
+		return runScenario;
+	}
+});
+
+//# sourceMappingURL=engine-vqA-eL_T.cjs.map

package/dist/engine-vqA-eL_T.cjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"engine-vqA-eL_T.cjs","names":["ParameterTypeRegistry","ParameterType","CucumberExpression","globalHookRegistry"],"sources":["../../src/runtime/engine.ts"],"sourcesContent":["/* eslint-disable @typescript-eslint/no-explicit-any */\nimport {\n  CucumberExpression,\n  ParameterType,\n  ParameterTypeRegistry,\n} from \"@cucumber/cucumber-expressions\";\nimport { ParsedScenario, ParsedStep } from \"../analyzer/types\";\nimport { MergeableWorld } from \"../world\";\nimport { globalHookRegistry, HookRegistry, ScenarioHookFn } from \"./hooks\";\nimport { RegisteredStep, StepRegistry, StepType } from \"./registry\";\n\nconst keywordToStepType: Record<ParsedStep[\"effectiveKeyword\"], StepType> = {\n  Given: \"given\",\n  When: \"when\",\n  Then: \"then\",\n};\n\n/** A registered step paired with its compiled Cucumber expression. */\nexport interface CompiledStep {\n  step: RegisteredStep;\n  expression: CucumberExpression;\n}\n\nexport class UndefinedStepError extends Error {\n  constructor(public readonly step: ParsedStep) {\n    super(`Undefined step: ${step.effectiveKeyword} ${step.text}`);\n    this.name = \"UndefinedStepError\";\n  }\n}\n\nexport class AmbiguousStepError extends Error {\n  constructor(\n    public readonly step: ParsedStep,\n    public readonly matches: RegisteredStep[]\n  ) {\n    super(\n      `Ambiguous step: \"${step.text}\" matched ${matches.length} definitions:\\n` +\n        matches.map(m => `  - ${m.expression}`).join(\"\\n\")\n    );\n    this.name = \"AmbiguousStepError\";\n  }\n}\n\n/**\n * Compile a registry's steps into matchable Cucumber expressions **once** per\n * run. The result is reused for every scenario — compilation is pure and depends\n * only on the registry, so recompiling per scenario (as an earlier version did)\n * was wasted work proportional to scenarios × steps.\n */\nexport function compileRegistry(registry: StepRegistry): CompiledStep[] {\n  return registry.all().map(step => {\n    // Each step gets its own parameter-type registry (seeded with the\n    // built-ins). A parser whose name is already registered — the built-in\n    // `{int}`/`{float}`/`{string}`, or a repeat within the same step — reuses\n    // that type; a novel name (e.g. `{boolean}`, `{color}`) is registered from\n    // the parser's regexp + parse, so matching and coercion happen in one pass.\n    const paramRegistry = new ParameterTypeRegistry();\n    for (const parser of step.parsers) {\n      if (paramRegistry.lookupByTypeName(parser.name)) continue;\n      const regexps = Array.isArray(parser.regexp)\n        ? parser.regexp\n        : [parser.regexp];\n      paramRegistry.defineParameterType(\n        new ParameterType(parser.name, regexps, null, (value: string) =>\n          parser.parse(value)\n        )\n      );\n    }\n    return {\n      step,\n      expression: new CucumberExpression(step.expression, paramRegistry),\n    };\n  });\n}\n\n/**\n * Find the single step definition matching a Gherkin step. Matching is\n * opinionated and strict: the keyword must line up with the step type, exactly\n * one definition must match, and undefined/ambiguous both throw rather than\n * silently skipping (unlike Cucumber's pending/undefined dance).\n */\nfunction matchStep(\n  step: ParsedStep,\n  compiled: CompiledStep[]\n): { step: RegisteredStep; args: unknown[] } {\n  const expectedType = keywordToStepType[step.effectiveKeyword];\n  const matches: { step: RegisteredStep; args: unknown[] }[] = [];\n\n  for (const { step: def, expression } of compiled) {\n    if (def.stepType !== expectedType) continue;\n    const result = expression.match(step.text);\n    if (result) {\n      // The parsers are registered as the expression's parameter types, so the\n      // captured values are already coerced (`{int}` → number, `{color}` → the\n      // parser's T). `execute` consumes them as-is.\n      matches.push({ step: def, args: result.map(a => a.getValue(null)) });\n    }\n  }\n\n  if (matches.length === 0) throw new UndefinedStepError(step);\n  if (matches.length > 1) {\n    throw new AmbiguousStepError(\n      step,\n      matches.map(m => m.step)\n    );\n  }\n  return matches[0];\n}\n\nexport interface StepResult {\n  step: ParsedStep;\n  status: \"passed\" | \"failed\" | \"skipped\";\n  error?: Error;\n  /**\n   * Absolute `file:line:column` where the matched step is *defined* (its\n   * `.step(...)` call site), for Cucumber-style reporting. Absent when no step\n   * matched (undefined/ambiguous) or the step was skipped.\n   */\n  source?: string;\n  durationMs?: number;\n}\n\nexport interface ScenarioResult {\n  scenario: ParsedScenario;\n  status: \"passed\" | \"failed\";\n  steps: StepResult[];\n  /**\n   * The scenario's first error, if it failed. Usually the same object as the\n   * failing step's `error`; for a hook failure there's no step to point at, so\n   * this is the only place it surfaces. Reporters read this; the runner never\n   * throws it.\n   */\n  error?: Error;\n  /** Wall-clock duration of the whole scenario, in milliseconds. */\n  durationMs?: number;\n}\n\n/**\n * Run one scenario against a pre-compiled step table. A fresh world is created\n * per scenario (state never leaks between scenarios). On the first failing step\n * the remaining steps are marked skipped, matching Cucumber's execution\n * semantics.\n *\n * Never throws for step or hook failures: it always resolves to a\n * `ScenarioResult` carrying the per-step breakdown and (on failure) the first\n * `error` with a synthetic `.feature` stack frame attached. Callers decide what\n * to do with a failure — the CLI runner reports it, a test-runner adapter can\n * re-throw `result.error`. It still rejects for truly exceptional conditions\n * (e.g. a bug in the engine itself), never for a normal test failure.\n *\n * Pass the compiled table from {@link compileRegistry} once and reuse it across\n * every scenario in the run.\n */\nexport async function runScenario(\n  scenario: ParsedScenario,\n  compiled: CompiledStep[],\n  makeWorld: () => MergeableWorld<any, any, any>,\n  hooks: HookRegistry = globalHookRegistry\n): Promise<ScenarioResult> {\n  const start = now();\n  const world = makeWorld();\n  const scenarioInfo = { name: scenario.name, file: scenario.file };\n  const steps: StepResult[] = [];\n  let failed = false;\n  let firstError: Error | undefined;\n\n  const fail = (err: unknown) => {\n    if (failed) return;\n    failed = true;\n    firstError = err instanceof Error ? err : new Error(String(err));\n  };\n\n  // before-scenario hooks: a throw here aborts the scenario before any step.\n  try {\n    for (const hook of hooks.for(\"scenario\", \"before\")) {\n      await (hook.fn as ScenarioHookFn)({ world, scenario: scenarioInfo });\n    }\n  } catch (err) {\n    fail(err);\n  }\n\n  for (const step of scenario.steps) {\n    if (failed) {\n      steps.push({ step, status: \"skipped\" });\n      continue;\n    }\n    // `source` is captured before `execute` so a failing step still carries its\n    // definition location; it stays undefined if matching itself throws\n    // (undefined/ambiguous step).\n    let source: string | undefined;\n    try {\n      const { step: def, args } = matchStep(step, compiled);\n      source = def.source;\n      await def.execute(world, args);\n      steps.push({ step, status: \"passed\", source });\n    } catch (err) {\n      const error = err instanceof Error ? err : new Error(String(err));\n      steps.push({ step, status: \"failed\", error, source });\n      fail(error);\n    }\n  }\n\n  // after-scenario hooks always run (teardown), even on failure. A hook failure\n  // only becomes the scenario's error if nothing else failed first.\n  for (const hook of hooks.for(\"scenario\", \"after\")) {\n    try {\n      await (hook.fn as ScenarioHookFn)({ world, scenario: scenarioInfo });\n    } catch (err) {\n      fail(err);\n    }\n  }\n\n  return {\n    scenario,\n    status: failed ? \"failed\" : \"passed\",\n    steps,\n    error: firstError,\n    durationMs: now() - start,\n  };\n}\n\n/**\n * Monotonic-ish millisecond clock. `performance.now()` where available (Node &\n * Bun both expose it globally), falling back to `Date.now()`. Kept in one place\n * so timing is consistent across scenarios.\n */\nfunction now(): number {\n  return typeof performance !== \"undefined\" ? performance.now() : Date.now();\n}\n"],"mappings":"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"}

package/dist/gherkinParser-BT40q_i3.cjs

@@ -0,0 +1,338 @@
+//#region \0rolldown/runtime.js
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __copyProps = (to, from, except, desc) => {
+	if (from && typeof from === "object" || typeof from === "function") for (var keys = __getOwnPropNames(from), i = 0, n = keys.length, key; i < n; i++) {
+		key = keys[i];
+		if (!__hasOwnProp.call(to, key) && key !== except) __defProp(to, key, {
+			get: ((k) => from[k]).bind(null, key),
+			enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable
+		});
+	}
+	return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", {
+	value: mod,
+	enumerable: true
+}) : target, mod));
+//#endregion
+let lodash = require("lodash");
+lodash = __toESM(lodash, 1);
+let node_path = require("node:path");
+node_path = __toESM(node_path, 1);
+let node_url = require("node:url");
+let node_fs_promises = require("node:fs/promises");
+let node_fs = require("node:fs");
+node_fs = __toESM(node_fs, 1);
+let _cucumber_gherkin = require("@cucumber/gherkin");
+let _cucumber_messages = require("@cucumber/messages");
+_cucumber_messages = __toESM(_cucumber_messages, 1);
+//#region src/sourceLocation.ts
+/**
+* Directory holding the library's own compiled code. In development this is the
+* `src/` tree; in the published package it's `dist/` (this module is bundled
+* into the shipped chunks). Stack frames under it are internal plumbing —
+* builders, the engine, the runner — and are hidden from users so that a
+* failure points at *their* step, not ours.
+*/
+const LIB_ROOT = node_path.dirname((0, node_url.fileURLToPath)(require("url").pathToFileURL(__filename).href));
+/**
+* A frame belongs to user code if it's an absolute path that is neither inside
+* the library nor inside any `node_modules` (assertion libs, etc.). That leaves
+* exactly the frames a user cares about: their own step definitions.
+*/
+function isUserFile(file) {
+	return node_path.isAbsolute(file) && !file.startsWith(LIB_ROOT + node_path.sep) && !file.includes(`${node_path.sep}node_modules${node_path.sep}`);
+}
+/** Parse one `Error.stack` line into a frame, tolerating V8/Bun variations. */
+function parseFrame(frameLine) {
+	const m = /:(\d+):(\d+)\)?\s*$/.exec(frameLine);
+	if (!m) return void 0;
+	let file = frameLine.slice(0, m.index);
+	const paren = file.lastIndexOf("(");
+	if (paren !== -1) file = file.slice(paren + 1);
+	file = file.trim().replace(/^at\s+/, "");
+	if (file.startsWith("file://")) try {
+		file = (0, node_url.fileURLToPath)(file);
+	} catch {
+		return;
+	}
+	return {
+		file,
+		line: Number(m[1]),
+		column: Number(m[2])
+	};
+}
+/** Every user-code frame in a stack, nearest-first, internals removed. */
+function userFrames(stack) {
+	if (!stack) return [];
+	const frames = [];
+	for (const line of stack.split("\n")) {
+		const frame = parseFrame(line);
+		if (frame && isUserFile(frame.file)) frames.push(frame);
+	}
+	return frames;
+}
+/**
+* Capture the user source location of the current call site — the first
+* user-code frame above this function. Called from `.step()` registration so
+* each step remembers where it was defined (Cucumber-style), independent of
+* where an error is later thrown. Returns an absolute `file:line:column`, or
+* `undefined` if no user frame is visible.
+*/
+function captureDefinitionSite() {
+	const frame = userFrames((/* @__PURE__ */ new Error()).stack)[0];
+	return frame ? `${frame.file}:${frame.line}:${frame.column}` : void 0;
+}
+/** Render an absolute `file:line:column` relative to `cwd` for display. */
+function relativeLocation(location, cwd) {
+	const m = /^(.*):(\d+):(\d+)$/.exec(location);
+	if (!m) return location;
+	return `${node_path.relative(cwd, m[1])}:${m[2]}:${m[3]}`;
+}
+/** Render a frame relative to `cwd`. */
+function relativeFrame(frame, cwd) {
+	return `${node_path.relative(cwd, frame.file)}:${frame.line}:${frame.column}`;
+}
+//#endregion
+//#region src/world.ts
+function mergeCustomizer(objValue, srcValue) {
+	if (lodash.default.isArray(objValue)) return objValue.concat(srcValue);
+	else if (objValue && !lodash.default.isPlainObject(objValue) && objValue !== srcValue) throw new Error(`Merge would have destroyed previous value ${objValue} with ${srcValue}`);
+	return objValue;
+}
+var BasicWorld = class {
+	givenState = {};
+	whenState = {};
+	thenState = {};
+	get given() {
+		return {
+			...this.givenState,
+			merge: (newState) => {
+				this.givenState = lodash.default.merge({ ...this.givenState }, newState, mergeCustomizer);
+			}
+		};
+	}
+	get when() {
+		return {
+			...this.whenState,
+			merge: (newState) => {
+				this.whenState = lodash.default.merge({ ...this.whenState }, newState, mergeCustomizer);
+			}
+		};
+	}
+	get then() {
+		return {
+			...this.thenState,
+			merge: (newState) => {
+				this.thenState = lodash.default.merge({ ...this.thenState }, newState, mergeCustomizer);
+			}
+		};
+	}
+};
+//#endregion
+//#region src/globFiles.ts
+/** Glob metacharacters. A pattern with none of these is a literal path. */
+const MAGIC = /[*?[\]{}!()]/;
+async function isFile(p) {
+	try {
+		return (await (0, node_fs_promises.stat)(p)).isFile();
+	} catch {
+		return false;
+	}
+}
+/**
+* Resolve glob patterns to a de-duplicated list of absolute file paths, with one
+* important portability guarantee: a **literal absolute path** (no glob magic)
+* is returned directly if it exists, without being handed to `glob()`.
+*
+* This exists because `node:fs`'s `glob` diverges between runtimes — Node
+* matches an absolute-path pattern, Bun returns nothing for one. Rather than
+* depend on that behaviour, we only ever glob relative patterns (against `cwd`)
+* and short-circuit concrete absolute paths ourselves, so callers get identical
+* results under Node and Bun.
+*/
+async function globFiles(patterns, cwd = process.cwd()) {
+	const files = /* @__PURE__ */ new Set();
+	for (const pattern of patterns) {
+		if (node_path.isAbsolute(pattern) && !MAGIC.test(pattern)) {
+			if (await isFile(pattern)) files.add(pattern);
+			continue;
+		}
+		for await (const match of (0, node_fs_promises.glob)(pattern, { cwd })) files.add(node_path.resolve(cwd, match));
+	}
+	return [...files];
+}
+//#endregion
+//#region src/analyzer/gherkinParser.ts
+function parseFeatureFiles(filePaths) {
+	const scenarios = [];
+	for (const filePath of filePaths) {
+		const parsed = parseFeatureContent(node_fs.readFileSync(filePath, "utf-8"), filePath);
+		scenarios.push(...parsed);
+	}
+	return scenarios;
+}
+function parseFeatureContent(content, filePath) {
+	const feature = new _cucumber_gherkin.Parser(new _cucumber_gherkin.AstBuilder(_cucumber_messages.IdGenerator.uuid()), new _cucumber_gherkin.GherkinClassicTokenMatcher()).parse(content).feature;
+	if (!feature) return [];
+	const featureBackground = [];
+	const scenarios = [];
+	const featureTags = tagNames(feature.tags);
+	for (const child of feature.children) {
+		if (child.background) featureBackground.push(...child.background.steps);
+		if (child.scenario) scenarios.push(...expandScenario(child.scenario, featureBackground, filePath, featureTags));
+		if (child.rule) {
+			const ruleBackground = [...featureBackground];
+			const ruleTags = [...featureTags, ...tagNames(child.rule.tags)];
+			for (const ruleChild of child.rule.children) {
+				if (ruleChild.background) ruleBackground.push(...ruleChild.background.steps);
+				if (ruleChild.scenario) scenarios.push(...expandScenario(ruleChild.scenario, ruleBackground, filePath, ruleTags));
+			}
+		}
+	}
+	return scenarios;
+}
+/** Extract tag names (each keeping its leading `@`), deduped in order. */
+function tagNames(tags) {
+	return [...new Set((tags ?? []).map((t) => t.name))];
+}
+function expandScenario(scenario, backgroundSteps, filePath, inheritedTags) {
+	const scenarioTags = [...inheritedTags, ...tagNames(scenario.tags)];
+	if (!(scenario.examples.length > 0 && scenario.examples.some((e) => e.tableBody.length > 0))) {
+		const bgParsed = convertSteps(backgroundSteps);
+		const scenarioParsed = convertSteps(scenario.steps);
+		const allSteps = resolveEffectiveKeywords([...bgParsed, ...scenarioParsed]);
+		return [{
+			name: scenario.name,
+			file: filePath,
+			line: scenario.location.line,
+			steps: allSteps,
+			tags: scenarioTags
+		}];
+	}
+	const results = [];
+	for (const example of scenario.examples) {
+		if (!example.tableHeader || example.tableBody.length === 0) continue;
+		const headers = example.tableHeader.cells.map((c) => c.value);
+		const exampleTags = [...scenarioTags, ...tagNames(example.tags)];
+		for (const row of example.tableBody) {
+			const values = row.cells.map((c) => c.value);
+			const substitution = {};
+			headers.forEach((h, i) => {
+				substitution[h] = values[i];
+			});
+			const bgParsed = convertSteps(backgroundSteps);
+			const scenarioSteps = convertSteps(scenario.steps).map((step) => ({
+				...step,
+				text: substituteExampleValues(step.text, substitution)
+			}));
+			const allSteps = resolveEffectiveKeywords([...bgParsed, ...scenarioSteps]);
+			results.push({
+				name: headers.map((h, i) => `${h}=${values[i]}`).join(", "),
+				file: filePath,
+				line: row.location.line,
+				steps: allSteps,
+				tags: exampleTags,
+				outline: { name: scenario.name }
+			});
+		}
+	}
+	return results;
+}
+function convertSteps(steps) {
+	return steps.map((step) => ({
+		keyword: normalizeKeyword(step.keyword),
+		text: step.text,
+		line: step.location.line,
+		column: (step.location.column ?? 1) + step.keyword.length
+	}));
+}
+function normalizeKeyword(keyword) {
+	const trimmed = keyword.trim();
+	if (trimmed === "Given") return "Given";
+	if (trimmed === "When") return "When";
+	if (trimmed === "Then") return "Then";
+	if (trimmed === "And") return "And";
+	if (trimmed === "But") return "But";
+	return "Given";
+}
+function resolveEffectiveKeywords(steps) {
+	let lastEffective = "Given";
+	return steps.map((step) => {
+		let effectiveKeyword;
+		if (step.keyword === "And" || step.keyword === "But") effectiveKeyword = lastEffective;
+		else effectiveKeyword = step.keyword;
+		lastEffective = effectiveKeyword;
+		return {
+			...step,
+			effectiveKeyword
+		};
+	});
+}
+function substituteExampleValues(text, substitution) {
+	let result = text;
+	for (const [key, value] of Object.entries(substitution)) result = result.replace(new RegExp(`<${key}>`, "g"), value);
+	return result;
+}
+//#endregion
+Object.defineProperty(exports, "BasicWorld", {
+	enumerable: true,
+	get: function() {
+		return BasicWorld;
+	}
+});
+Object.defineProperty(exports, "__toESM", {
+	enumerable: true,
+	get: function() {
+		return __toESM;
+	}
+});
+Object.defineProperty(exports, "captureDefinitionSite", {
+	enumerable: true,
+	get: function() {
+		return captureDefinitionSite;
+	}
+});
+Object.defineProperty(exports, "globFiles", {
+	enumerable: true,
+	get: function() {
+		return globFiles;
+	}
+});
+Object.defineProperty(exports, "parseFeatureContent", {
+	enumerable: true,
+	get: function() {
+		return parseFeatureContent;
+	}
+});
+Object.defineProperty(exports, "parseFeatureFiles", {
+	enumerable: true,
+	get: function() {
+		return parseFeatureFiles;
+	}
+});
+Object.defineProperty(exports, "relativeFrame", {
+	enumerable: true,
+	get: function() {
+		return relativeFrame;
+	}
+});
+Object.defineProperty(exports, "relativeLocation", {
+	enumerable: true,
+	get: function() {
+		return relativeLocation;
+	}
+});
+Object.defineProperty(exports, "userFrames", {
+	enumerable: true,
+	get: function() {
+		return userFrames;
+	}
+});
+
+//# sourceMappingURL=gherkinParser-BT40q_i3.cjs.map

package/dist/gherkinParser-BT40q_i3.cjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"gherkinParser-BT40q_i3.cjs","names":["path","_","path","fs","Parser","AstBuilder","messages","GherkinClassicTokenMatcher"],"sources":["../../src/sourceLocation.ts","../../src/world.ts","../../src/globFiles.ts","../../src/analyzer/gherkinParser.ts"],"sourcesContent":["import * as path from \"node:path\";\nimport { fileURLToPath } from \"node:url\";\n\n/**\n * Directory holding the library's own compiled code. In development this is the\n * `src/` tree; in the published package it's `dist/` (this module is bundled\n * into the shipped chunks). Stack frames under it are internal plumbing —\n * builders, the engine, the runner — and are hidden from users so that a\n * failure points at *their* step, not ours.\n */\nconst LIB_ROOT = path.dirname(fileURLToPath(import.meta.url));\n\nexport interface SourceFrame {\n  file: string;\n  line: number;\n  column: number;\n}\n\n/**\n * A frame belongs to user code if it's an absolute path that is neither inside\n * the library nor inside any `node_modules` (assertion libs, etc.). That leaves\n * exactly the frames a user cares about: their own step definitions.\n */\nfunction isUserFile(file: string): boolean {\n  return (\n    path.isAbsolute(file) &&\n    !file.startsWith(LIB_ROOT + path.sep) &&\n    !file.includes(`${path.sep}node_modules${path.sep}`)\n  );\n}\n\n/** Parse one `Error.stack` line into a frame, tolerating V8/Bun variations. */\nfunction parseFrame(frameLine: string): SourceFrame | undefined {\n  const m = /:(\\d+):(\\d+)\\)?\\s*$/.exec(frameLine);\n  if (!m) return undefined;\n  let file = frameLine.slice(0, m.index);\n  const paren = file.lastIndexOf(\"(\");\n  if (paren !== -1) file = file.slice(paren + 1);\n  file = file.trim().replace(/^at\\s+/, \"\");\n  if (file.startsWith(\"file://\")) {\n    try {\n      file = fileURLToPath(file);\n    } catch {\n      return undefined;\n    }\n  }\n  return { file, line: Number(m[1]), column: Number(m[2]) };\n}\n\n/** Every user-code frame in a stack, nearest-first, internals removed. */\nexport function userFrames(stack: string | undefined): SourceFrame[] {\n  if (!stack) return [];\n  const frames: SourceFrame[] = [];\n  for (const line of stack.split(\"\\n\")) {\n    const frame = parseFrame(line);\n    if (frame && isUserFile(frame.file)) frames.push(frame);\n  }\n  return frames;\n}\n\n/**\n * Capture the user source location of the current call site — the first\n * user-code frame above this function. Called from `.step()` registration so\n * each step remembers where it was defined (Cucumber-style), independent of\n * where an error is later thrown. Returns an absolute `file:line:column`, or\n * `undefined` if no user frame is visible.\n */\nexport function captureDefinitionSite(): string | undefined {\n  const frame = userFrames(new Error().stack)[0];\n  return frame ? `${frame.file}:${frame.line}:${frame.column}` : undefined;\n}\n\n/** Render an absolute `file:line:column` relative to `cwd` for display. */\nexport function relativeLocation(location: string, cwd: string): string {\n  const m = /^(.*):(\\d+):(\\d+)$/.exec(location);\n  if (!m) return location;\n  return `${path.relative(cwd, m[1])}:${m[2]}:${m[3]}`;\n}\n\n/** Render a frame relative to `cwd`. */\nexport function relativeFrame(frame: SourceFrame, cwd: string): string {\n  return `${path.relative(cwd, frame.file)}:${frame.line}:${frame.column}`;\n}\n","import _ from \"lodash\";\n\nexport type WorldState<State> = {\n  readonly [K in keyof State]?: State[K];\n};\n\nexport type MergeableWorldState<T> = WorldState<T> & {\n  merge: (newState: Partial<T>) => void;\n};\n\nfunction mergeCustomizer(objValue: unknown, srcValue: unknown) {\n  if (_.isArray(objValue)) {\n    return objValue.concat(srcValue);\n  } else if (objValue && !_.isPlainObject(objValue) && objValue !== srcValue) {\n    throw new Error(\n      `Merge would have destroyed previous value ${objValue} with ${srcValue}`\n    );\n  }\n  return objValue;\n}\n\nexport const createMergeableState = <T>(\n  state: WorldState<T>\n): MergeableWorldState<T> => {\n  return {\n    ...state,\n    merge: (newState: Partial<T>) => {\n      state = _.merge({ ...state }, newState, mergeCustomizer);\n    },\n  };\n};\n\nexport type MergeableWorld<Given, When, Then> = {\n  given: MergeableWorldState<Given>;\n  when: MergeableWorldState<When>;\n  then: MergeableWorldState<Then>;\n};\n\nexport class BasicWorld<Given, When, Then> {\n  private givenState: WorldState<Given> = {};\n  private whenState: WorldState<When> = {};\n  private thenState: WorldState<Then> = {};\n\n  public get given(): MergeableWorldState<Given> {\n    return {\n      ...this.givenState,\n      merge: (newState: Partial<Given>) => {\n        this.givenState = _.merge(\n          { ...this.givenState },\n          newState,\n          mergeCustomizer\n        );\n      },\n    };\n  }\n\n  public get when(): MergeableWorldState<When> {\n    return {\n      ...this.whenState,\n      merge: (newState: Partial<When>) => {\n        this.whenState = _.merge(\n          { ...this.whenState },\n          newState,\n          mergeCustomizer\n        );\n      },\n    };\n  }\n\n  public get then(): MergeableWorldState<Then> {\n    return {\n      ...this.thenState,\n      merge: (newState: Partial<Then>) => {\n        this.thenState = _.merge(\n          { ...this.thenState },\n          newState,\n          mergeCustomizer\n        );\n      },\n    };\n  }\n}\n\nexport const createBasicWorld = <Given, When, Then>(): MergeableWorld<\n  Given,\n  When,\n  Then\n> => {\n  return new BasicWorld<Given, When, Then>();\n};\n","import { glob } from \"node:fs/promises\";\nimport { stat } from \"node:fs/promises\";\nimport * as path from \"node:path\";\n\n/** Glob metacharacters. A pattern with none of these is a literal path. */\nconst MAGIC = /[*?[\\]{}!()]/;\n\nasync function isFile(p: string): Promise<boolean> {\n  try {\n    return (await stat(p)).isFile();\n  } catch {\n    return false;\n  }\n}\n\n/**\n * Resolve glob patterns to a de-duplicated list of absolute file paths, with one\n * important portability guarantee: a **literal absolute path** (no glob magic)\n * is returned directly if it exists, without being handed to `glob()`.\n *\n * This exists because `node:fs`'s `glob` diverges between runtimes — Node\n * matches an absolute-path pattern, Bun returns nothing for one. Rather than\n * depend on that behaviour, we only ever glob relative patterns (against `cwd`)\n * and short-circuit concrete absolute paths ourselves, so callers get identical\n * results under Node and Bun.\n */\nexport async function globFiles(\n  patterns: string[],\n  cwd: string = process.cwd()\n): Promise<string[]> {\n  const files = new Set<string>();\n  for (const pattern of patterns) {\n    if (path.isAbsolute(pattern) && !MAGIC.test(pattern)) {\n      if (await isFile(pattern)) files.add(pattern);\n      continue;\n    }\n    for await (const match of glob(pattern, { cwd })) {\n      files.add(path.resolve(cwd, match));\n    }\n  }\n  return [...files];\n}\n","import * as fs from \"node:fs\";\nimport { GherkinClassicTokenMatcher, Parser, AstBuilder } from \"@cucumber/gherkin\";\nimport * as messages from \"@cucumber/messages\";\nimport { ParsedScenario, ParsedStep } from \"./types.js\";\n\ntype GherkinKeyword = \"Given\" | \"When\" | \"Then\" | \"And\" | \"But\";\n\nexport function parseFeatureFiles(filePaths: string[]): ParsedScenario[] {\n  const scenarios: ParsedScenario[] = [];\n\n  for (const filePath of filePaths) {\n    const content = fs.readFileSync(filePath, \"utf-8\");\n    const parsed = parseFeatureContent(content, filePath);\n    scenarios.push(...parsed);\n  }\n\n  return scenarios;\n}\n\nexport function parseFeatureContent(\n  content: string,\n  filePath: string\n): ParsedScenario[] {\n  const newId = messages.IdGenerator.uuid();\n  const builder = new AstBuilder(newId);\n  const matcher = new GherkinClassicTokenMatcher();\n  const parser = new Parser(builder, matcher);\n\n  const gherkinDocument: messages.GherkinDocument = parser.parse(content);\n  const feature = gherkinDocument.feature;\n  if (!feature) return [];\n\n  // Collect background steps at the feature level\n  const featureBackground: messages.Step[] = [];\n  const scenarios: ParsedScenario[] = [];\n  const featureTags = tagNames(feature.tags);\n\n  for (const child of feature.children) {\n    if (child.background) {\n      featureBackground.push(...child.background.steps);\n    }\n\n    if (child.scenario) {\n      scenarios.push(\n        ...expandScenario(\n          child.scenario,\n          featureBackground,\n          filePath,\n          featureTags\n        )\n      );\n    }\n\n    if (child.rule) {\n      // Rules can have their own backgrounds and tags, both inherited by the\n      // rule's scenarios.\n      const ruleBackground: messages.Step[] = [...featureBackground];\n      const ruleTags = [...featureTags, ...tagNames(child.rule.tags)];\n      for (const ruleChild of child.rule.children) {\n        if (ruleChild.background) {\n          ruleBackground.push(...ruleChild.background.steps);\n        }\n        if (ruleChild.scenario) {\n          scenarios.push(\n            ...expandScenario(\n              ruleChild.scenario,\n              ruleBackground,\n              filePath,\n              ruleTags\n            )\n          );\n        }\n      }\n    }\n  }\n\n  return scenarios;\n}\n\n/** Extract tag names (each keeping its leading `@`), deduped in order. */\nfunction tagNames(tags: readonly messages.Tag[] | undefined): string[] {\n  return [...new Set((tags ?? []).map(t => t.name))];\n}\n\nfunction expandScenario(\n  scenario: messages.Scenario,\n  backgroundSteps: messages.Step[],\n  filePath: string,\n  inheritedTags: string[]\n): ParsedScenario[] {\n  const scenarioTags = [...inheritedTags, ...tagNames(scenario.tags)];\n  const hasExamples =\n    scenario.examples.length > 0 &&\n    scenario.examples.some((e) => e.tableBody.length > 0);\n\n  if (!hasExamples) {\n    // Regular scenario\n    const bgParsed = convertSteps(backgroundSteps);\n    const scenarioParsed = convertSteps(scenario.steps);\n    const allSteps = resolveEffectiveKeywords([...bgParsed, ...scenarioParsed]);\n\n    return [\n      {\n        name: scenario.name,\n        file: filePath,\n        line: scenario.location.line,\n        steps: allSteps,\n        tags: scenarioTags,\n      },\n    ];\n  }\n\n  // Scenario Outline — expand with each example row. Rows carry the outline's\n  // base name so the runner can group them, plus the Examples-block tags.\n  const results: ParsedScenario[] = [];\n  for (const example of scenario.examples) {\n    if (!example.tableHeader || example.tableBody.length === 0) continue;\n    const headers = example.tableHeader.cells.map((c) => c.value);\n    const exampleTags = [...scenarioTags, ...tagNames(example.tags)];\n\n    for (const row of example.tableBody) {\n      const values = row.cells.map((c) => c.value);\n      const substitution: Record<string, string> = {};\n      headers.forEach((h, i) => {\n        substitution[h] = values[i];\n      });\n\n      const bgParsed = convertSteps(backgroundSteps);\n      const scenarioSteps = convertSteps(scenario.steps).map((step) => ({\n        ...step,\n        text: substituteExampleValues(step.text, substitution),\n      }));\n      const allSteps = resolveEffectiveKeywords([...bgParsed, ...scenarioSteps]);\n\n      results.push({\n        name: headers.map((h, i) => `${h}=${values[i]}`).join(\", \"),\n        file: filePath,\n        line: row.location.line,\n        steps: allSteps,\n        tags: exampleTags,\n        outline: { name: scenario.name },\n      });\n    }\n  }\n\n  return results;\n}\n\nfunction convertSteps(\n  steps: readonly messages.Step[]\n): Omit<ParsedStep, \"effectiveKeyword\">[] {\n  return steps.map((step) => ({\n    keyword: normalizeKeyword(step.keyword),\n    text: step.text,\n    line: step.location.line,\n    // step.location.column points to the keyword start; shift past the\n    // keyword (which includes a trailing space) so column points to the\n    // start of the step text. This makes `column + text.length` produce\n    // the correct end position for diagnostic ranges.\n    column: (step.location.column ?? 1) + step.keyword.length,\n  }));\n}\n\nfunction normalizeKeyword(keyword: string): GherkinKeyword {\n  const trimmed = keyword.trim();\n  // Gherkin keywords may include trailing space, e.g. \"Given \"\n  if (trimmed === \"Given\") return \"Given\";\n  if (trimmed === \"When\") return \"When\";\n  if (trimmed === \"Then\") return \"Then\";\n  if (trimmed === \"And\") return \"And\";\n  if (trimmed === \"But\") return \"But\";\n  // Fallback: treat as Given (shouldn't happen with valid Gherkin)\n  return \"Given\";\n}\n\nfunction resolveEffectiveKeywords(\n  steps: Omit<ParsedStep, \"effectiveKeyword\">[]\n): ParsedStep[] {\n  let lastEffective: \"Given\" | \"When\" | \"Then\" = \"Given\";\n\n  return steps.map((step) => {\n    let effectiveKeyword: \"Given\" | \"When\" | \"Then\";\n    if (step.keyword === \"And\" || step.keyword === \"But\") {\n      effectiveKeyword = lastEffective;\n    } else {\n      effectiveKeyword = step.keyword as \"Given\" | \"When\" | \"Then\";\n    }\n    lastEffective = effectiveKeyword;\n\n    return {\n      ...step,\n      effectiveKeyword,\n    };\n  });\n}\n\nfunction substituteExampleValues(\n  text: string,\n  substitution: Record<string, string>\n): string {\n  let result = text;\n  for (const [key, value] of Object.entries(substitution)) {\n    result = result.replace(new RegExp(`<${key}>`, \"g\"), value);\n  }\n  return result;\n}\n"],"mappings":"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"}