@zohodesk/testinglibrary 0.0.4 → 0.0.5-exp.2

package/build/bdd-framework/snippets/index.js

@@ -0,0 +1,184 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.Snippets = void 0;
+var _regenerator = _interopRequireDefault(require("@babel/runtime/regenerator"));
+var _asyncToGenerator2 = _interopRequireDefault(require("@babel/runtime/helpers/asyncToGenerator"));
+var _classCallCheck2 = _interopRequireDefault(require("@babel/runtime/helpers/classCallCheck"));
+var _createClass2 = _interopRequireDefault(require("@babel/runtime/helpers/createClass"));
+var _defineProperty2 = _interopRequireDefault(require("@babel/runtime/helpers/defineProperty"));
+var _loadSnippetBuilder = require("../cucumber/loadSnippetBuilder");
+var _utils = require("../utils");
+var _defineStep = require("../stepDefinitions/defineStep");
+var _logger = require("../utils/logger");
+/**
+ * Generate and show snippets for undefined steps
+ */
+var Snippets = /*#__PURE__*/function (_printSnippetsAndExit, _createSnippetBuilder) {
+  function Snippets(files, runConfiguration, supportCodeLibrary) {
+    (0, _classCallCheck2["default"])(this, Snippets);
+    (0, _defineProperty2["default"])(this, "snippetBuilder", void 0);
+    (0, _defineProperty2["default"])(this, "bddBuiltInSyntax", false);
+    this.files = files;
+    this.runConfiguration = runConfiguration;
+    this.supportCodeLibrary = supportCodeLibrary;
+  }
+  (0, _createClass2["default"])(Snippets, [{
+    key: "printSnippetsAndExit",
+    value: function printSnippetsAndExit() {
+      return (_printSnippetsAndExit = _printSnippetsAndExit || (0, _asyncToGenerator2["default"])( /*#__PURE__*/_regenerator["default"].mark(function _callee() {
+        var snippets;
+        return _regenerator["default"].wrap(function _callee$(_context) {
+          while (1) switch (_context.prev = _context.next) {
+            case 0:
+              _context.next = 2;
+              return this.createSnippetBuilder();
+            case 2:
+              this.snippetBuilder = _context.sent;
+              snippets = this.getSnippets();
+              this.printHeader();
+              this.printSnippets(snippets);
+              this.printFooter(snippets);
+            case 7:
+            case "end":
+              return _context.stop();
+          }
+        }, _callee, this);
+      }))).apply(this, arguments);
+    }
+  }, {
+    key: "createSnippetBuilder",
+    value: function createSnippetBuilder() {
+      return (_createSnippetBuilder = _createSnippetBuilder || (0, _asyncToGenerator2["default"])( /*#__PURE__*/_regenerator["default"].mark(function _callee2() {
+        var snippetInterface, snippetSyntax;
+        return _regenerator["default"].wrap(function _callee2$(_context2) {
+          while (1) switch (_context2.prev = _context2.next) {
+            case 0:
+              snippetInterface = this.runConfiguration.formats.options.snippetInterface;
+              snippetSyntax = this.getSnippetSyntax();
+              return _context2.abrupt("return", (0, _loadSnippetBuilder.loadSnippetBuilder)(this.supportCodeLibrary, snippetInterface, snippetSyntax));
+            case 3:
+            case "end":
+              return _context2.stop();
+          }
+        }, _callee2, this);
+      }))).apply(this, arguments);
+    }
+  }, {
+    key: "getSnippetSyntax",
+    value: function getSnippetSyntax() {
+      var snippetSyntax = this.runConfiguration.formats.options.snippetSyntax;
+      if (!snippetSyntax && this.isPlaywrightStyle()) {
+        this.bddBuiltInSyntax = true;
+        return this.isDecorators() ? require.resolve('./snippetSyntaxDecorators.js') : this.isTypeScript() ? require.resolve('./snippetSyntaxTs.js') : require.resolve('./snippetSyntax.js');
+      } else {
+        return snippetSyntax;
+      }
+    }
+  }, {
+    key: "getSnippets",
+    value: function getSnippets() {
+      var _this = this;
+      var snippetsSet = new Set();
+      var snippets = [];
+      this.files.forEach(function (file) {
+        file.undefinedSteps.forEach(function (undefinedStep) {
+          var _this$getSnippet = _this.getSnippet(file, snippets.length + 1, undefinedStep),
+            snippet = _this$getSnippet.snippet,
+            snippetWithLocation = _this$getSnippet.snippetWithLocation;
+          if (!snippetsSet.has(snippet)) {
+            snippetsSet.add(snippet);
+            snippets.push(snippetWithLocation);
+          }
+        });
+      });
+      return snippets;
+    }
+  }, {
+    key: "getSnippet",
+    value: function getSnippet(file, index, undefinedStep) {
+      var snippet = this.snippetBuilder.build({
+        keywordType: undefinedStep.keywordType,
+        pickleStep: undefinedStep.pickleStep
+      });
+      var _undefinedStep$step$l = undefinedStep.step.location,
+        line = _undefinedStep$step$l.line,
+        column = _undefinedStep$step$l.column;
+      var snippetWithLocation = ["// ".concat(index, ". Missing step definition for \"").concat(file.sourceFile, ":").concat(line, ":").concat(column, "\""), snippet].join('\n');
+      return {
+        snippet: snippet,
+        snippetWithLocation: snippetWithLocation
+      };
+    }
+  }, {
+    key: "isTypeScript",
+    value: function isTypeScript() {
+      var _this$supportCodeLibr = this.supportCodeLibrary.originalCoordinates,
+        requirePaths = _this$supportCodeLibr.requirePaths,
+        importPaths = _this$supportCodeLibr.importPaths;
+      return requirePaths.some(function (p) {
+        return p.endsWith('.ts');
+      }) || importPaths.some(function (p) {
+        return p.endsWith('.ts');
+      });
+    }
+  }, {
+    key: "isPlaywrightStyle",
+    value: function isPlaywrightStyle() {
+      var stepDefinitions = this.supportCodeLibrary.stepDefinitions;
+      return stepDefinitions.length > 0 ? stepDefinitions.some(function (step) {
+        return (0, _defineStep.isPlaywrightStyle)(step);
+      }) : true;
+    }
+  }, {
+    key: "isDecorators",
+    value: function isDecorators() {
+      var stepDefinitions = this.supportCodeLibrary.stepDefinitions;
+      var decoratorSteps = stepDefinitions.filter(function (step) {
+        var _getStepConfig;
+        return (_getStepConfig = (0, _defineStep.getStepConfig)(step)) === null || _getStepConfig === void 0 ? void 0 : _getStepConfig.isDecorator;
+      });
+      return decoratorSteps.length > stepDefinitions.length / 2;
+    }
+  }, {
+    key: "printHeader",
+    value: function printHeader() {
+      var lines = ["Missing steps found. Use snippets below:"];
+      if (this.bddBuiltInSyntax) {
+        if (this.isDecorators()) {
+          // TODO: For Decorators support
+          lines.push("import { Fixture, Given, When, Then } from 'playwright-bdd/decorators';\n");
+        } else {
+          lines.push("import { createBdd } from '@zohodesk/testinglibrary';", "const { Given, When, Then } = createBdd();\n");
+        }
+      } else {
+        lines.push("import { Given, When, Then } from '@cucumber/cucumber';\n");
+      }
+      _logger.logger.error(lines.join('\n\n'));
+    }
+  }, {
+    key: "printSnippets",
+    value: function printSnippets(snippets) {
+      _logger.logger.error(snippets.concat(['']).join('\n\n'));
+    }
+  }, {
+    key: "printFooter",
+    value: function printFooter(snippets) {
+      (0, _utils.exitWithMessage)("Missing step definitions (".concat(snippets.length, ")."), 'Use snippets above to create them.', this.getWarnOnZeroScannedFiles());
+    }
+  }, {
+    key: "getWarnOnZeroScannedFiles",
+    value: function getWarnOnZeroScannedFiles() {
+      var _this$supportCodeLibr2 = this.supportCodeLibrary.originalCoordinates,
+        requirePaths = _this$supportCodeLibr2.requirePaths,
+        importPaths = _this$supportCodeLibr2.importPaths;
+      var scannedFilesCount = requirePaths.length + importPaths.length;
+      return scannedFilesCount === 0 && !this.isDecorators() ? "\nNote that 0 step definition files found, check the config." : '';
+    }
+  }]);
+  return Snippets;
+}();
+exports.Snippets = Snippets;

