@lynxwall/cucumber-tsflow 7.1.2 → 7.3.0

package/lib/transpilers/esm/esbuild-transpiler.mjs

@@ -0,0 +1,19 @@
+// This file gets transpiled to CJS via scripts/build-esm-transpiler-cjs as part of the build
+
+import { transpileCode } from './esbuild.mjs';
+
+export function create(_createOptions) {
+	return {
+		transpile(input, options) {
+			const result = transpileCode(input, options.fileName);
+
+			return {
+				outputText: result.output,
+				sourceMapText: result.sourceMap
+			};
+		}
+	};
+}
+
+// Also export as default in case ts-node expects that
+export default { create };

package/lib/transpilers/esm/esbuild.mjs

@@ -0,0 +1,141 @@
+import { transformSync } from 'esbuild';
+import path from 'path';
+import { loadConfig } from 'tsconfig-paths';
+import { pathToFileURL } from 'url';
+
+export const defaultOptions = {
+	debug: true
+};
+
+// Cache for tsconfig data
+let tsconfigCache = null;
+
+function loadTsConfigPaths() {
+	if (tsconfigCache) return tsconfigCache;
+
+	try {
+		const configLoaderResult = loadConfig(process.cwd());
+		if (configLoaderResult.resultType === 'success') {
+			tsconfigCache = {
+				absoluteBaseUrl: configLoaderResult.absoluteBaseUrl,
+				paths: configLoaderResult.paths
+			};
+		}
+	} catch (error) {
+		console.error('Failed to load tsconfig for aliases:', error);
+	}
+
+	return tsconfigCache || { paths: {} };
+}
+
+// Add this function to handle path replacements
+function rewritePathMappings(code) {
+	const { absoluteBaseUrl, paths } = loadTsConfigPaths();
+
+	if (!paths || !absoluteBaseUrl) return code;
+
+	let modifiedCode = code;
+
+	// Process each path mapping
+	for (const [pattern, replacements] of Object.entries(paths)) {
+		// Convert @fixtures/* to a regex pattern
+		const searchPattern = pattern.replace('/*', '');
+		const replacementPath = replacements[0].replace('/*', '');
+
+		// Create regex to match imports/exports
+		const regex = new RegExp(`(from\\s+['"])${searchPattern}(/[^'"]+)?(['"])`, 'g');
+
+		modifiedCode = modifiedCode.replace(regex, (match, prefix, subPath, suffix) => {
+			// If subPath is provided, remove leading slash
+			const pathSuffix = subPath ? subPath.substring(1) : '';
+			// Calculate the absolute path
+			const absolutePath = path.resolve(absoluteBaseUrl, replacementPath, pathSuffix);
+			// Convert to file URL for ESM
+			const fileUrl = pathToFileURL(absolutePath).href;
+
+			return `${prefix}${fileUrl}${suffix}`;
+		});
+	}
+
+	return modifiedCode;
+}
+const commonOptions = {
+	format: 'esm',
+	logLevel: 'info',
+	target: ['es2022'],
+	minify: false,
+	sourcemap: 'external',
+	platform: 'node'
+};
+
+if (process.env.CUCUMBER_EXPERIMENTAL_DECORATORS === 'true') {
+	commonOptions.tsconfigRaw = {
+		compilerOptions: {
+			experimentalDecorators: true,
+			importsNotUsedAsValues: 'remove',
+			strict: true
+		}
+	};
+} else {
+	commonOptions.tsconfigRaw = {
+		compilerOptions: {
+			importsNotUsedAsValues: 'remove',
+			strict: true
+		}
+	};
+}
+
+export const loaders = {
+	'.js': 'js',
+	'.mjs': 'js',
+	'.cjs': 'js',
+	'.jsx': 'jsx',
+	'.ts': 'ts',
+	'.tsx': 'tsx',
+	'.json': 'json'
+};
+
+export const supports = filename => {
+	// Don't transpile TypeScript files - they're handled by TypeScript compiler
+	if (filename.endsWith('.ts') || filename.endsWith('.tsx')) return false;
+
+	// Don't transpile cucumber-tsflow's lib files - they're CommonJS
+	if (filename.includes('cucumber-tsflow/lib') || filename.includes('cucumber-tsflow\\lib')) {
+		return false;
+	}
+
+	// Don't transpile node_modules
+	if (filename.includes('node_modules')) return false;
+
+	// Only transpile files in the test project
+	if (!filename.includes('cucumber-tsflow-specs')) return false;
+
+	return path.extname(filename) in loaders;
+};
+
+const getLoaders = options => {
+	const ret = { ...loaders };
+	if (typeof options.esbuild?.loader === 'object') {
+		for (const [e, l] of Object.entries(options.esbuild.loader)) ret[e] = l;
+	}
+	return ret;
+};
+
+// In esbuild.mjs
+export const transpileCode = (code, filename, ext, _options) => {
+	const options = { ...defaultOptions, ..._options };
+	const loadersMap = getLoaders(options);
+	const loaderExt = ext != undefined ? ext : path.extname(filename);
+
+	// Rewrite path mappings before transpiling
+	let processedCode = rewritePathMappings(code);
+
+	const ret = transformSync(processedCode, {
+		...commonOptions,
+		...(options.esbuild || {}),
+		loader: loadersMap[loaderExt],
+		sourcefile: filename
+	});
+
+	return { output: ret.code, sourceMap: ret.map };
+};

