@step-forge/step-forge 0.0.20 → 0.0.22

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_hooks = require("./hooks-CGYzwDOv.cjs");
+const require_gherkinParser = require("./gherkinParser-BT40q_i3.cjs");
+const require_hooks = require("./hooks-Be0cjULN.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
@@ -146,11 +117,13 @@ const addStep = (statement, stepType, dependencies = {
 		});
 		world[stepType].merge({ ...result });
 	};
+	const source = require_gherkinParser.captureDefinitionSite();
 	require_hooks.globalRegistry.add({
 		stepType,
 		expression,
 		parsers,
-		execute
+		execute,
+		source
 	});
 	return {
 		statement,
@@ -224,42 +197,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",
@@ -267,6 +204,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 = typescript.default.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 = typescript.default.sys.readFile(filePath);
+	if (text === void 0) return null;
+	const scriptKind = filePath.endsWith(".tsx") ? typescript.default.ScriptKind.TSX : typescript.default.ScriptKind.TS;
+	return typescript.default.createSourceFile(filePath, text, typescript.default.ScriptTarget.ESNext, true, scriptKind);
+}
+/** Resolve compiler options from tsconfig (fallback to sane defaults). */
+function resolveCompilerOptions(tsConfigPath) {
 	const configPath = tsConfigPath ?? typescript.default.findConfigFile(process.cwd(), typescript.default.sys.fileExists);
 	let compilerOptions = {
 		target: typescript.default.ScriptTarget.ESNext,
@@ -280,22 +232,25 @@ function extractStepDefinitions(filePaths, tsConfigPath) {
 		if (!configFile.error) compilerOptions = typescript.default.parseJsonConfigFileContent(configFile.config, typescript.default.sys, configPath.replace(/[/\\][^/\\]+$/, "")).options;
 	}
 	compilerOptions.noEmit = true;
-	const program = typescript.default.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 (typescript.default.isCallExpression(node) && typescript.default.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);
 		}
 		typescript.default.forEachChild(node, visit);
@@ -303,7 +258,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;
@@ -318,7 +273,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") {
@@ -335,7 +290,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;
@@ -422,33 +377,37 @@ function extractDependencies(depsCall) {
 	}
 	return deps;
 }
-function extractProducedKeys(stepCall, checker) {
+function extractProducedKeys(stepCall, ctx) {
 	const callback = stepCall.arguments[0];
 	if (!callback) return [];
-	if (typescript.default.isArrowFunction(callback) || typescript.default.isFunctionExpression(callback)) return extractProducedKeysFromCallback(callback, checker);
+	if (typescript.default.isArrowFunction(callback) || typescript.default.isFunctionExpression(callback)) return extractProducedKeysFromCallback(callback, ctx);
 	return [];
 }
-function extractProducedKeysFromCallback(callback, checker) {
+function extractProducedKeysFromCallback(callback, ctx) {
 	const body = callback.body;
-	if (!typescript.default.isBlock(body)) return extractKeysFromExpression(body, checker);
+	if (!typescript.default.isBlock(body)) return extractKeysFromExpression(body, ctx);
 	const keys = /* @__PURE__ */ new Set();
 	function visitReturn(node) {
-		if (typescript.default.isReturnStatement(node) && node.expression) for (const key of extractKeysFromExpression(node.expression, checker)) keys.add(key);
+		if (typescript.default.isReturnStatement(node) && node.expression) for (const key of extractKeysFromExpression(node.expression, ctx)) keys.add(key);
 		typescript.default.forEachChild(node, visitReturn);
 	}
 	visitReturn(body);
 	return [...keys];
 }
-function extractKeysFromExpression(expr, checker) {
+function extractKeysFromExpression(expr, ctx) {
 	while (typescript.default.isParenthesizedExpression(expr)) expr = expr.expression;
 	if (typescript.default.isObjectLiteralExpression(expr)) return expr.properties.filter((p) => typescript.default.isPropertyAssignment(p) || typescript.default.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;
@@ -456,7 +415,11 @@ function resolveReExportedCall(chain, checker) {
 	if (typescript.default.isIdentifier(expr)) identifier = expr;
 	else if (typescript.default.isPropertyAccessExpression(expr) && typescript.default.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 || !typescript.default.isVariableDeclaration(decl) || !decl.initializer) return null;
@@ -477,116 +440,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 +574,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 +587,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 = () => {
@@ -791,7 +639,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) {
 	require_hooks.globalHookRegistry.add({
 		scope: "global",
@@ -799,7 +652,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) {
 	require_hooks.globalHookRegistry.add({
 		scope: "global",
@@ -812,14 +669,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;