@autometa/jest-executor 0.0.0

package/.eslintignore

@@ -0,0 +1,3 @@
+/dist
+/out
+node_modules

package/.eslintrc.cjs

@@ -0,0 +1,4 @@
+module.exports = {
+  root: true,
+  extends: ["custom"],
+};

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) undefined Ben Aherne
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,3 @@
+# Introduction
+
+There's nothing here yet

package/dist/esm/index.js

@@ -0,0 +1,333 @@
+// src/executor.ts
+import {
+  ScenarioOutlineBridge,
+  find
+} from "@autometa/test-builder";
+import {
+  describe,
+  it,
+  expect,
+  beforeEach,
+  afterEach,
+  afterAll,
+  beforeAll
+} from "@jest/globals";
+import { getApp } from "@autometa/app";
+import { AutomationError } from "@autometa/errors";
+import { Query } from "@autometa/test-builder";
+function execute({ app, world }, bridge, events) {
+  const featureTitle = bridge.data.scope.title(bridge.data.gherkin);
+  const [group, modifier] = getGroupOrModifier(bridge);
+  beforeAll(() => {
+    events.feature.emitStart({
+      title: featureTitle,
+      path: bridge.data.scope.path,
+      modifier,
+      tags: [...bridge.data.gherkin.tags]
+    });
+  });
+  group(featureTitle, () => {
+    let localApp;
+    const staticApp = getApp(app, world);
+    beforeEach(() => {
+      localApp = getApp(app, world);
+    });
+    bootstrapSetupHooks(bridge, staticApp, events);
+    bootstrapBeforeHooks(bridge, () => localApp, events);
+    bootstrapBackground(bridge, () => localApp, events);
+    bootstrapScenarios(bridge, () => localApp, staticApp, events);
+    bootstrapRules(bridge, () => localApp, staticApp, events);
+    bootstrapAfterHooks(bridge, () => localApp, events);
+    bootstrapTeardownHooks(bridge, staticApp, events);
+  });
+  afterAll(() => {
+    const failures = Query.find.failed(bridge);
+    const status = modifier === "skip" ? "SKIPPED" : failures.length === 0 ? "PASSED" : "FAILED";
+    events.feature.emitEnd({
+      title: featureTitle,
+      modifier,
+      tags: [...bridge.data.gherkin.tags],
+      status
+    });
+  });
+}
+function bootstrapBackground(bridge, localApp, events) {
+  const background = bridge.background;
+  if (!background)
+    return;
+  const testName = expect.getState().currentTestName;
+  if (!testName)
+    throw new AutomationError("A Scenario must have a title");
+  const scenarioBridge = find(bridge, testName);
+  if (!scenarioBridge) {
+    throw new AutomationError(
+      `No matching scenario bridge was found matching the test name: ${testName}`
+    );
+  }
+  const tags = bridge?.data?.gherkin?.tags ?? [];
+  if (tags.has("@skip") || tags.has("@skipped"))
+    return;
+  beforeEach(async () => {
+    const title = background.data.scope.title(background.data.gherkin);
+    events.before.emitStart({
+      title,
+      tags: [...tags]
+    });
+    const steps = background.steps;
+    try {
+      for (const step of steps) {
+        await step.data.scope.execute(step.data.gherkin, localApp());
+      }
+    } catch (e) {
+      events.before.emitEnd({
+        title: background.data.scope.title(background.data.gherkin),
+        tags: [...tags],
+        status: "FAILED",
+        error: e
+      });
+      const message = `${title} failed to execute.
+Test: ${testName}`;
+      throw new AutomationError(message, { cause: e });
+    }
+  });
+}
+function bootstrapScenarios(bridge, localApp, staticApp, events) {
+  const { scenarios } = bridge;
+  scenarios.forEach((scenario) => {
+    if (isOutline(scenario)) {
+      bootstrapScenarioOutline(scenario, localApp, staticApp, events);
+      return;
+    }
+    bootstrapScenario(scenario, localApp, events);
+  });
+}
+function bootstrapScenario(bridge, localApp, events) {
+  const { data } = bridge;
+  const scenarioName = data.scope.title(data.gherkin);
+  const test = getTestOrModifier(bridge);
+  test(scenarioName, async () => {
+    events.scenario.emitStart({
+      title: scenarioName,
+      tags: [...data.gherkin.tags]
+    });
+    try {
+      for (const step of bridge.steps) {
+        await step.data.scope.execute(step.data.gherkin, localApp());
+      }
+    } catch (e) {
+      events.scenario.emitEnd({
+        title: scenarioName,
+        tags: [...data.gherkin.tags],
+        status: "FAILED",
+        error: e
+      });
+      const message = `${scenarioName} failed to execute.`;
+      throw new AutomationError(message, { cause: e });
+    }
+  });
+}
+function isOutline(data) {
+  return data instanceof ScenarioOutlineBridge;
+}
+function bootstrapScenarioOutline(bridge, localApp, staticApp, events) {
+  const {
+    data: { scope, gherkin },
+    examples
+  } = bridge;
+  const title = scope.title(gherkin);
+  const [group, modifier] = getGroupOrModifier(bridge);
+  group(title, () => {
+    beforeAll(() => {
+      events.scenarioOutline.emitStart({
+        title,
+        modifier,
+        tags: [...gherkin.tags]
+      });
+    });
+    bootstrapSetupHooks(bridge, staticApp, events);
+    bootstrapBeforeHooks(bridge, localApp, events);
+    examples.forEach((example) => {
+      bootstrapExamples(example, localApp, staticApp, events);
+    });
+    bootstrapAfterHooks(bridge, localApp, events);
+    bootstrapTeardownHooks(bridge, staticApp, events);
+    afterAll(() => {
+      const failures = Query.find.failed(bridge);
+      const status = modifier === "skip" ? "SKIPPED" : failures.length === 0 ? "PASSED" : "FAILED";
+      events.scenarioOutline.emitEnd({
+        title,
+        modifier,
+        tags: [...gherkin.tags],
+        status
+      });
+    });
+  });
+}
+function bootstrapExamples(example, localApp, staticApp, events) {
+  const title = example.data.scope.title(example.data.gherkin);
+  const [group] = getGroupOrModifier(example);
+  group(title, () => {
+    bootstrapScenarios(example, localApp, staticApp, events);
+  });
+}
+function bootstrapRules(bridge, localApp, staticApp, events) {
+  bridge.rules.forEach(({ data }) => {
+    const ruleName = data.scope.title(data.gherkin);
+    const [group, modifier] = getGroupOrModifier(bridge);
+    group(ruleName, () => {
+      beforeAll(() => {
+        events.rule.emitStart({
+          title: ruleName,
+          modifier,
+          tags: [...data.gherkin.tags]
+        });
+      });
+      bootstrapSetupHooks(bridge, staticApp, events);
+      bootstrapBeforeHooks(bridge, localApp, events);
+      bootstrapBackground(bridge, localApp, events);
+      bootstrapScenarios(bridge, localApp, staticApp, events);
+      bootstrapAfterHooks(bridge, localApp, events);
+      bootstrapTeardownHooks(bridge, staticApp, events);
+      afterAll(() => {
+        const failures = Query.find.failed(bridge);
+        const status = modifier === "skip" ? "SKIPPED" : failures.length === 0 ? "PASSED" : "FAILED";
+        events.rule.emitEnd({
+          title: ruleName,
+          modifier,
+          tags: [...data.gherkin.tags],
+          status
+        });
+      });
+    });
+  });
+}
+function getGroupOrModifier({
+  data
+}) {
+  if (data.gherkin.tags?.has("@skip") || data.gherkin.tags?.has("@skipped")) {
+    return [describe.skip, "skip"];
+  }
+  if (data.gherkin.tags?.has("@only")) {
+    return [describe.only, "only"];
+  }
+  return [describe, void 0];
+}
+function getTestOrModifier({ data }) {
+  if (data.gherkin.tags?.has("@skip") || data.gherkin.tags?.has("@skipped")) {
+    return it.skip;
+  }
+  if (data.gherkin.tags?.has("@only")) {
+    return it.only;
+  }
+  return it;
+}
+function bootstrapBeforeHooks(bridge, localApp, events) {
+  bridge.data.scope.hooks.before.forEach((hook) => {
+    const testName = expect.getState().currentTestName;
+    if (!testName)
+      throw new AutomationError("A Scenario must have a title");
+    const scenarioBridge = find(bridge, testName);
+    if (!scenarioBridge) {
+      throw new AutomationError(
+        `No matching scenario was found matching the test name: ${testName}`
+      );
+    }
+    const tags = scenarioBridge?.data?.gherkin?.tags ?? [];
+    beforeEach(async () => {
+      events.before.emitStart({
+        title: hook.name,
+        tags: [...tags]
+      });
+      const report = await hook.execute(localApp(), ...tags);
+      events.before.emitEnd({
+        title: hook.name,
+        tags: [...tags],
+        status: report.status,
+        error: report.error
+      });
+      if (report.error) {
+        const message = `${hook.name}: ${hook.description} failed to execute.`;
+        throw new AutomationError(message, { cause: report.error });
+      }
+    });
+  });
+}
+function bootstrapSetupHooks(bridge, staticApp, events) {
+  bridge.data.scope.hooks.setup.forEach((hook) => {
+    const tags = bridge.data.gherkin.tags ?? [];
+    beforeAll(async () => {
+      events.setup.emitStart({
+        title: hook.name
+      });
+      const report = await hook.execute(staticApp, ...tags);
+      events.setup.emitEnd({
+        title: hook.name,
+        status: report.status,
+        error: report.error
+      });
+      if (report.error) {
+        const message = `${hook.name}: ${hook.description} failed to execute.`;
+        throw new AutomationError(message, { cause: report.error });
+      }
+    });
+  });
+}
+function bootstrapAfterHooks(bridge, localApp, events) {
+  bridge.data.scope.hooks.after.forEach((hook) => {
+    const testName = expect.getState().currentTestName;
+    if (!testName)
+      throw new AutomationError("A Scenario must have a title");
+    const scenarioBridge = find(bridge, testName);
+    if (!scenarioBridge) {
+      throw new AutomationError(
+        `No matching scenario bridge was found matching the test name: ${testName}`
+      );
+    }
+    const tags = scenarioBridge?.data?.gherkin?.tags ?? [];
+    afterEach(async () => {
+      events.after.emitStart({
+        title: hook.name,
+        tags: [...tags]
+      });
+      const report = await hook.execute(localApp(), ...tags);
+      events.after.emitEnd({
+        title: hook.name,
+        tags: [...tags],
+        status: report.status,
+        error: report.error
+      });
+      if (report.error) {
+        const message = `${hook.name}: ${hook.description} failed to execute.`;
+        throw new AutomationError(message, { cause: report.error });
+      }
+    });
+  });
+}
+function bootstrapTeardownHooks(bridge, staticApp, event) {
+  const tags = bridge.data.gherkin.tags ?? [];
+  bridge.data.scope.hooks.teardown.forEach((hook) => {
+    afterAll(async () => {
+      event.teardown.emitStart({
+        title: hook.name,
+        tags: [...tags]
+      });
+      const report = await hook.execute(staticApp, ...tags);
+      event.teardown.emitEnd({
+        title: hook.name,
+        tags: [...tags],
+        status: report.status,
+        error: report.error
+      });
+      if (report.error) {
+        const message = `${hook.name}: ${hook.description} failed to execute.`;
+        throw new AutomationError(message, { cause: report.error });
+      }
+    });
+  });
+}
+
+// src/index.ts
+var src_default = execute;
+export {
+  src_default as default
+};