package/lib/transpilers/esm/esmbuild-transpiler.d.ts

@@ -0,0 +1,4 @@
+import { TranspileOptions, Transpiler, TranspileOutput } from 'ts-node';
+export declare class EsmbuildTranspiler implements Transpiler {
+    transpile: (input: string, options: TranspileOptions) => TranspileOutput;
+}

package/lib/transpilers/esm/esmbuild-transpiler.js

@@ -0,0 +1,19 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.EsmbuildTranspiler = void 0;
+const esmbuild_1 = require("./esmbuild");
+const create = (_createOptions) => {
+    return new EsmbuildTranspiler();
+};
+class EsmbuildTranspiler {
+    transpile = (input, options) => {
+        const result = (0, esmbuild_1.transpileCode)(input, options.fileName);
+        return {
+            outputText: result.output,
+            sourceMapText: result.sourceMap
+        };
+    };
+}
+exports.EsmbuildTranspiler = EsmbuildTranspiler;
+exports.create = create;
+//# sourceMappingURL=esmbuild-transpiler.js.map

package/lib/transpilers/esm/esmbuild-transpiler.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"esmbuild-transpiler.js","sourceRoot":"","sources":["../../../src/transpilers/esm/esmbuild-transpiler.ts"],"names":[],"mappings":";;;AACA,yCAA2C;AAE3C,MAAM,MAAM,GAAG,CAAC,cAAuC,EAAc,EAAE;IACtE,OAAO,IAAI,kBAAkB,EAAE,CAAC;AACjC,CAAC,CAAC;AAEF,MAAa,kBAAkB;IAC9B,SAAS,GAAG,CAAC,KAAa,EAAE,OAAyB,EAAmB,EAAE;QACzE,MAAM,MAAM,GAAG,IAAA,wBAAa,EAAC,KAAK,EAAE,OAAO,CAAC,QAAQ,CAAC,CAAC;QAEtD,OAAO;YACN,UAAU,EAAE,MAAM,CAAC,MAAM;YACzB,aAAa,EAAE,MAAM,CAAC,SAAS;SACZ,CAAC;IACtB,CAAC,CAAC;CACF;AATD,gDASC;AAED,OAAO,CAAC,MAAM,GAAG,MAAM,CAAC","sourcesContent":["import { CreateTranspilerOptions, TranspileOptions, Transpiler, TranspileOutput } from 'ts-node';\r\nimport { transpileCode } from './esmbuild';\r\n\r\nconst create = (_createOptions: CreateTranspilerOptions): Transpiler => {\r\n\treturn new EsmbuildTranspiler();\r\n};\r\n\r\nexport class EsmbuildTranspiler implements Transpiler {\r\n\ttranspile = (input: string, options: TranspileOptions): TranspileOutput => {\r\n\t\tconst result = transpileCode(input, options.fileName);\r\n\r\n\t\treturn {\r\n\t\t\toutputText: result.output,\r\n\t\t\tsourceMapText: result.sourceMap\r\n\t\t} as TranspileOutput;\r\n\t};\r\n}\r\n\r\nexports.create = create;\r\n"]}

package/lib/transpilers/esm/esmbuild.d.ts

@@ -0,0 +1,12 @@
+import { Loader, CommonOptions, TransformOptions, BuildOptions } from 'esbuild';
+export type TranspileOptions = {
+    debug: boolean;
+    esbuild?: CommonOptions & TransformOptions & BuildOptions;
+};
+export type TranspileResults = {
+    output: string;
+    sourceMap?: string;
+};
+export declare const loaders: Record<string, Loader>;
+export declare const supports: (filename: string) => boolean;
+export declare const transpileCode: (code: string, filename: string, ext?: string, _options?: Partial<TranspileOptions>) => TranspileResults;

package/lib/transpilers/esm/esmbuild.js

