@step-forge/step-forge 0.0.20 → 0.0.22

package/dist/step-forge.js

@@ -1,11 +1,7 @@
-import { o as globalRegistry, r as globalHookRegistry } from "./hooks-CywugMQQ.js";
+import { n as globalHookRegistry, o as globalRegistry } from "./hooks-BDCMKeNq.js";
+import { a as captureDefinitionSite, i as BasicWorld, n as parseFeatureFiles, r as globFiles, t as parseFeatureContent } from "./gherkinParser-NcttZgN4.js";
 import _ from "lodash";
-import { glob } from "node:fs/promises";
-import * as path from "node:path";
 import ts from "typescript";
-import * as fs from "node:fs";
-import { AstBuilder, GherkinClassicTokenMatcher, Parser } from "@cucumber/gherkin";
-import * as messages from "@cucumber/messages";
 //#region src/builderTypeUtils.ts
 const isString = (statement) => typeof statement === "string";
 //#endregion
@@ -118,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,
@@ -196,42 +194,6 @@ const thenStatement = () => (statement) => {
 };
 const thenBuilder = () => ({ statement: thenStatement() });
 //#endregion
-//#region src/world.ts
-function mergeCustomizer(objValue, srcValue) {
-	if (_.isArray(objValue)) return objValue.concat(srcValue);
-	else if (objValue && !_.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 = _.merge({ ...this.givenState }, newState, mergeCustomizer);
-			}
-		};
-	}
-	get when() {
-		return {
-			...this.whenState,
-			merge: (newState) => {
-				this.whenState = _.merge({ ...this.whenState }, newState, mergeCustomizer);
-			}
-		};
-	}
-	get then() {
-		return {
-			...this.thenState,
-			merge: (newState) => {
-				this.thenState = _.merge({ ...this.thenState }, newState, mergeCustomizer);
-			}
-		};
-	}
-};
-//#endregion
 //#region src/analyzer/stepExtractor.ts
 const BUILDER_NAMES = {
 	givenBuilder: "given",
@@ -239,6 +201,21 @@ const BUILDER_NAMES = {
 	thenBuilder: "then"
 };
 function extractStepDefinitions(filePaths, tsConfigPath) {
+	const fast = extractWithSources(filePaths.map(parseSourceFile).filter((s) => s !== null), null);
+	if (!fast.needsChecker) return fast.results;
+	const program = ts.createProgram(filePaths, resolveCompilerOptions(tsConfigPath));
+	const checker = program.getTypeChecker();
+	return extractWithSources(filePaths.map((fp) => program.getSourceFile(fp)).filter((s) => s !== void 0), checker).results;
+}
+/** Parse a single file into an AST with no type resolution. */
+function parseSourceFile(filePath) {
+	const text = ts.sys.readFile(filePath);
+	if (text === void 0) return null;
+	const scriptKind = filePath.endsWith(".tsx") ? ts.ScriptKind.TSX : ts.ScriptKind.TS;
+	return ts.createSourceFile(filePath, text, ts.ScriptTarget.ESNext, true, scriptKind);
+}
+/** Resolve compiler options from tsconfig (fallback to sane defaults). */
+function resolveCompilerOptions(tsConfigPath) {
 	const configPath = tsConfigPath ?? ts.findConfigFile(process.cwd(), ts.sys.fileExists);
 	let compilerOptions = {
 		target: ts.ScriptTarget.ESNext,
@@ -252,22 +229,25 @@ function extractStepDefinitions(filePaths, tsConfigPath) {
 		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();
+	return compilerOptions;
+}
+function extractWithSources(sources, checker) {
+	const ctx = {
+		checker,
+		needsChecker: false
+	};
 	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;
+	for (const sourceFile of sources) results.push(...extractFromSourceFile(sourceFile, ctx));
+	return {
+		results,
+		needsChecker: ctx.needsChecker
+	};
 }
-function extractFromSourceFile(sourceFile, checker) {
+function extractFromSourceFile(sourceFile, ctx) {
 	const results = [];
 	function visit(node) {
 		if (ts.isCallExpression(node) && ts.isPropertyAccessExpression(node.expression) && node.expression.name.text === "step") {
-			const meta = extractFromRegisterCall(node, sourceFile, checker);
+			const meta = extractFromRegisterCall(node, sourceFile, ctx);
 			if (meta) results.push(meta);
 		}
 		ts.forEachChild(node, visit);
@@ -275,7 +255,7 @@ function extractFromSourceFile(sourceFile, checker) {
 	visit(sourceFile);
 	return results;
 }
-function extractFromRegisterCall(registerCall, sourceFile, checker) {
+function extractFromRegisterCall(registerCall, sourceFile, ctx) {
 	const chain = collectCallChain(registerCall);
 	let stepType = null;
 	let expression = null;
@@ -290,7 +270,7 @@ function extractFromRegisterCall(registerCall, sourceFile, checker) {
 		if (!name) continue;
 		if (name === "register") continue;
 		if (name === "step") {
-			produces = extractProducedKeys(link, checker);
+			produces = extractProducedKeys(link, ctx);
 			continue;
 		}
 		if (name === "dependencies") {
@@ -307,7 +287,7 @@ function extractFromRegisterCall(registerCall, sourceFile, checker) {
 		}
 	}
 	if (!stepType || !expression) {
-		const reExport = resolveReExportedCall(chain, checker);
+		const reExport = resolveReExportedCall(chain, ctx);
 		if (reExport) {
 			if (!stepType) stepType = reExport.stepType;
 			if (!expression) expression = reExport.expression;
@@ -394,33 +374,37 @@ function extractDependencies(depsCall) {
 	}
 	return deps;
 }
-function extractProducedKeys(stepCall, checker) {
+function extractProducedKeys(stepCall, ctx) {
 	const callback = stepCall.arguments[0];
 	if (!callback) return [];
-	if (ts.isArrowFunction(callback) || ts.isFunctionExpression(callback)) return extractProducedKeysFromCallback(callback, checker);
+	if (ts.isArrowFunction(callback) || ts.isFunctionExpression(callback)) return extractProducedKeysFromCallback(callback, ctx);
 	return [];
 }
-function extractProducedKeysFromCallback(callback, checker) {
+function extractProducedKeysFromCallback(callback, ctx) {
 	const body = callback.body;
-	if (!ts.isBlock(body)) return extractKeysFromExpression(body, checker);
+	if (!ts.isBlock(body)) return extractKeysFromExpression(body, ctx);
 	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);
+		if (ts.isReturnStatement(node) && node.expression) for (const key of extractKeysFromExpression(node.expression, ctx)) keys.add(key);
 		ts.forEachChild(node, visitReturn);
 	}
 	visitReturn(body);
 	return [...keys];
 }
-function extractKeysFromExpression(expr, checker) {
+function extractKeysFromExpression(expr, ctx) {
 	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);
+	if (!ctx.checker) {
+		ctx.needsChecker = true;
+		return [];
+	}
 	try {
-		return checker.getTypeAtLocation(expr).getProperties().map((p) => p.name).filter((n) => n !== "merge");
+		return ctx.checker.getTypeAtLocation(expr).getProperties().map((p) => p.name).filter((n) => n !== "merge");
 	} catch {
 		return [];
 	}
 }
-function resolveReExportedCall(chain, checker) {
+function resolveReExportedCall(chain, ctx) {
 	const lastCall = chain[chain.length - 1];
 	if (!lastCall) return null;
 	const expr = lastCall.expression;
@@ -428,7 +412,11 @@ function resolveReExportedCall(chain, checker) {
 	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 (!ctx.checker) {
+		ctx.needsChecker = true;
+		return null;
+	}
+	const symbol = ctx.checker.getSymbolAtLocation(identifier);
 	if (!symbol) return null;
 	const decl = symbol.valueDeclaration;
 	if (!decl || !ts.isVariableDeclaration(decl) || !decl.initializer) return null;
@@ -449,116 +437,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(fs.readFileSync(filePath, "utf-8"), filePath);
-		scenarios.push(...parsed);
-	}
-	return scenarios;
-}
-function parseFeatureContent(content, filePath) {
-	const feature = new Parser(new AstBuilder(messages.IdGenerator.uuid()), new 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 = [];
@@ -693,8 +571,8 @@ 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 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);
@@ -706,11 +584,6 @@ async function analyze(config, options) {
 	}
 	return diagnostics;
 }
-async function resolveGlobs(patterns) {
-	const files = [];
-	for (const pattern of patterns) for await (const file of glob(pattern)) files.push(path.resolve(file));
-	return [...new Set(files)];
-}
 //#endregion
 //#region src/init.ts
 const createBuilders = () => {
@@ -763,7 +636,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",
@@ -771,7 +649,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",