@lynxwall/cucumber-tsflow 4.1.5 → 5.0.1

package/lib/cucumber/managed-scenario-context.js

@@ -12,6 +12,9 @@ var __createBinding = (this && this.__createBinding) || (Object.create ? (functi
 var __exportStar = (this && this.__exportStar) || function(m, exports) {
     for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
 };
+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);
@@ -24,7 +27,7 @@ var __exportStar = (this && this.__exportStar) || function(m, exports) {
     "use strict";
     Object.defineProperty(exports, "__esModule", { value: true });
     exports.ManagedScenarioContext = void 0;
-    const _ = require("underscore");
+    const underscore_1 = __importDefault(require("underscore"));
     const scenario_context_1 = require("../types/scenario-context");
     /**
      * Represents a [[ScenarioContext]] implementation that manages a collection of context objects that
@@ -81,7 +84,7 @@ var __exportStar = (this && this.__exportStar) || function(m, exports) {
                         return new targetPrototype.constructor(args[0], args[1], args[2], args[3], args[4], args[5], args[6], args[7], args[8], args[9]);
                 }
             };
-            const contextObjects = _.map(contextTypes, contextType => this.getOrActivateObject(contextType.prototype, () => {
+            const contextObjects = underscore_1.default.map(contextTypes, contextType => this.getOrActivateObject(contextType.prototype, () => {
                 return new contextType();
             }));
             return invokeBindingConstructor(contextObjects);
@@ -99,4 +102,4 @@ var __exportStar = (this && this.__exportStar) || function(m, exports) {
     exports.ManagedScenarioContext = ManagedScenarioContext;
     __exportStar(require("../types/scenario-context"), exports);
 });
-//# sourceMappingURL=data:application/json;base64,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
+//# sourceMappingURL=data:application/json;base64,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

package/lib/cucumber/message-collector.d.ts

@@ -0,0 +1,55 @@
+import * as messages from '@cucumber/messages';
+import { StepBinding } from '../types/step-binding';
+import { ManagedScenarioContext } from './managed-scenario-context';
+declare class MessageCollector {
+    private pickleMap;
+    private testCaseMap;
+    private testCaseRunningMap;
+    /**
+     * Gets the Pickle from hook parameters passed in from Cucumber
+     * to find a matching Pickle (scenario) and return the scenario Context
+     * @param hookParam
+     * @returns
+     */
+    getHookScenarioContext(hookParam: any): ManagedScenarioContext | undefined;
+    /**
+     * Uses StepPattern information to find a matching scenario
+     * and return the ScenarioContext
+     * @param stepBinding
+     * @returns
+     */
+    getStepScenarioContext(stepBinding: StepBinding): ManagedScenarioContext | undefined;
+    /**
+     * Passed into runCucumber as a callback for all messages.
+     * Capture the ones we care about
+     * @param envelope
+     */
+    parseEnvelope(envelope: messages.Envelope): void;
+    /**
+     * Called when a test case (scenario) starts. Intercepting
+     * this message to initialize a new ScenarioContext
+     * @param testCaseStarted
+     */
+    private startTestCase;
+    /**
+     * Called when a test case (scenario) ends. Intercepting
+     * this message to dispose and clear the ScenarioContext
+     * @param testCaseFinished
+     */
+    private endTestCase;
+    /**
+     * Uses the testCaleId passed in to find the associated Pickle (scenario)
+     * @param testCaseId
+     * @returns
+     */
+    private getScenarioForTest;
+    /**
+     * StepBinding tags are initialized with an astrick when empty.
+     * Need to make sure tags has a value and not an astrick
+     * @param tags
+     * @returns
+     */
+    private stepHasTags;
+}
+declare const messageCollector: MessageCollector;
+export default messageCollector;

package/lib/cucumber/message-collector.js

@@ -0,0 +1,143 @@
+(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", "./managed-scenario-context", "./utils", "../utils/helpers"], factory);
+    }
+})(function (require, exports) {
+    "use strict";
+    Object.defineProperty(exports, "__esModule", { value: true });
+    const managed_scenario_context_1 = require("./managed-scenario-context");
+    const utils_1 = require("./utils");
+    const helpers_1 = require("../utils/helpers");
+    class MessageCollector {
+        constructor() {
+            this.pickleMap = {};
+            this.testCaseMap = {};
+            this.testCaseRunningMap = {};
+        }
+        /**
+         * Gets the Pickle from hook parameters passed in from Cucumber
+         * to find a matching Pickle (scenario) and return the scenario Context
+         * @param hookParam
+         * @returns
+         */
+        getHookScenarioContext(hookParam) {
+            let scenarioContext;
+            if (hookParam) {
+                const pickle = hookParam.pickle;
+                const scenario = this.pickleMap[pickle.id];
+                if (scenario && scenario.scenarioContext) {
+                    scenarioContext = scenario.scenarioContext;
+                }
+            }
+            return scenarioContext;
+        }
+        /**
+         * Uses StepPattern information to find a matching scenario
+         * and return the ScenarioContext
+         * @param stepBinding
+         * @returns
+         */
+        getStepScenarioContext(stepBinding) {
+            let scenarioContext;
+            for (const [, scenario] of Object.entries(this.pickleMap)) {
+                for (const step of scenario.steps) {
+                    if ((0, utils_1.hasMatchingStep)(stepBinding.stepPattern.toString(), step.text)) {
+                        // 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 (stepBinding.tags && this.stepHasTags(stepBinding.tags)) {
+                            if (scenario.tags.length > 0 &&
+                                (0, utils_1.hasMatchingTags)(stepBinding.tags, scenario.tags.map(x => x.name))) {
+                                scenarioContext = scenario.scenarioContext;
+                            }
+                        }
+                        else {
+                            scenarioContext = scenario.scenarioContext;
+                        }
+                    }
+                    if (scenarioContext)
+                        break;
+                }
+                if (scenarioContext)
+                    break;
+            }
+            return scenarioContext;
+        }
+        /**
+         * Passed into runCucumber as a callback for all messages.
+         * Capture the ones we care about
+         * @param envelope
+         */
+        parseEnvelope(envelope) {
+            if (envelope.pickle && envelope.pickle.id) {
+                this.pickleMap[envelope.pickle.id] = envelope.pickle;
+            }
+            else if (envelope.testCase && envelope.testCase.id) {
+                this.testCaseMap[envelope.testCase.id] = envelope.testCase;
+            }
+            else if (envelope.testCaseStarted) {
+                this.startTestCase(envelope.testCaseStarted);
+            }
+            else if (envelope.testCaseFinished) {
+                this.endTestCase(envelope.testCaseFinished);
+            }
+        }
+        /**
+         * Called when a test case (scenario) starts. Intercepting
+         * this message to initialize a new ScenarioContext
+         * @param testCaseStarted
+         */
+        startTestCase(testCaseStarted) {
+            this.testCaseRunningMap[testCaseStarted.id] = testCaseStarted;
+            const scenario = this.getScenarioForTest(testCaseStarted.testCaseId);
+            if (scenario) {
+                const tags = scenario.tags.map(t => t.name);
+                scenario.scenarioContext = new managed_scenario_context_1.ManagedScenarioContext(scenario.name, tags);
+            }
+        }
+        /**
+         * Called when a test case (scenario) ends. Intercepting
+         * this message to dispose and clear the ScenarioContext
+         * @param testCaseFinished
+         */
+        endTestCase(testCaseFinished) {
+            const testCase = this.testCaseRunningMap[testCaseFinished.testCaseStartedId];
+            if (testCase) {
+                const scenario = this.getScenarioForTest(testCase.testCaseId);
+                if (scenario && scenario.scenarioContext) {
+                    scenario.scenarioContext.dispose();
+                    scenario.scenarioContext = undefined;
+                }
+            }
+        }
+        /**
+         * Uses the testCaleId passed in to find the associated Pickle (scenario)
+         * @param testCaseId
+         * @returns
+         */
+        getScenarioForTest(testCaseId) {
+            const testCase = this.testCaseMap[testCaseId];
+            if (testCase) {
+                return this.pickleMap[testCase.pickleId];
+            }
+            return undefined;
+        }
+        /**
+         * StepBinding tags are initialized with an astrick when empty.
+         * Need to make sure tags has a value and not an astrick
+         * @param tags
+         * @returns
+         */
+        stepHasTags(tags) {
+            return (0, helpers_1.hasStringValue)(tags) && !(tags === null || tags === void 0 ? void 0 : tags.includes('*'));
+        }
+    }
+    // this needs to be initialized once since it's used
+    // throughout the test run in different modules
+    const messageCollector = new MessageCollector();
+    exports.default = messageCollector;
+});
+//# sourceMappingURL=data:application/json;base64,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