package/build/bdd-framework/snippets/snippetSyntax.js

@@ -0,0 +1,61 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports["default"] = void 0;
+var _toConsumableArray2 = _interopRequireDefault(require("@babel/runtime/helpers/toConsumableArray"));
+var _classCallCheck2 = _interopRequireDefault(require("@babel/runtime/helpers/classCallCheck"));
+var _createClass2 = _interopRequireDefault(require("@babel/runtime/helpers/createClass"));
+var _defineProperty2 = _interopRequireDefault(require("@babel/runtime/helpers/defineProperty"));
+/**
+ * Playwright-style snippet syntax.
+ *
+ * See: https://github.com/cucumber/cucumber-js/blob/main/docs/custom_snippet_syntaxes.md
+ */
+// todo: custom cucumber parameters
+// See: https://github.com/cucumber/cucumber-expressions#custom-parameter-types
+var _default = /*#__PURE__*/function () {
+  function _default() {
+    (0, _classCallCheck2["default"])(this, _default);
+    (0, _defineProperty2["default"])(this, "isTypescript", false);
+  }
+  (0, _createClass2["default"])(_default, [{
+    key: "build",
+    value: function build(_ref) {
+      var _this = this;
+      var generatedExpressions = _ref.generatedExpressions,
+        functionName = _ref.functionName,
+        stepParameterNames = _ref.stepParameterNames;
+      // Always take only first generatedExpression
+      // Other expressions are for int/float combinations
+      var generatedExpression = generatedExpressions[0];
+      var expressionParameters = generatedExpression.parameterNames.map(function (name, i) {
+        var argName = "arg".concat(i === 0 ? '' : i);
+        var type = name.startsWith('string') ? 'string' : 'number';
+        return _this.isTypescript ? "".concat(argName, ": ").concat(type) : argName;
+      });
+      var stepParameters = stepParameterNames.map(function (argName) {
+        var type = argName === 'dataTable' ? 'DataTable' : 'string';
+        return _this.isTypescript ? "".concat(argName, ": ").concat(type) : argName;
+      });
+      var allParameterNames = ['{}'].concat((0, _toConsumableArray2["default"])(expressionParameters), (0, _toConsumableArray2["default"])(stepParameters));
+      var functionSignature = "".concat(functionName, "('").concat(this.escapeSpecialCharacters(generatedExpression), "', async (").concat(allParameterNames.join(', '), ") => {");
+      return [functionSignature, // prettier-ignore
+      "  // ...", '});'].join('\n');
+    }
+  }, {
+    key: "escapeSpecialCharacters",
+    value: function escapeSpecialCharacters(generatedExpression) {
+      var source = generatedExpression.source;
+      // double up any backslashes because we're in a javascript string
+      source = source.replace(/\\/g, '\\\\');
+      // escape any single quotes because that's our quote delimiter
+      source = source.replace(/'/g, "\\'");
+      return source;
+    }
+  }]);
+  return _default;
+}();
+exports["default"] = _default;

package/build/bdd-framework/snippets/snippetSyntaxDecorators.js

@@ -0,0 +1,42 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports["default"] = void 0;
+var _classCallCheck2 = _interopRequireDefault(require("@babel/runtime/helpers/classCallCheck"));
+var _createClass2 = _interopRequireDefault(require("@babel/runtime/helpers/createClass"));
+/**
+ * Playwright-style snippet syntax for decorators.
+ *
+ * See: https://github.com/cucumber/cucumber-js/blob/main/docs/custom_snippet_syntaxes.md
+ */
+var _default = /*#__PURE__*/function () {
+  function _default() {
+    (0, _classCallCheck2["default"])(this, _default);
+  }
+  (0, _createClass2["default"])(_default, [{
+    key: "build",
+    value: function build(_ref) {
+      var generatedExpressions = _ref.generatedExpressions,
+        functionName = _ref.functionName;
+      // Always take only first generatedExpression
+      // Other expressions are for int/float combinations
+      var generatedExpression = generatedExpressions[0];
+      return "@".concat(functionName, "('").concat(this.escapeSpecialCharacters(generatedExpression), "')");
+    }
+  }, {
+    key: "escapeSpecialCharacters",
+    value: function escapeSpecialCharacters(generatedExpression) {
+      var source = generatedExpression.source;
+      // double up any backslashes because we're in a javascript string
+      source = source.replace(/\\/g, '\\\\');
+      // escape any single quotes because that's our quote delimiter
+      source = source.replace(/'/g, "\\'");
+      return source;
+    }
+  }]);
+  return _default;
+}();
+exports["default"] = _default;

package/build/bdd-framework/snippets/snippetSyntaxTs.js

@@ -0,0 +1,37 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports["default"] = void 0;
+var _createClass2 = _interopRequireDefault(require("@babel/runtime/helpers/createClass"));
+var _classCallCheck2 = _interopRequireDefault(require("@babel/runtime/helpers/classCallCheck"));
+var _assertThisInitialized2 = _interopRequireDefault(require("@babel/runtime/helpers/assertThisInitialized"));
+var _inherits2 = _interopRequireDefault(require("@babel/runtime/helpers/inherits"));
+var _possibleConstructorReturn2 = _interopRequireDefault(require("@babel/runtime/helpers/possibleConstructorReturn"));
+var _getPrototypeOf2 = _interopRequireDefault(require("@babel/runtime/helpers/getPrototypeOf"));
+var _defineProperty2 = _interopRequireDefault(require("@babel/runtime/helpers/defineProperty"));
+var _snippetSyntax = _interopRequireDefault(require("./snippetSyntax"));
+function _createSuper(Derived) { var hasNativeReflectConstruct = _isNativeReflectConstruct(); return function _createSuperInternal() { var Super = (0, _getPrototypeOf2["default"])(Derived), result; if (hasNativeReflectConstruct) { var NewTarget = (0, _getPrototypeOf2["default"])(this).constructor; result = Reflect.construct(Super, arguments, NewTarget); } else { result = Super.apply(this, arguments); } return (0, _possibleConstructorReturn2["default"])(this, result); }; }
+function _isNativeReflectConstruct() { if (typeof Reflect === "undefined" || !Reflect.construct) return false; if (Reflect.construct.sham) return false; if (typeof Proxy === "function") return true; try { Boolean.prototype.valueOf.call(Reflect.construct(Boolean, [], function () {})); return true; } catch (e) { return false; } } /**
+                                                                                                                                                                                                                                                                                                                                           * Playwright-style snippet syntax for typescript.
+                                                                                                                                                                                                                                                                                                                                           * Important to use separate file as it's simplest way to distinguish between js/ts
+                                                                                                                                                                                                                                                                                                                                           * without hooking into cucumber machinery.
+                                                                                                                                                                                                                                                                                                                                           */
+var _default = /*#__PURE__*/function (_SnippetSyntax) {
+  (0, _inherits2["default"])(_default, _SnippetSyntax);
+  var _super = _createSuper(_default);
+  function _default() {
+    var _this;
+    (0, _classCallCheck2["default"])(this, _default);
+    for (var _len = arguments.length, args = new Array(_len), _key = 0; _key < _len; _key++) {
+      args[_key] = arguments[_key];
+    }
+    _this = _super.call.apply(_super, [this].concat(args));
+    (0, _defineProperty2["default"])((0, _assertThisInitialized2["default"])(_this), "isTypescript", true);
+    return _this;
+  }
+  return (0, _createClass2["default"])(_default);
+}(_snippetSyntax["default"]);
+exports["default"] = _default;

package/build/bdd-framework/stepDefinitions/createBdd.js

@@ -0,0 +1,54 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.createBdd = createBdd;
+exports.extractFixtureNames = extractFixtureNames;
+var _fixtureParameterNames = require("../playwright/fixtureParameterNames");
+var _utils = require("../utils");
+var _bddFixtures = require("../run/bddFixtures");
+var _testTypeImpl = require("../playwright/testTypeImpl");
+var _defineStep = require("./defineStep");
+/**
+ * Stuff related to writing steps in Playwright-style.
+ */
+
+/* eslint-disable @typescript-eslint/no-explicit-any, @typescript-eslint/ban-types */
+
+function createBdd(customTest) {
+  var hasCustomTest = isCustomTest(customTest);
+  var Given = defineStepCtor('Given', hasCustomTest);
+  var When = defineStepCtor('When', hasCustomTest);
+  var Then = defineStepCtor('Then', hasCustomTest);
+  var Step = defineStepCtor('Unknown', hasCustomTest);
+  return {
+    Given: Given,
+    When: When,
+    Then: Then,
+    Step: Step
+  };
+}
+function defineStepCtor(keyword, hasCustomTest) {
+  return function (pattern, fn) {
+    (0, _defineStep.defineStep)({
+      keyword: keyword,
+      pattern: pattern,
+      fn: fn,
+      hasCustomTest: hasCustomTest,
+      isDecorator: false
+    });
+  };
+}
+function extractFixtureNames(fn) {
+  return (0, _fixtureParameterNames.fixtureParameterNames)(fn).filter(function (name) {
+    return !(0, _bddFixtures.isBddAutoInjectFixture)(name);
+  });
+}
+function isCustomTest(customTest) {
+  var isCustomTest = Boolean(customTest && customTest !== _bddFixtures.test);
+  if (isCustomTest && customTest && !(0, _testTypeImpl.isParentChildTest)(_bddFixtures.test, customTest)) {
+    (0, _utils.exitWithMessage)("createBdd() should use test extended from \"playwright-bdd\"");
+  }
+  return isCustomTest;
+}

package/build/bdd-framework/stepDefinitions/createDecorators.js

@@ -0,0 +1,123 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.Fixture = Fixture;
+exports.appendDecoratorSteps = appendDecoratorSteps;
+exports.createStepDecorator = createStepDecorator;
+exports.getPomNodeByFixtureName = getPomNodeByFixtureName;
+var _bddFixtures = require("../run/bddFixtures");
+var _defineStep = require("./defineStep");
+var _buildStepDefinition = require("../cucumber/buildStepDefinition");
+function _createForOfIteratorHelper(o, allowArrayLike) { var it = typeof Symbol !== "undefined" && o[Symbol.iterator] || o["@@iterator"]; if (!it) { if (Array.isArray(o) || (it = _unsupportedIterableToArray(o)) || allowArrayLike && o && typeof o.length === "number") { if (it) o = it; var i = 0; var F = function F() {}; return { s: F, n: function n() { if (i >= o.length) return { done: true }; return { done: false, value: o[i++] }; }, e: function e(_e) { throw _e; }, f: F }; } throw new TypeError("Invalid attempt to iterate non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method."); } var normalCompletion = true, didErr = false, err; return { s: function s() { it = it.call(o); }, n: function n() { var step = it.next(); normalCompletion = step.done; return step; }, e: function e(_e2) { didErr = true; err = _e2; }, f: function f() { try { if (!normalCompletion && it["return"] != null) it["return"](); } finally { if (didErr) throw err; } } }; }
+function _unsupportedIterableToArray(o, minLen) { if (!o) return; if (typeof o === "string") return _arrayLikeToArray(o, minLen); var n = Object.prototype.toString.call(o).slice(8, -1); if (n === "Object" && o.constructor) n = o.constructor.name; if (n === "Map" || n === "Set") return Array.from(o); if (n === "Arguments" || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(n)) return _arrayLikeToArray(o, minLen); }
+function _arrayLikeToArray(arr, len) { if (len == null || len > arr.length) len = arr.length; for (var i = 0, arr2 = new Array(len); i < len; i++) arr2[i] = arr[i]; return arr2; } /**
+                                                                                                                                                                                     * Define steps via decorators.
+                                                                                                                                                                                     */ /* eslint-disable @typescript-eslint/ban-types */
+var pomGraph = new Map();
+var decoratedStepSymbol = Symbol('decoratedStep');
+var decoratedSteps = new Set();
+function Fixture(fixtureName) {
+  // context parameter is required for decorator by TS even though it's not used
+  return function (Ctor, _context) {
+    createPomNode(Ctor, fixtureName);
+  };
+}
+function createStepDecorator(keyword) {
+  return function (pattern) {
+    // context parameter is required for decorator by TS even though it's not used
+    return function (method, _context) {
+      method[decoratedStepSymbol] = {
+        keyword: keyword,
+        pattern: pattern,
+        fn: method,
+        hasCustomTest: true,
+        isDecorator: true
+      };
+    };
+  };
+}
+function appendDecoratorSteps(supportCodeLibrary) {
+  decoratedSteps.forEach(function (stepConfig) {
+    var keyword = stepConfig.keyword,
+      pattern = stepConfig.pattern,
+      fn = stepConfig.fn;
+    stepConfig.fn = function (fixturesArg) {
+      var fixture = getFirstNonAutoInjectFixture(fixturesArg, stepConfig);
+      for (var _len = arguments.length, args = new Array(_len > 1 ? _len - 1 : 0), _key = 1; _key < _len; _key++) {
+        args[_key - 1] = arguments[_key];
+      }
+      return fn.call.apply(fn, [fixture].concat(args));
+    };
+    var code = (0, _defineStep.buildCucumberStepFn)(stepConfig);
+    var stepDefinition = (0, _buildStepDefinition.buildStepDefinition)({
+      keyword: keyword,
+      pattern: pattern,
+      code: code,
+      line: 0,
+      // not used in playwright-bdd
+      options: {},
+      // not used in playwright-bdd
+      uri: '' // not used in playwright-bdd
+    }, supportCodeLibrary);
+    supportCodeLibrary.stepDefinitions.push(stepDefinition);
+  });
+  decoratedSteps.clear();
+  // todo: fill supportCodeLibrary.originalCoordinates as it is used in snippets?
+}
+
+function getPomNodeByFixtureName(fixtureName) {
+  var _iterator = _createForOfIteratorHelper(pomGraph.values()),
+    _step;
+  try {
+    for (_iterator.s(); !(_step = _iterator.n()).done;) {
+      var pomNode = _step.value;
+      if (pomNode.fixtureName === fixtureName) return pomNode;
+    }
+  } catch (err) {
+    _iterator.e(err);
+  } finally {
+    _iterator.f();
+  }
+}
+function createPomNode(Ctor, fixtureName) {
+  var pomNode = {
+    fixtureName: fixtureName,
+    children: new Set()
+  };
+  pomGraph.set(Ctor, pomNode);
+  getDecoratedSteps(Ctor).forEach(function (stepConfig) {
+    stepConfig.pomNode = pomNode;
+    decoratedSteps.add(stepConfig);
+  });
+  var parentCtor = Object.getPrototypeOf(Ctor);
+  if (!parentCtor) return;
+  var parentPomNode = pomGraph.get(parentCtor) || createPomNode(parentCtor, '');
+  parentPomNode === null || parentPomNode === void 0 || parentPomNode.children.add(pomNode);
+  return pomNode;
+}
+function getDecoratedSteps(Ctor) {
+  if (!(Ctor !== null && Ctor !== void 0 && Ctor.prototype)) return [];
+  var propertyDescriptors = Object.getOwnPropertyDescriptors(Ctor.prototype);
+  return Object.keys(propertyDescriptors)
+  // filter out getters / setters
+  .filter(function (methodName) {
+    return typeof propertyDescriptors[methodName].value === 'function';
+  }).map(function (methodName) {
+    return propertyDescriptors[methodName].value[decoratedStepSymbol];
+  }).filter(Boolean);
+}
+function getFirstNonAutoInjectFixture(fixturesArg, stepConfig) {
+  // there should be exatcly one suitable fixture in fixturesArg
+  var fixtureNames = Object.keys(fixturesArg).filter(function (fixtureName) {
+    return !(0, _bddFixtures.isBddAutoInjectFixture)(fixtureName);
+  });
+  if (fixtureNames.length === 0) {
+    throw new Error("No suitable fixtures found for decorator step \"".concat(stepConfig.pattern, "\""));
+  }
+  if (fixtureNames.length > 1) {
+    throw new Error("Several suitable fixtures found for decorator step \"".concat(stepConfig.pattern, "\""));
+  }
+  return fixturesArg[fixtureNames[0]];
+}

package/build/bdd-framework/stepDefinitions/defineStep.js

@@ -0,0 +1,64 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.buildCucumberStepFn = buildCucumberStepFn;
+exports.defineStep = defineStep;
+exports.getStepConfig = getStepConfig;
+exports.isPlaywrightStyle = isPlaywrightStyle;
+var _cucumber = require("@cucumber/cucumber");
+var _utils = require("../utils");
+function defineStep(stepConfig) {
+  var keyword = stepConfig.keyword,
+    pattern = stepConfig.pattern;
+  var cucumberDefineStepFn = getCucumberDefineStepFn(keyword);
+  var code = buildCucumberStepFn(stepConfig);
+  try {
+    cucumberDefineStepFn(pattern, code);
+  } catch (e) {
+    // todo: detect that this is import from test file
+    // and skip/delay registering cucumber steps until cucumber is loaded
+    var isMissingCucumber = /Cucumber that isn't running/i.test(e.message);
+    if (isMissingCucumber) {
+      (0, _utils.exitWithMessage)("Option \"importTestFrom\" should point to separate file without step definitions", "(e.g. without calls of Given, When, Then)");
+    } else {
+      throw e;
+    }
+  }
+}
+function buildCucumberStepFn(stepConfig) {
+  // eslint-disable-next-line @typescript-eslint/no-explicit-any
+  var code = function code() {
+    var _stepConfig$fn;
+    var fixturesArg = Object.assign({}, this.customFixtures, {
+      $testInfo: this.testInfo,
+      $test: this.test,
+      $tags: this.tags
+    });
+    for (var _len = arguments.length, args = new Array(_len), _key = 0; _key < _len; _key++) {
+      args[_key] = arguments[_key];
+    }
+    return (_stepConfig$fn = stepConfig.fn).call.apply(_stepConfig$fn, [this, fixturesArg].concat(args));
+  };
+  code.stepConfig = stepConfig;
+  return code;
+}
+function getStepConfig(step) {
+  return step.code.stepConfig;
+}
+function isPlaywrightStyle(step) {
+  return Boolean(getStepConfig(step));
+}
+function getCucumberDefineStepFn(keyword) {
+  switch (keyword) {
+    case 'Given':
+      return _cucumber.Given;
+    case 'When':
+      return _cucumber.When;
+    case 'Then':
+      return _cucumber.Then;
+    default:
+      return _cucumber.defineStep;
+  }
+}

package/build/bdd-framework/utils/index.js

@@ -0,0 +1,59 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.exitWithMessage = exitWithMessage;
+exports.getPackageVersion = getPackageVersion;
+exports.getSymbolByName = getSymbolByName;
+exports.removeDuplicates = removeDuplicates;
+exports.resolvePackageRoot = resolvePackageRoot;
+exports.template = template;
+var _toConsumableArray2 = _interopRequireDefault(require("@babel/runtime/helpers/toConsumableArray"));
+var _fs = _interopRequireDefault(require("fs"));
+var _path = _interopRequireDefault(require("path"));
+var _logger = require("./logger");
+function exitWithMessage() {
+  for (var _len = arguments.length, messages = new Array(_len), _key = 0; _key < _len; _key++) {
+    messages[_key] = arguments[_key];
+  }
+  _logger.logger.error.apply(_logger.logger, ['ERROR:'].concat(messages));
+  process.exit(1);
+}
+
+// See: https://stackoverflow.com/questions/50453640/how-can-i-get-the-value-of-a-symbol-property
+function getSymbolByName(target, name) {
+  var ownKeys = Reflect.ownKeys(target);
+  var symbol = ownKeys.find(function (key) {
+    return key.toString() === "Symbol(".concat(name, ")");
+  });
+  if (!symbol) {
+    throw new Error("Symbol \"".concat(name, "\" not found in target. ownKeys: ").concat(ownKeys));
+  }
+  return symbol;
+}
+
+/**
+ * Inserts params into template.
+ * Params defined as <param>.
+ */
+function template(t) {
+  var params = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {};
+  return t.replace(/<(.+?)>/g, function (match, key) {
+    return params[key] !== undefined ? String(params[key]) : match;
+  });
+}
+function removeDuplicates(arr) {
+  return (0, _toConsumableArray2["default"])(new Set(arr));
+}
+function resolvePackageRoot(packageName) {
+  var packageJsonPath = require.resolve("".concat(packageName, "/package.json"));
+  return _path["default"].dirname(packageJsonPath);
+}
+function getPackageVersion(packageName) {
+  var packageRoot = resolvePackageRoot(packageName);
+  var packageJsonPath = _path["default"].join(packageRoot, 'package.json');
+  var packageJson = JSON.parse(_fs["default"].readFileSync(packageJsonPath, 'utf8'));
+  return packageJson.version || '';
+}