@@ -0,0 +1,72 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.transpileCode = exports.supports = exports.loaders = void 0;
+const esbuild_1 = require("esbuild");
+const path_1 = __importDefault(require("path"));
+const defaultOptions = {
+    debug: true
+};
+const commonOptions = {
+    format: 'esm',
+    logLevel: 'info',
+    target: [`esnext`],
+    minify: false,
+    sourcemap: 'external'
+};
+if (global.experimentalDecorators) {
+    commonOptions.tsconfigRaw = {
+        compilerOptions: {
+            experimentalDecorators: true,
+            importsNotUsedAsValues: 'remove',
+            strict: true
+        }
+    };
+}
+else {
+    commonOptions.tsconfigRaw = {
+        compilerOptions: {
+            importsNotUsedAsValues: 'remove',
+            strict: true
+        }
+    };
+}
+exports.loaders = {
+    '.js': 'js',
+    '.mjs': 'js',
+    '.cjs': 'js',
+    '.jsx': 'jsx',
+    '.ts': 'ts',
+    '.tsx': 'tsx',
+    '.json': 'json'
+};
+const supports = (filename) => {
+    if (filename.includes('node_modules') || filename.includes('cucumber-tsflow/lib'))
+        return false;
+    return path_1.default.extname(filename) in exports.loaders;
+};
+exports.supports = supports;
+const getLoaders = (options) => {
+    const ret = { ...exports.loaders };
+    if (typeof options.esbuild?.loader == 'object') {
+        for (const [e, l] of Object.entries(options.esbuild.loader))
+            ret[e] = l;
+    }
+    return ret;
+};
+const transpileCode = (code, filename, ext, _options) => {
+    const options = { ...defaultOptions, ..._options };
+    const loaders = getLoaders(options);
+    const loaderExt = ext != undefined ? ext : path_1.default.extname(filename);
+    const ret = (0, esbuild_1.transformSync)(code, {
+        ...commonOptions,
+        ...options.esbuild,
+        loader: loaders[loaderExt],
+        sourcefile: filename
+    });
+    return { output: ret.code, sourceMap: ret.map };
+};
+exports.transpileCode = transpileCode;
+//# sourceMappingURL=esmbuild.js.map

