@step-forge/step-forge 0.0.20 → 0.0.21

package/dist/runtime.js

@@ -1,159 +1,3 @@
 import { a as StepRegistry, i as runHooks, n as ensureGlobalHooks, o as globalRegistry, r as globalHookRegistry, t as HookRegistry } from "./hooks-CywugMQQ.js";
-import { CucumberExpression, ParameterType, ParameterTypeRegistry } from "@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";
-	}
-};
-function compile(registry) {
-	return registry.all().map((step) => {
-		const paramRegistry = new 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 ParameterType(parser.name, regexps, null, (value) => parser.parse(value)));
-		}
-		return {
-			step,
-			expression: new 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 registry. 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.
-*
-* Throws on failure so it maps cleanly onto a test runner's `test()` body, but
-* the returned/attached `ScenarioResult` carries the per-step breakdown.
-*/
-async function runScenario(scenario, registry, makeWorld, hooks = globalHookRegistry) {
-	const compiled = compile(registry);
-	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;
-		}
-		try {
-			const { step: def, args } = matchStep(step, compiled);
-			await def.execute(world, args);
-			steps.push({
-				step,
-				status: "passed"
-			});
-		} catch (err) {
-			const error = err instanceof Error ? err : new Error(String(err));
-			steps.push({
-				step,
-				status: "failed",
-				error
-			});
-			fail(error);
-		}
-	}
-	for (const hook of hooks.for("scenario", "after")) try {
-		await hook.fn({
-			world,
-			scenario: scenarioInfo
-		});
-	} catch (err) {
-		fail(err);
-	}
-	const result = {
-		scenario,
-		status: failed ? "failed" : "passed",
-		steps
-	};
-	if (failed && firstError) {
-		const failing = steps.find((s) => s.status === "failed");
-		if (failing) attachFeatureFrame(firstError, scenario.file, failing.step);
-		throw firstError;
-	}
-	return result;
-}
-/**
-* Prepend a synthetic stack frame pointing at the failing Gherkin step. Because
-* the frame's file is the real `.feature` on disk, the test runner treats it as
-* a source location and shows a code frame at the step — instead of us jamming
-* `file:line` into the error message. The frame goes *above* the real stack, so
-* the step-definition frames (the actual throw site) are preserved below it.
-*/
-function attachFeatureFrame(error, file, step) {
-	const frame = `    at ${`${step.effectiveKeyword} ${step.text}`} (${file}:${step.line}:${step.column})`;
-	const stack = error.stack;
-	if (!stack) {
-		error.stack = `${error.name}: ${error.message}\n${frame}`;
-		return;
-	}
-	const firstFrame = stack.indexOf("\n    at ");
-	if (firstFrame === -1) error.stack = `${stack}\n${frame}`;
-	else error.stack = stack.slice(0, firstFrame) + `\n${frame}` + stack.slice(firstFrame);
-}
-//#endregion
-export { AmbiguousStepError, HookRegistry, StepRegistry, UndefinedStepError, ensureGlobalHooks, globalHookRegistry, globalRegistry, runHooks, runScenario };
-
-//# sourceMappingURL=runtime.js.map
+import { i as runScenario, n as UndefinedStepError, r as compileRegistry, t as AmbiguousStepError } from "./engine-DPRxs6eC.js";
+export { AmbiguousStepError, HookRegistry, StepRegistry, UndefinedStepError, compileRegistry, ensureGlobalHooks, globalHookRegistry, globalRegistry, runHooks, runScenario };

package/dist/step-forge.cjs

@@ -1,39 +1,10 @@
 Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
-//#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
+const require_gherkinParser = require("./gherkinParser-CHpkEwii.cjs");
 const require_hooks = require("./hooks-CGYzwDOv.cjs");
 let lodash = require("lodash");
-lodash = __toESM(lodash, 1);
-let node_fs_promises = require("node:fs/promises");
-let node_path = require("node:path");
-node_path = __toESM(node_path, 1);
+lodash = require_gherkinParser.__toESM(lodash, 1);
 let typescript = require("typescript");
-typescript = __toESM(typescript, 1);
-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);
+typescript = require_gherkinParser.__toESM(typescript, 1);
 //#region src/builderTypeUtils.ts
 const isString = (statement) => typeof statement === "string";
 //#endregion
@@ -224,42 +195,6 @@ const thenStatement = () => (statement) => {
 };
 const thenBuilder = () => ({ statement: thenStatement() });
 //#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/analyzer/stepExtractor.ts
 const BUILDER_NAMES = {
 	givenBuilder: "given",
@@ -477,116 +412,6 @@ function resolveReExportedCall(chain, checker) {
 	return null;
 }
 //#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,
-			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,
-				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
 //#region src/analyzer/stepMatcher.ts
 function compileDefinitions(definitions) {
 	const compiled = [];
@@ -721,12 +546,12 @@ function runRules(rules, scenario, matchedSteps) {
 //#region src/analyzer/index.ts
 async function analyze(config, options) {
 	const rules = options?.rules ?? defaultRules;
-	const stepFilePaths = await resolveGlobs(config.stepFiles);
-	const featureFilePaths = await resolveGlobs(config.featureFiles);
+	const stepFilePaths = await require_gherkinParser.globFiles(config.stepFiles);
+	const featureFilePaths = await require_gherkinParser.globFiles(config.featureFiles);
 	if (stepFilePaths.length === 0) return [];
 	if (featureFilePaths.length === 0) return [];
 	const stepDefinitions = extractStepDefinitions(stepFilePaths, config.tsConfigPath);
-	const scenarios = parseFeatureFiles(featureFilePaths);
+	const scenarios = require_gherkinParser.parseFeatureFiles(featureFilePaths);
 	const diagnostics = [];
 	for (const scenario of scenarios) {
 		const scenarioDiags = runRules(rules, scenario, matchScenarioSteps(scenario, stepDefinitions));
@@ -734,11 +559,6 @@ async function analyze(config, options) {
 	}
 	return diagnostics;
 }
-async function resolveGlobs(patterns) {
-	const files = [];
-	for (const pattern of patterns) for await (const file of (0, node_fs_promises.glob)(pattern)) files.push(node_path.resolve(file));
-	return [...new Set(files)];
-}
 //#endregion
 //#region src/init.ts
 const createBuilders = () => {
@@ -812,14 +632,14 @@ function afterAll(fn) {
 const analyzer = {
 	analyze,
 	extractStepDefinitions,
-	parseFeatureFiles,
-	parseFeatureContent,
+	parseFeatureFiles: require_gherkinParser.parseFeatureFiles,
+	parseFeatureContent: require_gherkinParser.parseFeatureContent,
 	matchScenarioSteps,
 	findMatchingDefinitions,
 	defaultRules
 };
 //#endregion
-exports.BasicWorld = BasicWorld;
+exports.BasicWorld = require_gherkinParser.BasicWorld;
 exports.afterAll = afterAll;
 exports.afterFeature = afterFeature;
 exports.afterScenario = afterScenario;