@zohodesk/testinglibrary 0.4.8-experimental → 2.9.2

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

@@ -0,0 +1,12 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+Object.defineProperty(exports, "PlaywrightLocation", {
+  enumerable: true,
+  get: function () {
+    return _reporter.Location;
+  }
+});
+var _reporter = require("@playwright/test/reporter");

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

@@ -0,0 +1,56 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.getPlaywrightModulePath = getPlaywrightModulePath;
+exports.playwrightVersion = void 0;
+exports.requirePlaywrightModule = requirePlaywrightModule;
+exports.updateAnnotation = updateAnnotation;
+var _fs = _interopRequireDefault(require("fs"));
+var _path = _interopRequireDefault(require("path"));
+var _utils = require("../utils");
+// cache playwright root
+let playwrightRoot = '';
+const playwrightVersion = exports.playwrightVersion = (0, _utils.getPackageVersion)('@playwright/test');
+/**
+ * Requires Playwright's internal module that is not exported via package.exports.
+ */
+function requirePlaywrightModule(modulePath) {
+  const absPath = _path.default.isAbsolute(modulePath) ? modulePath : getPlaywrightModulePath(modulePath);
+  return require(absPath);
+}
+function getPlaywrightModulePath(relativePath) {
+  return _path.default.join(getPlaywrightRoot(), relativePath);
+}
+function getPlaywrightRoot() {
+  if (!playwrightRoot) {
+    // Since 1.38 all modules moved from @playwright/test to playwright.
+    // Here we check existance of 'lib' dir instead of checking version.
+    // See: https://github.com/microsoft/playwright/pull/26946
+    const playwrightTestRoot = (0, _utils.resolvePackageRoot)('@playwright/test');
+    const libDir = _path.default.join(playwrightTestRoot, 'lib');
+    playwrightRoot = _fs.default.existsSync(libDir) ? playwrightTestRoot : (0, _utils.resolvePackageRoot)('playwright');
+  }
+  return playwrightRoot;
+}
+/**
+ * Create or update annotation with provided type.
+ */
+function updateAnnotation(testInfo, annotation, {
+  create = false
+} = {}) {
+  const {
+    annotations
+  } = testInfo;
+  const index = annotations.findIndex(a => a.type === annotation.type);
+  if (index === -1 && !create) {
+    throw new Error(`Annotation "${annotation.type}" is not found.`);
+  }
+  if (index === -1) {
+    annotations.push(annotation);
+  } else {
+    annotations[index] = annotation;
+  }
+}

package/build/bdd-framework/reporter/cucumber/base.js

@@ -0,0 +1,52 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = void 0;
+var _path = _interopRequireDefault(require("path"));
+var _fs = _interopRequireDefault(require("fs"));
+var _promises = require("node:stream/promises");
+/**
+ * Base reporter for Cucumber reporters.
+ * Reference: https://github.com/cucumber/cucumber-js/blob/main/src/formatter/index.ts
+ */
+
+class BaseReporter {
+  internalOptions;
+  outputStream = process.stdout;
+  constructor(internalOptions) {
+    this.internalOptions = internalOptions;
+  }
+  get eventBroadcaster() {
+    return this.internalOptions.eventBroadcaster;
+  }
+  get eventDataCollector() {
+    return this.internalOptions.eventDataCollector;
+  }
+  printsToStdio() {
+    return isStdout(this.outputStream);
+  }
+  async init() {}
+  async finished() {
+    if (!isStdout(this.outputStream)) {
+      this.outputStream.end();
+      await (0, _promises.finished)(this.outputStream);
+    }
+  }
+  setOutputStream(outputFile) {
+    if (!outputFile) {
+      return;
+    }
+    const absolutePath = _path.default.resolve(this.internalOptions.cwd, outputFile);
+    _fs.default.mkdirSync(_path.default.dirname(absolutePath), {
+      recursive: true
+    });
+    this.outputStream = _fs.default.createWriteStream(absolutePath);
+  }
+}
+exports.default = BaseReporter;
+function isStdout(stream) {
+  return stream === process.stdout;
+}

package/build/bdd-framework/reporter/cucumber/custom.js