package/lib/transpilers/esm/esmbuild.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"esmbuild.js","sourceRoot":"","sources":["../../../src/transpilers/esm/esmbuild.ts"],"names":[],"mappings":";;;;;;AAAA,qCAA+F;AAC/F,gDAAwB;AAMxB,MAAM,cAAc,GAAqB;IACxC,KAAK,EAAE,IAAI;CACX,CAAC;AAEF,MAAM,aAAa,GAAkB;IACpC,MAAM,EAAE,KAAK;IACb,QAAQ,EAAE,MAAM;IAChB,MAAM,EAAE,CAAC,QAAQ,CAAC;IAClB,MAAM,EAAE,KAAK;IACb,SAAS,EAAE,UAAU;CACrB,CAAC;AAEF,IAAI,MAAM,CAAC,sBAAsB,EAAE,CAAC;IACnC,aAAa,CAAC,WAAW,GAAG;QAC3B,eAAe,EAAE;YAChB,sBAAsB,EAAE,IAAI;YAC5B,sBAAsB,EAAE,QAAQ;YAChC,MAAM,EAAE,IAAI;SACZ;KACD,CAAC;AACH,CAAC;KAAM,CAAC;IACP,aAAa,CAAC,WAAW,GAAG;QAC3B,eAAe,EAAE;YAChB,sBAAsB,EAAE,QAAQ;YAChC,MAAM,EAAE,IAAI;SACZ;KACD,CAAC;AACH,CAAC;AAOY,QAAA,OAAO,GAA2B;IAC9C,KAAK,EAAE,IAAI;IACX,MAAM,EAAE,IAAI;IACZ,MAAM,EAAE,IAAI;IACZ,MAAM,EAAE,KAAK;IACb,KAAK,EAAE,IAAI;IACX,MAAM,EAAE,KAAK;IACb,OAAO,EAAE,MAAM;CACf,CAAC;AAEK,MAAM,QAAQ,GAAG,CAAC,QAAgB,EAAE,EAAE;IAC5C,IAAI,QAAQ,CAAC,QAAQ,CAAC,cAAc,CAAC,IAAI,QAAQ,CAAC,QAAQ,CAAC,qBAAqB,CAAC;QAAE,OAAO,KAAK,CAAC;IAChG,OAAO,cAAI,CAAC,OAAO,CAAC,QAAQ,CAAC,IAAI,eAAO,CAAC;AAC1C,CAAC,CAAC;AAHW,QAAA,QAAQ,YAGnB;AAEF,MAAM,UAAU,GAAG,CAAC,OAAyB,EAAE,EAAE;IAChD,MAAM,GAAG,GAAG,EAAE,GAAG,eAAO,EAAE,CAAC;IAC3B,IAAI,OAAO,OAAO,CAAC,OAAO,EAAE,MAAM,IAAI,QAAQ,EAAE,CAAC;QAChD,KAAK,MAAM,CAAC,CAAC,EAAE,CAAC,CAAC,IAAI,MAAM,CAAC,OAAO,CAAC,OAAO,CAAC,OAAO,CAAC,MAAM,CAAC;YAAE,GAAG,CAAC,CAAC,CAAC,GAAG,CAAW,CAAC;IACnF,CAAC;IACD,OAAO,GAAG,CAAC;AACZ,CAAC,CAAC;AAEK,MAAM,aAAa,GAAG,CAC5B,IAAY,EACZ,QAAgB,EAChB,GAAY,EACZ,QAAoC,EACjB,EAAE;IACrB,MAAM,OAAO,GAAqB,EAAE,GAAG,cAAc,EAAE,GAAG,QAAQ,EAAE,CAAC;IACrE,MAAM,OAAO,GAAG,UAAU,CAAC,OAAO,CAAC,CAAC;IACpC,MAAM,SAAS,GAAG,GAAG,IAAI,SAAS,CAAC,CAAC,CAAC,GAAG,CAAC,CAAC,CAAC,cAAI,CAAC,OAAO,CAAC,QAAQ,CAAC,CAAC;IAElE,MAAM,GAAG,GAAG,IAAA,uBAAa,EAAC,IAAI,EAAE;QAC/B,GAAG,aAAa;QAChB,GAAI,OAAO,CAAC,OAAwC;QACpD,MAAM,EAAE,OAAO,CAAC,SAAS,CAAC;QAC1B,UAAU,EAAE,QAAQ;KACpB,CAAC,CAAC;IACH,OAAO,EAAE,MAAM,EAAE,GAAG,CAAC,IAAI,EAAE,SAAS,EAAE,GAAG,CAAC,GAAG,EAAE,CAAC;AACjD,CAAC,CAAC;AAjBW,QAAA,aAAa,iBAiBxB","sourcesContent":["import { Loader, transformSync, CommonOptions, TransformOptions, BuildOptions } from 'esbuild';\r\nimport path from 'path';\r\n\r\nexport type TranspileOptions = {\r\n\tdebug: boolean;\r\n\tesbuild?: CommonOptions & TransformOptions & BuildOptions;\r\n};\r\nconst defaultOptions: TranspileOptions = {\r\n\tdebug: true\r\n};\r\n\r\nconst commonOptions: CommonOptions = {\r\n\tformat: 'esm',\r\n\tlogLevel: 'info',\r\n\ttarget: [`esnext`],\r\n\tminify: false,\r\n\tsourcemap: 'external'\r\n};\r\n\r\nif (global.experimentalDecorators) {\r\n\tcommonOptions.tsconfigRaw = {\r\n\t\tcompilerOptions: {\r\n\t\t\texperimentalDecorators: true,\r\n\t\t\timportsNotUsedAsValues: 'remove',\r\n\t\t\tstrict: true\r\n\t\t}\r\n\t};\r\n} else {\r\n\tcommonOptions.tsconfigRaw = {\r\n\t\tcompilerOptions: {\r\n\t\t\timportsNotUsedAsValues: 'remove',\r\n\t\t\tstrict: true\r\n\t\t}\r\n\t};\r\n}\r\n\r\nexport type TranspileResults = {\r\n\toutput: string;\r\n\tsourceMap?: string;\r\n};\r\n\r\nexport const loaders: Record<string, Loader> = {\r\n\t'.js': 'js',\r\n\t'.mjs': 'js',\r\n\t'.cjs': 'js',\r\n\t'.jsx': 'jsx',\r\n\t'.ts': 'ts',\r\n\t'.tsx': 'tsx',\r\n\t'.json': 'json'\r\n};\r\n\r\nexport const supports = (filename: string) => {\r\n\tif (filename.includes('node_modules') || filename.includes('cucumber-tsflow/lib')) return false;\r\n\treturn path.extname(filename) in loaders;\r\n};\r\n\r\nconst getLoaders = (options: TranspileOptions) => {\r\n\tconst ret = { ...loaders };\r\n\tif (typeof options.esbuild?.loader == 'object') {\r\n\t\tfor (const [e, l] of Object.entries(options.esbuild.loader)) ret[e] = l as Loader;\r\n\t}\r\n\treturn ret;\r\n};\r\n\r\nexport const transpileCode = (\r\n\tcode: string,\r\n\tfilename: string,\r\n\text?: string,\r\n\t_options?: Partial<TranspileOptions>\r\n): TranspileResults => {\r\n\tconst options: TranspileOptions = { ...defaultOptions, ..._options };\r\n\tconst loaders = getLoaders(options);\r\n\tconst loaderExt = ext != undefined ? ext : path.extname(filename);\r\n\r\n\tconst ret = transformSync(code, {\r\n\t\t...commonOptions,\r\n\t\t...(options.esbuild as TransformOptions | undefined),\r\n\t\tloader: loaders[loaderExt],\r\n\t\tsourcefile: filename\r\n\t});\r\n\treturn { output: ret.code, sourceMap: ret.map };\r\n};\r\n"]}

