@zohodesk/testinglibrary 0.0.4 → 0.0.5-exp.2

package/.babelrc

@@ -0,0 +1,6 @@
+{
+  "presets": ["@babel/preset-env"],
+  "plugins": [
+      ["@babel/plugin-transform-runtime"]
+  ]
+}

package/bin/cli.js

@@ -1,3 +1,3 @@
 #!/usr/bin/env node
 
-require('../src/lib/cli');
+require('../build/lib/cli');

package/bin/postinstall.js

@@ -1,16 +1 @@
-const path = require('path');
-const { spawn } = require('child_process');
-const { Logger } = require('../src/utils/logger');
-const getFilePathWithExtension = require('../src/utils/getFilePath');
-
-const playwrightPath = path.resolve('node_modules', '.bin', getFilePathWithExtension('playwright'));
-const command = playwrightPath;
-const args = ['install'];
-
-Logger.log(Logger.INFO_TYPE, 'Downloading browsers for running tests');
-
-const childProcess = spawn(command, args, { stdio: 'inherit' });
-
-childProcess.on('error', (error) => {
-  Logger.log(Logger.FAILURE_TYPE, error);
-});
+require('../build/lib/post-install');

package/build/bdd-framework/cli/commands/env.js

@@ -0,0 +1,44 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.envCommand = void 0;
+exports.getOwnVersion = getOwnVersion;
+var _fs = _interopRequireDefault(require("fs"));
+var _commander = require("commander");
+var _options = require("../options");
+var _path = _interopRequireDefault(require("path"));
+var _logger = require("../../utils/logger");
+var _utils = require("../../utils");
+var _loadConfig = require("../../playwright/loadConfig");
+var envCommand = new _commander.Command('env').description('Prints environment info').addOption(_options.configOption).action(function (opts) {
+  _logger.logger.log("Playwright-bdd environment info:\n");
+  _logger.logger.log("platform: ".concat(process.platform));
+  _logger.logger.log("node: ".concat(process.version));
+  showPackageVersion('playwright-bdd');
+  showPackageVersion('@playwright/test');
+  showPackageVersion('@cucumber/cucumber');
+  showPlaywrightConfigPath(opts.config);
+});
+exports.envCommand = envCommand;
+function showPackageVersion(packageName) {
+  var version = packageName === 'playwright-bdd' ? getOwnVersion() : (0, _utils.getPackageVersion)(packageName);
+  _logger.logger.log("".concat(packageName, ": v").concat(version));
+}
+
+/**
+ * Getting own version by relative path instead of using getPackageVersion(),
+ * to aneble using directly from /dist in tests.
+ */
+function getOwnVersion() {
+  // const packageJsonPath = path.resolve(__dirname, '..', '..', '..', `package.json`);
+  // const pkg = JSON.parse(fs.readFileSync(packageJsonPath, 'utf8'));
+  return '5.2.0';
+}
+function showPlaywrightConfigPath(cliConfigPath) {
+  var resolvedConfigFile = (0, _loadConfig.resolveConfigFile)(cliConfigPath);
+  var relPath = _path["default"].relative(process.cwd(), resolvedConfigFile);
+  _logger.logger.log("Playwright config file: ".concat(relPath));
+}

package/build/bdd-framework/cli/commands/export.js