@@ -0,0 +1,73 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = void 0;
+var _base = _interopRequireDefault(require("./base"));
+var _loadUtils = require("../../playwright/loadUtils");
+var _getColorFns = _interopRequireDefault(require("../../cucumber/formatter/getColorFns"));
+/**
+ * Custom Cucumber reporter.
+ * See: https://github.com/cucumber/cucumber-js/blob/main/docs/custom_formatters.md
+ */
+
+class CustomReporter extends _base.default {
+  reporterPathOrModule;
+  userOptions;
+  formatter;
+  constructor(internalOptions, reporterPathOrModule, userOptions = {}) {
+    super(internalOptions);
+    this.reporterPathOrModule = reporterPathOrModule;
+    this.userOptions = userOptions;
+    this.setOutputStream(this.userOptions.outputFile);
+  }
+  printsToStdio() {
+    // currently always return true, b/c loading of custom reporter is async,
+    // but printsToStdio() is called synchronously at the beginning.
+    return true;
+  }
+  async init() {
+    const formatterOptions = this.buildFormatterOptions();
+    const FormatterConstructor = await this.loadFormatterFromFile();
+    this.formatter = new FormatterConstructor(formatterOptions);
+  }
+  async finished() {
+    var _this$formatter;
+    await ((_this$formatter = this.formatter) === null || _this$formatter === void 0 ? void 0 : _this$formatter.finished());
+    await super.finished();
+  }
+  async loadFormatterFromFile() {
+    // see: https://github.com/microsoft/playwright/blob/main/packages/playwright/src/common/config.ts#L225
+    const reporterPath = require.resolve(this.reporterPathOrModule, {
+      paths: [this.internalOptions.cwd]
+    });
+    return (0, _loadUtils.requireOrImportDefaultFunction)(reporterPath, true);
+  }
+  buildFormatterOptions() {
+    const colorFns = (0, _getColorFns.default)(this.outputStream, process.env, this.userOptions.colorsEnabled);
+    return {
+      cwd: this.internalOptions.cwd,
+      eventBroadcaster: this.eventBroadcaster,
+      eventDataCollector: this.eventDataCollector,
+      parsedArgvOptions: this.userOptions,
+      colorFns,
+      stream: this.outputStream,
+      log: this.outputStream.write.bind(this.outputStream),
+      cleanup: async () => {},
+      snippetBuilder: null,
+      supportCodeLibrary: {
+        World: {}
+      }
+    };
+  }
+}
+// const fakeSuportCodeLibrary = {
+//   parameterTypeRegistry: ParameterTypeRegistry;
+// stepDefinitions: StepDefinition[];
+// // eslint-disable-next-line @typescript-eslint/no-explicit-any
+// World: any;
+// originalCoordinates: ISupportCodeCoordinates;
+// }
+exports.default = CustomReporter;

package/build/bdd-framework/reporter/cucumber/helper.js

@@ -0,0 +1,12 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.cucumberReporter = cucumberReporter;
+function cucumberReporter(type, userOptions) {
+  return ['../../../bdd-framework/reporter/cucumber/index.js', {
+    $type: type,
+    ...(userOptions || {})
+  }];
+}

package/build/bdd-framework/reporter/cucumber/html.js

@@ -0,0 +1,40 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = void 0;
+var _promises = require("node:stream/promises");
+var _htmlFormatter = _interopRequireDefault(require("@cucumber/html-formatter"));
+var _utils = require("../../utils");
+var _path = _interopRequireDefault(require("path"));
+var _base = _interopRequireDefault(require("./base"));
+/**
+ * Cucumber html reporter.
+ * Based on: https://github.com/cucumber/cucumber-js/blob/main/src/formatter/html_formatter.ts
+ * See: https://github.com/cucumber/html-formatter
+ * See: https://github.com/cucumber/react-components
+ */
+
+class HtmlReporter extends _base.default {
+  userOptions;
+  htmlStream;
+  constructor(internalOptions, userOptions = {}) {
+    super(internalOptions);
+    this.userOptions = userOptions;
+    this.setOutputStream(this.userOptions.outputFile);
+    const packageRoot = (0, _utils.resolvePackageRoot)('@cucumber/html-formatter');
+    this.htmlStream = new _htmlFormatter.default(_path.default.join(packageRoot, 'dist/main.css'), _path.default.join(packageRoot, 'dist/main.js'));
+    this.eventBroadcaster.on('envelope', envelope => {
+      this.htmlStream.write(envelope);
+    });
+    this.htmlStream.pipe(this.outputStream);
+  }
+  async finished() {
+    this.htmlStream.end();
+    await (0, _promises.finished)(this.htmlStream);
+    await super.finished();
+  }
+}
+exports.default = HtmlReporter;