package/lib/cucumber/step-definition-decorators.js

@@ -1,10 +1,13 @@
+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", "./binding-registry", "../utils/our-callsite", "../types/step-binding"], factory);
+        define(["require", "exports", "./binding-registry", "../utils/our-callsite", "../types/step-binding", "short-uuid"], factory);
     }
 })(function (require, exports) {
     "use strict";
@@ -13,6 +16,7 @@
     const binding_registry_1 = require("./binding-registry");
     const our_callsite_1 = require("../utils/our-callsite");
     const step_binding_1 = require("../types/step-binding");
+    const short_uuid_1 = __importDefault(require("short-uuid"));
     /**
      * A method decorator that marks the associated function as a 'Given' step.
      *
@@ -29,10 +33,11 @@
                 targetPrototype: target,
                 targetPropertyKey: propertyKey,
                 argsLength: target[propertyKey].length,
-                tag: tag,
+                tags: tag,
                 timeout: timeout,
                 wrapperOption: wrapperOption,
-                callsite: callsite
+                callsite: callsite,
+                cucumberKey: (0, short_uuid_1.default)().new()
             };
             binding_registry_1.BindingRegistry.instance.registerStepBinding(stepBinding);
             return descriptor;
@@ -55,10 +60,11 @@
                 targetPrototype: target,
                 targetPropertyKey: propertyKey,
                 argsLength: target[propertyKey].length,
-                tag: tag,
+                tags: tag,
                 timeout: timeout,
                 wrapperOption: wrapperOption,
-                callsite: callsite
+                callsite: callsite,
+                cucumberKey: (0, short_uuid_1.default)().new()
             };
             binding_registry_1.BindingRegistry.instance.registerStepBinding(stepBinding);
             return descriptor;
@@ -81,10 +87,11 @@
                 targetPrototype: target,
                 targetPropertyKey: propertyKey,
                 argsLength: target[propertyKey].length,
-                tag: tag,
+                tags: tag,
                 timeout: timeout,
                 wrapperOption: wrapperOption,
-                callsite: callsite
+                callsite: callsite,
+                cucumberKey: (0, short_uuid_1.default)().new()
             };
             binding_registry_1.BindingRegistry.instance.registerStepBinding(stepBinding);
             return descriptor;
@@ -92,4 +99,4 @@
     }
     exports.then = then;
 });
-//# sourceMappingURL=data:application/json;base64,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
+//# sourceMappingURL=data:application/json;base64,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

package/lib/cucumber/utils.d.ts

@@ -0,0 +1,16 @@
+/**
+ * Uses a regular expression to match a step expression with
+ * the feature text passed in
+ * @param stepText
+ * @param featureText
+ * @returns
+ */
+export declare const hasMatchingStep: (stepText: string, featureText: string) => boolean;
+/**
+ * Helper that uses a lexical parser to apply the tag patterns used by
+ * Cucumber to associate hooks with scenario and feature tags
+ * @param tagPattern examples: 'tag1', 'tag1 and tag2', 'tag1 or tag2)
+ * @param tags
+ * @returns
+ */
+export declare const hasMatchingTags: (tagPattern: string, tags: string[]) => boolean;

package/lib/cucumber/utils.js

@@ -0,0 +1,88 @@
+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", "@jeanbenitez/logical-expression-parser", "../utils/logger"], factory);
+    }
+})(function (require, exports) {
+    "use strict";
+    Object.defineProperty(exports, "__esModule", { value: true });
+    exports.hasMatchingTags = exports.hasMatchingStep = void 0;
+    const logical_expression_parser_1 = __importDefault(require("@jeanbenitez/logical-expression-parser"));
+    const logger_1 = __importDefault(require("../utils/logger"));
+    /**
+     * Uses a regular expression to match a step expression with
+     * the feature text passed in
+     * @param stepText
+     * @param featureText
+     * @returns
+     */
+    const hasMatchingStep = (stepText, featureText) => {
+        if (stepText.trim().length === 0)
+            return false;
+        try {
+            const regexStep = new RegExp(getRegTextForStep(stepText));
+            const match = featureText.match(regexStep);
+            return match !== null && match.length > 0;
+        }
+        catch (err) {
+            logger_1.default.error(err.message);
+            return false;
+        }
+    };
+    exports.hasMatchingStep = hasMatchingStep;
+    /**
+     * Helper that uses a lexical parser to apply the tag patterns used by
+     * Cucumber to associate hooks with scenario and feature tags
+     * @param tagPattern examples: 'tag1', 'tag1 and tag2', 'tag1 or tag2)
+     * @param tags
+     * @returns
+     */
+    const hasMatchingTags = (tagPattern, tags) => {
+        return logical_expression_parser_1.default.parse(tagPattern.toLowerCase(), (t) => tags.map(tag => tag.toLowerCase()).includes(t));
+    };
+    exports.hasMatchingTags = hasMatchingTags;
+    const getRegTextForStep = (step) => {
+        //Ruby interpolation (like `#{Something}` ) should be replaced with `.*`
+        //https://github.com/alexkrechik/VSCucumberAutoComplete/issues/65
+        step = step.replace(/#{(.*?)}/g, '.*');
+        //Parameter-types
+        //https://github.com/alexkrechik/VSCucumberAutoComplete/issues/66
+        //https://docs.cucumber.io/cucumber/cucumber-expressions/
+        step = step.replace(/{float}/g, '-?\\d*\\.?\\d+');
+        step = step.replace(/{bigdecimal}/g, '-?\\d*\\.?\\d+');
+        step = step.replace(/{double}/g, '-?\\d*\\.?\\d+');
+        step = step.replace(/{int}/g, '-?\\d+');
+        step = step.replace(/{biginteger}/g, '-?\\d+');
+        step = step.replace(/{byte}/g, '-?\\d+');
+        step = step.replace(/{short}/g, '-?\\d+');
+        step = step.replace(/{long}/g, '-?\\d+');
+        step = step.replace(/{stringInDoubleQuotes}/g, '"[^"]+"');
+        step = step.replace(/{word}/g, '[A-Za-z]+');
+        step = step.replace(/{string}/g, '("|\')[^\\1]*\\1');
+        step = step.replace(/{boolean}/gi, '(true|false)');
+        step = step.replace(/{}/g, '.*');
+        //Optional Text
+        step = step.replace(/\(([a-z]+)\)/g, '($1)?');
+        //Alternative text a/b/c === (a|b|c)
+        step = step.replace(/([a-zA-Z]+)(?:\/([a-zA-Z]+))+/g, match => `(${match.replace(/\//g, '|')})`);
+        //Handle Cucumber Expressions (like `{Something}`) should be replaced with `.*`
+        //https://github.com/alexkrechik/VSCucumberAutoComplete/issues/99
+        //Cucumber Expressions Custom Parameter Type Documentation
+        //https://docs.cucumber.io/cucumber-expressions/#custom-parameters
+        step = step.replace(/([^\\]|^){(?![\d,])(.*?)}/g, '$1.*');
+        //Escape all the regex symbols to avoid errors
+        step = escapeRegExp(step);
+        return step;
+    };
+    const escapeRegExp = (str) => {
+        // eslint-disable-next-line no-useless-escape
+        return str.replace(/[\-\[\]\/\{\}\(\)\*\+\?\.\\\^\$\|]/g, '$&');
+    };
+});
+//# sourceMappingURL=data:application/json;base64,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

package/lib/esnode.js

@@ -0,0 +1,20 @@
+"use strict";
+require('ts-node').register({
+    compilerOptions: {
+        module: 'commonjs',
+        moduleResolution: 'node',
+        target: 'es2021',
+        strict: true,
+        experimentalDecorators: true,
+        allowSyntheticDefaultImports: true,
+        resolveJsonModule: true,
+        esModuleInterop: true,
+        skipLibCheck: true,
+        lib: ['es2021']
+    },
+    ignore: ['(?:^|/)node_modules/', '(?:^|/)cucumber-tsflow/lib/'],
+    transpileOnly: true,
+    transpiler: '@lynxwall/cucumber-tsflow/lib/transpilers/esbuild-transpiler'
+});
+require('tsconfig-paths').register();
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiZXNub2RlLmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vc3JjL2Vzbm9kZS50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiO0FBQUEsT0FBTyxDQUFDLFNBQVMsQ0FBQyxDQUFDLFFBQVEsQ0FBQztJQUMzQixlQUFlLEVBQUU7UUFDaEIsTUFBTSxFQUFFLFVBQVU7UUFDbEIsZ0JBQWdCLEVBQUUsTUFBTTtRQUN4QixNQUFNLEVBQUUsUUFBUTtRQUNoQixNQUFNLEVBQUUsSUFBSTtRQUNaLHNCQUFzQixFQUFFLElBQUk7UUFDNUIsNEJBQTRCLEVBQUUsSUFBSTtRQUNsQyxpQkFBaUIsRUFBRSxJQUFJO1FBQ3ZCLGVBQWUsRUFBRSxJQUFJO1FBQ3JCLFlBQVksRUFBRSxJQUFJO1FBQ2xCLEdBQUcsRUFBRSxDQUFDLFFBQVEsQ0FBQztLQUNmO0lBQ0QsTUFBTSxFQUFFLENBQUMsc0JBQXNCLEVBQUUsNkJBQTZCLENBQUM7SUFDL0QsYUFBYSxFQUFFLElBQUk7SUFDbkIsVUFBVSxFQUFFLDhEQUE4RDtDQUMxRSxDQUFDLENBQUM7QUFFSCxPQUFPLENBQUMsZ0JBQWdCLENBQUMsQ0FBQyxRQUFRLEVBQUUsQ0FBQyJ9

package/lib/esvue.js

@@ -0,0 +1,52 @@
+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", "./transpilers/vue-sfc"], factory);
+    }
+})(function (require, exports) {
+    "use strict";
+    Object.defineProperty(exports, "__esModule", { value: true });
+    const hooks = require('require-extension-hooks');
+    const vue_sfc_1 = __importDefault(require("./transpilers/vue-sfc"));
+    require('ts-node').register({
+        compilerOptions: {
+            module: 'commonjs',
+            moduleResolution: 'node',
+            target: 'es2021',
+            strict: true,
+            experimentalDecorators: true,
+            allowSyntheticDefaultImports: true,
+            resolveJsonModule: true,
+            esModuleInterop: true,
+            skipLibCheck: true,
+            lib: ['es2021']
+        },
+        ignore: ['(?:^|/)node_modules/', '(?:^|/)cucumber-tsflow/lib/'],
+        transpileOnly: true,
+        transpiler: '@lynxwall/cucumber-tsflow/lib/transpilers/esbuild-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=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiZXN2dWUuanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi9zcmMvZXN2dWUudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6Ijs7Ozs7Ozs7Ozs7Ozs7SUFBQSxNQUFNLEtBQUssR0FBRyxPQUFPLENBQUMseUJBQXlCLENBQUMsQ0FBQztJQUNqRCxvRUFBbUQ7SUFFbkQsT0FBTyxDQUFDLFNBQVMsQ0FBQyxDQUFDLFFBQVEsQ0FBQztRQUMzQixlQUFlLEVBQUU7WUFDaEIsTUFBTSxFQUFFLFVBQVU7WUFDbEIsZ0JBQWdCLEVBQUUsTUFBTTtZQUN4QixNQUFNLEVBQUUsUUFBUTtZQUNoQixNQUFNLEVBQUUsSUFBSTtZQUNaLHNCQUFzQixFQUFFLElBQUk7WUFDNUIsNEJBQTRCLEVBQUUsSUFBSTtZQUNsQyxpQkFBaUIsRUFBRSxJQUFJO1lBQ3ZCLGVBQWUsRUFBRSxJQUFJO1lBQ3JCLFlBQVksRUFBRSxJQUFJO1lBQ2xCLEdBQUcsRUFBRSxDQUFDLFFBQVEsQ0FBQztTQUNmO1FBQ0QsTUFBTSxFQUFFLENBQUMsc0JBQXNCLEVBQUUsNkJBQTZCLENBQUM7UUFDL0QsYUFBYSxFQUFFLElBQUk7UUFDbkIsVUFBVSxFQUFFLDhEQUE4RDtLQUMxRSxDQUFDLENBQUM7SUFFSCxPQUFPLENBQUMsZ0JBQWdCLENBQUMsQ0FBQyxRQUFRLEVBQUUsQ0FBQztJQUVyQyx1REFBdUQ7SUFDdkQsT0FBTyxDQUFDLGNBQWMsQ0FBQyxFQUFFLENBQUM7SUFDekIsTUFBYyxDQUFDLFVBQVUsR0FBSSxNQUFjLENBQUMsTUFBTSxDQUFDLFVBQVUsQ0FBQztJQUUvRCxLQUFLLENBQUMsS0FBSyxDQUFDLENBQUMsSUFBSSxDQUFDLFVBQVUsTUFBVztRQUN0QyxJQUFJO1lBQ0gsTUFBTSxXQUFXLEdBQUcsSUFBSSxpQkFBYyxDQUFDO2dCQUN0QyxPQUFPLEVBQUUsQ0FBQyxzQkFBc0IsRUFBRSw2QkFBNkIsQ0FBQzthQUNoRSxDQUFDLENBQUM7WUFDSCxNQUFNLGVBQWUsR0FBRyxXQUFXLENBQUMsYUFBYSxDQUFDLE1BQU0sQ0FBQyxPQUFPLEVBQUUsTUFBTSxDQUFDLFFBQVEsQ0FBQyxDQUFDO1lBRW5GLE9BQU8sZUFBZSxDQUFDLElBQUksQ0FBQztTQUM1QjtRQUFDLE9BQU8sR0FBRyxFQUFFO1lBQ2IsT0FBTyxDQUFDLEdBQUcsQ0FBQyxHQUFHLENBQUMsQ0FBQztTQUNqQjtRQUNELE9BQU8sTUFBTSxDQUFDLE9BQU8sQ0FBQztJQUN2QixDQUFDLENBQUMsQ0FBQyJ9

package/lib/formatters/behave-json-formatter.d.ts

@@ -1,5 +1,39 @@
-import JsonFormatter, { IJsonStep } from '@cucumber/cucumber/lib/formatter/json_formatter';
 import * as messages from '@cucumber/messages';
+import JsonFormatter from '@cucumber/cucumber/lib/formatter/json_formatter';
+export interface IJsonFeature {
+    description: string;
+    elements: IJsonScenario[];
+    id: string;
+    keyword: string;
+    line: number;
+    name: string;
+    tags: IJsonTag[];
+    uri: string;
+}
+export interface IJsonScenario {
+    description: string;
+    id: string;
+    keyword: string;
+    line: number;
+    name: string;
+    steps: IJsonStep[];
+    tags: IJsonTag[];
+    type: string;
+}
+export interface IJsonStep {
+    arguments?: any;
+    embeddings?: any;
+    hidden?: boolean;
+    keyword?: string;
+    line?: number;
+    match?: any;
+    name?: string;
+    result?: any;
+}
+export interface IJsonTag {
+    name: string;
+    line: number;
+}
 interface IBuildJsonStepOptions {
     isBeforeHook: boolean;
     gherkinStepMap: Record<string, messages.Step>;
@@ -8,11 +42,8 @@ interface IBuildJsonStepOptions {
     testStepAttachments: messages.Attachment[];
     testStepResult: messages.TestStepResult;
 }
-/**
- * Extending JsonFormatter.getStepData to add a name field to 	before
- * and After steps so that json can be exported to Behave Pro (name on steps required)
- */
 export default class BehaveJsonFormatter extends JsonFormatter {
+    static readonly documentation: string;
     getStepData({ isBeforeHook, gherkinStepMap, pickleStepMap, testStep, testStepAttachments, testStepResult }: IBuildJsonStepOptions): IJsonStep;
 }
 export {};