@dev-blinq/cucumber-js 1.0.34 → 1.0.36

package/lib/cli/helpers.js

@@ -1,224 +1,224 @@
-"use strict";
-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;
-};
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.getRunName = exports.emitSupportCodeMessages = exports.emitMetaMessage = exports.orderPickles = exports.parseGherkinMessageStream = void 0;
-const ci_environment_1 = __importDefault(require("@cucumber/ci-environment"));
-const messages = __importStar(require("@cucumber/messages"));
-const knuth_shuffle_seeded_1 = __importDefault(require("knuth-shuffle-seeded"));
-const os_1 = __importDefault(require("os"));
-const configuration_1 = require("../configuration");
-const value_checker_1 = require("../value_checker");
-const version_1 = require("../version");
-/**
- * Process a stream of envelopes from Gherkin and resolve to an array of filtered, ordered pickle Ids
- *
- * @param eventBroadcaster
- * @param eventDataCollector
- * @param gherkinMessageStream
- * @param order
- * @param pickleFilter
- */
-async function parseGherkinMessageStream({ eventBroadcaster, eventDataCollector, gherkinMessageStream, order, pickleFilter, }) {
-    return await new Promise((resolve, reject) => {
-        const result = [];
-        gherkinMessageStream.on('data', (envelope) => {
-            eventBroadcaster.emit('envelope', envelope);
-            if ((0, value_checker_1.doesHaveValue)(envelope.pickle)) {
-                const pickle = envelope.pickle;
-                const pickleId = pickle.id;
-                const gherkinDocument = eventDataCollector.getGherkinDocument(pickle.uri);
-                if (pickleFilter.matches({ gherkinDocument, pickle })) {
-                    result.push(pickleId);
-                }
-            }
-        });
-        gherkinMessageStream.on('end', () => {
-            orderPickles(result, order, console);
-            resolve(result);
-        });
-        gherkinMessageStream.on('error', reject);
-    });
-}
-exports.parseGherkinMessageStream = parseGherkinMessageStream;
-// Orders the pickleIds in place - morphs input
-function orderPickles(pickleIds, order, logger) {
-    const [type, seed] = configuration_1.OptionSplitter.split(order);
-    switch (type) {
-        case 'defined':
-            break;
-        case 'random':
-            if (seed === '') {
-                const newSeed = Math.floor(Math.random() * 1000 * 1000).toString();
-                logger.warn(`Random order using seed: ${newSeed}`);
-                (0, knuth_shuffle_seeded_1.default)(pickleIds, newSeed);
-            }
-            else {
-                (0, knuth_shuffle_seeded_1.default)(pickleIds, seed);
-            }
-            break;
-        default:
-            throw new Error('Unrecgonized order type. Should be `defined` or `random`');
-    }
-}
-exports.orderPickles = orderPickles;
-async function emitMetaMessage(eventBroadcaster, env, runName) {
-    const meta = {
-        protocolVersion: messages.version,
-        implementation: {
-            version: version_1.version,
-            name: 'cucumber-js',
-        },
-        cpu: {
-            name: os_1.default.arch(),
-        },
-        os: {
-            name: os_1.default.platform(),
-            version: os_1.default.release(),
-        },
-        runtime: {
-            name: 'node.js',
-            version: process.versions.node,
-        },
-        ci: (0, ci_environment_1.default)(env),
-        runName,
-    };
-    eventBroadcaster.emit('envelope', {
-        meta,
-    });
-}
-exports.emitMetaMessage = emitMetaMessage;
-const makeSourceReference = (source) => ({
-    uri: source.uri,
-    location: {
-        line: source.line,
-    },
-});
-function emitParameterTypes(supportCodeLibrary, eventBroadcaster, newId) {
-    for (const parameterType of supportCodeLibrary.parameterTypeRegistry
-        .parameterTypes) {
-        if (parameterType.builtin) {
-            continue;
-        }
-        const source = supportCodeLibrary.parameterTypeRegistry.lookupSource(parameterType);
-        const envelope = {
-            parameterType: {
-                id: newId(),
-                name: parameterType.name,
-                preferForRegularExpressionMatch: parameterType.preferForRegexpMatch,
-                regularExpressions: parameterType.regexpStrings,
-                useForSnippets: parameterType.useForSnippets,
-                sourceReference: makeSourceReference(source),
-            },
-        };
-        eventBroadcaster.emit('envelope', envelope);
-    }
-}
-function emitUndefinedParameterTypes(supportCodeLibrary, eventBroadcaster) {
-    for (const undefinedParameterType of supportCodeLibrary.undefinedParameterTypes) {
-        const envelope = {
-            undefinedParameterType,
-        };
-        eventBroadcaster.emit('envelope', envelope);
-    }
-}
-function emitStepDefinitions(supportCodeLibrary, eventBroadcaster) {
-    supportCodeLibrary.stepDefinitions.forEach((stepDefinition) => {
-        const envelope = {
-            stepDefinition: {
-                id: stepDefinition.id,
-                pattern: {
-                    source: stepDefinition.pattern.toString(),
-                    type: typeof stepDefinition.pattern === 'string'
-                        ? messages.StepDefinitionPatternType.CUCUMBER_EXPRESSION
-                        : messages.StepDefinitionPatternType.REGULAR_EXPRESSION,
-                },
-                sourceReference: makeSourceReference(stepDefinition),
-            },
-        };
-        eventBroadcaster.emit('envelope', envelope);
-    });
-}
-function emitTestCaseHooks(supportCodeLibrary, eventBroadcaster) {
-    ;
-    []
-        .concat(supportCodeLibrary.beforeTestCaseHookDefinitions, supportCodeLibrary.afterTestCaseHookDefinitions)
-        .forEach((testCaseHookDefinition) => {
-        const envelope = {
-            hook: {
-                id: testCaseHookDefinition.id,
-                name: testCaseHookDefinition.name,
-                tagExpression: testCaseHookDefinition.tagExpression,
-                sourceReference: makeSourceReference(testCaseHookDefinition),
-            },
-        };
-        eventBroadcaster.emit('envelope', envelope);
-    });
-}
-function emitTestRunHooks(supportCodeLibrary, eventBroadcaster) {
-    ;
-    []
-        .concat(supportCodeLibrary.beforeTestRunHookDefinitions, supportCodeLibrary.afterTestRunHookDefinitions)
-        .forEach((testRunHookDefinition) => {
-        const envelope = {
-            hook: {
-                id: testRunHookDefinition.id,
-                sourceReference: makeSourceReference(testRunHookDefinition),
-            },
-        };
-        eventBroadcaster.emit('envelope', envelope);
-    });
-}
-function emitSupportCodeMessages({ eventBroadcaster, supportCodeLibrary, newId, }) {
-    emitParameterTypes(supportCodeLibrary, eventBroadcaster, newId);
-    emitUndefinedParameterTypes(supportCodeLibrary, eventBroadcaster);
-    emitStepDefinitions(supportCodeLibrary, eventBroadcaster);
-    emitTestCaseHooks(supportCodeLibrary, eventBroadcaster);
-    emitTestRunHooks(supportCodeLibrary, eventBroadcaster);
-}
-exports.emitSupportCodeMessages = emitSupportCodeMessages;
-function getRunName(argvConfiguration) {
-    if ((0, value_checker_1.doesHaveValue)(argvConfiguration.runName)) {
-        return argvConfiguration.runName;
-    }
-    if ((0, value_checker_1.doesHaveValue)(argvConfiguration.name && argvConfiguration.name.length > 0)) {
-        return argvConfiguration.name[0];
-    }
-    if ((0, value_checker_1.doesHaveValue)(argvConfiguration.tags)) {
-        //replace word "and" with &  and "or" with |
-        let tags = argvConfiguration.tags
-            .split(' ')
-            .map((tag) => (tag === 'and' ? '&' : tag === 'or' ? '|' : tag))
-            .join('');
-        //remove the starting and ending paranthesis if present
-        tags = tags.replace(/^\(/, '').replace(/\)$/, '');
-        return tags;
-    }
-    return '';
-}
-exports.getRunName = getRunName;
+"use strict";
+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;
+};
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getRunName = exports.emitSupportCodeMessages = exports.emitMetaMessage = exports.orderPickles = exports.parseGherkinMessageStream = void 0;
+const ci_environment_1 = __importDefault(require("@cucumber/ci-environment"));
+const messages = __importStar(require("@cucumber/messages"));
+const knuth_shuffle_seeded_1 = __importDefault(require("knuth-shuffle-seeded"));
+const os_1 = __importDefault(require("os"));
+const configuration_1 = require("../configuration");
+const value_checker_1 = require("../value_checker");
+const version_1 = require("../version");
+/**
+ * Process a stream of envelopes from Gherkin and resolve to an array of filtered, ordered pickle Ids
+ *
+ * @param eventBroadcaster
+ * @param eventDataCollector
+ * @param gherkinMessageStream
+ * @param order
+ * @param pickleFilter
+ */
+async function parseGherkinMessageStream({ eventBroadcaster, eventDataCollector, gherkinMessageStream, order, pickleFilter, }) {
+    return await new Promise((resolve, reject) => {
+        const result = [];
+        gherkinMessageStream.on('data', (envelope) => {
+            eventBroadcaster.emit('envelope', envelope);
+            if ((0, value_checker_1.doesHaveValue)(envelope.pickle)) {
+                const pickle = envelope.pickle;
+                const pickleId = pickle.id;
+                const gherkinDocument = eventDataCollector.getGherkinDocument(pickle.uri);
+                if (pickleFilter.matches({ gherkinDocument, pickle })) {
+                    result.push(pickleId);
+                }
+            }
+        });
+        gherkinMessageStream.on('end', () => {
+            orderPickles(result, order, console);
+            resolve(result);
+        });
+        gherkinMessageStream.on('error', reject);
+    });
+}
+exports.parseGherkinMessageStream = parseGherkinMessageStream;
+// Orders the pickleIds in place - morphs input
+function orderPickles(pickleIds, order, logger) {
+    const [type, seed] = configuration_1.OptionSplitter.split(order);
+    switch (type) {
+        case 'defined':
+            break;
+        case 'random':
+            if (seed === '') {
+                const newSeed = Math.floor(Math.random() * 1000 * 1000).toString();
+                logger.warn(`Random order using seed: ${newSeed}`);
+                (0, knuth_shuffle_seeded_1.default)(pickleIds, newSeed);
+            }
+            else {
+                (0, knuth_shuffle_seeded_1.default)(pickleIds, seed);
+            }
+            break;
+        default:
+            throw new Error('Unrecgonized order type. Should be `defined` or `random`');
+    }
+}
+exports.orderPickles = orderPickles;
+async function emitMetaMessage(eventBroadcaster, env, runName) {
+    const meta = {
+        protocolVersion: messages.version,
+        implementation: {
+            version: version_1.version,
+            name: 'cucumber-js',
+        },
+        cpu: {
+            name: os_1.default.arch(),
+        },
+        os: {
+            name: os_1.default.platform(),
+            version: os_1.default.release(),
+        },
+        runtime: {
+            name: 'node.js',
+            version: process.versions.node,
+        },
+        ci: (0, ci_environment_1.default)(env),
+        runName,
+    };
+    eventBroadcaster.emit('envelope', {
+        meta,
+    });
+}
+exports.emitMetaMessage = emitMetaMessage;
+const makeSourceReference = (source) => ({
+    uri: source.uri,
+    location: {
+        line: source.line,
+    },
+});
+function emitParameterTypes(supportCodeLibrary, eventBroadcaster, newId) {
+    for (const parameterType of supportCodeLibrary.parameterTypeRegistry
+        .parameterTypes) {
+        if (parameterType.builtin) {
+            continue;
+        }
+        const source = supportCodeLibrary.parameterTypeRegistry.lookupSource(parameterType);
+        const envelope = {
+            parameterType: {
+                id: newId(),
+                name: parameterType.name,
+                preferForRegularExpressionMatch: parameterType.preferForRegexpMatch,
+                regularExpressions: parameterType.regexpStrings,
+                useForSnippets: parameterType.useForSnippets,
+                sourceReference: makeSourceReference(source),
+            },
+        };
+        eventBroadcaster.emit('envelope', envelope);
+    }
+}
+function emitUndefinedParameterTypes(supportCodeLibrary, eventBroadcaster) {
+    for (const undefinedParameterType of supportCodeLibrary.undefinedParameterTypes) {
+        const envelope = {
+            undefinedParameterType,
+        };
+        eventBroadcaster.emit('envelope', envelope);
+    }
+}
+function emitStepDefinitions(supportCodeLibrary, eventBroadcaster) {
+    supportCodeLibrary.stepDefinitions.forEach((stepDefinition) => {
+        const envelope = {
+            stepDefinition: {
+                id: stepDefinition.id,
+                pattern: {
+                    source: stepDefinition.pattern.toString(),
+                    type: typeof stepDefinition.pattern === 'string'
+                        ? messages.StepDefinitionPatternType.CUCUMBER_EXPRESSION
+                        : messages.StepDefinitionPatternType.REGULAR_EXPRESSION,
+                },
+                sourceReference: makeSourceReference(stepDefinition),
+            },
+        };
+        eventBroadcaster.emit('envelope', envelope);
+    });
+}
+function emitTestCaseHooks(supportCodeLibrary, eventBroadcaster) {
+    ;
+    []
+        .concat(supportCodeLibrary.beforeTestCaseHookDefinitions, supportCodeLibrary.afterTestCaseHookDefinitions)
+        .forEach((testCaseHookDefinition) => {
+        const envelope = {
+            hook: {
+                id: testCaseHookDefinition.id,
+                name: testCaseHookDefinition.name,
+                tagExpression: testCaseHookDefinition.tagExpression,
+                sourceReference: makeSourceReference(testCaseHookDefinition),
+            },
+        };
+        eventBroadcaster.emit('envelope', envelope);
+    });
+}
+function emitTestRunHooks(supportCodeLibrary, eventBroadcaster) {
+    ;
+    []
+        .concat(supportCodeLibrary.beforeTestRunHookDefinitions, supportCodeLibrary.afterTestRunHookDefinitions)
+        .forEach((testRunHookDefinition) => {
+        const envelope = {
+            hook: {
+                id: testRunHookDefinition.id,
+                sourceReference: makeSourceReference(testRunHookDefinition),
+            },
+        };
+        eventBroadcaster.emit('envelope', envelope);
+    });
+}
+function emitSupportCodeMessages({ eventBroadcaster, supportCodeLibrary, newId, }) {
+    emitParameterTypes(supportCodeLibrary, eventBroadcaster, newId);
+    emitUndefinedParameterTypes(supportCodeLibrary, eventBroadcaster);
+    emitStepDefinitions(supportCodeLibrary, eventBroadcaster);
+    emitTestCaseHooks(supportCodeLibrary, eventBroadcaster);
+    emitTestRunHooks(supportCodeLibrary, eventBroadcaster);
+}
+exports.emitSupportCodeMessages = emitSupportCodeMessages;
+function getRunName(argvConfiguration) {
+    if ((0, value_checker_1.doesHaveValue)(argvConfiguration.runName)) {
+        return argvConfiguration.runName;
+    }
+    if ((0, value_checker_1.doesHaveValue)(argvConfiguration.name && argvConfiguration.name.length > 0)) {
+        return argvConfiguration.name[0];
+    }
+    if ((0, value_checker_1.doesHaveValue)(argvConfiguration.tags)) {
+        //replace word "and" with &  and "or" with |
+        let tags = argvConfiguration.tags
+            .split(' ')
+            .map((tag) => (tag === 'and' ? '&' : tag === 'or' ? '|' : tag))
+            .join('');
+        //remove the starting and ending paranthesis if present
+        tags = tags.replace(/^\(/, '').replace(/\)$/, '');
+        return tags;
+    }
+    return '';
+}
+exports.getRunName = getRunName;
 //# sourceMappingURL=helpers.js.map