package/lib/transpilers/esm/esmnode.js

@@ -0,0 +1,8 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+require('ts-node/esm').register({
+    transpileOnly: true,
+    transpiler: '@lynxwall/cucumber-tsflow/lib/transpilers/esm/esmbuild-transpiler'
+});
+require('tsconfig-paths').register();
+//# sourceMappingURL=esmnode.js.map

package/lib/transpilers/esm/esmnode.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"esmnode.js","sourceRoot":"","sources":["../../../src/transpilers/esm/esmnode.ts"],"names":[],"mappings":";;AAAA,OAAO,CAAC,aAAa,CAAC,CAAC,QAAQ,CAAC;IAC/B,aAAa,EAAE,IAAI;IACnB,UAAU,EAAE,mEAAmE;CAC/E,CAAC,CAAC;AAEH,OAAO,CAAC,gBAAgB,CAAC,CAAC,QAAQ,EAAE,CAAC","sourcesContent":["require('ts-node/esm').register({\r\n\ttranspileOnly: true,\r\n\ttranspiler: '@lynxwall/cucumber-tsflow/lib/transpilers/esm/esmbuild-transpiler'\r\n});\r\n\r\nrequire('tsconfig-paths').register();\r\n"]}

package/lib/transpilers/esm/esmvue.js

@@ -0,0 +1,29 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const hooks = require('require-extension-hooks');
+const vue_sfc_1 = __importDefault(require("../vue-sfc"));
+require('ts-node/esm').register({
+    transpileOnly: true,
+    transpiler: '@lynxwall/cucumber-tsflow/lib/transpilers/esm/esmbuild-transpiler'
+});
+require('tsconfig-paths').register();
+// Register jsdom globally and set SVGElement on global
+require('jsdom-global')();
+global.SVGElement = global.window.SVGElement;
+hooks('vue').push(function (params) {
+    try {
+        const transformer = new vue_sfc_1.default({
+            exclude: ['(?:^|/)node_modules/', '(?:^|/)cucumber-tsflow/lib/']
+        });
+        const transformResult = transformer.transformCode(params.content, params.filename);
+        return transformResult.code;
+    }
+    catch (err) {
+        console.log(err);
+    }
+    return params.content;
+});
+//# sourceMappingURL=esmvue.js.map

package/lib/transpilers/esm/esmvue.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"esmvue.js","sourceRoot":"","sources":["../../../src/transpilers/esm/esmvue.ts"],"names":[],"mappings":";;;;;AAAA,MAAM,KAAK,GAAG,OAAO,CAAC,yBAAyB,CAAC,CAAC;AACjD,yDAAwC;AAExC,OAAO,CAAC,aAAa,CAAC,CAAC,QAAQ,CAAC;IAC/B,aAAa,EAAE,IAAI;IACnB,UAAU,EAAE,mEAAmE;CAC/E,CAAC,CAAC;AAEH,OAAO,CAAC,gBAAgB,CAAC,CAAC,QAAQ,EAAE,CAAC;AAErC,uDAAuD;AACvD,OAAO,CAAC,cAAc,CAAC,EAAE,CAAC;AACzB,MAAc,CAAC,UAAU,GAAI,MAAc,CAAC,MAAM,CAAC,UAAU,CAAC;AAE/D,KAAK,CAAC,KAAK,CAAC,CAAC,IAAI,CAAC,UAAU,MAAW;IACtC,IAAI,CAAC;QACJ,MAAM,WAAW,GAAG,IAAI,iBAAc,CAAC;YACtC,OAAO,EAAE,CAAC,sBAAsB,EAAE,6BAA6B,CAAC;SAChE,CAAC,CAAC;QACH,MAAM,eAAe,GAAG,WAAW,CAAC,aAAa,CAAC,MAAM,CAAC,OAAO,EAAE,MAAM,CAAC,QAAQ,CAAC,CAAC;QAEnF,OAAO,eAAe,CAAC,IAAI,CAAC;IAC7B,CAAC;IAAC,OAAO,GAAG,EAAE,CAAC;QACd,OAAO,CAAC,GAAG,CAAC,GAAG,CAAC,CAAC;IAClB,CAAC;IACD,OAAO,MAAM,CAAC,OAAO,CAAC;AACvB,CAAC,CAAC,CAAC","sourcesContent":["const hooks = require('require-extension-hooks');\r\nimport VueTransformer from '../vue-sfc';\r\n\r\nrequire('ts-node/esm').register({\r\n\ttranspileOnly: true,\r\n\ttranspiler: '@lynxwall/cucumber-tsflow/lib/transpilers/esm/esmbuild-transpiler'\r\n});\r\n\r\nrequire('tsconfig-paths').register();\r\n\r\n// Register jsdom globally and set SVGElement on global\r\nrequire('jsdom-global')();\r\n(global as any).SVGElement = (global as any).window.SVGElement;\r\n\r\nhooks('vue').push(function (params: any) {\r\n\ttry {\r\n\t\tconst transformer = new VueTransformer({\r\n\t\t\texclude: ['(?:^|/)node_modules/', '(?:^|/)cucumber-tsflow/lib/']\r\n\t\t});\r\n\t\tconst transformResult = transformer.transformCode(params.content, params.filename);\r\n\r\n\t\treturn transformResult.code;\r\n\t} catch (err) {\r\n\t\tconsole.log(err);\r\n\t}\r\n\treturn params.content;\r\n});\r\n"]}

