@zohodesk/testinglibrary 0.0.4 → 0.0.5-exp.2

package/build/bdd-framework/gen/testFile.js

@@ -0,0 +1,422 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.TestFile = 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"));
+var _fs = _interopRequireDefault(require("fs"));
+var _path = _interopRequireDefault(require("path"));
+var _formatter = require("./formatter");
+var _i18n = require("./i18n");
+var _loadSteps = require("../cucumber/loadSteps");
+var _createBdd = require("../stepDefinitions/createBdd");
+var _index = require("@cucumber/cucumber/lib/formatter/helpers/index");
+var _utils = require("../utils");
+var _defineStep = require("../stepDefinitions/defineStep");
+var _poms = require("./poms");
+var _testNode = require("./testNode");
+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; } /**
+                                                                                                                                                                                     * Generate test code.
+                                                                                                                                                                                     */ /* eslint-disable max-lines, max-params */
+var TestFile = /*#__PURE__*/function () {
+  function TestFile(options) {
+    (0, _classCallCheck2["default"])(this, TestFile);
+    (0, _defineProperty2["default"])(this, "lines", []);
+    (0, _defineProperty2["default"])(this, "i18nKeywordsMap", void 0);
+    (0, _defineProperty2["default"])(this, "formatter", void 0);
+    (0, _defineProperty2["default"])(this, "testNodes", []);
+    (0, _defineProperty2["default"])(this, "hasCustomTest", false);
+    (0, _defineProperty2["default"])(this, "undefinedSteps", []);
+    this.options = options;
+    this.formatter = new _formatter.Formatter(options.config);
+  }
+  (0, _createClass2["default"])(TestFile, [{
+    key: "sourceFile",
+    get: function get() {
+      var uri = this.options.doc.uri;
+      if (!uri) throw new Error("Document without uri");
+      return uri;
+    }
+  }, {
+    key: "content",
+    get: function get() {
+      return this.lines.join('\n');
+    }
+  }, {
+    key: "language",
+    get: function get() {
+      var _this$options$doc$fea;
+      return ((_this$options$doc$fea = this.options.doc.feature) === null || _this$options$doc$fea === void 0 ? void 0 : _this$options$doc$fea.language) || 'en';
+    }
+  }, {
+    key: "config",
+    get: function get() {
+      return this.options.config;
+    }
+  }, {
+    key: "outputPath",
+    get: function get() {
+      return this.options.outputPath;
+    }
+  }, {
+    key: "build",
+    value: function build() {
+      this.loadI18nKeywords();
+      this.lines = [].concat((0, _toConsumableArray2["default"])(this.getFileHeader()), (0, _toConsumableArray2["default"])(this.getRootSuite()), (0, _toConsumableArray2["default"])(this.getFileFixtures()));
+      return this;
+    }
+  }, {
+    key: "save",
+    value: function save() {
+      var dir = _path["default"].dirname(this.outputPath);
+      if (!_fs["default"].existsSync(dir)) _fs["default"].mkdirSync(dir, {
+        recursive: true
+      });
+      _fs["default"].writeFileSync(this.outputPath, this.content);
+    }
+  }, {
+    key: "getFileHeader",
+    value: function getFileHeader() {
+      var importTestFrom = this.getRelativeImportTestFrom();
+      return this.formatter.fileHeader(this.sourceFile, importTestFrom);
+    }
+  }, {
+    key: "loadI18nKeywords",
+    value: function loadI18nKeywords() {
+      if (this.language !== 'en') {
+        this.i18nKeywordsMap = (0, _i18n.getKeywordsMap)(this.language);
+      }
+    }
+  }, {
+    key: "getRelativeImportTestFrom",
+    value: function getRelativeImportTestFrom() {
+      var importTestFrom = this.config.importTestFrom;
+      if (!importTestFrom) return;
+      var file = importTestFrom.file,
+        varName = importTestFrom.varName;
+      var dir = _path["default"].dirname(this.outputPath);
+      return {
+        file: _path["default"].relative(dir, file),
+        varName: varName
+      };
+    }
+  }, {
+    key: "getFileFixtures",
+    value: function getFileFixtures() {
+      return this.formatter.useFixtures([].concat((0, _toConsumableArray2["default"])(this.formatter.testFixture()), (0, _toConsumableArray2["default"])(this.formatter.tagsFixture(this.testNodes))));
+    }
+  }, {
+    key: "getRootSuite",
+    value: function getRootSuite() {
+      var feature = this.options.doc.feature;
+      if (!feature) throw new Error("Document without feature.");
+      return this.getSuite(feature);
+    }
+
+    /**
+     * Generate test.describe suite for root Feature or Rule
+     */
+  }, {
+    key: "getSuite",
+    value: function getSuite(feature, parent) {
+      var _this = this;
+      var node = new _testNode.TestNode(feature, parent);
+      var lines = [];
+      feature.children.forEach(function (child) {
+        return lines.push.apply(lines, (0, _toConsumableArray2["default"])(_this.getSuiteChild(child, node)));
+      });
+      return this.formatter.suite(node, lines);
+    }
+  }, {
+    key: "getSuiteChild",
+    value: function getSuiteChild(child, parent) {
+      if ('rule' in child && child.rule) return this.getSuite(child.rule, parent);
+      if (child.background) return this.getBeforeEach(child.background);
+      if (child.scenario) return this.getScenarioLines(child.scenario, parent);
+      throw new Error("Empty child: ".concat(JSON.stringify(child)));
+    }
+  }, {
+    key: "getScenarioLines",
+    value: function getScenarioLines(scenario, parent) {
+      return isOutline(scenario) ? this.getOutlineSuite(scenario, parent) : this.getTest(scenario, parent);
+    }
+
+    /**
+     * Generate test.beforeEach for Background
+     */
+  }, {
+    key: "getBeforeEach",
+    value: function getBeforeEach(bg) {
+      var _this$getSteps = this.getSteps(bg),
+        fixtures = _this$getSteps.fixtures,
+        lines = _this$getSteps.lines;
+      return this.formatter.beforeEach(fixtures, lines);
+    }
+
+    /**
+     * Generate test.describe suite for Scenario Outline
+     */
+  }, {
+    key: "getOutlineSuite",
+    value: function getOutlineSuite(scenario, parent) {
+      var _this2 = this;
+      var node = new _testNode.TestNode(scenario, parent);
+      var lines = [];
+      var exampleIndex = 0;
+      scenario.examples.forEach(function (examples) {
+        var titleFormat = _this2.getExamplesTitleFormat(examples);
+        examples.tableBody.forEach(function (exampleRow) {
+          var testTitle = _this2.getOutlineTestTitle(titleFormat, examples, exampleRow, ++exampleIndex);
+          var testLines = _this2.getOutlineTest(scenario, examples, exampleRow, testTitle, node);
+          lines.push.apply(lines, (0, _toConsumableArray2["default"])(testLines));
+        });
+      });
+      return this.formatter.suite(node, lines);
+    }
+
+    /**
+     * Generate test from Examples row of Scenario Outline
+     */
+    // eslint-disable-next-line max-params
+  }, {
+    key: "getOutlineTest",
+    value: function getOutlineTest(scenario, examples, exampleRow, title, parent) {
+      var node = new _testNode.TestNode({
+        name: title,
+        tags: examples.tags
+      }, parent);
+      if (this.skipByTagsExpression(node)) return [];
+      this.testNodes.push(node);
+      var _this$getSteps2 = this.getSteps(scenario, node.ownTags, exampleRow.id),
+        fixtures = _this$getSteps2.fixtures,
+        lines = _this$getSteps2.lines;
+      return this.formatter.test(node, fixtures, lines);
+    }
+
+    /**
+     * Generate test from Scenario
+     */
+  }, {
+    key: "getTest",
+    value: function getTest(scenario, parent) {
+      var node = new _testNode.TestNode(scenario, parent);
+      if (this.skipByTagsExpression(node)) return [];
+      this.testNodes.push(node);
+      var _this$getSteps3 = this.getSteps(scenario, node.ownTags),
+        fixtures = _this$getSteps3.fixtures,
+        lines = _this$getSteps3.lines;
+      return this.formatter.test(node, fixtures, lines);
+    }
+
+    /**
+     * Generate test steps
+     */
+  }, {
+    key: "getSteps",
+    value: function getSteps(scenario, ownTestTags, outlineExampleRowId) {
+      var _this3 = this;
+      var testFixtureNames = new Set();
+      var usedPoms = new _poms.POMS();
+      var decoratorSteps = [];
+      var previousKeywordType = undefined;
+      var lines = scenario.steps.map(function (step, index) {
+        var _this3$getStep = _this3.getStep(step, previousKeywordType, outlineExampleRowId),
+          keyword = _this3$getStep.keyword,
+          keywordType = _this3$getStep.keywordType,
+          stepFixtureNames = _this3$getStep.fixtureNames,
+          line = _this3$getStep.line,
+          pickleStep = _this3$getStep.pickleStep,
+          stepConfig = _this3$getStep.stepConfig;
+        previousKeywordType = keywordType;
+        testFixtureNames.add(keyword);
+        stepFixtureNames.forEach(function (fixtureName) {
+          return testFixtureNames.add(fixtureName);
+        });
+        if (!line && stepConfig !== null && stepConfig !== void 0 && stepConfig.pomNode) {
+          usedPoms.add(stepConfig.pomNode);
+          decoratorSteps.push({
+            index: index,
+            keyword: keyword,
+            pickleStep: pickleStep,
+            pomNode: stepConfig.pomNode
+          });
+        }
+        return line;
+      });
+      if (decoratorSteps.length) {
+        testFixtureNames.forEach(function (fixtureName) {
+          return usedPoms.addByFixtureName(fixtureName);
+        });
+        ownTestTags === null || ownTestTags === void 0 || ownTestTags.forEach(function (tag) {
+          return usedPoms.addByTag(tag);
+        });
+        decoratorSteps.forEach(function (step) {
+          var _this3$getDecoratorSt = _this3.getDecoratorStep(step, usedPoms),
+            line = _this3$getDecoratorSt.line,
+            fixtureNames = _this3$getDecoratorSt.fixtureNames;
+          lines[step.index] = line;
+          fixtureNames.forEach(function (fixtureName) {
+            return testFixtureNames.add(fixtureName);
+          });
+        });
+      }
+      return {
+        fixtures: testFixtureNames,
+        lines: lines
+      };
+    }
+
+    /**
+     * Generate step for Given, When, Then
+     */
+    // eslint-disable-next-line max-statements, complexity
+  }, {
+    key: "getStep",
+    value: function getStep(step, previousKeywordType, outlineExampleRowId) {
+      var pickleStep = this.getPickleStep(step, outlineExampleRowId);
+      var stepDefinition = (0, _loadSteps.findStepDefinition)(this.options.supportCodeLibrary, pickleStep.text, this.sourceFile);
+      var keywordType = (0, _index.getStepKeywordType)({
+        keyword: step.keyword,
+        language: this.language,
+        previousKeywordType: previousKeywordType
+      });
+      var keyword = this.getStepKeyword(step);
+      if (!stepDefinition) {
+        this.undefinedSteps.push({
+          keywordType: keywordType,
+          step: step,
+          pickleStep: pickleStep
+        });
+        return this.getMissingStep(keyword, keywordType, pickleStep);
+      }
+      // for cucumber-style stepConfig is undefined
+      var stepConfig = (0, _defineStep.getStepConfig)(stepDefinition);
+      if (stepConfig !== null && stepConfig !== void 0 && stepConfig.hasCustomTest) this.hasCustomTest = true;
+      // for cucumber-style transform Given/When/Then -> Given_/When_/Then_
+      // to use fixtures with own bddWorld (containing fixtures)
+      if (!(0, _defineStep.isPlaywrightStyle)(stepDefinition)) keyword = "".concat(keyword, "_");
+      // for decorator steps fixtures defined later in second pass
+      var fixtureNames = stepConfig !== null && stepConfig !== void 0 && stepConfig.isDecorator ? [] : (0, _createBdd.extractFixtureNames)(stepConfig === null || stepConfig === void 0 ? void 0 : stepConfig.fn);
+      var line = stepConfig !== null && stepConfig !== void 0 && stepConfig.isDecorator ? '' : this.formatter.step(keyword, pickleStep.text, pickleStep.argument, fixtureNames);
+      return {
+        keyword: keyword,
+        keywordType: keywordType,
+        fixtureNames: fixtureNames,
+        line: line,
+        pickleStep: pickleStep,
+        stepConfig: stepConfig
+      };
+    }
+  }, {
+    key: "getMissingStep",
+    value: function getMissingStep(keyword, keywordType, pickleStep) {
+      return {
+        keyword: keyword,
+        keywordType: keywordType,
+        fixtureNames: [],
+        line: this.formatter.missingStep(keyword, pickleStep.text),
+        pickleStep: pickleStep,
+        stepConfig: undefined
+      };
+    }
+  }, {
+    key: "getPickleStep",
+    value: function getPickleStep(step, outlineExampleRowId) {
+      var _iterator = _createForOfIteratorHelper(this.options.pickles),
+        _step;
+      try {
+        for (_iterator.s(); !(_step = _iterator.n()).done;) {
+          var pickle = _step.value;
+          var pickleStep = pickle.steps.find(function (_ref) {
+            var astNodeIds = _ref.astNodeIds;
+            var hasStepId = astNodeIds.includes(step.id);
+            var hasRowId = !outlineExampleRowId || astNodeIds.includes(outlineExampleRowId);
+            return hasStepId && hasRowId;
+          });
+          if (pickleStep) return pickleStep;
+        }
+      } catch (err) {
+        _iterator.e(err);
+      } finally {
+        _iterator.f();
+      }
+      throw new Error("Pickle step not found for step: ".concat(step.text));
+    }
+  }, {
+    key: "getStepKeyword",
+    value: function getStepKeyword(step) {
+      var origKeyword = step.keyword.trim();
+      var enKeyword;
+      if (origKeyword === '*') {
+        enKeyword = 'And';
+      } else {
+        enKeyword = this.i18nKeywordsMap ? this.i18nKeywordsMap.get(origKeyword) : origKeyword;
+      }
+      if (!enKeyword) throw new Error("Keyword not found: ".concat(origKeyword));
+      return enKeyword;
+    }
+  }, {
+    key: "getDecoratorStep",
+    value: function getDecoratorStep(step, usedPoms) {
+      var keyword = step.keyword,
+        pickleStep = step.pickleStep,
+        pomNode = step.pomNode;
+      var fixtureNames = usedPoms.resolveFixtureNames(pomNode);
+      if (fixtureNames.length !== 1) {
+        var suggestedTags = fixtureNames.map(function (name) {
+          return (0, _poms.buildFixtureTag)(name);
+        }).join(', ');
+        (0, _utils.exitWithMessage)("Can't guess fixture for decorator step \"".concat(pickleStep.text, "\" in file: ").concat(this.sourceFile, "."), "Please set one of the following tags (".concat(suggestedTags, ") or refactor your Page Object classes."));
+      }
+      return {
+        fixtureNames: fixtureNames,
+        line: this.formatter.step(keyword, pickleStep.text, pickleStep.argument, [fixtureNames[0]])
+      };
+    }
+  }, {
+    key: "getOutlineTestTitle",
+    value: function getOutlineTestTitle(titleFormat, examples, exampleRow, exampleIndex) {
+      var params = {
+        _index_: exampleIndex
+      };
+      exampleRow.cells.forEach(function (cell, index) {
+        var _examples$tableHeader;
+        var colName = (_examples$tableHeader = examples.tableHeader) === null || _examples$tableHeader === void 0 || (_examples$tableHeader = _examples$tableHeader.cells[index]) === null || _examples$tableHeader === void 0 ? void 0 : _examples$tableHeader.value;
+        if (colName) params[colName] = cell.value;
+      });
+      return (0, _utils.template)(titleFormat, params);
+    }
+  }, {
+    key: "getExamplesTitleFormat",
+    value: function getExamplesTitleFormat(examples) {
+      var _comment$text;
+      var line = examples.location.line;
+      var titleFormatCommentLine = line - 1;
+      var comment = this.options.doc.comments.find(function (c) {
+        return c.location.line === titleFormatCommentLine;
+      });
+      var commentText = comment === null || comment === void 0 || (_comment$text = comment.text) === null || _comment$text === void 0 ? void 0 : _comment$text.trim();
+      var prefix = '# title-format:';
+      return commentText !== null && commentText !== void 0 && commentText.startsWith(prefix) ? commentText.replace(prefix, '').trim() : this.config.examplesTitleFormat;
+    }
+  }, {
+    key: "skipByTagsExpression",
+    value: function skipByTagsExpression(node) {
+      var _this$options$tagsExp;
+      // see: https://github.com/cucumber/tag-expressions/tree/main/javascript
+      return ((_this$options$tagsExp = this.options.tagsExpression) === null || _this$options$tagsExp === void 0 ? void 0 : _this$options$tagsExp.evaluate(node.tags)) === false;
+    }
+  }]);
+  return TestFile;
+}();
+exports.TestFile = TestFile;
+function isOutline(scenario) {
+  return scenario.keyword === 'Scenario Outline' || scenario.keyword === 'Scenario Template';
+}