package/dist/index.d.ts

@@ -0,0 +1,11 @@
+import { FeatureBridge } from '@autometa/test-builder';
+import { AutometaApp, AutometaWorld } from '@autometa/app';
+import { Class } from '@autometa/types';
+import { TestEventEmitter } from '@autometa/events';
+
+declare function execute({ app, world }: {
+    app: Class<AutometaApp>;
+    world: Class<AutometaWorld>;
+}, bridge: FeatureBridge, events: TestEventEmitter): void;
+
+export { execute as default };

package/dist/index.js

@@ -0,0 +1,345 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+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 __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/index.ts
+var src_exports = {};
+__export(src_exports, {
+  default: () => src_default
+});
+module.exports = __toCommonJS(src_exports);
+
+// src/executor.ts
+var import_test_builder = require("@autometa/test-builder");
+var import_globals = require("@jest/globals");
+var import_app = require("@autometa/app");
+var import_errors = require("@autometa/errors");
+var import_test_builder2 = require("@autometa/test-builder");
+function execute({ app, world }, bridge, events) {
+  const featureTitle = bridge.data.scope.title(bridge.data.gherkin);
+  const [group, modifier] = getGroupOrModifier(bridge);
+  (0, import_globals.beforeAll)(() => {
+    events.feature.emitStart({
+      title: featureTitle,
+      path: bridge.data.scope.path,
+      modifier,
+      tags: [...bridge.data.gherkin.tags]
+    });
+  });
+  group(featureTitle, () => {
+    let localApp;
+    const staticApp = (0, import_app.getApp)(app, world);
+    (0, import_globals.beforeEach)(() => {
+      localApp = (0, import_app.getApp)(app, world);
+    });
+    bootstrapSetupHooks(bridge, staticApp, events);
+    bootstrapBeforeHooks(bridge, () => localApp, events);
+    bootstrapBackground(bridge, () => localApp, events);
+    bootstrapScenarios(bridge, () => localApp, staticApp, events);
+    bootstrapRules(bridge, () => localApp, staticApp, events);
+    bootstrapAfterHooks(bridge, () => localApp, events);
+    bootstrapTeardownHooks(bridge, staticApp, events);
+  });
+  (0, import_globals.afterAll)(() => {
+    const failures = import_test_builder2.Query.find.failed(bridge);
+    const status = modifier === "skip" ? "SKIPPED" : failures.length === 0 ? "PASSED" : "FAILED";
+    events.feature.emitEnd({
+      title: featureTitle,
+      modifier,
+      tags: [...bridge.data.gherkin.tags],
+      status
+    });
+  });
+}
+function bootstrapBackground(bridge, localApp, events) {
+  const background = bridge.background;
+  if (!background)
+    return;
+  const testName = import_globals.expect.getState().currentTestName;
+  if (!testName)
+    throw new import_errors.AutomationError("A Scenario must have a title");
+  const scenarioBridge = (0, import_test_builder.find)(bridge, testName);
+  if (!scenarioBridge) {
+    throw new import_errors.AutomationError(
+      `No matching scenario bridge was found matching the test name: ${testName}`
+    );
+  }
+  const tags = bridge?.data?.gherkin?.tags ?? [];
+  if (tags.has("@skip") || tags.has("@skipped"))
+    return;
+  (0, import_globals.beforeEach)(async () => {
+    const title = background.data.scope.title(background.data.gherkin);
+    events.before.emitStart({
+      title,
+      tags: [...tags]
+    });
+    const steps = background.steps;
+    try {
+      for (const step of steps) {
+        await step.data.scope.execute(step.data.gherkin, localApp());
+      }
+    } catch (e) {
+      events.before.emitEnd({
+        title: background.data.scope.title(background.data.gherkin),
+        tags: [...tags],
+        status: "FAILED",
+        error: e
+      });
+      const message = `${title} failed to execute.
+Test: ${testName}`;
+      throw new import_errors.AutomationError(message, { cause: e });
+    }
+  });
+}
+function bootstrapScenarios(bridge, localApp, staticApp, events) {
+  const { scenarios } = bridge;
+  scenarios.forEach((scenario) => {
+    if (isOutline(scenario)) {
+      bootstrapScenarioOutline(scenario, localApp, staticApp, events);
+      return;
+    }
+    bootstrapScenario(scenario, localApp, events);
+  });
+}
+function bootstrapScenario(bridge, localApp, events) {
+  const { data } = bridge;
+  const scenarioName = data.scope.title(data.gherkin);
+  const test = getTestOrModifier(bridge);
+  test(scenarioName, async () => {
+    events.scenario.emitStart({
+      title: scenarioName,
+      tags: [...data.gherkin.tags]
+    });
+    try {
+      for (const step of bridge.steps) {
+        await step.data.scope.execute(step.data.gherkin, localApp());
+      }
+    } catch (e) {
+      events.scenario.emitEnd({
+        title: scenarioName,
+        tags: [...data.gherkin.tags],
+        status: "FAILED",
+        error: e
+      });
+      const message = `${scenarioName} failed to execute.`;
+      throw new import_errors.AutomationError(message, { cause: e });
+    }
+  });
+}
+function isOutline(data) {
+  return data instanceof import_test_builder.ScenarioOutlineBridge;
+}
+function bootstrapScenarioOutline(bridge, localApp, staticApp, events) {
+  const {
+    data: { scope, gherkin },
+    examples
+  } = bridge;
+  const title = scope.title(gherkin);
+  const [group, modifier] = getGroupOrModifier(bridge);
+  group(title, () => {
+    (0, import_globals.beforeAll)(() => {
+      events.scenarioOutline.emitStart({
+        title,
+        modifier,
+        tags: [...gherkin.tags]
+      });
+    });
+    bootstrapSetupHooks(bridge, staticApp, events);
+    bootstrapBeforeHooks(bridge, localApp, events);
+    examples.forEach((example) => {
+      bootstrapExamples(example, localApp, staticApp, events);
+    });
+    bootstrapAfterHooks(bridge, localApp, events);
+    bootstrapTeardownHooks(bridge, staticApp, events);
+    (0, import_globals.afterAll)(() => {
+      const failures = import_test_builder2.Query.find.failed(bridge);
+      const status = modifier === "skip" ? "SKIPPED" : failures.length === 0 ? "PASSED" : "FAILED";
+      events.scenarioOutline.emitEnd({
+        title,
+        modifier,
+        tags: [...gherkin.tags],
+        status
+      });
+    });
+  });
+}
+function bootstrapExamples(example, localApp, staticApp, events) {
+  const title = example.data.scope.title(example.data.gherkin);
+  const [group] = getGroupOrModifier(example);
+  group(title, () => {
+    bootstrapScenarios(example, localApp, staticApp, events);
+  });
+}
+function bootstrapRules(bridge, localApp, staticApp, events) {
+  bridge.rules.forEach(({ data }) => {
+    const ruleName = data.scope.title(data.gherkin);
+    const [group, modifier] = getGroupOrModifier(bridge);
+    group(ruleName, () => {
+      (0, import_globals.beforeAll)(() => {
+        events.rule.emitStart({
+          title: ruleName,
+          modifier,
+          tags: [...data.gherkin.tags]
+        });
+      });
+      bootstrapSetupHooks(bridge, staticApp, events);
+      bootstrapBeforeHooks(bridge, localApp, events);
+      bootstrapBackground(bridge, localApp, events);
+      bootstrapScenarios(bridge, localApp, staticApp, events);
+      bootstrapAfterHooks(bridge, localApp, events);
+      bootstrapTeardownHooks(bridge, staticApp, events);
+      (0, import_globals.afterAll)(() => {
+        const failures = import_test_builder2.Query.find.failed(bridge);
+        const status = modifier === "skip" ? "SKIPPED" : failures.length === 0 ? "PASSED" : "FAILED";
+        events.rule.emitEnd({
+          title: ruleName,
+          modifier,
+          tags: [...data.gherkin.tags],
+          status
+        });
+      });
+    });
+  });
+}
+function getGroupOrModifier({
+  data
+}) {
+  if (data.gherkin.tags?.has("@skip") || data.gherkin.tags?.has("@skipped")) {
+    return [import_globals.describe.skip, "skip"];
+  }
+  if (data.gherkin.tags?.has("@only")) {
+    return [import_globals.describe.only, "only"];
+  }
+  return [import_globals.describe, void 0];
+}
+function getTestOrModifier({ data }) {
+  if (data.gherkin.tags?.has("@skip") || data.gherkin.tags?.has("@skipped")) {
+    return import_globals.it.skip;
+  }
+  if (data.gherkin.tags?.has("@only")) {
+    return import_globals.it.only;
+  }
+  return import_globals.it;
+}
+function bootstrapBeforeHooks(bridge, localApp, events) {
+  bridge.data.scope.hooks.before.forEach((hook) => {
+    const testName = import_globals.expect.getState().currentTestName;
+    if (!testName)
+      throw new import_errors.AutomationError("A Scenario must have a title");
+    const scenarioBridge = (0, import_test_builder.find)(bridge, testName);
+    if (!scenarioBridge) {
+      throw new import_errors.AutomationError(
+        `No matching scenario was found matching the test name: ${testName}`
+      );
+    }
+    const tags = scenarioBridge?.data?.gherkin?.tags ?? [];
+    (0, import_globals.beforeEach)(async () => {
+      events.before.emitStart({
+        title: hook.name,
+        tags: [...tags]
+      });
+      const report = await hook.execute(localApp(), ...tags);
+      events.before.emitEnd({
+        title: hook.name,
+        tags: [...tags],
+        status: report.status,
+        error: report.error
+      });
+      if (report.error) {
+        const message = `${hook.name}: ${hook.description} failed to execute.`;
+        throw new import_errors.AutomationError(message, { cause: report.error });
+      }
+    });
+  });
+}
+function bootstrapSetupHooks(bridge, staticApp, events) {
+  bridge.data.scope.hooks.setup.forEach((hook) => {
+    const tags = bridge.data.gherkin.tags ?? [];
+    (0, import_globals.beforeAll)(async () => {
+      events.setup.emitStart({
+        title: hook.name
+      });
+      const report = await hook.execute(staticApp, ...tags);
+      events.setup.emitEnd({
+        title: hook.name,
+        status: report.status,
+        error: report.error
+      });
+      if (report.error) {
+        const message = `${hook.name}: ${hook.description} failed to execute.`;
+        throw new import_errors.AutomationError(message, { cause: report.error });
+      }
+    });
+  });
+}
+function bootstrapAfterHooks(bridge, localApp, events) {
+  bridge.data.scope.hooks.after.forEach((hook) => {
+    const testName = import_globals.expect.getState().currentTestName;
+    if (!testName)
+      throw new import_errors.AutomationError("A Scenario must have a title");
+    const scenarioBridge = (0, import_test_builder.find)(bridge, testName);
+    if (!scenarioBridge) {
+      throw new import_errors.AutomationError(
+        `No matching scenario bridge was found matching the test name: ${testName}`
+      );
+    }
+    const tags = scenarioBridge?.data?.gherkin?.tags ?? [];
+    (0, import_globals.afterEach)(async () => {
+      events.after.emitStart({
+        title: hook.name,
+        tags: [...tags]
+      });
+      const report = await hook.execute(localApp(), ...tags);
+      events.after.emitEnd({
+        title: hook.name,
+        tags: [...tags],
+        status: report.status,
+        error: report.error
+      });
+      if (report.error) {
+        const message = `${hook.name}: ${hook.description} failed to execute.`;
+        throw new import_errors.AutomationError(message, { cause: report.error });
+      }
+    });
+  });
+}
+function bootstrapTeardownHooks(bridge, staticApp, event) {
+  const tags = bridge.data.gherkin.tags ?? [];
+  bridge.data.scope.hooks.teardown.forEach((hook) => {
+    (0, import_globals.afterAll)(async () => {
+      event.teardown.emitStart({
+        title: hook.name,
+        tags: [...tags]
+      });
+      const report = await hook.execute(staticApp, ...tags);
+      event.teardown.emitEnd({
+        title: hook.name,
+        tags: [...tags],
+        status: report.status,
+        error: report.error
+      });
+      if (report.error) {
+        const message = `${hook.name}: ${hook.description} failed to execute.`;
+        throw new import_errors.AutomationError(message, { cause: report.error });
+      }
+    });
+  });
+}
+
+// src/index.ts
+var src_default = execute;