@@ -0,0 +1,95 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.exportCommand = void 0;
+var _regenerator = _interopRequireDefault(require("@babel/runtime/regenerator"));
+var _asyncToGenerator2 = _interopRequireDefault(require("@babel/runtime/helpers/asyncToGenerator"));
+var _path = _interopRequireDefault(require("path"));
+var _commander = require("commander");
+var _options = require("../options");
+var _loadConfig = require("../../playwright/loadConfig");
+var _logger = require("../../utils/logger");
+var _env = require("../../config/env");
+var _test = require("./test");
+var _gen = require("../../gen");
+var _ref, _showStepsForConfigs;
+// filter by project?
+
+var exportCommand = new _commander.Command('export').description('Prints all step definitions').addOption(_options.configOption).action(function (_x) {
+  return (_ref = _ref || (0, _asyncToGenerator2["default"])( /*#__PURE__*/_regenerator["default"].mark(function _callee(opts) {
+    var _yield$loadPlaywright, resolvedConfigFile, configs;
+    return _regenerator["default"].wrap(function _callee$(_context) {
+      while (1) switch (_context.prev = _context.next) {
+        case 0:
+          _context.next = 2;
+          return (0, _loadConfig.loadConfig)(opts.config);
+        case 2:
+          _yield$loadPlaywright = _context.sent;
+          resolvedConfigFile = _yield$loadPlaywright.resolvedConfigFile;
+          _logger.logger.log("List of all steps found by config: ".concat(_path["default"].relative(process.cwd(), resolvedConfigFile), "\n"));
+          configs = Object.values((0, _env.getEnvConfigs)());
+          (0, _test.assertConfigsCount)(configs);
+          _context.next = 9;
+          return showStepsForConfigs(configs);
+        case 9:
+        case "end":
+          return _context.stop();
+      }
+    }, _callee);
+  }))).apply(this, arguments);
+});
+exports.exportCommand = exportCommand;
+function showStepsForConfigs(_x2) {
+  return (_showStepsForConfigs = _showStepsForConfigs || (0, _asyncToGenerator2["default"])( /*#__PURE__*/_regenerator["default"].mark(function _callee3(configs) {
+    var _ref2;
+    var steps, tasks;
+    return _regenerator["default"].wrap(function _callee3$(_context3) {
+      while (1) switch (_context3.prev = _context3.next) {
+        case 0:
+          // here we don't need workers (as in test command) because if some step files
+          // are already in node cache, we collected them.
+          steps = new Set();
+          tasks = configs.map(function (_x3) {
+            return (_ref2 = _ref2 || (0, _asyncToGenerator2["default"])( /*#__PURE__*/_regenerator["default"].mark(function _callee2(config) {
+              var stepDefinitions;
+              return _regenerator["default"].wrap(function _callee2$(_context2) {
+                while (1) switch (_context2.prev = _context2.next) {
+                  case 0:
+                    _context2.next = 2;
+                    return new _gen.TestFilesGenerator(config).extractSteps();
+                  case 2:
+                    stepDefinitions = _context2.sent;
+                    stepDefinitions.forEach(function (s) {
+                      return steps.add("* ".concat(getStepText(s)));
+                    });
+                  case 4:
+                  case "end":
+                    return _context2.stop();
+                }
+              }, _callee2);
+            }))).apply(this, arguments);
+          });
+          _context3.next = 4;
+          return Promise.all(tasks);
+        case 4:
+          steps.forEach(function (stepText) {
+            return _logger.logger.log(stepText);
+          });
+        case 5:
+        case "end":
+          return _context3.stop();
+      }
+    }, _callee3);
+  }))).apply(this, arguments);
+}
+function getStepText(_ref3) {
+  var pattern = _ref3.pattern,
+    keyword = _ref3.keyword;
+  // for Unknown return When as it looks the most suitable
+  var keywordText = keyword === 'Unknown' ? 'When' : keyword;
+  var patternText = typeof pattern === 'string' ? pattern : pattern.source;
+  return "".concat(keywordText, " ").concat(patternText);
+}

package/build/bdd-framework/cli/commands/test.js