package/build/bdd-framework/gen/testNode.js

@@ -0,0 +1,64 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.TestNode = void 0;
+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 _utils = require("../utils");
+/**
+ * Universal TestNode class with accumulated data (tags, titiles)
+ * of parent-child relations in test file structure.
+ */
+
+var SPECIAL_TAGS = ['@only', '@skip', '@fixme'];
+var TestNode = /*#__PURE__*/function () {
+  function TestNode(origItem, parent) {
+    (0, _classCallCheck2["default"])(this, TestNode);
+    (0, _defineProperty2["default"])(this, "title", void 0);
+    (0, _defineProperty2["default"])(this, "titlePath", void 0);
+    (0, _defineProperty2["default"])(this, "ownTags", []);
+    (0, _defineProperty2["default"])(this, "tags", []);
+    (0, _defineProperty2["default"])(this, "flags", {});
+    this.origItem = origItem;
+    this.parent = parent;
+    this.initOwnTags(origItem);
+    this.tags = (0, _utils.removeDuplicates)(((parent === null || parent === void 0 ? void 0 : parent.tags) || []).concat(this.ownTags));
+    this.title = origItem.name;
+    this.titlePath = ((parent === null || parent === void 0 ? void 0 : parent.titlePath) || []).concat([this.title]);
+  }
+  (0, _createClass2["default"])(TestNode, [{
+    key: "initOwnTags",
+    value: function initOwnTags(origItem) {
+      var _this = this;
+      var tagNames = (0, _utils.removeDuplicates)(getTagNames(origItem.tags));
+      tagNames.forEach(function (tag) {
+        if (isSpecialTag(tag)) {
+          _this.setFlag(tag);
+        } else {
+          _this.ownTags.push(tag);
+        }
+      });
+    }
+  }, {
+    key: "setFlag",
+    value: function setFlag(tag) {
+      if (tag === '@only') this.flags.only = true;
+      if (tag === '@skip') this.flags.skip = true;
+      if (tag === '@fixme') this.flags.fixme = true;
+    }
+  }]);
+  return TestNode;
+}();
+exports.TestNode = TestNode;
+function getTagNames(tags) {
+  return tags.map(function (tag) {
+    return tag.name;
+  });
+}
+function isSpecialTag(tag) {
+  return SPECIAL_TAGS.includes(tag);
+}

