@dev-blinq/cucumber-js 1.0.36 → 1.0.37-stage

package/lib/models/definition.js

@@ -1,22 +1,22 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-class Definition {
-    constructor({ code, id, line, options, unwrappedCode, uri, }) {
-        this.code = code;
-        this.id = id;
-        this.line = line;
-        this.options = options;
-        this.unwrappedCode = unwrappedCode;
-        this.uri = uri;
-    }
-    buildInvalidCodeLengthMessage(syncOrPromiseLength, callbackLength) {
-        return (`function has ${this.code.length.toString()} arguments` +
-            `, should have ${syncOrPromiseLength.toString()} (if synchronous or returning a promise)` +
-            ` or ${callbackLength.toString()} (if accepting a callback)`);
-    }
-    baseGetInvalidCodeLengthMessage(parameters) {
-        return this.buildInvalidCodeLengthMessage(parameters.length, parameters.length + 1);
-    }
-}
-exports.default = Definition;
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+class Definition {
+    constructor({ code, id, line, options, unwrappedCode, uri, }) {
+        this.code = code;
+        this.id = id;
+        this.line = line;
+        this.options = options;
+        this.unwrappedCode = unwrappedCode;
+        this.uri = uri;
+    }
+    buildInvalidCodeLengthMessage(syncOrPromiseLength, callbackLength) {
+        return (`function has ${this.code.length.toString()} arguments` +
+            `, should have ${syncOrPromiseLength.toString()} (if synchronous or returning a promise)` +
+            ` or ${callbackLength.toString()} (if accepting a callback)`);
+    }
+    baseGetInvalidCodeLengthMessage(parameters) {
+        return this.buildInvalidCodeLengthMessage(parameters.length, parameters.length + 1);
+    }
+}
+exports.default = Definition;
 //# sourceMappingURL=definition.js.map

package/lib/models/gherkin_step_keyword.d.ts

@@ -1 +1 @@
-export type GherkinStepKeyword = 'Unknown' | 'Given' | 'When' | 'Then';
+export type GherkinStepKeyword = 'Unknown' | 'Given' | 'When' | 'Then';

package/lib/models/gherkin_step_keyword.js

@@ -1,3 +1,3 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
 //# sourceMappingURL=gherkin_step_keyword.js.map

package/lib/models/pickle_order.d.ts

@@ -1 +1 @@
-export type PickleOrder = 'defined' | 'random' | string;
+export type PickleOrder = 'defined' | 'random' | string;

package/lib/models/pickle_order.js

@@ -1,3 +1,3 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
 //# sourceMappingURL=pickle_order.js.map

package/lib/models/step_definition.d.ts

@@ -1,11 +1,11 @@
-import Definition, { IDefinition, IGetInvocationDataRequest, IGetInvocationDataResponse, IStepDefinitionParameters } from './definition';
-import { Expression } from '@cucumber/cucumber-expressions';
-import { GherkinStepKeyword } from './gherkin_step_keyword';
-export default class StepDefinition extends Definition implements IDefinition {
-    readonly keyword: GherkinStepKeyword;
-    readonly pattern: string | RegExp;
-    readonly expression: Expression;
-    constructor(data: IStepDefinitionParameters);
-    getInvocationParameters({ step, world, }: IGetInvocationDataRequest): Promise<IGetInvocationDataResponse>;
-    matchesStepName(stepName: string): boolean;
-}
+import Definition, { IDefinition, IGetInvocationDataRequest, IGetInvocationDataResponse, IStepDefinitionParameters } from './definition';
+import { Expression } from '@cucumber/cucumber-expressions';
+import { GherkinStepKeyword } from './gherkin_step_keyword';
+export default class StepDefinition extends Definition implements IDefinition {
+    readonly keyword: GherkinStepKeyword;
+    readonly pattern: string | RegExp;
+    readonly expression: Expression;
+    constructor(data: IStepDefinitionParameters);
+    getInvocationParameters({ step, world, }: IGetInvocationDataRequest): Promise<IGetInvocationDataResponse>;
+    matchesStepName(stepName: string): boolean;
+}

package/lib/models/step_definition.js

