@autometa/jest-executor 0.6.3 → 1.0.0-rc.2

package/dist/esm/index.js

@@ -1,982 +0,0 @@
-var __require = /* @__PURE__ */ ((x) => typeof require !== "undefined" ? require : typeof Proxy !== "undefined" ? new Proxy(x, {
-  get: (a, b) => (typeof require !== "undefined" ? require : a)[b]
-}) : x)(function(x) {
-  if (typeof require !== "undefined")
-    return require.apply(this, arguments);
-  throw Error('Dynamic require of "' + x + '" is not supported');
-});
-
-// src/executor.ts
-import {
-  ScenarioOutlineBridge,
-  find,
-  GlobalBridge
-} from "@autometa/test-builder";
-import {
-  describe,
-  it,
-  expect,
-  beforeEach,
-  afterEach,
-  afterAll,
-  beforeAll,
-  jest
-} from "@jest/globals";
-import { AutomationError, formatErrorCauses, raise } from "@autometa/errors";
-import { Query } from "@autometa/test-builder";
-
-// src/timeout-selector.ts
-import { NullTimeout, Timeout } from "@autometa/scopes";
-function getTimeout(target, config) {
-  if (target && !(target instanceof NullTimeout)) {
-    return target;
-  }
-  return Timeout.from(config?.current?.test?.timeout);
-}
-function chooseTimeout(timeout1, timeout2) {
-  if (timeout2 instanceof Timeout && !(timeout2 instanceof NullTimeout)) {
-    return {
-      getTimeout: getTimeout.bind(null, timeout2)
-    };
-  }
-  if (timeout1 instanceof Timeout && !(timeout1 instanceof NullTimeout)) {
-    return {
-      getTimeout: getTimeout.bind(null, timeout1)
-    };
-  }
-  return {
-    getTimeout: getTimeout.bind(null, Timeout.from(0))
-  };
-}
-
-// src/executor.ts
-import { NullTimeout as NullTimeout2, Timeout as Timeout2 } from "@autometa/scopes";
-import { Container, defineContainerContext } from "@autometa/injection";
-import { isTagsMatch } from "@autometa/gherkin";
-var outlineApps = /* @__PURE__ */ new Map();
-var examplesApps = /* @__PURE__ */ new Map();
-var featureApps = /* @__PURE__ */ new Map();
-var ruleApps = /* @__PURE__ */ new Map();
-function execute({ app, world }, global, bridge, events, config) {
-  const globalBridge = new GlobalBridge(global);
-  const featureTitle = bridge.data.scope.title(bridge.data.gherkin);
-  const [group, modifier] = getGroupOrModifier(
-    bridge,
-    config.current.test?.tagFilter
-  );
-  const chosenTimeout = chooseTimeout(
-    new NullTimeout2(),
-    bridge.data.scope.timeout
-  ).getTimeout(config);
-  beforeAll(() => {
-    events.feature.emitStart({
-      title: featureTitle,
-      path: bridge.data.scope.path,
-      modifier,
-      tags: [...bridge.data.gherkin.tags]
-    });
-  }, chosenTimeout.milliseconds);
-  group(featureTitle, () => {
-    const tags = [...bridge.data.gherkin.tags];
-    const retries = tags.find((tag) => tag.startsWith("@retries="));
-    let testContainerContext;
-    let testContainer;
-    let localApp;
-    const globalContainerContext = defineContainerContext("global");
-    const globalContainer = new Container(globalContainerContext);
-    globalContainer.registerCached(world);
-    const staticApp = globalContainer.get(app);
-    staticApp.world = globalContainer.get(world);
-    staticApp.di = globalContainer;
-    beforeAll(() => {
-      if (retries) {
-        const count = parseInt(retries.split("=")[1]);
-        jest.retryTimes(count);
-      }
-    });
-    beforeEach(() => {
-      const name = expect.getState().currentTestName ?? raise("A test must have a name");
-      testContainerContext = defineContainerContext(name);
-      testContainer = new Container(testContainerContext);
-      testContainer.registerCached(world);
-      localApp = testContainer.get(app);
-      localApp.world = testContainer.get(world);
-      localApp.di = testContainer;
-      if (!featureApps.has(name)) {
-        featureApps.set(name, []);
-      }
-      featureApps.get(name)?.push(localApp);
-    });
-    bridge.data.scope.hooks.beforeFeatureHooks.forEach((hook) => {
-      const hookTimeout = chooseTimeout(
-        chosenTimeout,
-        hook.options.timeout
-      ).getTimeout(config).milliseconds;
-      beforeAll(async () => {
-        const tags2 = bridge?.data?.gherkin?.tags ?? [];
-        if (!hook.canExecute(...tags2)) {
-          return;
-        }
-        events.beforeFeature.emitStart({
-          title: hook.description,
-          tags: [...tags2]
-        });
-        const report = await hook.execute(staticApp, ...tags2);
-        if (report.error) {
-          const message = `${hook.name}: ${hook.description} failed to execute.`;
-          events.beforeFeature.emitEnd({
-            title: hook.description,
-            tags: [...tags2],
-            status: "FAILED",
-            error: report.error
-          });
-          throw new AutomationError(message, { cause: report.error });
-        }
-        events.beforeFeature.emitEnd({
-          title: hook.description,
-          tags: [...tags2],
-          status: "PASSED"
-        });
-      }, hookTimeout);
-    });
-    bridge.data.scope.hooks.afterFeatureHooks.forEach((hook) => {
-      const hookTimeout = chooseTimeout(
-        chosenTimeout,
-        hook.options.timeout
-      ).getTimeout(config).milliseconds;
-      afterAll(async () => {
-        const tags2 = bridge?.data?.gherkin?.tags ?? [];
-        if (!hook.canExecute(...bridge.data.gherkin.tags)) {
-          return;
-        }
-        events.afterFeature.emitStart({
-          title: hook.description,
-          tags: [...tags2]
-        });
-        const testName = expect.getState().currentTestName;
-        const apps = featureApps.get(testName);
-        const report = await hook.execute(staticApp, apps, ...tags2);
-        if (report.error) {
-          const message = `${hook.name}: ${hook.description} failed to execute.`;
-          events.afterFeature.emitEnd({
-            title: hook.description,
-            tags: [...tags2],
-            status: "FAILED",
-            error: report.error
-          });
-          throw new AutomationError(message, { cause: report.error });
-        }
-        events.afterFeature.emitEnd({
-          title: hook.description,
-          tags: [...tags2],
-          status: "PASSED"
-        });
-      }, hookTimeout);
-    });
-    bootstrapSetupHooks(globalBridge, staticApp, events, [
-      config,
-      chosenTimeout
-    ]);
-    bootstrapSetupHooks(bridge, staticApp, events, [config, chosenTimeout]);
-    bootstrapBeforeHooks(
-      bridge,
-      globalBridge,
-      () => [testContainer, localApp],
-      events,
-      [config, chosenTimeout]
-    );
-    bootstrapBeforeHooks(
-      bridge,
-      bridge,
-      () => [testContainer, localApp],
-      events,
-      [config, chosenTimeout]
-    );
-    bootstrapBackground(bridge, bridge, () => [testContainer, localApp], events, [
-      config,
-      chosenTimeout
-    ]);
-    bootstrapScenarios(
-      bridge,
-      bridge,
-      () => [testContainer, localApp],
-      staticApp,
-      events,
-      [config, chosenTimeout]
-    );
-    bootstrapRules(bridge, () => [testContainer, localApp], staticApp, events, [
-      config,
-      chosenTimeout
-    ]);
-    bootstrapAfterHooks(bridge, bridge, () => [testContainer, localApp], events, [
-      config,
-      chosenTimeout
-    ]);
-    bootstrapAfterHooks(bridge, globalBridge, () => [testContainer, localApp], events, [
-      config,
-      chosenTimeout
-    ]);
-    bootstrapTeardownHooks(globalBridge, staticApp, events, [
-      config,
-      chosenTimeout
-    ]);
-    bootstrapTeardownHooks(bridge, staticApp, events, [config, chosenTimeout]);
-    afterAll(async () => {
-      await globalContainer.disposeGlobal(tags, isTagsMatch);
-    });
-  });
-  afterAll(async () => {
-    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
-    });
-    const settled = await events.settleAsyncEvents();
-    const failedCount = settled.filter((e) => e.status === "rejected").length;
-    if (failedCount > 0) {
-      const count = `${failedCount}/${settled.length}`;
-      const message = `${count} asynchronous Test Events were rejected.`;
-      console.warn(message);
-    }
-    featureApps.clear();
-    outlineApps.clear();
-    examplesApps.clear();
-    ruleApps.clear();
-  });
-}
-function bootstrapBackground(root, bridge, localApp, events, [config, timeout]) {
-  const background = bridge.background;
-  if (!background)
-    return;
-  const chosenTimeout = chooseTimeout(
-    timeout,
-    bridge.data.scope.timeout
-  ).getTimeout(config).milliseconds;
-  const tags = bridge?.data?.gherkin?.tags ?? [];
-  if (tags.has("@skip") || tags.has("@skipped"))
-    return;
-  beforeEach(async () => {
-    const testName = expect.getState().currentTestName;
-    if (!testName)
-      throw new AutomationError("A Scenario must have a title");
-    const scenarioBridge = find(root, testName);
-    if (!scenarioBridge) {
-      throw new AutomationError(
-        `No matching scenario bridge was found matching the test name: ${testName}`
-      );
-    }
-    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) {
-        const [_, app] = localApp();
-        const args = step.args?.(app) ?? [];
-        const title2 = step.data.scope.stepText(
-          step.data.gherkin.keyword,
-          step.data.gherkin.text
-        );
-        events.step.emitStart({
-          title: title2,
-          args,
-          expression: step.data.scope.expression.source
-        });
-        await step.data.scope.execute(step.data.gherkin, args, app);
-        events.step.emitEnd({
-          expression: step.data.scope.expression.source,
-          title: title2,
-          args
-        });
-      }
-      events.before.emitEnd({
-        title,
-        tags: [...tags],
-        status: "PASSED"
-      });
-    } catch (e) {
-      events.before.emitEnd({
-        title,
-        tags: [...tags],
-        status: "FAILED",
-        error: e
-      });
-      const message = `${title} failed to execute.
-Test: ${testName}`;
-      throw new AutomationError(message, { cause: e });
-    }
-  }, chosenTimeout);
-}
-function bootstrapScenarios(root, bridge, localApp, staticApp, events, [config, timeout]) {
-  const { scenarios } = bridge;
-  const chosenTimeout = chooseTimeout(
-    timeout,
-    bridge.data.scope.timeout
-  ).getTimeout(config);
-  scenarios.forEach((scenario) => {
-    if (isOutline(scenario)) {
-      bootstrapScenarioOutline(root, scenario, localApp, staticApp, events, [
-        config,
-        chosenTimeout
-      ]);
-      return;
-    }
-    bootstrapScenario(scenario, localApp, events, [config, chosenTimeout]);
-  });
-}
-function bootstrapScenario(bridge, localApp, events, [config, timeout]) {
-  const { data } = bridge;
-  const chosenTimeout = chooseTimeout(
-    timeout,
-    bridge.data.scope.timeout
-  ).getTimeout(config);
-  const scenarioName = data.scope.title(data.gherkin);
-  const test = getTestOrModifier(bridge, config.current.test?.tagFilter);
-  test(
-    scenarioName,
-    async () => {
-      events.scenario.emitStart({
-        title: bridge.title,
-        tags: bridge.tags
-      });
-      const [container, app] = localApp();
-      try {
-        for (const step of bridge.steps) {
-          await tryRunStep(step, events, bridge, () => app);
-        }
-        bridge.report = { passed: true };
-        events.scenario.emitEnd({
-          title: bridge.title,
-          tags: bridge.tags,
-          status: "PASSED"
-        });
-      } catch (e) {
-        const error = e;
-        bridge.report = { passed: false, error: e };
-        events.scenario.emitEnd({
-          title: bridge.title,
-          tags: bridge.tags,
-          status: "FAILED",
-          error
-        });
-        const message = `${bridge.title} failed while executing a step`;
-        const meta = { cause: error };
-        throw new AutomationError(message, meta);
-      } finally {
-        await container.disposeAll(bridge.tags, isTagsMatch);
-      }
-    },
-    chosenTimeout.milliseconds
-  );
-}
-async function tryRunStep(step, events, bridge, localApp) {
-  await bootstrapStep(step, events, bridge, localApp);
-}
-async function bootstrapStep(step, events, bridge, localApp) {
-  const title = step.data.scope.stepText(
-    step.data.gherkin.keyword,
-    step.data.gherkin.text
-  );
-  let args = [];
-  try {
-    const app = localApp();
-    args = step.args?.(app) ?? [];
-    events.step.emitStart({
-      title,
-      args,
-      expression: step.expressionText
-    });
-    await step.data.scope.execute(step.data.gherkin, args, app);
-    events.step.emitEnd({
-      expression: step.expressionText,
-      title,
-      args,
-      status: "PASSED"
-    });
-  } catch (e) {
-    const error = e;
-    events.step.emitEnd({
-      expression: step.expressionText,
-      title,
-      args,
-      status: "FAILED",
-      error: e
-    });
-    const message = `${title} experienced an error`;
-    const meta = { cause: error };
-    const newError = new AutomationError(message, meta);
-    console.error(formatErrorCauses(newError));
-    throw newError;
-  }
-}
-function isOutline(data) {
-  return data instanceof ScenarioOutlineBridge;
-}
-function bootstrapScenarioOutline(root, bridge, localApp, staticApp, events, [config, timeout]) {
-  const {
-    data: { scope, gherkin },
-    examples
-  } = bridge;
-  const title = scope.title(gherkin);
-  const retry = [...gherkin.tags].find((tag) => tag.startsWith("@retries="));
-  const { beforeScenarioOutlineHooks, afterScenarioOutlineHooks } = scope.hooks;
-  const [group, modifier] = getGroupOrModifier(
-    bridge,
-    config.current.test?.tagFilter
-  );
-  const chosenTimeout = chooseTimeout(
-    timeout,
-    bridge.data.scope.timeout
-  ).getTimeout(config).milliseconds;
-  const original = localApp;
-  localApp = () => {
-    const testName = expect.getState().currentTestName;
-    if (!outlineApps.has(testName)) {
-      outlineApps.set(testName, []);
-    }
-    const apps = outlineApps.get(testName);
-    const [container, app] = original();
-    apps.push(app);
-    return [container, app];
-  };
-  group(title, () => {
-    beforeScenarioOutlineHooks.forEach((hook) => {
-      const hookTimeout = chooseTimeout(
-        timeout,
-        hook.options.timeout
-      ).getTimeout(config).milliseconds;
-      beforeAll(async () => {
-        if (!hook.canExecute(...gherkin.tags)) {
-          return;
-        }
-        events.beforeScenarioOutline.emitStart({
-          title,
-          modifier,
-          tags: [...gherkin.tags]
-        });
-        const tags = gherkin.tags ?? [];
-        events.beforeScenarioOutline.emitStart({
-          title,
-          modifier,
-          tags: [...gherkin.tags]
-        });
-        const report = await hook.execute(staticApp, ...tags);
-        if (report.error) {
-          const message = `${hook.name}: ${hook.description} failed to execute.`;
-          events.beforeScenarioOutline.emitEnd({
-            title,
-            modifier,
-            error: report.error,
-            tags: [...gherkin.tags],
-            status: "FAILED"
-          });
-          throw new AutomationError(message, { cause: report.error });
-        }
-        events.beforeScenarioOutline.emitEnd({
-          title,
-          modifier,
-          tags: [...gherkin.tags],
-          status: "PASSED"
-        });
-      }, hookTimeout);
-    });
-    beforeAll(() => {
-      if (retry) {
-        const count = parseInt(retry.split("=")[1]);
-        jest.retryTimes(count);
-      }
-      events.scenarioOutline.emitStart({
-        title,
-        modifier,
-        tags: [...gherkin.tags]
-      });
-    });
-    bootstrapSetupHooks(bridge, staticApp, events, [config, timeout]);
-    bootstrapBeforeHooks(root, bridge, localApp, events, [config, timeout]);
-    examples.forEach((example) => {
-      bootstrapExamples(root, example, localApp, staticApp, events, [
-        config,
-        timeout
-      ]);
-    });
-    bootstrapAfterHooks(root, bridge, localApp, events, [config, timeout]);
-    bootstrapTeardownHooks(bridge, staticApp, events, [config, timeout]);
-    afterScenarioOutlineHooks.forEach((hook) => {
-      const hookTimeout = chooseTimeout(
-        timeout,
-        hook.options.timeout
-      ).getTimeout(config).milliseconds;
-      afterAll(async () => {
-        if (!hook.canExecute(...gherkin.tags)) {
-          return;
-        }
-        const testName = expect.getState().currentTestName;
-        const tags = gherkin.tags ?? [];
-        const apps = outlineApps.get(testName);
-        events.afterScenarioOutline.emitStart({
-          title,
-          modifier,
-          tags: [...gherkin.tags]
-        });
-        const report = await hook.execute(staticApp, apps, ...tags);
-        if (report.error) {
-          const message = `${hook.name}: ${hook.description} failed to execute.`;
-          events.scenarioOutline.emitEnd({
-            title,
-            modifier,
-            error: report.error,
-            tags: [...gherkin.tags],
-            status: "FAILED"
-          });
-          throw new AutomationError(message, { cause: report.error });
-        }
-        events.afterScenarioOutline.emitEnd({
-          title,
-          modifier,
-          tags: [...gherkin.tags],
-          status: "PASSED"
-        });
-      }, hookTimeout);
-    });
-    afterAll(() => {
-      const failures = Query.find.failed(bridge);
-      const status = getStatus(modifier, failures);
-      events.scenarioOutline.emitEnd({
-        title,
-        modifier,
-        tags: [...gherkin.tags],
-        status
-      });
-      outlineApps.clear();
-      examplesApps.clear();
-    }, chosenTimeout);
-  });
-}
-function bootstrapExamples(root, example, localApp, staticApp, events, timeout) {
-  const { gherkin } = example.data;
-  const title = `${gherkin.keyword}: ${gherkin.name}`;
-  const retry = [...example.data.gherkin.tags].find(
-    (tag) => tag.startsWith("@retries=")
-  );
-  const original = localApp;
-  localApp = () => {
-    const testName = expect.getState().currentTestName ?? "unnamed test";
-    if (!examplesApps.has(testName)) {
-      examplesApps.set(testName, []);
-    }
-    const apps = examplesApps.get(testName);
-    const [container, app] = original();
-    apps.push(app);
-    return [container, app];
-  };
-  const [group] = getGroupOrModifier(
-    example,
-    timeout[0].current.test?.tagFilter
-  );
-  group(title, () => {
-    beforeAll(() => {
-      if (retry) {
-        const count = parseInt(retry.split("=")[1]);
-        jest.retryTimes(count);
-      }
-    });
-    example.data.scope.hooks.beforeExamplesHooks.forEach((hook) => {
-      const hookTimeout = chooseTimeout(
-        timeout[1],
-        hook.options.timeout
-      ).getTimeout(timeout[0]).milliseconds;
-      beforeAll(async () => {
-        if (!hook.canExecute(...example.data.gherkin.tags)) {
-          return;
-        }
-        const tags = example?.data?.gherkin?.tags ?? [];
-        events.beforeExamples.emitStart({
-          title,
-          tags: [...tags]
-        });
-        const report = await hook.execute(staticApp, ...tags);
-        if (report.error) {
-          const message = `${hook.name}: ${hook.description} failed to execute.`;
-          events.beforeExamples.emitEnd({
-            title,
-            error: report.error,
-            tags: [...tags],
-            status: "FAILED"
-          });
-          throw new AutomationError(message, { cause: report.error });
-        }
-        events.beforeExamples.emitEnd({
-          title,
-          tags: [...tags],
-          status: "PASSED"
-        });
-      }, hookTimeout);
-    });
-    bootstrapScenarios(root, example, localApp, staticApp, events, timeout);
-    example.data.scope.hooks.afterExamplesHooks.forEach((hook) => {
-      const hookTimeout = chooseTimeout(
-        timeout[1],
-        hook.options.timeout
-      ).getTimeout(timeout[0]).milliseconds;
-      afterAll(async () => {
-        const testName = expect.getState().currentTestName;
-        if (!hook.canExecute(...example.data.gherkin.tags)) {
-          return;
-        }
-        const tags = example?.data?.gherkin?.tags ?? [];
-        const apps = examplesApps.get(testName);
-        const report = await hook.execute(staticApp, apps, ...tags);
-        if (report.error) {
-          const message = `${hook.name}: ${hook.description} failed to execute.`;
-          throw new AutomationError(message, { cause: report.error });
-        }
-      }, hookTimeout);
-    });
-    afterAll(() => {
-      const testName = expect.getState().currentTestName;
-      examplesApps.delete(testName);
-    });
-  });
-}
-function bootstrapRules(bridge, localApp, staticApp, events, [config, timeout]) {
-  const chosenTimeout = chooseTimeout(
-    timeout,
-    bridge.data.scope.timeout
-  ).getTimeout(config);
-  bridge.rules.forEach((rule) => {
-    const tags = [...rule.data.gherkin.tags];
-    const retry = tags.find((tag) => tag.startsWith("@retries="));
-    const ruleTimeout = chooseTimeout(
-      chosenTimeout,
-      rule.data.scope.timeout
-    ).getTimeout(config);
-    const transferTimeout = [config, ruleTimeout];
-    const { data } = rule;
-    const ruleName = data.scope.title(data.gherkin);
-    const [group, modifier] = getGroupOrModifier(
-      bridge,
-      config.current.test?.tagFilter
-    );
-    group(ruleName, () => {
-      beforeAll(() => {
-        events.rule.emitStart({
-          title: ruleName,
-          modifier,
-          tags: [...data.gherkin.tags]
-        });
-        if (retry) {
-          const count = parseInt(retry.split("=")[1]);
-          jest.retryTimes(count);
-        }
-        const original = localApp;
-        localApp = () => {
-          const testName = expect.getState().currentTestName;
-          if (!ruleApps.has(testName)) {
-            ruleApps.set(testName, []);
-          }
-          const apps = ruleApps.get(testName);
-          const [container, app] = original();
-          apps.push(app);
-          return [container, app];
-        };
-      });
-      bridge.data.scope.hooks.beforeRuleHooks.forEach((hook) => {
-        const hookTimeout = chooseTimeout(
-          ruleTimeout,
-          hook.options.timeout
-        ).getTimeout(config).milliseconds;
-        beforeAll(async () => {
-          if (!hook.canExecute(...data.gherkin.tags)) {
-            return;
-          }
-          const tags2 = data.gherkin.tags ?? [];
-          events.beforeRule.emitStart({
-            title: `${hook.name}: ${hook.description}`,
-            tags: [...tags2]
-          });
-          const report = await hook.execute(staticApp, ...tags2);
-          if (report.error) {
-            const message = `${hook.name}: ${hook.description} failed to execute.`;
-            events.beforeRule.emitEnd({
-              title: `${hook.name}: ${hook.description}`,
-              tags: [...tags2],
-              status: "FAILED",
-              error: report.error
-            });
-            throw new AutomationError(message, { cause: report.error });
-          }
-          events.beforeRule.emitEnd({
-            title: `${hook.name}: ${hook.description}`,
-            tags: [...tags2],
-            status: "PASSED"
-          });
-        }, hookTimeout);
-      });
-      bridge.data.scope.hooks.afterRuleHooks.forEach((hook) => {
-        const hookTimeout = chooseTimeout(
-          ruleTimeout,
-          hook.options.timeout
-        ).getTimeout(config).milliseconds;
-        afterAll(async () => {
-          const testName = expect.getState().currentTestName;
-          if (!hook.canExecute(...data.gherkin.tags)) {
-            return;
-          }
-          const tags2 = data.gherkin.tags ?? [];
-          const apps = ruleApps.get(testName);
-          events.afterRule.emitStart({
-            title: `${hook.name}: ${hook.description}`,
-            tags: [...tags2]
-          });
-          const report = await hook.execute(staticApp, apps, ...tags2);
-          if (report.error) {
-            const message = `${hook.name}: ${hook.description} failed to execute.`;
-            events.afterRule.emitEnd({
-              title: `${hook.name}: ${hook.description}`,
-              tags: [...tags2],
-              status: "FAILED",
-              error: report.error
-            });
-            throw new AutomationError(message, { cause: report.error });
-          }
-          events.afterRule.emitEnd({
-            title: `${hook.name}: ${hook.description}`,
-            tags: [...tags2],
-            status: "PASSED"
-          });
-        }, hookTimeout);
-      });
-      bootstrapSetupHooks(rule, staticApp, events, transferTimeout);
-      bootstrapBeforeHooks(bridge, rule, localApp, events, transferTimeout);
-      bootstrapBackground(bridge, rule, localApp, events, transferTimeout);
-      bootstrapScenarios(
-        bridge,
-        rule,
-        localApp,
-        staticApp,
-        events,
-        transferTimeout
-      );
-      bootstrapAfterHooks(bridge, rule, localApp, events, transferTimeout);
-      bootstrapTeardownHooks(rule, staticApp, events, transferTimeout);
-      afterAll(() => {
-        const failures = Query.find.failed(rule);
-        const status = getStatus(modifier, failures);
-        events.rule.emitEnd({
-          title: ruleName,
-          modifier,
-          tags: [...data.gherkin.tags],
-          status
-        });
-        const testName = expect.getState().currentTestName;
-        ruleApps.delete(testName);
-      }, ruleTimeout.milliseconds);
-    });
-  });
-}
-function getStatus(modifier, failures) {
-  if (modifier === "skip") {
-    return "SKIPPED";
-  }
-  if (failures.length === 0) {
-    return "PASSED";
-  }
-  return "FAILED";
-}
-function getGroupOrModifier(bridge, tagFilter) {
-  const { data } = bridge;
-  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"];
-  }
-  if (tagFilter) {
-    const parse = __require("@cucumber/tag-expressions").default;
-    const expression = parse(tagFilter).evaluate([...bridge.data.gherkin.tags]);
-    if (!expression) {
-      return [describe.skip, "skip"];
-    }
-  }
-  return [describe, void 0];
-}
-function getTestOrModifier({ data }, tagFilter) {
-  if (data.gherkin.tags?.has("@skip") || data.gherkin.tags?.has("@skipped")) {
-    return it.skip;
-  }
-  if (data.gherkin.tags?.has("@only")) {
-    return it.only;
-  }
-  if (tagFilter) {
-    const parse = __require("@cucumber/tag-expressions").default;
-    const expression = parse(tagFilter).evaluate([...data.gherkin.tags]);
-    if (!expression) {
-      return it.skip;
-    }
-  }
-  return it;
-}
-function bootstrapBeforeHooks(root, bridge, localApp, events, [config, timeout]) {
-  const chosenTimeout = chooseTimeout(
-    timeout,
-    bridge.data.scope.timeout
-  ).getTimeout(config);
-  bridge.data.scope.hooks.before.forEach((hook) => {
-    const hookTimeout = chooseTimeout(
-      chosenTimeout,
-      hook.options.timeout
-    ).getTimeout(config).milliseconds;
-    beforeEach(async () => {
-      const testName = expect.getState().currentTestName;
-      if (!testName)
-        throw new AutomationError("A Scenario must have a title");
-      const scenarioBridge = find(root, testName);
-      if (!scenarioBridge) {
-        throw new AutomationError(
-          `No matching scenario was found matching the test name: ${testName}`
-        );
-      }
-      if (!hook.canExecute(...scenarioBridge.data.gherkin.tags)) {
-        return;
-      }
-      const tags = scenarioBridge?.data?.gherkin?.tags ?? [];
-      events.before.emitStart({
-        title: `${hook.name}: ${hook.description}`,
-        tags: [...tags]
-      });
-      const report = await hook.execute(localApp()[1], ...tags);
-      events.before.emitEnd({
-        title: `${hook.name}: ${hook.description}`,
-        tags: [...tags],
-        status: report.status,
-        error: report.error
-      });
-      if (report.error) {
-        const message = `${hook.name}: ${hook.description} experienced a failure.`;
-        throw new AutomationError(message, { cause: report.error });
-      }
-    }, hookTimeout);
-  });
-}
-function bootstrapSetupHooks(bridge, staticApp, events, [config, timeout]) {
-  const { scope, gherkin } = bridge.data;
-  const chosenTimeout = chooseTimeout(
-    timeout,
-    bridge.data.scope.timeout
-  ).getTimeout(config).milliseconds;
-  const setups = scope.hooks.setup;
-  setups.forEach((hook) => {
-    const hookTimeout = chooseTimeout(
-      Timeout2.from(chosenTimeout),
-      hook.options.timeout
-    ).getTimeout(config).milliseconds;
-    const tags = gherkin.tags ?? [];
-    beforeAll(async () => {
-      if (!hook.canExecute(...tags)) {
-        return;
-      }
-      events.setup.emitStart({
-        title: `${hook.name}: ${hook.description}`
-      });
-      const report = await hook.execute(staticApp, ...tags);
-      events.setup.emitEnd({
-        title: `${hook.name}: ${hook.description}`,
-        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 });
-      }
-    }, hookTimeout);
-  });
-}
-function bootstrapAfterHooks(root, bridge, localApp, events, [config, timeout]) {
-  const { scope } = bridge.data;
-  const chosenTimeout = chooseTimeout(timeout, scope.timeout).getTimeout(
-    config
-  ).milliseconds;
-  scope.hooks.after.forEach((hook) => {
-    const hookTimeout = chooseTimeout(
-      Timeout2.from(chosenTimeout),
-      hook.options.timeout
-    ).getTimeout(config).milliseconds;
-    afterEach(async () => {
-      const testName = expect.getState().currentTestName;
-      if (!testName)
-        throw new AutomationError("A Scenario must have a title");
-      const scenarioBridge = find(root, testName);
-      if (!scenarioBridge) {
-        throw new AutomationError(
-          `No scenario was found matching the test path: ${testName}`
-        );
-      }
-      if (!hook.canExecute(...scenarioBridge.data.gherkin.tags)) {
-        return;
-      }
-      const tags = scenarioBridge?.data?.gherkin?.tags ?? [];
-      events.after.emitStart({
-        title: `${hook.name}: ${hook.description}`,
-        tags: [...tags]
-      });
-      const report = await hook.execute(localApp()[1], ...tags);
-      events.after.emitEnd({
-        title: `${hook.name}: ${hook.description}`,
-        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 });
-      }
-    }, hookTimeout);
-  });
-}
-function bootstrapTeardownHooks(bridge, staticApp, event, [config, timeout]) {
-  const tags = [...bridge.data.gherkin.tags];
-  const { scope } = bridge.data;
-  const chosenTimeout = chooseTimeout(timeout, scope.timeout).getTimeout(
-    config
-  );
-  scope.hooks.teardown.forEach((hook) => {
-    const hookTimeout = chooseTimeout(
-      chosenTimeout,
-      hook.options.timeout
-    ).getTimeout(config).milliseconds;
-    afterAll(async () => {
-      if (!hook.canExecute(...tags)) {
-        return;
-      }
-      event.teardown.emitStart({
-        title: `${hook.name}: ${hook.description}`,
-        tags: [...tags]
-      });
-      const report = await hook.execute(staticApp, tags);
-      event.teardown.emitEnd({
-        title: `${hook.name}: ${hook.description}`,
-        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 });
-      }
-    }, hookTimeout);
-  });
-}
-
-// src/index.ts
-var src_default = execute;
-export {
-  src_default as default,
-  execute,
-  getTimeout
-};
-//# sourceMappingURL=index.js.map