package/build/bdd-framework/reporter/cucumber/index.js

@@ -0,0 +1,74 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = void 0;
+var _events = _interopRequireDefault(require("events"));
+var _messagesBuilder = require("./messagesBuilder");
+var _configDir = require("../../config/configDir");
+var _enrichReporterData = require("../../config/enrichReporterData");
+var _message = _interopRequireDefault(require("./message"));
+var _html = _interopRequireDefault(require("./html"));
+var _junit = _interopRequireDefault(require("./junit"));
+var _json = _interopRequireDefault(require("./json"));
+var _custom = _interopRequireDefault(require("./custom"));
+/**
+ * Playwright reporter that generates different Cucumber reports.
+ */
+
+const builtinReporters = {
+  html: _html.default,
+  message: _message.default,
+  junit: _junit.default,
+  json: _json.default
+};
+class CucumberReporterAdapter {
+  messagesBuilderRef;
+  type;
+  userOptions;
+  reporter;
+  constructor(fullOptions) {
+    const {
+      $type,
+      ...userOptions
+    } = fullOptions;
+    this.type = $type;
+    this.userOptions = userOptions;
+    (0, _enrichReporterData.enableEnrichReporterData)();
+    this.messagesBuilderRef = (0, _messagesBuilder.getMessagesBuilderRef)();
+    this.reporter = this.createCucumberReporter();
+  }
+  printsToStdio() {
+    return this.reporter.printsToStdio();
+  }
+  onTestEnd(test, result) {
+    this.messagesBuilderRef.onTestEnd(test, result);
+  }
+  async onEnd(result) {
+    this.messagesBuilderRef.onEnd(result);
+    await this.reporter.init();
+    await this.messagesBuilderRef.builder.buildMessages();
+    this.messagesBuilderRef.builder.emitMessages(this.reporter.eventBroadcaster);
+    await this.reporter.finished();
+  }
+  createCucumberReporter() {
+    const internalOptions = {
+      cwd: (0, _configDir.getPlaywrightConfigDir)(),
+      eventBroadcaster: new _events.default(),
+      eventDataCollector: this.messagesBuilderRef.builder.eventDataCollector
+    };
+    if (isBuiltInReporter(this.type)) {
+      const BuiltInReporter = builtinReporters[this.type];
+      return new BuiltInReporter(internalOptions, this.userOptions);
+    } else {
+      const reporterPath = this.type;
+      return new _custom.default(internalOptions, reporterPath, this.userOptions);
+    }
+  }
+}
+exports.default = CucumberReporterAdapter;
+function isBuiltInReporter(type) {
+  return type in builtinReporters;
+}

package/build/bdd-framework/reporter/cucumber/json.js