@@ -1,37 +1,37 @@
-"use strict";
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-const data_table_1 = __importDefault(require("./data_table"));
-const definition_1 = __importDefault(require("./definition"));
-const step_arguments_1 = require("../step_arguments");
-const value_checker_1 = require("../value_checker");
-class StepDefinition extends definition_1.default {
-    constructor(data) {
-        super(data);
-        this.keyword = data.keyword;
-        this.pattern = data.pattern;
-        this.expression = data.expression;
-    }
-    async getInvocationParameters({ step, world, }) {
-        const parameters = await Promise.all(this.expression.match(step.text).map((arg) => arg.getValue(world)));
-        if ((0, value_checker_1.doesHaveValue)(step.argument)) {
-            const argumentParamater = (0, step_arguments_1.parseStepArgument)(step.argument, {
-                dataTable: (arg) => new data_table_1.default(arg),
-                docString: (arg) => arg.content,
-            });
-            parameters.push(argumentParamater);
-        }
-        return {
-            getInvalidCodeLengthMessage: () => this.baseGetInvalidCodeLengthMessage(parameters),
-            parameters,
-            validCodeLengths: [parameters.length, parameters.length + 1],
-        };
-    }
-    matchesStepName(stepName) {
-        return (0, value_checker_1.doesHaveValue)(this.expression.match(stepName));
-    }
-}
-exports.default = StepDefinition;
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const data_table_1 = __importDefault(require("./data_table"));
+const definition_1 = __importDefault(require("./definition"));
+const step_arguments_1 = require("../step_arguments");
+const value_checker_1 = require("../value_checker");
+class StepDefinition extends definition_1.default {
+    constructor(data) {
+        super(data);
+        this.keyword = data.keyword;
+        this.pattern = data.pattern;
+        this.expression = data.expression;
+    }
+    async getInvocationParameters({ step, world, }) {
+        const parameters = await Promise.all(this.expression.match(step.text).map((arg) => arg.getValue(world)));
+        if ((0, value_checker_1.doesHaveValue)(step.argument)) {
+            const argumentParamater = (0, step_arguments_1.parseStepArgument)(step.argument, {
+                dataTable: (arg) => new data_table_1.default(arg),
+                docString: (arg) => arg.content,
+            });
+            parameters.push(argumentParamater);
+        }
+        return {
+            getInvalidCodeLengthMessage: () => this.baseGetInvalidCodeLengthMessage(parameters),
+            parameters,
+            validCodeLengths: [parameters.length, parameters.length + 1],
+        };
+    }
+    matchesStepName(stepName) {
+        return (0, value_checker_1.doesHaveValue)(this.expression.match(stepName));
+    }
+}
+exports.default = StepDefinition;
 //# sourceMappingURL=step_definition.js.map

package/lib/models/test_case_hook_definition.d.ts

@@ -1,10 +1,10 @@
-import Definition, { IDefinition, IDefinitionParameters, IGetInvocationDataRequest, IGetInvocationDataResponse, IHookDefinitionOptions } from './definition';
-import * as messages from '@cucumber/messages';
-export default class TestCaseHookDefinition extends Definition implements IDefinition {
-    readonly name: string;
-    readonly tagExpression: string;
-    private readonly pickleTagFilter;
-    constructor(data: IDefinitionParameters<IHookDefinitionOptions>);
-    appliesToTestCase(pickle: messages.Pickle): boolean;
-    getInvocationParameters({ hookParameter, }: IGetInvocationDataRequest): Promise<IGetInvocationDataResponse>;
-}
+import Definition, { IDefinition, IDefinitionParameters, IGetInvocationDataRequest, IGetInvocationDataResponse, IHookDefinitionOptions } from './definition';
+import * as messages from '@cucumber/messages';
+export default class TestCaseHookDefinition extends Definition implements IDefinition {
+    readonly name: string;
+    readonly tagExpression: string;
+    private readonly pickleTagFilter;
+    constructor(data: IDefinitionParameters<IHookDefinitionOptions>);
+    appliesToTestCase(pickle: messages.Pickle): boolean;
+    getInvocationParameters({ hookParameter, }: IGetInvocationDataRequest): Promise<IGetInvocationDataResponse>;
+}

package/lib/models/test_case_hook_definition.js

