jest-bdd-generator/dist/lib/gherkin-to-test/index.js

Jest code generator empowered with Gherkin and BDD

"use strict";
var __create = Object.create;
var __defProp = Object.defineProperty;
var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
var __getOwnPropNames = Object.getOwnPropertyNames;
var __getProtoOf = Object.getPrototypeOf;
var __hasOwnProp = Object.prototype.hasOwnProperty;
var __export = (target, all) => {
  for (var name in all)
    __defProp(target, name, { get: all[name], enumerable: true });
};
var __copyProps = (to, from, except, desc) => {
  if (from && typeof from === "object" || typeof from === "function") {
    for (let key of __getOwnPropNames(from))
      if (!__hasOwnProp.call(to, key) && key !== except)
        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
  }
  return to;
};
var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
  // If the importer is in node compatibility mode or this is not an ESM
  // file that has been converted to a CommonJS file using a Babel-
  // compatible transform (i.e. "__esModule" has not been set), then set
  // "default" to the CommonJS "module.exports" for node compatibility.
  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
  mod
));
var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
var gherkin_to_test_exports = {};
__export(gherkin_to_test_exports, {
  TestGenerator: () => TestGenerator
});
module.exports = __toCommonJS(gherkin_to_test_exports);
var import_gherkin = require("@cucumber/gherkin");
var import_messages = require("@cucumber/messages");
var prettier = __toESM(require("prettier"));
var fs = __toESM(require("fs"));
var import_TestGeneratorFromSource = require("./TestGeneratorFromSource");
function asyncGeneratorStep(gen, resolve, reject, _next, _throw, key, arg) {
  try {
    var info = gen[key](arg);
    var value = info.value;
  } catch (error) {
    reject(error);
    return;
  }
  if (info.done) {
    resolve(value);
  } else {
    Promise.resolve(value).then(_next, _throw);
  }
}
function _async_to_generator(fn) {
  return function() {
    var self = this, args = arguments;
    return new Promise(function(resolve, reject) {
      var gen = fn.apply(self, args);
      function _next(value) {
        asyncGeneratorStep(gen, resolve, reject, _next, _throw, "next", value);
      }
      function _throw(err) {
        asyncGeneratorStep(gen, resolve, reject, _next, _throw, "throw", err);
      }
      _next(void 0);
    });
  };
}
const newId = import_messages.IdGenerator.uuid();
const builder = new import_gherkin.AstBuilder(newId);
const matcher = new import_gherkin.GherkinClassicTokenMatcher();
const _parser = new import_gherkin.Parser(builder, matcher);
class TestGenerator extends import_TestGeneratorFromSource.TestGeneratorFromSource {
  compileKnownSteps(pathTestInput) {
    const source = fs.readFileSync(pathTestInput).toString();
    return this.compileKnownStepsFromSource(source);
  }
  generateGherkin(options) {
    var _this = this;
    return _async_to_generator(function* () {
      const { pathTestsInput, pathGherkinInput } = options;
      const steps = _this.compileKnownSteps(pathTestsInput);
      const gherkinSource = fs.readFileSync(pathGherkinInput).toString();
      const testingCode = _this.generateGherkinFromSource(steps, gherkinSource);
      return testingCode ? prettier.format(testingCode, {
        parser: "typescript"
      }) : void 0;
    })();
  }
}
// Annotate the CommonJS export names for ESM import in node:
0 && (module.exports = {
  TestGenerator
});

//# sourceMappingURL=index.js.map