@@ -0,0 +1,98 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.assertConfigsCount = assertConfigsCount;
+exports.testCommand = void 0;
+var _regenerator = _interopRequireDefault(require("@babel/runtime/regenerator"));
+var _defineProperty2 = _interopRequireDefault(require("@babel/runtime/helpers/defineProperty"));
+var _asyncToGenerator2 = _interopRequireDefault(require("@babel/runtime/helpers/asyncToGenerator"));
+var _worker_threads = require("worker_threads");
+var _events = require("events");
+var _path = _interopRequireDefault(require("path"));
+var _commander = require("commander");
+var _gen = require("../../gen");
+var _utils = require("../../utils");
+var _loadConfig = require("../../playwright/loadConfig");
+var _env = require("../../config/env");
+var _config = require("../../config");
+var _options = require("../options");
+var _ref, _runInWorker, _generateFilesForConfigs;
+function ownKeys(e, r) { var t = Object.keys(e); if (Object.getOwnPropertySymbols) { var o = Object.getOwnPropertySymbols(e); r && (o = o.filter(function (r) { return Object.getOwnPropertyDescriptor(e, r).enumerable; })), t.push.apply(t, o); } return t; }
+function _objectSpread(e) { for (var r = 1; r < arguments.length; r++) { var t = null != arguments[r] ? arguments[r] : {}; r % 2 ? ownKeys(Object(t), !0).forEach(function (r) { (0, _defineProperty2["default"])(e, r, t[r]); }) : Object.getOwnPropertyDescriptors ? Object.defineProperties(e, Object.getOwnPropertyDescriptors(t)) : ownKeys(Object(t)).forEach(function (r) { Object.defineProperty(e, r, Object.getOwnPropertyDescriptor(t, r)); }); } return e; }
+var GEN_WORKER_PATH = _path["default"].resolve(__dirname, '..', 'worker.js');
+var testCommand = new _commander.Command('test').description('Generate Playwright test files from Gherkin documents').addOption(_options.configOption).option('--tags <expression>', "Tags expression to filter scenarios for generation").option('--verbose', "Verbose mode (default: ".concat(Boolean(_config.defaults.verbose), ")")).action(function (_x) {
+  return (_ref = _ref || (0, _asyncToGenerator2["default"])( /*#__PURE__*/_regenerator["default"].mark(function _callee(opts) {
+    var configs, cliOptions;
+    return _regenerator["default"].wrap(function _callee$(_context) {
+      while (1) switch (_context.prev = _context.next) {
+        case 0:
+          _context.next = 2;
+          return (0, _loadConfig.loadConfig)(opts.config);
+        case 2:
+          configs = Object.values((0, _env.getEnvConfigs)());
+          assertConfigsCount(configs);
+          cliOptions = buildCliOptions(opts);
+          _context.next = 7;
+          return generateFilesForConfigs(configs, cliOptions);
+        case 7:
+        case "end":
+          return _context.stop();
+      }
+    }, _callee);
+  }))).apply(this, arguments);
+});
+exports.testCommand = testCommand;
+function buildCliOptions(opts) {
+  var config = {};
+  if ('tags' in opts) config.tags = opts.tags;
+  if ('verbose' in opts) config.verbose = Boolean(opts.verbose);
+  return config;
+}
+function assertConfigsCount(configs) {
+  if (configs.length === 0) {
+    (0, _utils.exitWithMessage)("No BDD configs found. Did you use defineBddConfig() in playwright.config.ts?");
+  }
+}
+function runInWorker(_x2) {
+  return (_runInWorker = _runInWorker || (0, _asyncToGenerator2["default"])( /*#__PURE__*/_regenerator["default"].mark(function _callee2(config) {
+    var worker;
+    return _regenerator["default"].wrap(function _callee2$(_context2) {
+      while (1) switch (_context2.prev = _context2.next) {
+        case 0:
+          worker = new _worker_threads.Worker(GEN_WORKER_PATH, {
+            workerData: {
+              config: config
+            }
+          }); // todo: check if worker exited with error?
+          _context2.next = 3;
+          return (0, _events.once)(worker, 'exit');
+        case 3:
+        case "end":
+          return _context2.stop();
+      }
+    }, _callee2);
+  }))).apply(this, arguments);
+}
+function generateFilesForConfigs(_x3, _x4) {
+  return (_generateFilesForConfigs = _generateFilesForConfigs || (0, _asyncToGenerator2["default"])( /*#__PURE__*/_regenerator["default"].mark(function _callee3(configs, cliConfig) {
+    var tasks;
+    return _regenerator["default"].wrap(function _callee3$(_context3) {
+      while (1) switch (_context3.prev = _context3.next) {
+        case 0:
+          // run first config in main thread and other in workers (to have fresh require cache)
+          // See: https://github.com/vitalets/playwright-bdd/issues/32
+          tasks = configs.map(function (config, index) {
+            var finalConfig = _objectSpread(_objectSpread({}, config), cliConfig);
+            return index === 0 ? new _gen.TestFilesGenerator(finalConfig).generate() : runInWorker(finalConfig);
+          });
+          return _context3.abrupt("return", Promise.all(tasks));
+        case 2:
+        case "end":
+          return _context3.stop();
+      }
+    }, _callee3);
+  }))).apply(this, arguments);
+}

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

