@step-forge/step-forge 0.0.21 → 0.0.23

package/dist/step-forge.d.cts

@@ -1,4 +1,4 @@
-import { C as numberParser, S as intParser, _ as StepDefinitionMeta, b as Parser, d as AnalysisRule, f as AnalyzerConfig, g as ParsedStep, h as ParsedScenario, i as PlainHookFn, m as MatchedStep, o as ScenarioHookFn, p as Diagnostic, s as ScenarioInfo, v as BasicWorld, w as stringParser, x as booleanParser, y as MergeableWorld } from "./hooks-Dar49TtT.cjs";
+import { C as booleanParser, E as stringParser, S as Parser, T as numberParser, _ as ParsedScenario, b as BasicWorld, c as ScenarioHookFn, g as MatchedStep, h as Diagnostic, l as ScenarioInfo, m as AnalyzerConfig, n as RunnerOptions, o as PlainHookFn, p as AnalysisRule, v as ParsedStep, w as intParser, x as MergeableWorld, y as StepDefinitionMeta } from "./config-C7PCYgYy.cjs";
 
 //#region src/builderTypeUtils.d.ts
 type StepType = "given" | "when" | "then";
@@ -470,9 +470,18 @@ declare function afterScenario<World extends MergeableWorld<any, any, any> = Mer
 declare function beforeFeature(fn: PlainHookFn): void;
 /** Run once at the end of each feature file (reverse registration order). */
 declare function afterFeature(fn: PlainHookFn): void;
-/** Run once before the entire test run, across all feature files. */
+/**
+ * Run once before the entire run, ahead of any scenario (and before
+ * concurrency starts). Multiple `beforeAll` hooks run **in parallel** with no
+ * ordering between them — if a step of setup must precede another, sequence both
+ * inside a single hook.
+ */
 declare function beforeAll(fn: PlainHookFn): void;
-/** Run once after the entire test run (reverse registration order). */
+/**
+ * Run once after the entire run, once every scenario is done. Multiple
+ * `afterAll` hooks run **in parallel** with no ordering between them — sequence
+ * dependent teardown inside a single hook.
+ */
 declare function afterAll(fn: PlainHookFn): void;
 //#endregion
 //#region src/typeHelpers.d.ts
@@ -501,5 +510,5 @@ declare const analyzer: {
   defaultRules: AnalysisRule[];
 };
 //#endregion
-export { type AnalysisRule, type AnalyzeOptions, type AnalyzerConfig, BasicWorld, type Diagnostic, type MatchedStep, type ParsedScenario, type ParsedStep, type Parser, type PlainHookFn, type ScenarioHookFn, type ScenarioInfo, type StateFromDependencies, type StepDefinitionMeta, afterAll, afterFeature, afterScenario, analyzer, beforeAll, beforeFeature, beforeScenario, booleanParser, createBuilders, givenBuilder, intParser, numberParser, stringParser, thenBuilder, whenBuilder };
+export { type AnalysisRule, type AnalyzeOptions, type AnalyzerConfig, BasicWorld, type Diagnostic, type MatchedStep, type ParsedScenario, type ParsedStep, type Parser, type PlainHookFn, type RunnerOptions, type ScenarioHookFn, type ScenarioInfo, type StateFromDependencies, type StepDefinitionMeta, afterAll, afterFeature, afterScenario, analyzer, beforeAll, beforeFeature, beforeScenario, booleanParser, createBuilders, givenBuilder, intParser, numberParser, stringParser, thenBuilder, whenBuilder };
 //# sourceMappingURL=step-forge.d.cts.map

package/dist/step-forge.d.ts