package/lib/transpilers/esm/esnode-loader.mjs

@@ -0,0 +1,9 @@
+import { createEsbuildLoader } from './loader-utils.mjs';
+
+// Create and export the loader with default options
+const loader = createEsbuildLoader({
+	loaderName: 'esnode-loader',
+	handleVue: false
+});
+
+export const { resolve, load, getFormat, transformSource } = loader;

package/lib/transpilers/esm/esvue-loader.mjs

@@ -0,0 +1,9 @@
+import { createEsbuildLoader } from './loader-utils.mjs';
+
+// Create and export the loader with Vue support
+const loader = createEsbuildLoader({
+	loaderName: 'esvue-loader',
+	handleVue: true
+});
+
+export const { resolve, load, getFormat, transformSource } = loader;

package/lib/transpilers/esm/loader-utils.mjs

@@ -0,0 +1,278 @@
+import { compileVueSFC } from './vue-sfc-compiler.mjs';
+import { fileURLToPath, pathToFileURL } from 'url';
+import { existsSync } from 'fs';
+import path from 'path';
+import { createMatchPath, loadConfig } from 'tsconfig-paths';
+import { createEsmHooks } from './tsnode-service.mjs';
+
+// Shared asset extensions
+export const ASSET_EXTENSIONS = [
+	'.jpg',
+	'.jpeg',
+	'.png',
+	'.gif',
+	'.svg',
+	'.webp',
+	'.ico',
+	'.woff',
+	'.woff2',
+	'.ttf',
+	'.eot'
+];
+export const CODE_EXTENSIONS = ['.vue', '.ts', '.tsx', '.js', '.jsx', '.mjs', '.cjs'];
+
+// TSConfig paths initialization
+let matchPath;
+export function initializeTsconfigPaths() {
+	if (matchPath) return matchPath;
+
+	try {
+		const configLoaderResult = loadConfig(process.cwd());
+		if (configLoaderResult.resultType === 'success') {
+			matchPath = createMatchPath(
+				configLoaderResult.absoluteBaseUrl,
+				configLoaderResult.paths,
+				configLoaderResult.mainFields,
+				configLoaderResult.addMatchAll
+			);
+		} else {
+			console.warn('>>> loader: no tsconfig paths found');
+		}
+	} catch (error) {
+		console.error('>>> loader: failed to load tsconfig paths:', error);
+	}
+
+	return matchPath;
+}
+
+// Extension resolution helper
+export async function resolveWithExtensions(specifier, parentURL, extensions = CODE_EXTENSIONS) {
+	let resolvedPath;
+
+	if (specifier.startsWith('file://')) {
+		// Handle file:// URLs
+		resolvedPath = fileURLToPath(specifier);
+	} else {
+		// Handle relative paths
+		const parentPath = fileURLToPath(parentURL);
+		const parentDir = path.dirname(parentPath);
+		resolvedPath = path.resolve(parentDir, specifier);
+	}
+	// Try various extensions
+	for (const ext of extensions) {
+		const fullPath = resolvedPath + ext;
+
+		if (existsSync(fullPath)) {
+			const result = pathToFileURL(fullPath).href;
+			return result;
+		}
+	}
+
+	// Try index files
+	for (const ext of extensions) {
+		const indexPath = path.join(resolvedPath, 'index' + ext);
+		if (existsSync(indexPath)) {
+			return pathToFileURL(indexPath).href;
+		}
+	}
+
+	return null;
+}
+
+// TSConfig path mapping resolver
+export function resolveTsconfigPaths(specifier) {
+	const matchPath = initializeTsconfigPaths();
+
+	if (matchPath && !specifier.startsWith('.') && !specifier.startsWith('/') && !specifier.startsWith('file:')) {
+		const mapped = matchPath(specifier);
+
+		if (mapped) {
+			return {
+				url: pathToFileURL(mapped).href,
+				shortCircuit: true
+			};
+		}
+	}
+
+	return null;
+}
+
+// Asset loader helper
+export function loadAsset(url) {
+	const filePath = fileURLToPath(url);
+	return {
+		format: 'module',
+		source: `export default ${JSON.stringify(filePath)};`,
+		shortCircuit: true
+	};
+}
+
+// Vue style configuration helper
+export function shouldEnableVueStyle() {
+	// Check if styles should be enabled (from environment or config)
+	// Vue styles are disabled by default. However, user could enable them when importing from compiled libraries
+	return (
+		global.enableVueStyle === true ||
+		process.env.CUCUMBER_ENABLE_VUE_STYLE === 'true' ||
+		process.env.enableVueStyle === 'true'
+	);
+}
+
+export async function loadVue(url, context, nextLoad) {
+	const { source } = await nextLoad(url, { ...context, format: 'module' });
+	const code = source.toString();
+	const filename = fileURLToPath(url);
+
+	const compiled = compileVueSFC(code, filename, {
+		enableStyle: shouldEnableVueStyle()
+	});
+
+	return {
+		format: 'module',
+		source: compiled.code,
+		shortCircuit: true
+	};
+}
+
+/**
+ * Resolves module specifiers with support for TypeScript paths, extensions, and more
+ * @param {string} specifier - The module specifier to resolve
+ * @param {object} context - The loader context
+ * @param {object} options - Resolution options
+ * @param {string} options.logPrefix - Prefix for log messages
+ * @param {boolean} options.checkExtensions - Whether to try adding extensions
+ * @param {boolean} options.handleTsFiles - Whether to delegate .ts files to ts-node
+ * @param {object} options.tsNodeHooks - The ts-node hooks (if handleTsFiles is true)
+ * @param {function} options.nextResolve - The next resolver in the chain
+ * @returns {Promise<object|null>} The resolution result or null
+ */
+export async function resolveSpecifier(specifier, context, options = {}) {
+	const { checkExtensions = true, handleTsFiles = false, tsNodeHooks = null, nextResolve } = options;
+
+	// 1. Handle TypeScript path mappings first
+	const mappedResult = resolveTsconfigPaths(specifier);
+	if (mappedResult) {
+		// Check if the mapped result needs extension resolution
+		const mappedUrl = mappedResult.url;
+		if (checkExtensions && !path.extname(mappedUrl)) {
+			// Try to resolve with extensions
+			const resolved = await resolveWithExtensions(mappedUrl, context.parentURL);
+			if (resolved) {
+				return { url: resolved, shortCircuit: true };
+			}
+		}
+
+		return mappedResult;
+	}
+
+	// 2. Handle TypeScript files if requested
+	if (handleTsFiles && tsNodeHooks && (specifier.endsWith('.ts') || specifier.endsWith('.tsx'))) {
+		try {
+			return await tsNodeHooks.resolve(specifier, context, nextResolve);
+		} catch (error) {
+			// Fall through to extension resolution
+		}
+	}
+
+	// 3. Extension resolution for relative imports and file:// URLs
+	if (checkExtensions && (specifier.startsWith('.') || specifier.startsWith('/') || specifier.startsWith('file://'))) {
+		const hasExtension = path.extname(specifier) !== '';
+
+		if (!hasExtension && context.parentURL) {
+			const resolved = await resolveWithExtensions(specifier, context.parentURL);
+			if (resolved) {
+				return { url: resolved, shortCircuit: true };
+			}
+		}
+	}
+
+	// 4. No resolution found
+	return null;
+}
+
+// Cache for different ESM hooks by transpiler path
+const esmHooksCache = new Map();
+
+export async function getEsmHooks(transpilerPath, loaderName = 'loader') {
+	if (esmHooksCache.has(transpilerPath)) {
+		return esmHooksCache.get(transpilerPath);
+	}
+
+	try {
+		const hooks = await createEsmHooks(transpilerPath);
+		esmHooksCache.set(transpilerPath, hooks);
+		return hooks;
+	} catch (error) {
+		console.error(`>>> ${loaderName}: Failed to load ESM hooks with transpiler ${transpilerPath}:`, error);
+		throw error;
+	}
+}
+
+// Helper to create hook exports
+export function createHookExports(getHooksFn) {
+	return {
+		getFormat: async (...args) => (await getHooksFn()).getFormat(...args),
+		transformSource: async (...args) => (await getHooksFn()).transformSource(...args)
+	};
+}
+
+// Common loader factory for esbuild-based loaders
+export function createEsbuildLoader(options = {}) {
+	const {
+		loaderName = 'loader',
+		handleVue = false,
+		transpilerPath = '@lynxwall/cucumber-tsflow/lib/transpilers/esm/esbuild-transpiler-cjs'
+	} = options;
+
+	const getLocalEsmHooks = () => getEsmHooks(transpilerPath, loaderName);
+
+	return {
+		resolve: async (specifier, context, nextResolve) => {
+			const resolved = await resolveSpecifier(specifier, context, {
+				checkExtensions: true,
+				handleTsFiles: true,
+				tsNodeHooks: await getLocalEsmHooks(),
+				nextResolve
+			});
+
+			if (resolved) {
+				return resolved;
+			}
+
+			return nextResolve(specifier, context);
+		},
+
+		load: async (url, context, nextLoad) => {
+			// Handle asset files
+			const ext = path.extname(url).toLowerCase();
+			if (ASSET_EXTENSIONS.includes(ext)) {
+				return loadAsset(url);
+			}
+
+			// Handle Vue files if enabled
+			if (handleVue && url.endsWith('.vue')) {
+				try {
+					return loadVue(url, context, nextLoad);
+				} catch (error) {
+					console.error(`>>> ${loaderName}: Failed to compile Vue SFC ${url}:`, error);
+					throw new Error(`Failed to compile Vue SFC ${url}: ${error.message}`);
+				}
+			}
+
+			// Handle TypeScript files
+			if (url.endsWith('.ts') || url.endsWith('.tsx')) {
+				try {
+					const tsNodeHooks = await getLocalEsmHooks();
+					return tsNodeHooks.load(url, context, nextLoad);
+				} catch (error) {
+					console.error(`>>> ${loaderName}: ts-node failed for ${url}:`, error);
+					throw error;
+				}
+			}
+
+			return nextLoad(url, context);
+		},
+
+		...createHookExports(getLocalEsmHooks)
+	};
+}