package/lib/cli/i18n.d.ts

@@ -1,2 +1,2 @@
-export declare function getLanguages(): string;
-export declare function getKeywords(isoCode: string): string;
+export declare function getLanguages(): string;
+export declare function getKeywords(isoCode: string): string;

package/lib/cli/i18n.js

@@ -1,70 +1,70 @@
-"use strict";
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.getKeywords = exports.getLanguages = void 0;
-const gherkin_1 = require("@cucumber/gherkin");
-const cli_table3_1 = __importDefault(require("cli-table3"));
-const capital_case_1 = require("capital-case");
-const keywords = [
-    'feature',
-    'rule',
-    'background',
-    'scenario',
-    'scenarioOutline',
-    'examples',
-    'given',
-    'when',
-    'then',
-    'and',
-    'but',
-];
-function getAsTable(header, rows) {
-    const table = new cli_table3_1.default({
-        chars: {
-            bottom: '',
-            'bottom-left': '',
-            'bottom-mid': '',
-            'bottom-right': '',
-            left: '',
-            'left-mid': '',
-            mid: '',
-            'mid-mid': '',
-            middle: ' | ',
-            right: '',
-            'right-mid': '',
-            top: '',
-            'top-left': '',
-            'top-mid': '',
-            'top-right': '',
-        },
-        style: {
-            border: [],
-            'padding-left': 0,
-            'padding-right': 0,
-        },
-    });
-    table.push(header);
-    table.push(...rows);
-    return table.toString();
-}
-function getLanguages() {
-    const rows = Object.keys(gherkin_1.dialects).map((isoCode) => [
-        isoCode,
-        gherkin_1.dialects[isoCode].name,
-        gherkin_1.dialects[isoCode].native,
-    ]);
-    return getAsTable(['ISO 639-1', 'ENGLISH NAME', 'NATIVE NAME'], rows);
-}
-exports.getLanguages = getLanguages;
-function getKeywords(isoCode) {
-    const language = gherkin_1.dialects[isoCode];
-    const rows = keywords.map((keyword) => {
-        const words = language[keyword].map((s) => `"${s}"`).join(', ');
-        return [(0, capital_case_1.capitalCase)(keyword), words];
-    });
-    return getAsTable(['ENGLISH KEYWORD', 'NATIVE KEYWORDS'], rows);
-}
-exports.getKeywords = getKeywords;
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getKeywords = exports.getLanguages = void 0;
+const gherkin_1 = require("@cucumber/gherkin");
+const cli_table3_1 = __importDefault(require("cli-table3"));
+const capital_case_1 = require("capital-case");
+const keywords = [
+    'feature',
+    'rule',
+    'background',
+    'scenario',
+    'scenarioOutline',
+    'examples',
+    'given',
+    'when',
+    'then',
+    'and',
+    'but',
+];
+function getAsTable(header, rows) {
+    const table = new cli_table3_1.default({
+        chars: {
+            bottom: '',
+            'bottom-left': '',
+            'bottom-mid': '',
+            'bottom-right': '',
+            left: '',
+            'left-mid': '',
+            mid: '',
+            'mid-mid': '',
+            middle: ' | ',
+            right: '',
+            'right-mid': '',
+            top: '',
+            'top-left': '',
+            'top-mid': '',
+            'top-right': '',
+        },
+        style: {
+            border: [],
+            'padding-left': 0,
+            'padding-right': 0,
+        },
+    });
+    table.push(header);
+    table.push(...rows);
+    return table.toString();
+}
+function getLanguages() {
+    const rows = Object.keys(gherkin_1.dialects).map((isoCode) => [
+        isoCode,
+        gherkin_1.dialects[isoCode].name,
+        gherkin_1.dialects[isoCode].native,
+    ]);
+    return getAsTable(['ISO 639-1', 'ENGLISH NAME', 'NATIVE NAME'], rows);
+}
+exports.getLanguages = getLanguages;
+function getKeywords(isoCode) {
+    const language = gherkin_1.dialects[isoCode];
+    const rows = keywords.map((keyword) => {
+        const words = language[keyword].map((s) => `"${s}"`).join(', ');
+        return [(0, capital_case_1.capitalCase)(keyword), words];
+    });
+    return getAsTable(['ENGLISH KEYWORD', 'NATIVE KEYWORDS'], rows);
+}
+exports.getKeywords = getKeywords;
 //# sourceMappingURL=i18n.js.map