@@ -1,4 +1,4 @@
-import { C as numberParser, S as intParser, _ as StepDefinitionMeta, b as Parser, d as AnalysisRule, f as AnalyzerConfig, g as ParsedStep, h as ParsedScenario, i as PlainHookFn, m as MatchedStep, o as ScenarioHookFn, p as Diagnostic, s as ScenarioInfo, v as BasicWorld, w as stringParser, x as booleanParser, y as MergeableWorld } from "./hooks-Dar49TtT.js";
+import { C as booleanParser, E as stringParser, S as Parser, T as numberParser, _ as ParsedScenario, b as BasicWorld, c as ScenarioHookFn, g as MatchedStep, h as Diagnostic, l as ScenarioInfo, m as AnalyzerConfig, n as RunnerOptions, o as PlainHookFn, p as AnalysisRule, v as ParsedStep, w as intParser, x as MergeableWorld, y as StepDefinitionMeta } from "./config-C7PCYgYy.js";
 
 //#region src/builderTypeUtils.d.ts
 type StepType = "given" | "when" | "then";
@@ -470,9 +470,18 @@ declare function afterScenario<World extends MergeableWorld<any, any, any> = Mer
 declare function beforeFeature(fn: PlainHookFn): void;
 /** Run once at the end of each feature file (reverse registration order). */
 declare function afterFeature(fn: PlainHookFn): void;
-/** Run once before the entire test run, across all feature files. */
+/**
+ * Run once before the entire run, ahead of any scenario (and before
+ * concurrency starts). Multiple `beforeAll` hooks run **in parallel** with no
+ * ordering between them — if a step of setup must precede another, sequence both
+ * inside a single hook.
+ */
 declare function beforeAll(fn: PlainHookFn): void;
-/** Run once after the entire test run (reverse registration order). */
+/**
+ * Run once after the entire run, once every scenario is done. Multiple
+ * `afterAll` hooks run **in parallel** with no ordering between them — sequence
+ * dependent teardown inside a single hook.
+ */
 declare function afterAll(fn: PlainHookFn): void;
 //#endregion
 //#region src/typeHelpers.d.ts
@@ -501,5 +510,5 @@ declare const analyzer: {
   defaultRules: AnalysisRule[];
 };
 //#endregion
-export { type AnalysisRule, type AnalyzeOptions, type AnalyzerConfig, BasicWorld, type Diagnostic, type MatchedStep, type ParsedScenario, type ParsedStep, type Parser, type PlainHookFn, type ScenarioHookFn, type ScenarioInfo, type StateFromDependencies, type StepDefinitionMeta, afterAll, afterFeature, afterScenario, analyzer, beforeAll, beforeFeature, beforeScenario, booleanParser, createBuilders, givenBuilder, intParser, numberParser, stringParser, thenBuilder, whenBuilder };
+export { type AnalysisRule, type AnalyzeOptions, type AnalyzerConfig, BasicWorld, type Diagnostic, type MatchedStep, type ParsedScenario, type ParsedStep, type Parser, type PlainHookFn, type RunnerOptions, type ScenarioHookFn, type ScenarioInfo, type StateFromDependencies, type StepDefinitionMeta, afterAll, afterFeature, afterScenario, analyzer, beforeAll, beforeFeature, beforeScenario, booleanParser, createBuilders, givenBuilder, intParser, numberParser, stringParser, thenBuilder, whenBuilder };
 //# sourceMappingURL=step-forge.d.ts.map

package/dist/step-forge.js

@@ -1,7 +1,7 @@
-import { o as globalRegistry, r as globalHookRegistry } from "./hooks-CywugMQQ.js";
-import { i as BasicWorld, n as parseFeatureFiles, r as globFiles, t as parseFeatureContent } from "./gherkinParser-CKARHgt4.js";
+import { a as matchScenarioSteps, i as findMatchingDefinitions, o as extractStepDefinitions, r as defaultRules, t as analyze } from "./analyzer-DnfK54Dw.js";
+import { n as globalHookRegistry, o as globalRegistry } from "./hooks-BDCMKeNq.js";
+import { a as BasicWorld, n as parseFeatureContent, o as captureDefinitionSite, r as parseFeatureFiles } from "./gherkinParser-i-Q7M6mi.js";
 import _ from "lodash";
