@lynxwall/cucumber-tsflow 4.1.5 → 5.0.1

package/lib/gherkin/gherkin-manager.d.ts

@@ -0,0 +1,29 @@
+import { ParsedFeature } from './models';
+declare class StepInfo {
+    constructor(name: string);
+    name: string;
+    text: string;
+    tags: string;
+}
+export default class GherkinManager {
+    private features;
+    private gherkinFeature;
+    constructor(paths: string[]);
+    /**
+     * Attempts to find a feature based on the steps found in
+     * a steps test file
+     * @param filePath
+     * @returns
+     */
+    findFeatureByStepFile: (filePath: string) => ParsedFeature | undefined;
+    generateKey: (name: string, tags: string[]) => string;
+    /**
+     * extracts 'given', 'when', 'then' step text and tags from
+     * the file passed in.
+     * @param filePath
+     * @returns
+     */
+    parseSteps: (filePath: string) => StepInfo[];
+    isHook: (stepName: string) => boolean;
+}
+export {};

package/lib/gherkin/gherkin-manager.js

@@ -0,0 +1,123 @@
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+(function (factory) {
+    if (typeof module === "object" && typeof module.exports === "object") {
+        var v = factory(require, exports);
+        if (v !== undefined) module.exports = v;
+    }
+    else if (typeof define === "function" && define.amd) {
+        define(["require", "exports", "fs", "./gherkin-feature", "../utils/helpers", "../cucumber/utils"], factory);
+    }
+})(function (require, exports) {
+    "use strict";
+    Object.defineProperty(exports, "__esModule", { value: true });
+    const fs_1 = require("fs");
+    const gherkin_feature_1 = __importDefault(require("./gherkin-feature"));
+    const helpers_1 = require("../utils/helpers");
+    const utils_1 = require("../cucumber/utils");
+    class StepInfo {
+        constructor(name) {
+            this.text = '';
+            this.tags = '';
+            this.name = name;
+        }
+    }
+    class GherkinManager {
+        constructor(paths) {
+            this.features = [];
+            this.gherkinFeature = new gherkin_feature_1.default();
+            /**
+             * Attempts to find a feature based on the steps found in
+             * a steps test file
+             * @param filePath
+             * @returns
+             */
+            this.findFeatureByStepFile = (filePath) => {
+                let featureResult = undefined;
+                const fileSteps = this.parseSteps(filePath);
+                for (const feature of this.features) {
+                    for (const scenario of feature.scenarios) {
+                        for (const step of scenario.steps) {
+                            if (['given', 'when', 'then'].find(x => x === step.keyword)) {
+                                const fileStep = fileSteps.find(s => (0, utils_1.hasMatchingStep)(s.text, step.stepText));
+                                if (fileStep) {
+                                    // if we have tags on the step binding check to see if it matches one in the
+                                    // current scenario, which also includes tags associated with the feature
+                                    if ((0, helpers_1.hasStringValue)(fileStep.tags)) {
+                                        if (scenario.tags.length > 0 && (0, utils_1.hasMatchingTags)(fileStep.tags, scenario.tags)) {
+                                            featureResult = feature;
+                                        }
+                                    }
+                                    else {
+                                        featureResult = feature;
+                                    }
+                                }
+                            }
+                            if (featureResult)
+                                break;
+                        }
+                        if (featureResult)
+                            break;
+                    }
+                    if (featureResult)
+                        break;
+                }
+                return featureResult;
+            };
+            this.generateKey = (name, tags) => {
+                return `${name}:${tags.map(tag => tag.toLowerCase()).join(',')}`;
+            };
+            /**
+             * extracts 'given', 'when', 'then' step text and tags from
+             * the file passed in.
+             * @param filePath
+             * @returns
+             */
+            this.parseSteps = (filePath) => {
+                const stepNames = ['before', 'beforestep', 'given', 'when', 'then', 'afterstep', 'after'];
+                const steps = new Array();
+                const stepText = (0, fs_1.readFileSync)(filePath, 'utf8');
+                // get all of the decorator strings
+                const stepDecorators = stepText.match(/@\w*\(([^()]+)\)/g);
+                stepDecorators === null || stepDecorators === void 0 ? void 0 : stepDecorators.forEach(decorator => {
+                    const stepName = stepNames.find(x => decorator.toLowerCase().indexOf(x) >= 0);
+                    if (stepName) {
+                        const stepInfo = new StepInfo(stepName);
+                        // extract strings from inside decorator parens,
+                        // can be wrapped in single or double quotes
+                        const stepParams = decorator.match(/["']\s*([^"']+?)\s*["']/g);
+                        if (stepParams && stepParams.length > 0) {
+                            // first param in hooks is the tags parameter
+                            if (this.isHook(stepName)) {
+                                stepInfo.tags = stepParams[0].substring(1, stepParams[0].length - 1);
+                            }
+                            else {
+                                // steps support four parameters with last three optional
+                                // first is the pattern and second is a tag, which are the
+                                // two peices of information we need to make a match
+                                stepInfo.text = stepParams[0].substring(1, stepParams[0].length - 1);
+                                if (stepParams.length > 1 && (0, helpers_1.hasStringValue)(stepParams[1])) {
+                                    stepInfo.tags = stepParams[1].substring(1, stepParams[1].length - 1);
+                                }
+                            }
+                        }
+                        steps.push(stepInfo);
+                    }
+                });
+                return steps;
+            };
+            this.isHook = (stepName) => {
+                const hookNames = ['beforeall', 'before', 'beforestep', 'afterstep', 'after', 'afterall'];
+                const match = hookNames.find(x => stepName.toLowerCase().indexOf(x) >= 0);
+                return match != undefined;
+            };
+            for (const path of paths) {
+                const features = this.gherkinFeature.loadFeatures(path);
+                this.features = [...this.features, ...features];
+            }
+        }
+    }
+    exports.default = GherkinManager;
+});
+//# sourceMappingURL=data:application/json;base64,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