@@ -0,0 +1,11 @@
+#!/usr/bin/env node
+"use strict";
+
+var _commander = require("commander");
+var _test = require("./commands/test");
+var _env = require("./commands/env");
+var _export = require("./commands/export");
+var program = new _commander.Command();
+program.name('bddgen').description("Playwright-bdd CLI v".concat((0, _env.getOwnVersion)())).addCommand(_test.testCommand, {
+  isDefault: true
+}).addCommand(_export.exportCommand).addCommand(_env.envCommand).addHelpCommand(false).parse();

package/build/bdd-framework/cli/options.js

@@ -0,0 +1,21 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.configOption = void 0;
+exports.getCliConfigPath = getCliConfigPath;
+var _commander = require("commander");
+/**
+ * Config option moved to separate file as it used in test run.
+ */
+
+var configOption = new _commander.Option("-c, --config <file>", "Path to Playwright configuration file (default: playwright.config.(js|ts))");
+
+/**
+ * Helper used in test run to detect config location.
+ */
+exports.configOption = configOption;
+function getCliConfigPath() {
+  return new _commander.Command().allowUnknownOption().addOption(configOption).parse().getOptionValue('config');
+}

package/build/bdd-framework/cli/worker.js

@@ -0,0 +1,27 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+var _regenerator = _interopRequireDefault(require("@babel/runtime/regenerator"));
+var _asyncToGenerator2 = _interopRequireDefault(require("@babel/runtime/helpers/asyncToGenerator"));
+var _worker_threads = require("worker_threads");
+var _gen = require("../gen");
+var _main;
+/**
+ * Worker to generate test files with fresh require/import cache
+ * See: https://github.com/nodejs/modules/issues/307#issuecomment-858729422
+ */
+function main() {
+  return (_main = _main || (0, _asyncToGenerator2["default"])( /*#__PURE__*/_regenerator["default"].mark(function _callee() {
+    return _regenerator["default"].wrap(function _callee$(_context) {
+      while (1) switch (_context.prev = _context.next) {
+        case 0:
+          _context.next = 2;
+          return new _gen.TestFilesGenerator(_worker_threads.workerData.config).generate();
+        case 2:
+        case "end":
+          return _context.stop();
+      }
+    }, _callee);
+  }))).apply(this, arguments);
+}
+main();

package/build/bdd-framework/config/dir.js