package/package.json

@@ -0,0 +1,60 @@
+{
+  "name": "@autometa/jest-executor",
+  "version": "0.0.0",
+  "description": "",
+  "type": "module",
+  "main": "dist/index.js",
+  "module": "dist/esm/index.js",
+  "types": "dist/index.d.ts",
+  "exports": {
+    "import": "./dist/esm/index.js",
+    "require": "./dist/index.js",
+    "default": "./dist/esm/index.js",
+    "types": "./dist/index.d.ts"
+  },
+  "license": "MIT",
+  "devDependencies": {
+    "@cucumber/cucumber-expressions": "^16.1.2",
+    "@jest/globals": "^29.5.0",
+    "@types/node": "^18.11.18",
+    "@types/uuid": "^9.0.1",
+    "@typescript-eslint/eslint-plugin": "^5.54.1",
+    "@typescript-eslint/parser": "^5.54.1",
+    "eslint": "^8.37.0",
+    "eslint-config-custom": "0.5.1",
+    "eslint-config-prettier": "^8.3.0",
+    "jest": "^29.5.0",
+    "rimraf": "^4.1.2",
+    "ts-jest": "^29.1.1",
+    "ts-node": "^10.9.1",
+    "tsconfig": " *",
+    "tsup": "^6.7.0",
+    "typescript": "^4.9.5",
+    "vitest": "^0.29.8"
+  },
+  "peerDependencies": {
+    "@jest/globals": "^29.5.0",
+    "jest": "^29.5.0"
+  },
+  "dependencies": {
+    "@autometa/app": "^0.0.0",
+    "@autometa/asserters": "^0.0.0",
+    "@autometa/config": "^0.0.0",
+    "@autometa/errors": "^0.0.0",
+    "@autometa/events": "^0.0.10",
+    "@autometa/gherkin": "^0.3.3",
+    "@autometa/scopes": "^0.1.10",
+    "@autometa/test-builder": "^0.0.0",
+    "@autometa/types": "^0.3.1"
+  },
+  "scripts": {
+    "test": "vitest run --passWithNoTests",
+    "prettify": "prettier --config .prettierrc 'src/**/*.ts' --write",
+    "lint": "eslint . --max-warnings 0",
+    "lint:fix": "eslint . --fix",
+    "clean": "rimraf dist",
+    "build": "tsup",
+    "build:watch": "tsup --watch"
+  },
+  "readme": "# Introduction\n\nThere's nothing here yet"
+}

package/tsup.config.ts

@@ -0,0 +1,14 @@
+import { defineConfig } from "tsup";
+
+export default defineConfig({
+  clean: true, // clean up the dist folder
+  format: ["cjs", "esm"], // generate cjs and esm files
+  dts: true,
+  sourcemap: false, // generate sourcemaps
+  skipNodeModulesBundle: true,
+  entryPoints: ["src/index.ts"],
+  target: "es2020",
+  outDir: "dist",
+  legacyOutput: true,
+  external: ["dist"],
+});