package/lib/gherkin/models.d.ts

@@ -0,0 +1,45 @@
+import { ManagedScenarioContext } from '../cucumber/managed-scenario-context';
+import { Options } from './configuration';
+export declare type StepFromStepDefinitions = {
+    stepMatcher: string | RegExp;
+    stepFunction(stepArguments?: any): void | PromiseLike<any>;
+};
+export declare type ScenarioFromStepDefinitions = {
+    title: string;
+    steps: StepFromStepDefinitions[];
+};
+export declare type FeatureFromStepDefinitions = {
+    title: string;
+    scenarios: ScenarioFromStepDefinitions[];
+};
+export declare type ParsedStep = {
+    keyword: string;
+    stepText: string;
+    stepArgument: string | {};
+    lineNumber: number;
+};
+export declare type ParsedScenario = {
+    title: string;
+    steps: ParsedStep[];
+    tags: string[];
+    lineNumber: number;
+    skippedViaTagFilter: boolean;
+    scenarioContext: ManagedScenarioContext | undefined;
+};
+export declare type ParsedScenarioOutline = {
+    title: string;
+    tags: string[];
+    scenarios: ParsedScenario[];
+    steps: ParsedStep[];
+    lineNumber: number;
+    skippedViaTagFilter: boolean;
+    scenarioContext: ManagedScenarioContext | undefined;
+};
+export declare type ParsedFeature = {
+    title: string;
+    featureFile: string;
+    scenarios: ParsedScenario[];
+    scenarioOutlines: ParsedScenarioOutline[];
+    options: Options;
+    tags: string[];
+};

package/lib/{tsflow.js → gherkin/models.js}

@@ -4,12 +4,10 @@
         if (v !== undefined) module.exports = v;
     }
     else if (typeof define === "function" && define.amd) {
-        define(["require", "exports", "./formatters/tsflow-snippet-syntax"], factory);
+        define(["require", "exports"], factory);
     }
 })(function (require, exports) {
     "use strict";
     Object.defineProperty(exports, "__esModule", { value: true });
-    const tsflow = require("./formatters/tsflow-snippet-syntax");
-    module.exports = tsflow;
 });
-//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoidHNmbG93LmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vc3JjL3RzZmxvdy50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiOzs7Ozs7Ozs7OztJQUFBLDZEQUE2RDtJQUU3RCxNQUFNLENBQUMsT0FBTyxHQUFHLE1BQU0sQ0FBQyJ9
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoibW9kZWxzLmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vLi4vc3JjL2doZXJraW4vbW9kZWxzLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiIifQ==

package/lib/snippet.d.ts

@@ -0,0 +1 @@
+export {};

package/lib/snippet.js