-import ts from "typescript";
 //#region src/builderTypeUtils.ts
 const isString = (statement) => typeof statement === "string";
 //#endregion
@@ -114,11 +114,13 @@ const addStep = (statement, stepType, dependencies = {
 		});
 		world[stepType].merge({ ...result });
 	};
+	const source = captureDefinitionSite();
 	globalRegistry.add({
 		stepType,
 		expression,
 		parsers,
-		execute
+		execute,
+		source
 	});
 	return {
 		statement,
@@ -192,371 +194,6 @@ const thenStatement = () => (statement) => {
 };
 const thenBuilder = () => ({ statement: thenStatement() });
 //#endregion
-//#region src/analyzer/stepExtractor.ts
-const BUILDER_NAMES = {
-	givenBuilder: "given",
-	whenBuilder: "when",
-	thenBuilder: "then"
-};
-function extractStepDefinitions(filePaths, tsConfigPath) {
-	const configPath = tsConfigPath ?? ts.findConfigFile(process.cwd(), ts.sys.fileExists);
-	let compilerOptions = {
-		target: ts.ScriptTarget.ESNext,
-		module: ts.ModuleKind.ESNext,
-		moduleResolution: ts.ModuleResolutionKind.Node10,
-		strict: true,
-		esModuleInterop: true
-	};
-	if (configPath) {
-		const configFile = ts.readConfigFile(configPath, ts.sys.readFile);
-		if (!configFile.error) compilerOptions = ts.parseJsonConfigFileContent(configFile.config, ts.sys, configPath.replace(/[/\\][^/\\]+$/, "")).options;
-	}
-	compilerOptions.noEmit = true;
-	const program = ts.createProgram(filePaths, compilerOptions);
-	const checker = program.getTypeChecker();
-	const results = [];
-	for (const filePath of filePaths) {
-		const sourceFile = program.getSourceFile(filePath);
-		if (!sourceFile) continue;
-		const fileResults = extractFromSourceFile(sourceFile, checker);
-		results.push(...fileResults);
-	}
-	return results;
-}
-function extractFromSourceFile(sourceFile, checker) {
-	const results = [];
-	function visit(node) {
-		if (ts.isCallExpression(node) && ts.isPropertyAccessExpression(node.expression) && node.expression.name.text === "step") {
-			const meta = extractFromRegisterCall(node, sourceFile, checker);
-			if (meta) results.push(meta);
-		}
-		ts.forEachChild(node, visit);
-	}
-	visit(sourceFile);
-	return results;
-}
-function extractFromRegisterCall(registerCall, sourceFile, checker) {
-	const chain = collectCallChain(registerCall);
-	let stepType = null;
-	let expression = null;
-	let dependencies = {
-		given: {},
-		when: {},
-		then: {}
-	};
-	let produces = [];
-	for (const link of chain) {
-		const name = getCallName(link);
-		if (!name) continue;
-		if (name === "register") continue;
-		if (name === "step") {
-			produces = extractProducedKeys(link, checker);
-			continue;
-		}
-		if (name === "dependencies") {
-			dependencies = extractDependencies(link);
-			continue;
-		}
-		if (name === "statement") {
-			expression = extractExpression(link);
-			continue;
-		}
-		if (BUILDER_NAMES[name]) {
-			stepType = BUILDER_NAMES[name];
-			continue;
-		}
-	}
-	if (!stepType || !expression) {
-		const reExport = resolveReExportedCall(chain, checker);
-		if (reExport) {
-			if (!stepType) stepType = reExport.stepType;
-			if (!expression) expression = reExport.expression;
-		}
-	}
-	if (!stepType || !expression) return null;
-	const line = sourceFile.getLineAndCharacterOfPosition(registerCall.getStart()).line + 1;
-	return {
-		stepType,
-		expression,
-		dependencies,
-		produces,
-		sourceFile: sourceFile.fileName,
-		line
-	};
-}
-/**
-* Collect all call expressions in the method chain, from register() back to the origin.
-*/
-function collectCallChain(call) {
-	const chain = [call];
-	let current = call.expression;
-	while (true) {
-		if (ts.isPropertyAccessExpression(current)) current = current.expression;
-		if (ts.isCallExpression(current)) {
-			chain.push(current);
-			current = current.expression;
-		} else break;
-	}
-	return chain;
-}
-function getCallName(call) {
-	const expr = call.expression;
-	if (ts.isPropertyAccessExpression(expr)) return expr.name.text;
-	if (ts.isIdentifier(expr)) return expr.text;
-	return null;
-}
-function extractExpression(statementCall) {
-	const arg = statementCall.arguments[0];
-	if (!arg) return null;
-	if (ts.isStringLiteral(arg)) return arg.text;
-	if (ts.isArrowFunction(arg)) return extractExpressionFromArrowFunction(arg);
-	return null;
-}
-function extractExpressionFromArrowFunction(fn) {
-	const params = fn.parameters.map((p) => p.name.getText());
-	let body = fn.body;
-	if (ts.isBlock(body)) {
-		const returnStmt = body.statements.find(ts.isReturnStatement);
-		if (returnStmt?.expression) body = returnStmt.expression;
-		else return null;
-	}
-	if (ts.isTemplateExpression(body)) return reconstructExpressionFromTemplate(body, params);
-	if (ts.isNoSubstitutionTemplateLiteral(body)) return body.text;
-	return null;
-}
-function reconstructExpressionFromTemplate(template, paramNames) {
-	let result = template.head.text;
-	for (const span of template.templateSpans) {
-		if (ts.isIdentifier(span.expression) && paramNames.includes(span.expression.text)) result += "{string}";
-		else result += "{string}";
-		result += span.literal.text;
-	}
-	return result;
-}
-function extractDependencies(depsCall) {
-	const deps = {
-		given: {},
-		when: {},
-		then: {}
-	};
-	const arg = depsCall.arguments[0];
-	if (!arg || !ts.isObjectLiteralExpression(arg)) return deps;
-	for (const prop of arg.properties) {
-		if (!ts.isPropertyAssignment(prop) || !ts.isIdentifier(prop.name)) continue;
-		const phase = prop.name.text;
-		if (!deps[phase]) continue;
-		if (ts.isObjectLiteralExpression(prop.initializer)) {
-			for (const innerProp of prop.initializer.properties) if (ts.isPropertyAssignment(innerProp) && ts.isIdentifier(innerProp.name) && ts.isStringLiteral(innerProp.initializer)) {
-				const val = innerProp.initializer.text;
-				if (val === "required" || val === "optional") deps[phase][innerProp.name.text] = val;
-			}
-		}
-	}
-	return deps;
-}
-function extractProducedKeys(stepCall, checker) {
-	const callback = stepCall.arguments[0];
-	if (!callback) return [];
-	if (ts.isArrowFunction(callback) || ts.isFunctionExpression(callback)) return extractProducedKeysFromCallback(callback, checker);
-	return [];
-}
-function extractProducedKeysFromCallback(callback, checker) {
-	const body = callback.body;
-	if (!ts.isBlock(body)) return extractKeysFromExpression(body, checker);
-	const keys = /* @__PURE__ */ new Set();
-	function visitReturn(node) {
-		if (ts.isReturnStatement(node) && node.expression) for (const key of extractKeysFromExpression(node.expression, checker)) keys.add(key);
-		ts.forEachChild(node, visitReturn);
-	}
-	visitReturn(body);
-	return [...keys];
-}
-function extractKeysFromExpression(expr, checker) {
-	while (ts.isParenthesizedExpression(expr)) expr = expr.expression;
-	if (ts.isObjectLiteralExpression(expr)) return expr.properties.filter((p) => ts.isPropertyAssignment(p) || ts.isShorthandPropertyAssignment(p)).map((p) => p.name.getText()).filter(Boolean);
-	try {
-		return checker.getTypeAtLocation(expr).getProperties().map((p) => p.name).filter((n) => n !== "merge");
-	} catch {
-		return [];
-	}
-}
-function resolveReExportedCall(chain, checker) {
-	const lastCall = chain[chain.length - 1];
-	if (!lastCall) return null;
-	const expr = lastCall.expression;
-	let identifier = null;
-	if (ts.isIdentifier(expr)) identifier = expr;
-	else if (ts.isPropertyAccessExpression(expr) && ts.isIdentifier(expr.expression)) identifier = expr.expression;
-	if (!identifier) return null;
-	const symbol = checker.getSymbolAtLocation(identifier);
-	if (!symbol) return null;
-	const decl = symbol.valueDeclaration;
-	if (!decl || !ts.isVariableDeclaration(decl) || !decl.initializer) return null;
-	const init = decl.initializer;
-	if (ts.isPropertyAccessExpression(init) && init.name.text === "statement") {
-		const callExpr = init.expression;
-		if (ts.isCallExpression(callExpr)) {
-			const callee = callExpr.expression;
-			if (ts.isIdentifier(callee) && BUILDER_NAMES[callee.text]) {
-				const expression = extractExpression(lastCall);
-				return {
-					stepType: BUILDER_NAMES[callee.text],
-					expression
-				};
-			}
-		}
-	}
-	return null;
-}
-//#endregion
-//#region src/analyzer/stepMatcher.ts
-function compileDefinitions(definitions) {
-	const compiled = [];
-	for (const def of definitions) try {
-		const placeholder = "###PLACEHOLDER###";
-		const regexStr = def.expression.replace(/\{[^}]+\}/g, placeholder).replace(/[.*+?^$()|[\]\\]/g, "\\$&").replace(new RegExp(placeholder, "g"), "(.+)");
-		compiled.push({
-			regex: new RegExp(`^${regexStr}$`, "i"),
-			definition: def
-		});
-	} catch {}
-	return compiled;
-}
-function matchScenarioSteps(scenario, definitions) {
-	const compiled = compileDefinitions(definitions);
-	return scenario.steps.map((step) => {
-		const matches = findMatches(step.text, step.effectiveKeyword, compiled);
-		return {
-			...step,
-			definitions: matches
-		};
-	});
-}
-function findMatchingDefinitions(text, effectiveKeyword, definitions) {
-	return findMatches(text, effectiveKeyword, compileDefinitions(definitions));
-}
-function findMatches(text, effectiveKeyword, compiled) {
-	const expectedStepType = {
-		Given: "given",
-		When: "when",
-		Then: "then"
-	}[effectiveKeyword];
-	const typedMatches = [];
-	for (const { regex, definition } of compiled) {
-		if (definition.stepType !== expectedStepType) continue;
-		if (regex.test(text)) typedMatches.push(definition);
-	}
-	if (typedMatches.length > 0) return typedMatches;
-	const fallbackMatches = [];
-	for (const { regex, definition } of compiled) if (regex.test(text)) fallbackMatches.push(definition);
-	return fallbackMatches;
-}
-//#endregion
-//#region src/analyzer/rules/index.ts
-const defaultRules = [
-	{
-		name: "undefined-step",
-		check(scenario, matchedSteps) {
-			return matchedSteps.filter((step) => step.definitions.length === 0).map((step) => ({
-				file: scenario.file,
-				range: {
-					startLine: step.line,
-					startColumn: step.column,
-					endLine: step.line,
-					endColumn: step.column + step.text.length
-				},
-				severity: "error",
-				message: `Step "${step.text}" does not match any step definition`,
-				rule: "undefined-step",
-				source: "step-forge"
-			}));
-		}
-	},
-	{
-		name: "ambiguous-step",
-		check(scenario, matchedSteps) {
-			return matchedSteps.filter((step) => step.definitions.length > 1).map((step) => {
-				const locations = step.definitions.map((d) => `${d.sourceFile}:${d.line}`).join(", ");
-				return {
-					file: scenario.file,
-					range: {
-						startLine: step.line,
-						startColumn: step.column,
-						endLine: step.line,
-						endColumn: step.column + step.text.length
-					},
-					severity: "error",
-					message: `Step "${step.text}" matches multiple step definitions: ${locations}`,
-					rule: "ambiguous-step",
-					source: "step-forge"
-				};
-			});
-		}
-	},
-	{
-		name: "dependency-check",
-		check(scenario, matchedSteps) {
-			const diagnostics = [];
-			const produced = {
-				given: /* @__PURE__ */ new Set(),
-				when: /* @__PURE__ */ new Set(),
-				then: /* @__PURE__ */ new Set()
-			};
-			for (const step of matchedSteps) {
-				if (step.definitions.length !== 1) continue;
-				const { dependencies, produces, stepType } = step.definitions[0];
-				const missing = {};
-				for (const phase of [
-					"given",
-					"when",
-					"then"
-				]) for (const [key, requirement] of Object.entries(dependencies[phase])) if (requirement === "required" && !produced[phase].has(key)) {
-					if (!missing[phase]) missing[phase] = [];
-					missing[phase].push(key);
-				}
-				if (Object.keys(missing).length > 0) {
-					const message = "Missing required dependencies:\n" + Object.entries(missing).map(([phase, keys]) => `${phase.charAt(0).toUpperCase() + phase.slice(1)}: ${keys.map((k) => `${phase}.${k}`).join(", ")}`).join("\n");
-					diagnostics.push({
-						file: scenario.file,
-						range: {
-							startLine: step.line,
-							startColumn: step.column,
-							endLine: step.line,
-							endColumn: step.column + step.text.length
-						},
-						severity: "error",
-						message,
-						rule: "dependency-check",
-						source: "step-forge"
-					});
-				}
-				for (const key of produces) produced[stepType].add(key);
-			}
-			return diagnostics;
-		}
-	}
-];
-function runRules(rules, scenario, matchedSteps) {
-	return rules.flatMap((rule) => rule.check(scenario, matchedSteps));
-}
-//#endregion
-//#region src/analyzer/index.ts
-async function analyze(config, options) {
-	const rules = options?.rules ?? defaultRules;
-	const stepFilePaths = await globFiles(config.stepFiles);
-	const featureFilePaths = await globFiles(config.featureFiles);
-	if (stepFilePaths.length === 0) return [];
-	if (featureFilePaths.length === 0) return [];
-	const stepDefinitions = extractStepDefinitions(stepFilePaths, config.tsConfigPath);
-	const scenarios = parseFeatureFiles(featureFilePaths);
-	const diagnostics = [];
-	for (const scenario of scenarios) {
-		const scenarioDiags = runRules(rules, scenario, matchScenarioSteps(scenario, stepDefinitions));
-		diagnostics.push(...scenarioDiags);
-	}
-	return diagnostics;
-}
-//#endregion
 //#region src/init.ts
 const createBuilders = () => {
 	return {
@@ -608,7 +245,12 @@ function afterFeature(fn) {
 		fn
 	});
 }
-/** Run once before the entire test run, across all feature files. */
+/**
+* Run once before the entire run, ahead of any scenario (and before
+* concurrency starts). Multiple `beforeAll` hooks run **in parallel** with no
+* ordering between them — if a step of setup must precede another, sequence both
+* inside a single hook.
+*/
 function beforeAll(fn) {
 	globalHookRegistry.add({
 		scope: "global",
@@ -616,7 +258,11 @@ function beforeAll(fn) {
 		fn
 	});
 }
-/** Run once after the entire test run (reverse registration order). */
+/**
+* Run once after the entire run, once every scenario is done. Multiple
+* `afterAll` hooks run **in parallel** with no ordering between them — sequence
+* dependent teardown inside a single hook.
+*/
 function afterAll(fn) {
 	globalHookRegistry.add({
 		scope: "global",