package/build/bdd-framework/index.js

@@ -0,0 +1,33 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+Object.defineProperty(exports, "BddWorld", {
+  enumerable: true,
+  get: function get() {
+    return _bddWorld.BddWorld;
+  }
+});
+Object.defineProperty(exports, "createBdd", {
+  enumerable: true,
+  get: function get() {
+    return _createBdd.createBdd;
+  }
+});
+Object.defineProperty(exports, "defineBddConfig", {
+  enumerable: true,
+  get: function get() {
+    return _config.defineBddConfig;
+  }
+});
+Object.defineProperty(exports, "test", {
+  enumerable: true,
+  get: function get() {
+    return _bddFixtures.test;
+  }
+});
+var _config = require("./config");
+var _createBdd = require("./stepDefinitions/createBdd");
+var _bddFixtures = require("./run/bddFixtures");
+var _bddWorld = require("./run/bddWorld");

package/build/bdd-framework/playwright/fixtureParameterNames.js

@@ -0,0 +1,109 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.fixtureParameterNames = fixtureParameterNames;
+var _slicedToArray2 = _interopRequireDefault(require("@babel/runtime/helpers/slicedToArray"));
+/**
+ * Extracted from playwright.
+ * https://github.com/microsoft/playwright/blob/main/packages/playwright-test/src/common/fixtures.ts#L226
+ */
+
+/* eslint-disable @typescript-eslint/no-explicit-any, @typescript-eslint/ban-types */
+/* eslint-disable max-statements, complexity, max-len, max-depth */
+
+var signatureSymbol = Symbol('signature');
+function fixtureParameterNames(fn) {
+  if (typeof fn !== 'function') {
+    return [];
+  }
+  ;
+  if (!fn[signatureSymbol]) {
+    fn[signatureSymbol] = innerFixtureParameterNames(fn);
+  }
+  return fn[signatureSymbol];
+}
+function innerFixtureParameterNames(fn) {
+  var text = filterOutComments(fn.toString());
+  var match = text.match(/(?:async)?(?:\s+function)?[^(]*\(([^)]*)/);
+  if (!match) {
+    return [];
+  }
+  ;
+  var trimmedParams = match[1].trim();
+  if (!trimmedParams) {
+    return [];
+  }
+  ;
+  var _splitByComma = splitByComma(trimmedParams),
+    _splitByComma2 = (0, _slicedToArray2["default"])(_splitByComma, 1),
+    firstParam = _splitByComma2[0];
+  if (firstParam[0] !== '{' || firstParam[firstParam.length - 1] !== '}') {
+    throw new Error('First argument must use the object destructuring pattern: ' + firstParam + ' ' + fn.toString());
+  }
+  var props = splitByComma(firstParam.substring(1, firstParam.length - 1)).map(function (prop) {
+    var colon = prop.indexOf(':');
+    return colon === -1 ? prop.trim() : prop.substring(0, colon).trim();
+  });
+  var restProperty = props.find(function (prop) {
+    return prop.startsWith('...');
+  });
+  if (restProperty) {
+    throw new Error("Rest property \"".concat(restProperty, "\" is not supported. List all used fixtures explicitly, separated by comma. ").concat(fn.toString()));
+  }
+  return props;
+}
+function filterOutComments(s) {
+  var result = [];
+  var commentState = 'none';
+  for (var i = 0; i < s.length; ++i) {
+    if (commentState === 'singleline') {
+      if (s[i] === '\n') {
+        commentState = 'none';
+      }
+      ;
+    } else if (commentState === 'multiline') {
+      if (s[i - 1] === '*' && s[i] === '/') {
+        commentState = 'none';
+      }
+      ;
+    } else if (commentState === 'none') {
+      if (s[i] === '/' && s[i + 1] === '/') {
+        commentState = 'singleline';
+      } else if (s[i] === '/' && s[i + 1] === '*') {
+        commentState = 'multiline';
+        i += 2;
+      } else {
+        result.push(s[i]);
+      }
+    }
+  }
+  return result.join('');
+}
+function splitByComma(s) {
+  var result = [];
+  var stack = [];
+  var start = 0;
+  for (var i = 0; i < s.length; i++) {
+    if (s[i] === '{' || s[i] === '[') {
+      stack.push(s[i] === '{' ? '}' : ']');
+    } else if (s[i] === stack[stack.length - 1]) {
+      stack.pop();
+    } else if (!stack.length && s[i] === ',') {
+      var token = s.substring(start, i).trim();
+      if (token) {
+        result.push(token);
+      }
+      ;
+      start = i + 1;
+    }
+  }
+  var lastToken = s.substring(start).trim();
+  if (lastToken) {
+    result.push(lastToken);
+  }
+  ;
+  return result;
+}

package/build/bdd-framework/playwright/getLocationInFile.js

@@ -0,0 +1,51 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.getLocationInFile = getLocationInFile;
+var _url = _interopRequireDefault(require("url"));
+var _utils = require("./utils");
+/**
+ * Inspects stacktrace and finds call location in provided file.
+ * This function is based on Playwright's getLocationByStacktrace().
+ * See: https://github.com/microsoft/playwright/blob/main/packages/playwright-test/src/common/transform.ts#L229
+ */
+function getLocationInFile(filePath) {
+  var _requirePlaywrightMod = (0, _utils.requirePlaywrightModule)('lib/utilsBundle.js'),
+    sourceMapSupport = _requirePlaywrightMod.sourceMapSupport;
+  var oldPrepareStackTrace = Error.prepareStackTrace;
+  Error.prepareStackTrace = function (error, stackFrames) {
+    var frameInFile = stackFrames.find(function (frame) {
+      return frame.getFileName() === filePath;
+    });
+    if (!frameInFile) {
+      return {
+        file: '',
+        line: 0,
+        column: 0
+      };
+    }
+    ;
+    var frame = sourceMapSupport.wrapCallSite(frameInFile);
+    var fileName = frame.getFileName();
+    // Node error stacks for modules use file:// urls instead of paths.
+    var file = fileName && fileName.startsWith('file://') ? _url["default"].fileURLToPath(fileName) : fileName;
+    return {
+      file: file,
+      line: frame.getLineNumber(),
+      column: frame.getColumnNumber()
+    };
+  };
+  // commented stackTraceLImit modification, todo: check if it has perf impact
+  // const oldStackTraceLimit = Error.stackTraceLimit;
+  // Error.stackTraceLimit = level + 1;
+  // eslint-disable-next-line @typescript-eslint/no-explicit-any
+  var obj = {};
+  Error.captureStackTrace(obj);
+  var location = obj.stack;
+  // Error.stackTraceLimit = oldStackTraceLimit;
+  Error.prepareStackTrace = oldPrepareStackTrace;
+  return location;
+}