@@ -1,27 +1,27 @@
-"use strict";
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-const pickle_filter_1 = require("../pickle_filter");
-const definition_1 = __importDefault(require("./definition"));
-class TestCaseHookDefinition extends definition_1.default {
-    constructor(data) {
-        super(data);
-        this.name = data.options.name;
-        this.tagExpression = data.options.tags;
-        this.pickleTagFilter = new pickle_filter_1.PickleTagFilter(data.options.tags);
-    }
-    appliesToTestCase(pickle) {
-        return this.pickleTagFilter.matchesAllTagExpressions(pickle);
-    }
-    async getInvocationParameters({ hookParameter, }) {
-        return await Promise.resolve({
-            getInvalidCodeLengthMessage: () => this.buildInvalidCodeLengthMessage('0 or 1', '2'),
-            parameters: [hookParameter],
-            validCodeLengths: [0, 1, 2],
-        });
-    }
-}
-exports.default = TestCaseHookDefinition;
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const pickle_filter_1 = require("../pickle_filter");
+const definition_1 = __importDefault(require("./definition"));
+class TestCaseHookDefinition extends definition_1.default {
+    constructor(data) {
+        super(data);
+        this.name = data.options.name;
+        this.tagExpression = data.options.tags;
+        this.pickleTagFilter = new pickle_filter_1.PickleTagFilter(data.options.tags);
+    }
+    appliesToTestCase(pickle) {
+        return this.pickleTagFilter.matchesAllTagExpressions(pickle);
+    }
+    async getInvocationParameters({ hookParameter, }) {
+        return await Promise.resolve({
+            getInvalidCodeLengthMessage: () => this.buildInvalidCodeLengthMessage('0 or 1', '2'),
+            parameters: [hookParameter],
+            validCodeLengths: [0, 1, 2],
+        });
+    }
+}
+exports.default = TestCaseHookDefinition;
 //# sourceMappingURL=test_case_hook_definition.js.map

package/lib/models/test_run_hook_definition.d.ts

@@ -1,3 +1,3 @@
-import Definition from './definition';
-export default class TestRunHookDefinition extends Definition {
-}
+import Definition from './definition';
+export default class TestRunHookDefinition extends Definition {
+}

package/lib/models/test_run_hook_definition.js

@@ -1,10 +1,10 @@
-"use strict";
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-const definition_1 = __importDefault(require("./definition"));
-class TestRunHookDefinition extends definition_1.default {
-}
-exports.default = TestRunHookDefinition;
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const definition_1 = __importDefault(require("./definition"));
+class TestRunHookDefinition extends definition_1.default {
+}
+exports.default = TestRunHookDefinition;
 //# sourceMappingURL=test_run_hook_definition.js.map

package/lib/models/test_step_hook_definition.d.ts

@@ -1,9 +1,9 @@
-import Definition, { IDefinition, IGetInvocationDataResponse, IGetInvocationDataRequest, IDefinitionParameters, IHookDefinitionOptions } from './definition';
-import * as messages from '@cucumber/messages';
-export default class TestStepHookDefinition extends Definition implements IDefinition {
-    readonly tagExpression: string;
-    private readonly pickleTagFilter;
-    constructor(data: IDefinitionParameters<IHookDefinitionOptions>);
-    appliesToTestCase(pickle: messages.Pickle): boolean;
-    getInvocationParameters({ hookParameter, }: IGetInvocationDataRequest): Promise<IGetInvocationDataResponse>;
-}
+import Definition, { IDefinition, IGetInvocationDataResponse, IGetInvocationDataRequest, IDefinitionParameters, IHookDefinitionOptions } from './definition';
+import * as messages from '@cucumber/messages';
+export default class TestStepHookDefinition extends Definition implements IDefinition {
+    readonly tagExpression: string;
+    private readonly pickleTagFilter;
+    constructor(data: IDefinitionParameters<IHookDefinitionOptions>);
+    appliesToTestCase(pickle: messages.Pickle): boolean;
+    getInvocationParameters({ hookParameter, }: IGetInvocationDataRequest): Promise<IGetInvocationDataResponse>;
+}

package/lib/models/test_step_hook_definition.js