@@ -0,0 +1,38 @@
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || function (mod) {
+    if (mod && mod.__esModule) return mod;
+    var result = {};
+    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
+    __setModuleDefault(result, mod);
+    return result;
+};
+(function (factory) {
+    if (typeof module === "object" && typeof module.exports === "object") {
+        var v = factory(require, exports);
+        if (v !== undefined) module.exports = v;
+    }
+    else if (typeof define === "function" && define.amd) {
+        define(["require", "exports", "./formatters/tsflow-snippet-syntax"], factory);
+    }
+})(function (require, exports) {
+    "use strict";
+    Object.defineProperty(exports, "__esModule", { value: true });
+    const tsflow = __importStar(require("./formatters/tsflow-snippet-syntax"));
+    module.exports = tsflow;
+});
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoic25pcHBldC5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uL3NyYy9zbmlwcGV0LnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiI7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7SUFBQSwyRUFBNkQ7SUFFN0QsTUFBTSxDQUFDLE9BQU8sR0FBRyxNQUFNLENBQUMifQ==

package/lib/transpilers/esbuild-transpiler.d.ts

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

package/lib/transpilers/esbuild-transpiler.js

@@ -0,0 +1,31 @@
+(function (factory) {
+    if (typeof module === "object" && typeof module.exports === "object") {
+        var v = factory(require, exports);
+        if (v !== undefined) module.exports = v;
+    }
+    else if (typeof define === "function" && define.amd) {
+        define(["require", "exports", "./esbuild"], factory);
+    }
+})(function (require, exports) {
+    "use strict";
+    Object.defineProperty(exports, "__esModule", { value: true });
+    exports.EsbuildTranspiler = void 0;
+    const esbuild_1 = require("./esbuild");
+    const create = (_createOptions) => {
+        return new EsbuildTranspiler();
+    };
+    class EsbuildTranspiler {
+        constructor() {
+            this.transpile = (input, options) => {
+                const result = (0, esbuild_1.transpileCode)(input, options.fileName);
+                return {
+                    outputText: result.output,
+                    sourceMapText: result.sourceMap
+                };
+            };
+        }
+    }
+    exports.EsbuildTranspiler = EsbuildTranspiler;
+    exports.create = create;
+});
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiZXNidWlsZC10cmFuc3BpbGVyLmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vLi4vc3JjL3RyYW5zcGlsZXJzL2VzYnVpbGQtdHJhbnNwaWxlci50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiOzs7Ozs7Ozs7Ozs7SUFDQSx1Q0FBMEM7SUFFMUMsTUFBTSxNQUFNLEdBQUcsQ0FBQyxjQUF1QyxFQUFjLEVBQUU7UUFDdEUsT0FBTyxJQUFJLGlCQUFpQixFQUFFLENBQUM7SUFDaEMsQ0FBQyxDQUFDO0lBRUYsTUFBYSxpQkFBaUI7UUFBOUI7WUFDQyxjQUFTLEdBQUcsQ0FBQyxLQUFhLEVBQUUsT0FBeUIsRUFBbUIsRUFBRTtnQkFDekUsTUFBTSxNQUFNLEdBQUcsSUFBQSx1QkFBYSxFQUFDLEtBQUssRUFBRSxPQUFPLENBQUMsUUFBUSxDQUFDLENBQUM7Z0JBRXRELE9BQU87b0JBQ04sVUFBVSxFQUFFLE1BQU0sQ0FBQyxNQUFNO29CQUN6QixhQUFhLEVBQUUsTUFBTSxDQUFDLFNBQVM7aUJBQ1osQ0FBQztZQUN0QixDQUFDLENBQUM7UUFDSCxDQUFDO0tBQUE7SUFURCw4Q0FTQztJQUVELE9BQU8sQ0FBQyxNQUFNLEdBQUcsTUFBTSxDQUFDIn0=

package/lib/transpilers/esbuild.d.ts

@@ -0,0 +1,12 @@
+import { Loader, CommonOptions, TransformOptions, BuildOptions } from 'esbuild';
+export declare type TranspileOptions = {
+    debug: boolean;
+    esbuild?: CommonOptions & TransformOptions & BuildOptions;
+};
+export declare 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 | undefined, _options?: Partial<TranspileOptions> | undefined) => TranspileResults;

package/lib/transpilers/esbuild.js