@@ -0,0 +1,27 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.getPlaywrightConfigDir = getPlaywrightConfigDir;
+var _path = _interopRequireDefault(require("path"));
+var _loadConfig = require("../playwright/loadConfig");
+var _options = require("../cli/options");
+/**
+ * Store playwright config dir in env to provide access to it in workers.
+ * Important that in workers there is different process.argv, that's why we save it to env.
+ * Config dir is needed to resolve all paths.
+ */
+
+/**
+ * Resolve playwright config dir considering cli flags.
+ */
+function getPlaywrightConfigDir() {
+  if (!process.env.PLAYWRIGHT_BDD_CONFIG_DIR) {
+    var cliConfigPath = (0, _options.getCliConfigPath)();
+    var playwrightConfigFile = (0, _loadConfig.resolveConfigFile)(cliConfigPath);
+    process.env.PLAYWRIGHT_BDD_CONFIG_DIR = playwrightConfigFile ? _path["default"].dirname(playwrightConfigFile) : process.cwd();
+  }
+  return process.env.PLAYWRIGHT_BDD_CONFIG_DIR;
+}

package/build/bdd-framework/config/env.js

@@ -0,0 +1,49 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.getConfigFromEnv = getConfigFromEnv;
+exports.getEnvConfigs = getEnvConfigs;
+exports.saveConfigToEnv = saveConfigToEnv;
+var _path = _interopRequireDefault(require("path"));
+var _utils = require("../utils");
+/**
+ * Storing configs in env var PLAYWRIGHT_BDD_CONFIGS as JSON-stringified values.
+ * For passing configs to playwright workers and bddgen.
+ */
+
+function saveConfigToEnv(config) {
+  var envConfigs = getEnvConfigs();
+  var existingConfig = envConfigs[config.outputDir];
+  if (existingConfig) {
+    // Playwright config can be evaluated several times.
+    // Throw error only if different calls of defineBddConfig() use the same outputDir.
+    // See: https://github.com/vitalets/playwright-bdd/issues/39#issuecomment-1653805368
+    if (!isSameConfigs(config, existingConfig)) {
+      (0, _utils.exitWithMessage)("When using several calls of defineBddConfig()", "please manually provide different \"outputDir\" option.");
+    }
+    return;
+  }
+  envConfigs[config.outputDir] = config;
+  saveEnvConfigs(envConfigs);
+}
+function getConfigFromEnv(outputDir) {
+  var envConfigs = getEnvConfigs();
+  outputDir = _path["default"].resolve(outputDir);
+  var config = envConfigs[outputDir];
+  if (!config) {
+    (0, _utils.exitWithMessage)("Config not found for outputDir: \"".concat(outputDir, "\"."), "Available dirs: ".concat(Object.keys(envConfigs).join('\n')));
+  }
+  return config;
+}
+function getEnvConfigs() {
+  return JSON.parse(process.env.PLAYWRIGHT_BDD_CONFIGS || '{}');
+}
+function saveEnvConfigs(envConfigs) {
+  process.env.PLAYWRIGHT_BDD_CONFIGS = JSON.stringify(envConfigs);
+}
+function isSameConfigs(config1, config2) {
+  return JSON.stringify(config1) === JSON.stringify(config2);
+}

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