@@ -1,26 +1,26 @@
-"use strict";
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-const pickle_filter_1 = require("../pickle_filter");
-const definition_1 = __importDefault(require("./definition"));
-class TestStepHookDefinition extends definition_1.default {
-    constructor(data) {
-        super(data);
-        this.tagExpression = data.options.tags;
-        this.pickleTagFilter = new pickle_filter_1.PickleTagFilter(data.options.tags);
-    }
-    appliesToTestCase(pickle) {
-        return this.pickleTagFilter.matchesAllTagExpressions(pickle);
-    }
-    async getInvocationParameters({ hookParameter, }) {
-        return await Promise.resolve({
-            getInvalidCodeLengthMessage: () => this.buildInvalidCodeLengthMessage('0 or 1', '2'),
-            parameters: [hookParameter],
-            validCodeLengths: [0, 1, 2],
-        });
-    }
-}
-exports.default = TestStepHookDefinition;
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const pickle_filter_1 = require("../pickle_filter");
+const definition_1 = __importDefault(require("./definition"));
+class TestStepHookDefinition extends definition_1.default {
+    constructor(data) {
+        super(data);
+        this.tagExpression = data.options.tags;
+        this.pickleTagFilter = new pickle_filter_1.PickleTagFilter(data.options.tags);
+    }
+    appliesToTestCase(pickle) {
+        return this.pickleTagFilter.matchesAllTagExpressions(pickle);
+    }
+    async getInvocationParameters({ hookParameter, }) {
+        return await Promise.resolve({
+            getInvalidCodeLengthMessage: () => this.buildInvalidCodeLengthMessage('0 or 1', '2'),
+            parameters: [hookParameter],
+            validCodeLengths: [0, 1, 2],
+        });
+    }
+}
+exports.default = TestStepHookDefinition;
 //# sourceMappingURL=test_step_hook_definition.js.map

package/lib/pickle_filter.d.ts

@@ -1,42 +1,42 @@
-import * as messages from '@cucumber/messages';
-import IGherkinDocument = messages.GherkinDocument;
-import IPickle = messages.Pickle;
-export interface IPickleFilterOptions {
-    cwd: string;
-    featurePaths?: string[];
-    names?: string[];
-    tagExpression?: string;
-}
-export interface IMatchesAnyLineRequest {
-    gherkinDocument: messages.GherkinDocument;
-    pickle: messages.Pickle;
-}
-export default class PickleFilter {
-    private readonly lineFilter;
-    private readonly nameFilter;
-    private readonly tagFilter;
-    constructor({ cwd, featurePaths, names, tagExpression, }: IPickleFilterOptions);
-    matches({ gherkinDocument, pickle, }: {
-        gherkinDocument: IGherkinDocument;
-        pickle: IPickle;
-    }): boolean;
-}
-export declare class PickleLineFilter {
-    private readonly featureUriToLinesMapping;
-    constructor(cwd: string, featurePaths?: string[]);
-    getFeatureUriToLinesMapping({ cwd, featurePaths, }: {
-        cwd: string;
-        featurePaths: string[];
-    }): Record<string, number[]>;
-    matchesAnyLine({ gherkinDocument, pickle }: IMatchesAnyLineRequest): boolean;
-}
-export declare class PickleNameFilter {
-    private readonly names;
-    constructor(names?: string[]);
-    matchesAnyName(pickle: messages.Pickle): boolean;
-}
-export declare class PickleTagFilter {
-    private readonly tagExpressionNode;
-    constructor(tagExpression: string);
-    matchesAllTagExpressions(pickle: messages.Pickle): boolean;
-}
+import * as messages from '@cucumber/messages';
+import IGherkinDocument = messages.GherkinDocument;
+import IPickle = messages.Pickle;
+export interface IPickleFilterOptions {
+    cwd: string;
+    featurePaths?: string[];
+    names?: string[];
+    tagExpression?: string;
+}
+export interface IMatchesAnyLineRequest {
+    gherkinDocument: messages.GherkinDocument;
+    pickle: messages.Pickle;
+}
+export default class PickleFilter {
+    private readonly lineFilter;
+    private readonly nameFilter;
+    private readonly tagFilter;
+    constructor({ cwd, featurePaths, names, tagExpression, }: IPickleFilterOptions);
+    matches({ gherkinDocument, pickle, }: {
+        gherkinDocument: IGherkinDocument;
+        pickle: IPickle;
+    }): boolean;
+}
+export declare class PickleLineFilter {
+    private readonly featureUriToLinesMapping;
+    constructor(cwd: string, featurePaths?: string[]);
+    getFeatureUriToLinesMapping({ cwd, featurePaths, }: {
+        cwd: string;
+        featurePaths: string[];
+    }): Record<string, number[]>;
+    matchesAnyLine({ gherkinDocument, pickle }: IMatchesAnyLineRequest): boolean;
+}
+export declare class PickleNameFilter {
+    private readonly names;
+    constructor(names?: string[]);
+    matchesAnyName(pickle: messages.Pickle): boolean;
+}
+export declare class PickleTagFilter {
+    private readonly tagExpressionNode;
+    constructor(tagExpression: string);
+    matchesAllTagExpressions(pickle: messages.Pickle): boolean;
+}