@@ -0,0 +1,66 @@
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+(function (factory) {
+    if (typeof module === "object" && typeof module.exports === "object") {
+        var v = factory(require, exports);
+        if (v !== undefined) module.exports = v;
+    }
+    else if (typeof define === "function" && define.amd) {
+        define(["require", "exports", "esbuild", "path"], factory);
+    }
+})(function (require, exports) {
+    "use strict";
+    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: false
+    };
+    const commonOptions = {
+        format: 'cjs',
+        logLevel: 'error',
+        target: [`node${process.version.slice(1)}`],
+        minify: false,
+        sourcemap: 'external'
+    };
+    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) => {
+        var _a;
+        const ret = { ...exports.loaders };
+        if (typeof ((_a = options.esbuild) === null || _a === void 0 ? void 0 : _a.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=data:application/json;base64,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

package/lib/transpilers/vue-sfc/compiler.d.ts

@@ -0,0 +1,7 @@
+declare module 'vue/compiler-sfc' {
+    interface SFCDescriptor {
+        id: string;
+    }
+}
+import type * as _compiler from 'vue/compiler-sfc';
+export declare const resolveCompiler: (root: string) => typeof _compiler;

package/lib/transpilers/vue-sfc/compiler.js

@@ -0,0 +1,32 @@
+(function (factory) {
+    if (typeof module === "object" && typeof module.exports === "object") {
+        var v = factory(require, exports);
+        if (v !== undefined) module.exports = v;
+    }
+    else if (typeof define === "function" && define.amd) {
+        define(["require", "exports"], factory);
+    }
+})(function (require, exports) {
+    "use strict";
+    Object.defineProperty(exports, "__esModule", { value: true });
+    exports.resolveCompiler = void 0;
+    const resolveCompiler = (root) => {
+        // resolve from project root first, then fallback to peer dep (if any)
+        const compiler = tryRequire('vue/compiler-sfc', root) || tryRequire('vue/compiler-sfc');
+        if (!compiler) {
+            throw new Error(`Failed to resolve vue/compiler-sfc.\n` +
+                `@lynxwall/cucumber-tsflow/vue requires vue (>=3.2.25) ` +
+                `to be present in the dependency tree.`);
+        }
+        return compiler;
+    };
+    exports.resolveCompiler = resolveCompiler;
+    const tryRequire = (id, from) => {
+        try {
+            return from ? require(require.resolve(id, { paths: [from] })) : require(id);
+            // eslint-disable-next-line no-empty
+        }
+        catch (e) { }
+    };
+});
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiY29tcGlsZXIuanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi9zcmMvdHJhbnNwaWxlcnMvdnVlLXNmYy9jb21waWxlci50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiOzs7Ozs7Ozs7Ozs7SUFTTyxNQUFNLGVBQWUsR0FBRyxDQUFDLElBQVksRUFBb0IsRUFBRTtRQUNqRSxzRUFBc0U7UUFDdEUsTUFBTSxRQUFRLEdBQUcsVUFBVSxDQUFDLGtCQUFrQixFQUFFLElBQUksQ0FBQyxJQUFJLFVBQVUsQ0FBQyxrQkFBa0IsQ0FBQyxDQUFDO1FBRXhGLElBQUksQ0FBQyxRQUFRLEVBQUU7WUFDZCxNQUFNLElBQUksS0FBSyxDQUNkLHVDQUF1QztnQkFDdEMsd0RBQXdEO2dCQUN4RCx1Q0FBdUMsQ0FDeEMsQ0FBQztTQUNGO1FBRUQsT0FBTyxRQUFRLENBQUM7SUFDakIsQ0FBQyxDQUFDO0lBYlcsUUFBQSxlQUFlLG1CQWExQjtJQUVGLE1BQU0sVUFBVSxHQUFHLENBQUMsRUFBVSxFQUFFLElBQWEsRUFBRSxFQUFFO1FBQ2hELElBQUk7WUFDSCxPQUFPLElBQUksQ0FBQyxDQUFDLENBQUMsT0FBTyxDQUFDLE9BQU8sQ0FBQyxPQUFPLENBQUMsRUFBRSxFQUFFLEVBQUUsS0FBSyxFQUFFLENBQUMsSUFBSSxDQUFDLEVBQUUsQ0FBQyxDQUFDLENBQUMsQ0FBQyxDQUFDLE9BQU8sQ0FBQyxFQUFFLENBQUMsQ0FBQztZQUM1RSxvQ0FBb0M7U0FDcEM7UUFBQyxPQUFPLENBQUMsRUFBRSxHQUFFO0lBQ2YsQ0FBQyxDQUFDIn0=

package/lib/transpilers/vue-sfc/index.d.ts

@@ -0,0 +1,25 @@
+import type { RollupError, RollupWarning } from 'rollup';
+import type { Options, VueTransformerContext, VueResolvedId } from './types';
+export { parseVueRequest, VueQuery } from './utils/query';
+declare class VueTransformer implements VueTransformerContext {
+    private filter;
+    private customElementFilter;
+    private refTransformFilter;
+    private options;
+    private isSSR;
+    constructor(rawOptions?: Options);
+    error: (err: string | RollupError, pos?: number | {
+        column: number;
+        line: number;
+    } | undefined) => void;
+    resolve: (id: string) => VueResolvedId | null;
+    warn: (warning: string | RollupWarning, pos?: number | {
+        column: number;
+        line: number;
+    } | undefined) => void;
+    transformCode: (code: string, filename: string) => {
+        code: string | undefined;
+        map: string | undefined;
+    };
+}
+export default VueTransformer;

package/lib/transpilers/vue-sfc/index.js

@@ -0,0 +1,62 @@
+(function (factory) {
+    if (typeof module === "object" && typeof module.exports === "object") {
+        var v = factory(require, exports);
+        if (v !== undefined) module.exports = v;
+    }
+    else if (typeof define === "function" && define.amd) {
+        define(["require", "exports", "@rollup/pluginutils", "./compiler", "./utils/query", "./main", "./utils/query"], factory);
+    }
+})(function (require, exports) {
+    "use strict";
+    Object.defineProperty(exports, "__esModule", { value: true });
+    exports.parseVueRequest = void 0;
+    /* eslint-disable @typescript-eslint/no-unused-vars */
+    const pluginutils_1 = require("@rollup/pluginutils");
+    const compiler_1 = require("./compiler");
+    const query_1 = require("./utils/query");
+    const main_1 = require("./main");
+    var query_2 = require("./utils/query");
+    Object.defineProperty(exports, "parseVueRequest", { enumerable: true, get: function () { return query_2.parseVueRequest; } });
+    class VueTransformer {
+        constructor(rawOptions = {}) {
+            this.isSSR = (opt) => opt === undefined ? false : typeof opt === 'boolean' ? opt : (opt === null || opt === void 0 ? void 0 : opt.ssr) === true;
+            this.error = (err, pos) => { };
+            this.resolve = (id) => {
+                // serve sub-part requests (*?vue) as virtual modules
+                if ((0, query_1.parseVueRequest)(id).query.vue) {
+                    return { external: false, id: id };
+                }
+                return null;
+            };
+            this.warn = (warning, pos) => { };
+            this.transformCode = (code, filename) => {
+                const ssr = this.isSSR(false);
+                const result = (0, main_1.transformMain)(code, filename, this.options, this, ssr, this.customElementFilter(filename));
+                return { code: result === null || result === void 0 ? void 0 : result.code, map: result === null || result === void 0 ? void 0 : result.map.mappings };
+            };
+            const { include = /\.vue$/, exclude, customElement = /\.ce\.vue$/, reactivityTransform = false } = rawOptions;
+            this.filter = (0, pluginutils_1.createFilter)(include, exclude);
+            this.customElementFilter = typeof customElement === 'boolean' ? () => customElement : (0, pluginutils_1.createFilter)(customElement);
+            this.refTransformFilter =
+                reactivityTransform === false
+                    ? () => false
+                    : reactivityTransform === true
+                        ? (0, pluginutils_1.createFilter)(/\.(j|t)sx?$/, /node_modules/)
+                        : (0, pluginutils_1.createFilter)(reactivityTransform);
+            const rootDir = process.cwd();
+            this.options = {
+                isProduction: process.env.NODE_ENV === 'production',
+                compiler: (0, compiler_1.resolveCompiler)(rootDir),
+                ...rawOptions,
+                include,
+                exclude,
+                customElement,
+                reactivityTransform,
+                root: rootDir,
+                sourceMap: true
+            };
+        }
+    }
+    exports.default = VueTransformer;
+});
+//# sourceMappingURL=data:application/json;base64,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

package/lib/transpilers/vue-sfc/main.d.ts

@@ -0,0 +1,8 @@
+import type { RawSourceMap } from 'source-map';
+import { VueTransformerContext, ResolvedOptions } from './types';
+export declare const transformMain: (code: string, filename: string, options: ResolvedOptions, transformerContext: VueTransformerContext, ssr: boolean, asCustomElement: boolean) => {
+    code: string;
+    map: RawSourceMap | {
+        mappings: string;
+    };
+} | null;