@@ -0,0 +1,91 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.defaults = void 0;
+exports.defineBddConfig = defineBddConfig;
+exports.extractCucumberConfig = extractCucumberConfig;
+var _defineProperty2 = _interopRequireDefault(require("@babel/runtime/helpers/defineProperty"));
+var _path = _interopRequireDefault(require("path"));
+var _env = require("./env");
+var _dir = require("./dir");
+var _utils = require("../utils");
+function ownKeys(e, r) { var t = Object.keys(e); if (Object.getOwnPropertySymbols) { var o = Object.getOwnPropertySymbols(e); r && (o = o.filter(function (r) { return Object.getOwnPropertyDescriptor(e, r).enumerable; })), t.push.apply(t, o); } return t; }
+function _objectSpread(e) { for (var r = 1; r < arguments.length; r++) { var t = null != arguments[r] ? arguments[r] : {}; r % 2 ? ownKeys(Object(t), !0).forEach(function (r) { (0, _defineProperty2["default"])(e, r, t[r]); }) : Object.getOwnPropertyDescriptors ? Object.defineProperties(e, Object.getOwnPropertyDescriptors(t)) : ownKeys(Object(t)).forEach(function (r) { Object.defineProperty(e, r, Object.getOwnPropertyDescriptor(t, r)); }); } return e; } /**
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                          * BDD Config.
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                          */
+var defaults = {
+  outputDir: '.features-gen',
+  verbose: false,
+  examplesTitleFormat: 'Example #<_index_>',
+  publishQuiet: true,
+  quotes: 'double'
+};
+exports.defaults = defaults;
+function defineBddConfig(inputConfig) {
+  var config = getConfig(inputConfig);
+
+  // In main process store config in env to be accessible by workers
+  if (!process.env.TEST_WORKER_INDEX) {
+    (0, _env.saveConfigToEnv)(config);
+  }
+  return config.outputDir;
+}
+function getConfig(inputConfig) {
+  var config = Object.assign({}, defaults, inputConfig);
+  var configDir = (0, _dir.getPlaywrightConfigDir)();
+  var featuresRoot = config.featuresRoot ? _path["default"].resolve(configDir, config.featuresRoot) : configDir;
+  return _objectSpread(_objectSpread({}, config), {}, {
+    // important to resolve outputDir as it is used as unique key for input configs
+    outputDir: _path["default"].resolve(configDir, config.outputDir),
+    importTestFrom: resolveImportTestFrom(configDir, config.importTestFrom),
+    featuresRoot: featuresRoot
+  });
+}
+function extractCucumberConfig(config) {
+  // todo: find more strict way to omit own config fields
+  // see: https://bobbyhadz.com/blog/typescript-object-remove-property
+  var omitProps = {
+    outputDir: true,
+    importTestFrom: true,
+    verbose: true,
+    skip: true,
+    examplesTitleFormat: true,
+    quotes: true,
+    tags: true,
+    featuresRoot: true
+  };
+  var keys = Object.keys(omitProps);
+  var cucumberConfig = _objectSpread({}, config);
+  keys.forEach(function (key) {
+    return delete cucumberConfig[key];
+  });
+  stripPublishQuiet(cucumberConfig);
+  return cucumberConfig;
+}
+function resolveImportTestFrom(configDir, importTestFrom) {
+  if (importTestFrom) {
+    var _ref = typeof importTestFrom === 'string' ? {
+        file: importTestFrom
+      } : importTestFrom,
+      file = _ref.file,
+      varName = _ref.varName;
+    return {
+      file: _path["default"].resolve(configDir, file),
+      varName: varName
+    };
+  }
+}
+function stripPublishQuiet(cucumberConfig) {
+  var cucumberVersion = (0, _utils.getPackageVersion)('@cucumber/cucumber');
+  // Playwright-bdd supports Cucumber from v9+
+  // publishQuiet was deprecated in Cucumber 9.4.0.
+  // See: https://github.com/cucumber/cucumber-js/pull/2311
+  // Remove publishQuite from Cucumber config to hide deprecation warning.
+  // See: https://github.com/vitalets/playwright-bdd/pull/47
+  if (!/^9\.[0123]\./.test(cucumberVersion)) {
+    delete cucumberConfig.publishQuiet;
+  }
+}

package/build/bdd-framework/cucumber/buildStepDefinition.js