package/lib/transpilers/esm/tsnode-esm.js

@@ -0,0 +1,25 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+require('ts-node').register({
+    compilerOptions: {
+        module: 'es2022',
+        target: 'ESNext',
+        moduleResolution: 'node',
+        esModuleInterop: true,
+        strict: true,
+        allowJs: true,
+        allowSyntheticDefaultImports: true,
+        experimentalDecorators: false,
+        resolveJsonModule: true,
+        skipLibCheck: true,
+        forceConsistentCasingInFileNames: true,
+        lib: ['es2022', 'esnext.decorators']
+    },
+    'ts-node': {
+        esm: true,
+        experimentalSpecifierResolution: 'node'
+    },
+    transpileOnly: true
+});
+require('tsconfig-paths').register();
+//# sourceMappingURL=tsnode-esm.js.map

package/lib/transpilers/esm/tsnode-esm.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"tsnode-esm.js","sourceRoot":"","sources":["../../../src/transpilers/esm/tsnode-esm.ts"],"names":[],"mappings":";;AAAA,OAAO,CAAC,SAAS,CAAC,CAAC,QAAQ,CAAC;IAC3B,eAAe,EAAE;QAChB,MAAM,EAAE,QAAQ;QAChB,MAAM,EAAE,QAAQ;QAChB,gBAAgB,EAAE,MAAM;QACxB,eAAe,EAAE,IAAI;QACrB,MAAM,EAAE,IAAI;QACZ,OAAO,EAAE,IAAI;QACb,4BAA4B,EAAE,IAAI;QAClC,sBAAsB,EAAE,KAAK;QAC7B,iBAAiB,EAAE,IAAI;QACvB,YAAY,EAAE,IAAI;QAClB,gCAAgC,EAAE,IAAI;QACtC,GAAG,EAAE,CAAC,QAAQ,EAAE,mBAAmB,CAAC;KACpC;IACD,SAAS,EAAE;QACV,GAAG,EAAE,IAAI;QACT,+BAA+B,EAAE,MAAM;KACvC;IACD,aAAa,EAAE,IAAI;CACnB,CAAC,CAAC;AAEH,OAAO,CAAC,gBAAgB,CAAC,CAAC,QAAQ,EAAE,CAAC","sourcesContent":["require('ts-node').register({\r\n\tcompilerOptions: {\r\n\t\tmodule: 'es2022',\r\n\t\ttarget: 'ESNext',\r\n\t\tmoduleResolution: 'node',\r\n\t\tesModuleInterop: true,\r\n\t\tstrict: true,\r\n\t\tallowJs: true,\r\n\t\tallowSyntheticDefaultImports: true,\r\n\t\texperimentalDecorators: false,\r\n\t\tresolveJsonModule: true,\r\n\t\tskipLibCheck: true,\r\n\t\tforceConsistentCasingInFileNames: true,\r\n\t\tlib: ['es2022', 'esnext.decorators']\r\n\t},\r\n\t'ts-node': {\r\n\t\tesm: true,\r\n\t\texperimentalSpecifierResolution: 'node'\r\n\t},\r\n\ttranspileOnly: true\r\n});\r\n\r\nrequire('tsconfig-paths').register();\r\n"]}