package/lib/cli/index.d.ts

@@ -1,21 +1,21 @@
-/// <reference types="node" />
-import { IFormatterStream } from '../formatter';
-export interface ICliRunResult {
-    shouldExitImmediately: boolean;
-    success: boolean;
-}
-export default class Cli {
-    private readonly argv;
-    private readonly cwd;
-    private readonly stdout;
-    private readonly stderr;
-    private readonly env;
-    constructor({ argv, cwd, stdout, stderr, env, }: {
-        argv: string[];
-        cwd: string;
-        stdout: IFormatterStream;
-        stderr?: IFormatterStream;
-        env: NodeJS.ProcessEnv;
-    });
-    run(): Promise<ICliRunResult>;
-}
+/// <reference types="node" />
+import { IFormatterStream } from '../formatter';
+export interface ICliRunResult {
+    shouldExitImmediately: boolean;
+    success: boolean;
+}
+export default class Cli {
+    private readonly argv;
+    private readonly cwd;
+    private readonly stdout;
+    private readonly stderr;
+    private readonly env;
+    constructor({ argv, cwd, stdout, stderr, env, }: {
+        argv: string[];
+        cwd: string;
+        stdout: IFormatterStream;
+        stderr?: IFormatterStream;
+        env: NodeJS.ProcessEnv;
+    });
+    run(): Promise<ICliRunResult>;
+}