package/lib/pickle_filter.js

@@ -1,99 +1,99 @@
-"use strict";
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.PickleTagFilter = exports.PickleNameFilter = exports.PickleLineFilter = void 0;
-const path_1 = __importDefault(require("path"));
-const tag_expressions_1 = __importDefault(require("@cucumber/tag-expressions"));
-const gherkin_document_parser_1 = require("./formatter/helpers/gherkin_document_parser");
-const value_checker_1 = require("./value_checker");
-const FEATURE_LINENUM_REGEXP = /^(.*?)((?::[\d]+)+)?$/;
-class PickleFilter {
-    constructor({ cwd, featurePaths, names, tagExpression, }) {
-        this.lineFilter = new PickleLineFilter(cwd, featurePaths);
-        this.nameFilter = new PickleNameFilter(names);
-        this.tagFilter = new PickleTagFilter(tagExpression);
-    }
-    matches({ gherkinDocument, pickle, }) {
-        return (this.lineFilter.matchesAnyLine({ gherkinDocument, pickle }) &&
-            this.nameFilter.matchesAnyName(pickle) &&
-            this.tagFilter.matchesAllTagExpressions(pickle));
-    }
-}
-exports.default = PickleFilter;
-class PickleLineFilter {
-    constructor(cwd, featurePaths = []) {
-        this.featureUriToLinesMapping = this.getFeatureUriToLinesMapping({
-            cwd,
-            featurePaths,
-        });
-    }
-    getFeatureUriToLinesMapping({ cwd, featurePaths, }) {
-        const mapping = {};
-        featurePaths.forEach((featurePath) => {
-            const match = FEATURE_LINENUM_REGEXP.exec(featurePath);
-            if ((0, value_checker_1.doesHaveValue)(match)) {
-                let uri = match[1];
-                if (path_1.default.isAbsolute(uri)) {
-                    uri = path_1.default.relative(cwd, uri);
-                }
-                else {
-                    uri = path_1.default.normalize(uri);
-                }
-                const linesExpression = match[2];
-                if ((0, value_checker_1.doesHaveValue)(linesExpression)) {
-                    if ((0, value_checker_1.doesNotHaveValue)(mapping[uri])) {
-                        mapping[uri] = [];
-                    }
-                    linesExpression
-                        .slice(1)
-                        .split(':')
-                        .forEach((line) => {
-                        mapping[uri].push(parseInt(line));
-                    });
-                }
-            }
-        });
-        return mapping;
-    }
-    matchesAnyLine({ gherkinDocument, pickle }) {
-        const uri = path_1.default.normalize(pickle.uri);
-        const linesToMatch = this.featureUriToLinesMapping[uri];
-        if ((0, value_checker_1.doesHaveValue)(linesToMatch)) {
-            const gherkinScenarioLocationMap = (0, gherkin_document_parser_1.getGherkinScenarioLocationMap)(gherkinDocument);
-            const pickleLines = new Set(pickle.astNodeIds.map((sourceId) => gherkinScenarioLocationMap[sourceId].line));
-            const linesIntersection = linesToMatch.filter((x) => pickleLines.has(x));
-            return linesIntersection.length > 0;
-        }
-        return true;
-    }
-}
-exports.PickleLineFilter = PickleLineFilter;
-class PickleNameFilter {
-    constructor(names = []) {
-        this.names = names;
-    }
-    matchesAnyName(pickle) {
-        if (this.names.length === 0) {
-            return true;
-        }
-        return this.names.some((name) => pickle.name.match(name));
-    }
-}
-exports.PickleNameFilter = PickleNameFilter;
-class PickleTagFilter {
-    constructor(tagExpression) {
-        if ((0, value_checker_1.doesHaveValue)(tagExpression) && tagExpression !== '') {
-            this.tagExpressionNode = (0, tag_expressions_1.default)(tagExpression);
-        }
-    }
-    matchesAllTagExpressions(pickle) {
-        if ((0, value_checker_1.doesNotHaveValue)(this.tagExpressionNode)) {
-            return true;
-        }
-        return this.tagExpressionNode.evaluate(pickle.tags.map((x) => x.name));
-    }
-}
-exports.PickleTagFilter = PickleTagFilter;
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.PickleTagFilter = exports.PickleNameFilter = exports.PickleLineFilter = void 0;
+const path_1 = __importDefault(require("path"));
+const tag_expressions_1 = __importDefault(require("@cucumber/tag-expressions"));
+const gherkin_document_parser_1 = require("./formatter/helpers/gherkin_document_parser");
+const value_checker_1 = require("./value_checker");
+const FEATURE_LINENUM_REGEXP = /^(.*?)((?::[\d]+)+)?$/;
+class PickleFilter {
+    constructor({ cwd, featurePaths, names, tagExpression, }) {
+        this.lineFilter = new PickleLineFilter(cwd, featurePaths);
+        this.nameFilter = new PickleNameFilter(names);
+        this.tagFilter = new PickleTagFilter(tagExpression);
+    }
+    matches({ gherkinDocument, pickle, }) {
+        return (this.lineFilter.matchesAnyLine({ gherkinDocument, pickle }) &&
+            this.nameFilter.matchesAnyName(pickle) &&
+            this.tagFilter.matchesAllTagExpressions(pickle));
+    }
+}
+exports.default = PickleFilter;
+class PickleLineFilter {
+    constructor(cwd, featurePaths = []) {
+        this.featureUriToLinesMapping = this.getFeatureUriToLinesMapping({
+            cwd,
+            featurePaths,
+        });
+    }
+    getFeatureUriToLinesMapping({ cwd, featurePaths, }) {
+        const mapping = {};
+        featurePaths.forEach((featurePath) => {
+            const match = FEATURE_LINENUM_REGEXP.exec(featurePath);
+            if ((0, value_checker_1.doesHaveValue)(match)) {
+                let uri = match[1];
+                if (path_1.default.isAbsolute(uri)) {
+                    uri = path_1.default.relative(cwd, uri);
+                }
+                else {
+                    uri = path_1.default.normalize(uri);
+                }
+                const linesExpression = match[2];
+                if ((0, value_checker_1.doesHaveValue)(linesExpression)) {
+                    if ((0, value_checker_1.doesNotHaveValue)(mapping[uri])) {
+                        mapping[uri] = [];
+                    }
+                    linesExpression
+                        .slice(1)
+                        .split(':')
+                        .forEach((line) => {
+                        mapping[uri].push(parseInt(line));
+                    });
+                }
+            }
+        });
+        return mapping;
+    }
+    matchesAnyLine({ gherkinDocument, pickle }) {
+        const uri = path_1.default.normalize(pickle.uri);
+        const linesToMatch = this.featureUriToLinesMapping[uri];
+        if ((0, value_checker_1.doesHaveValue)(linesToMatch)) {
+            const gherkinScenarioLocationMap = (0, gherkin_document_parser_1.getGherkinScenarioLocationMap)(gherkinDocument);
+            const pickleLines = new Set(pickle.astNodeIds.map((sourceId) => gherkinScenarioLocationMap[sourceId].line));
+            const linesIntersection = linesToMatch.filter((x) => pickleLines.has(x));
+            return linesIntersection.length > 0;
+        }
+        return true;
+    }
+}
+exports.PickleLineFilter = PickleLineFilter;
+class PickleNameFilter {
+    constructor(names = []) {
+        this.names = names;
+    }
+    matchesAnyName(pickle) {
+        if (this.names.length === 0) {
+            return true;
+        }
+        return this.names.some((name) => pickle.name.match(name));
+    }
+}
+exports.PickleNameFilter = PickleNameFilter;
+class PickleTagFilter {
+    constructor(tagExpression) {
+        if ((0, value_checker_1.doesHaveValue)(tagExpression) && tagExpression !== '') {
+            this.tagExpressionNode = (0, tag_expressions_1.default)(tagExpression);
+        }
+    }
+    matchesAllTagExpressions(pickle) {
+        if ((0, value_checker_1.doesNotHaveValue)(this.tagExpressionNode)) {
+            return true;
+        }
+        return this.tagExpressionNode.evaluate(pickle.tags.map((x) => x.name));
+    }
+}
+exports.PickleTagFilter = PickleTagFilter;
 //# sourceMappingURL=pickle_filter.js.map

package/lib/plugin/index.d.ts

@@ -1,2 +1,2 @@
-export * from './types';
-export * from './plugin_manager';
+export * from './types';
+export * from './plugin_manager';