@@ -0,0 +1,44 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.buildStepDefinition = buildStepDefinition;
+var _messages = require("@cucumber/messages");
+var _cucumberExpressions = require("@cucumber/cucumber-expressions");
+var _step_definition = _interopRequireDefault(require("@cucumber/cucumber/lib/models/step_definition"));
+/**
+ * Extracted from cucumber SupportCodeLibraryBuilder.
+ * See: https://github.com/cucumber/cucumber-js/blob/main/src/support_code_library_builder/index.ts
+ */
+
+var newId = _messages.IdGenerator.uuid();
+function buildStepDefinition(_ref, supportCodeLibrary) {
+  var keyword = _ref.keyword,
+    pattern = _ref.pattern,
+    code = _ref.code,
+    line = _ref.line,
+    options = _ref.options,
+    uri = _ref.uri;
+  // todo: handle error.undefinedParameterTypeName as it's done in cucumber?
+  var expression = typeof pattern === 'string' ? new _cucumberExpressions.CucumberExpression(pattern, supportCodeLibrary.parameterTypeRegistry) : new _cucumberExpressions.RegularExpression(pattern, supportCodeLibrary.parameterTypeRegistry);
+
+  // skip wrapping code as it is not needed for decorator steps
+  // const wrappedCode = this.wrapCode({
+  //   code,
+  //   wrapperOptions: options.wrapperOptions,
+  // })
+
+  return new _step_definition["default"]({
+    code: code,
+    expression: expression,
+    id: newId(),
+    line: line,
+    options: options,
+    keyword: keyword,
+    pattern: pattern,
+    unwrappedCode: code,
+    uri: uri
+  });
+}

package/build/bdd-framework/cucumber/gherkin.d.ts

@@ -0,0 +1,45 @@
+/**
+ * Copied from @cucumber/cucumber/lib/api/gherkin.d.ts
+ * Fixes error:
+ * Return type of exported function has or is using name 'PickleWithDocument'
+ * from external module "../node_modules/@cucumber/cucumber/lib/api/gherkin"
+ * but cannot be named
+ */
+import {
+  Envelope,
+  GherkinDocument,
+  IdGenerator,
+  Location,
+  ParseError,
+  Pickle,
+} from '@cucumber/messages';
+import { ISourcesCoordinates } from '@cucumber/cucumber/lib/api/types';
+import { ILogger } from '@cucumber/cucumber/lib/logger';
+
+declare module '@cucumber/cucumber/lib/api/gherkin' {
+  export interface PickleWithDocument {
+    gherkinDocument: GherkinDocument;
+    location: Location;
+    pickle: Pickle;
+  }
+  export function getFilteredPicklesAndErrors({
+    newId,
+    cwd,
+    logger,
+    unexpandedFeaturePaths,
+    featurePaths,
+    coordinates,
+    onEnvelope,
+  }: {
+    newId: IdGenerator.NewId;
+    cwd: string;
+    logger: ILogger;
+    unexpandedFeaturePaths: string[];
+    featurePaths: string[];
+    coordinates: ISourcesCoordinates;
+    onEnvelope?: (envelope: Envelope) => void;
+  }): Promise<{
+    filteredPickles: PickleWithDocument[];
+    parseErrors: ParseError[];
+  }>;
+}

package/build/bdd-framework/cucumber/loadConfig.js

@@ -0,0 +1,32 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.loadConfig = loadConfig;
+var _regenerator = _interopRequireDefault(require("@babel/runtime/regenerator"));
+var _asyncToGenerator2 = _interopRequireDefault(require("@babel/runtime/helpers/asyncToGenerator"));
+var _api = require("@cucumber/cucumber/api");
+var _loadConfig;
+var cache = new Map();
+function loadConfig(_x, _x2) {
+  return (_loadConfig = _loadConfig || (0, _asyncToGenerator2["default"])( /*#__PURE__*/_regenerator["default"].mark(function _callee(options, environment) {
+    var cacheKey, config;
+    return _regenerator["default"].wrap(function _callee$(_context) {
+      while (1) switch (_context.prev = _context.next) {
+        case 0:
+          cacheKey = JSON.stringify(options);
+          config = cache.get(cacheKey);
+          if (!config) {
+            config = (0, _api.loadConfiguration)(options, environment);
+            cache.set(cacheKey, config);
+          }
+          return _context.abrupt("return", config);
+        case 4:
+        case "end":
+          return _context.stop();
+      }
+    }, _callee);
+  }))).apply(this, arguments);
+}