@@ -0,0 +1,312 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = void 0;
+var messages = _interopRequireWildcard(require("@cucumber/messages"));
+var _base = _interopRequireDefault(require("./base"));
+var GherkinDocumentParser = _interopRequireWildcard(require("../../cucumber/formatter/GherkinDocumentParser"));
+var PickleParser = _interopRequireWildcard(require("../../cucumber/formatter/PickleParser"));
+var _valueChecker = require("../../cucumber/valueChecker");
+var _stepArguments = require("../../cucumber/stepArguments");
+var _durationHelpers = require("../../cucumber/formatter/durationHelpers");
+var _locationHelpers = require("../../cucumber/formatter/locationHelpers");
+var _GherkinDocument = require("./messagesBuilder/GherkinDocument");
+var _Projects = require("./messagesBuilder/Projects");
+function _getRequireWildcardCache(e) { if ("function" != typeof WeakMap) return null; var r = new WeakMap(), t = new WeakMap(); return (_getRequireWildcardCache = function (e) { return e ? t : r; })(e); }
+function _interopRequireWildcard(e, r) { if (!r && e && e.__esModule) return e; if (null === e || "object" != typeof e && "function" != typeof e) return { default: e }; var t = _getRequireWildcardCache(r); if (t && t.has(e)) return t.get(e); var n = { __proto__: null }, a = Object.defineProperty && Object.getOwnPropertyDescriptor; for (var u in e) if ("default" !== u && Object.prototype.hasOwnProperty.call(e, u)) { var i = a ? Object.getOwnPropertyDescriptor(e, u) : null; i && (i.get || i.set) ? Object.defineProperty(n, u, i) : n[u] = e[u]; } return n.default = e, t && t.set(e, n), n; }
+/**
+ * Cucumber json reporter.
+ * Based on: https://github.com/cucumber/cucumber-js/blob/main/src/formatter/json_formatter.ts
+ *
+ * Although json reporter is marked as deprecated in CucumberJS docs
+ * (see https://github.com/cucumber/cucumber-js/blob/main/docs/formatters.md#json),
+ * this decision was rolled back:
+ * (see https://github.com/cucumber/json-formatter/issues/34).
+ *
+ * See also: separate tool to convert cucumber messages to cucumber json:
+ * https://github.com/vrymar/cucumber-json-report-formatter/tree/master
+ */
+/* eslint-disable max-lines, max-statements, max-nested-callbacks, complexity */
+
+const {
+  getGherkinExampleRuleMap,
+  getGherkinScenarioLocationMap,
+  getGherkinStepMap,
+  getGherkinScenarioMap
+} = GherkinDocumentParser;
+const {
+  getScenarioDescription,
+  getPickleStepMap,
+  getStepKeyword
+} = PickleParser;
+class JsonReporter extends _base.default {
+  userOptions;
+  // for now omit step definitions
+  supportCodeLibrary = {
+    stepDefinitions: []
+  };
+  constructor(internalOptions, userOptions = {}) {
+    super(internalOptions);
+    this.userOptions = userOptions;
+    this.setOutputStream(this.userOptions.outputFile);
+    this.eventBroadcaster.on('envelope', envelope => {
+      if ((0, _valueChecker.doesHaveValue)(envelope.testRunFinished)) {
+        this.onTestRunFinished();
+      }
+    });
+  }
+  convertNameToId(obj) {
+    return obj.name.replace(/ /g, '-').toLowerCase();
+  }
+  formatDataTable(dataTable) {
+    return {
+      rows: dataTable.rows.map(row => ({
+        cells: row.cells.map(x => x.value)
+      }))
+    };
+  }
+  formatDocString(docString, gherkinStep) {
+    var _gherkinStep$docStrin;
+    return {
+      content: docString.content,
+      line: (_gherkinStep$docStrin = gherkinStep.docString) === null || _gherkinStep$docStrin === void 0 ? void 0 : _gherkinStep$docStrin.location.line
+    };
+  }
+  formatStepArgument(stepArgument, gherkinStep) {
+    if ((0, _valueChecker.doesNotHaveValue)(stepArgument)) {
+      return [];
+    }
+    return [(0, _stepArguments.parseStepArgument)(stepArgument, {
+      dataTable: dataTable => this.formatDataTable(dataTable),
+      docString: docString => this.formatDocString(docString, gherkinStep)
+    })];
+  }
+  onTestRunFinished() {
+    const groupedTestCaseAttempts = {};
+    this.eventDataCollector.getTestCaseAttempts().forEach(testCaseAttempt => {
+      if (!testCaseAttempt.willBeRetried) {
+        const uri = testCaseAttempt.pickle.uri;
+        if ((0, _valueChecker.doesNotHaveValue)(groupedTestCaseAttempts[uri])) {
+          groupedTestCaseAttempts[uri] = [];
+        }
+        groupedTestCaseAttempts[uri].push(testCaseAttempt);
+      }
+    });
+    const features = Object.keys(groupedTestCaseAttempts).map(uri => {
+      const group = groupedTestCaseAttempts[uri];
+      const {
+        gherkinDocument
+      } = group[0];
+      const gherkinStepMap = getGherkinStepMap(gherkinDocument);
+      const gherkinScenarioMap = getGherkinScenarioMap(gherkinDocument);
+      const gherkinExampleRuleMap = getGherkinExampleRuleMap(gherkinDocument);
+      const gherkinScenarioLocationMap = getGherkinScenarioLocationMap(gherkinDocument);
+      const elements = group.map(testCaseAttempt => {
+        const {
+          pickle
+        } = testCaseAttempt;
+        const pickleStepMap = getPickleStepMap(pickle);
+        let isBeforeHook = true;
+        const steps = testCaseAttempt.testCase.testSteps.map(testStep => {
+          isBeforeHook = isBeforeHook && !(0, _valueChecker.doesHaveValue)(testStep.pickleStepId);
+          return this.getStepData({
+            isBeforeHook,
+            gherkinStepMap,
+            pickleStepMap,
+            testStep,
+            testStepAttachments: testCaseAttempt.stepAttachments[testStep.id],
+            testStepResult: testCaseAttempt.stepResults[testStep.id]
+          });
+        });
+        return this.getScenarioData({
+          feature: gherkinDocument.feature,
+          gherkinScenarioLocationMap,
+          gherkinExampleRuleMap,
+          gherkinScenarioMap,
+          pickle,
+          steps
+        });
+      });
+      return this.getFeatureData({
+        gherkinDocument,
+        elements
+      });
+    });
+    this.outputStream.write(JSON.stringify(features, null, 2));
+  }
+  getFeatureData({
+    gherkinDocument,
+    elements
+  }) {
+    const meta = _GherkinDocument.GherkinDocumentMessage.extractMeta(gherkinDocument);
+    const feature = gherkinDocument.feature;
+    const featureNameWithProject = (0, _Projects.getFeatureNameWithProject)(meta.projectName, feature.name);
+    return {
+      description: feature.description,
+      elements,
+      id: this.convertNameToId({
+        name: featureNameWithProject
+      }),
+      line: feature.location.line,
+      keyword: feature.keyword,
+      name: this.userOptions.addProjectToFeatureName ? featureNameWithProject : feature.name,
+      tags: this.getFeatureTags(feature),
+      uri: meta.originalUri,
+      metadata: this.getFeatureMetadata(gherkinDocument)
+    };
+  }
+  getFeatureMetadata(gherkinDocument) {
+    if (!this.userOptions.addMetadata) {
+      return;
+    }
+    const meta = _GherkinDocument.GherkinDocumentMessage.extractMeta(gherkinDocument);
+    const metadata = {
+      Project: meta.projectName || '',
+      Browser: meta.browserName || ''
+    };
+    return this.userOptions.addMetadata === 'object' ? metadata : Object.keys(metadata).map(name => ({
+      name,
+      value: metadata[name]
+    }));
+  }
+  getScenarioData({
+    feature,
+    gherkinScenarioLocationMap,
+    gherkinExampleRuleMap,
+    gherkinScenarioMap,
+    pickle,
+    steps
+  }) {
+    const description = getScenarioDescription({
+      pickle,
+      gherkinScenarioMap
+    });
+    return {
+      description,
+      id: this.formatScenarioId({
+        feature,
+        pickle,
+        gherkinExampleRuleMap
+      }),
+      keyword: gherkinScenarioMap[pickle.astNodeIds[0]].keyword,
+      line: gherkinScenarioLocationMap[pickle.astNodeIds[pickle.astNodeIds.length - 1]].line,
+      name: pickle.name,
+      steps,
+      tags: this.getScenarioTags({
+        feature,
+        pickle,
+        gherkinScenarioMap
+      }),
+      type: 'scenario'
+    };
+  }
+  formatScenarioId({
+    feature,
+    pickle,
+    gherkinExampleRuleMap
+  }) {
+    let parts;
+    const rule = gherkinExampleRuleMap[pickle.astNodeIds[0]];
+    if ((0, _valueChecker.doesHaveValue)(rule)) {
+      parts = [feature, rule, pickle];
+    } else {
+      parts = [feature, pickle];
+    }
+    return parts.map(part => this.convertNameToId(part)).join(';');
+  }
+  getStepData({
+    isBeforeHook,
+    gherkinStepMap,
+    pickleStepMap,
+    testStep,
+    testStepAttachments,
+    testStepResult
+  }) {
+    const data = {};
+    if ((0, _valueChecker.doesHaveValue)(testStep.pickleStepId)) {
+      const pickleStep = pickleStepMap[testStep.pickleStepId];
+      data.arguments = this.formatStepArgument(pickleStep.argument, gherkinStepMap[pickleStep.astNodeIds[0]]);
+      data.keyword = getStepKeyword({
+        pickleStep,
+        gherkinStepMap
+      });
+      data.line = gherkinStepMap[pickleStep.astNodeIds[0]].location.line;
+      data.name = pickleStep.text;
+    } else {
+      data.keyword = isBeforeHook ? 'Before' : 'After';
+      data.hidden = true;
+    }
+    if ((0, _valueChecker.doesHaveValue)(testStep.stepDefinitionIds) && testStep.stepDefinitionIds.length === 1) {
+      const stepDefinition = this.supportCodeLibrary.stepDefinitions.find(s => {
+        var _testStep$stepDefinit;
+        return s.id === ((_testStep$stepDefinit = testStep.stepDefinitionIds) === null || _testStep$stepDefinit === void 0 ? void 0 : _testStep$stepDefinit[0]);
+      });
+      if ((0, _valueChecker.doesHaveValue)(stepDefinition)) {
+        data.match = {
+          location: (0, _locationHelpers.formatLocation)(stepDefinition)
+        };
+      }
+    }
+    const {
+      message,
+      status
+    } = testStepResult;
+    data.result = {
+      status: messages.TestStepResultStatus[status].toLowerCase()
+    };
+    if ((0, _valueChecker.doesHaveValue)(testStepResult.duration)) {
+      data.result.duration = (0, _durationHelpers.durationToNanoseconds)(testStepResult.duration);
+    }
+    if (status === messages.TestStepResultStatus.FAILED && (0, _valueChecker.doesHaveValue)(message)) {
+      data.result.error_message = message;
+    }
+    const allowedAttachments = this.getAllowedAttachments(testStepAttachments);
+    if (allowedAttachments && allowedAttachments.length > 0) {
+      data.embeddings = allowedAttachments.map(attachment => ({
+        data: attachment.contentEncoding === messages.AttachmentContentEncoding.IDENTITY ? Buffer.from(attachment.body).toString('base64') : attachment.body,
+        mime_type: attachment.mediaType
+      }));
+    }
+    return data;
+  }
+  getFeatureTags(feature) {
+    return feature.tags.map(tagData => ({
+      name: tagData.name,
+      line: tagData.location.line
+    }));
+  }
+  getScenarioTags({
+    feature,
+    pickle,
+    gherkinScenarioMap
+  }) {
+    const scenario = gherkinScenarioMap[pickle.astNodeIds[0]];
+    return pickle.tags.map(tagData => this.getScenarioTag(tagData, feature, scenario));
+  }
+  getScenarioTag(tagData, feature, scenario) {
+    var _tag$location;
+    const byAstNodeId = tag => tag.id === tagData.astNodeId;
+    const flatten = (acc, val) => acc.concat(val);
+    const tag = feature.tags.find(byAstNodeId) || scenario.tags.find(byAstNodeId) || scenario.examples.map(e => e.tags).reduce((acc, val) => flatten(acc, val), []).find(byAstNodeId);
+    return {
+      name: tagData.name,
+      line: tag === null || tag === void 0 || (_tag$location = tag.location) === null || _tag$location === void 0 ? void 0 : _tag$location.line
+    };
+  }
+  getAllowedAttachments(testStepAttachments) {
+    const {
+      skipAttachments
+    } = this.userOptions;
+    if (Array.isArray(skipAttachments)) {
+      return testStepAttachments === null || testStepAttachments === void 0 ? void 0 : testStepAttachments.filter(attachment => {
+        return !skipAttachments.includes(attachment.mediaType);
+      });
+    } else {
+      return skipAttachments ? [] : testStepAttachments;
+    }
+  }
+}
+exports.default = JsonReporter;