@elliemae/smoked-suite 26.2.15

package/dist/cjs/page-setup/index.js

@@ -0,0 +1,116 @@
+"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);
+var page_setup_exports = {};
+__export(page_setup_exports, {
+  PageSetup: () => PageSetup
+});
+module.exports = __toCommonJS(page_setup_exports);
+class PageSetup {
+  /**
+   * Apply all page-level setup. Call once per test — each test
+   * receives a fresh Playwright page, so init scripts and route
+   * blocks do not carry over.
+   * @param page
+   */
+  async apply(page) {
+    await Promise.all([
+      this.stubDiagnostics(page),
+      this.suppressErrorOverlays(page)
+    ]);
+    await this.blockThirdPartyScripts(page);
+  }
+  /**
+   * Provide a no-op fallback for the emuiDiagnostics webpack external.
+   * @param page
+   */
+  async stubDiagnostics(page) {
+    await page.addInitScript(() => {
+      if (typeof window.emuiDiagnostics === "undefined") {
+        const noop = () => {
+        };
+        const noopTransport = { log: async () => true };
+        const fallbackLogger = new Proxy({}, {
+          get(_target, prop) {
+            if (typeof prop === "string" && typeof console[prop] === "function") {
+              return console[prop].bind(console);
+            }
+            return prop === "setOptions" ? noop : console.log.bind(console);
+          }
+        });
+        window.emuiDiagnostics = {
+          http: () => noopTransport,
+          logger: () => fallbackLogger,
+          Console: () => noopTransport,
+          logUnhandledErrors: noop,
+          webvitals: noop,
+          parentApp: () => noopTransport,
+          redactPii: (val) => val,
+          LogLevels: { DEBUG: 0, INFO: 1, WARN: 2, ERROR: 3, FATAL: 4 }
+        };
+      }
+    });
+  }
+  /**
+   * Auto-hide webpack / react-error-overlay iframes that obscure
+   * the page during tests.
+   * @param page
+   */
+  async suppressErrorOverlays(page) {
+    await page.addInitScript(() => {
+      const hideOverlayIframes = () => {
+        document.querySelectorAll("body > iframe").forEach((el) => {
+          el.style.display = "none";
+        });
+      };
+      const start = () => {
+        hideOverlayIframes();
+        new MutationObserver(hideOverlayIframes).observe(document.body, {
+          childList: true
+        });
+      };
+      if (document.body) start();
+      else document.addEventListener("DOMContentLoaded", start);
+    });
+  }
+  /** Domains that are blocked during tests to speed up page loads. */
+  static BLOCKED_DOMAINS = [
+    "googletagmanager.com",
+    "google-analytics.com",
+    "fonts.googleapis.com",
+    "fonts.gstatic.com",
+    "hotjar.com",
+    "newrelic.com",
+    "nr-data.net",
+    "sentry.io",
+    "fullstory.com",
+    "pendo.io"
+  ];
+  /** Single regex matching all {@link BLOCKED_DOMAINS}. */
+  static BLOCKED_PATTERN = new RegExp(
+    PageSetup.BLOCKED_DOMAINS.map((d) => d.replace(/\./g, "\\.")).join("|")
+  );
+  /**
+   * Block analytics, fonts, and monitoring scripts that slow page loads.
+   * Uses a single route handler instead of one per domain.
+   * @param page
+   */
+  async blockThirdPartyScripts(page) {
+    await page.route(PageSetup.BLOCKED_PATTERN, (route) => route.abort());
+  }
+}

package/dist/cjs/playwright-config/index.js

@@ -0,0 +1,116 @@
+"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 playwright_config_exports = {};
+__export(playwright_config_exports, {
+  createPlaywrightConfig: () => createPlaywrightConfig
+});
+module.exports = __toCommonJS(playwright_config_exports);
+var path = __toESM(require("path"), 1);
+var import_test = require("@playwright/test");
+var import_global_setup = require("../global-setup/index.js");
+var import_monocartCoverage = require("../monocartCoverage/index.js");
+const DEFAULT_ACTION_TIMEOUT = 3e4;
+const DEFAULT_NAVIGATION_TIMEOUT = 45e3;
+const DEFAULT_TEST_TIMEOUT = 12e4;
+const DEFAULT_EXPECT_TIMEOUT = 3e4;
+const FAST_MODE_USE = {
+  trace: "off",
+  screenshot: "off",
+  video: "off"
+};
+const DEFAULT_USE = {
+  trace: "retain-on-failure",
+  screenshot: "only-on-failure",
+  video: "retain-on-failure"
+};
+const CI_CONFIG = {
+  workers: "100%",
+  forbidOnly: true,
+  retries: 2,
+  reporter: [
+    ["list"],
+    ["junit", { outputFile: "playwright-report/junit.xml" }]
+  ]
+};
+const LOCAL_CONFIG = {
+  workers: "50%",
+  forbidOnly: false,
+  retries: 0,
+  reporter: [
+    ["html", { outputFolder: "playwright-report" }],
+    ["list"]
+  ]
+};
+function createPlaywrightConfig(params = {}) {
+  const {
+    overrides = {},
+    globalAuth = true,
+    fastMode = false,
+    coverage
+  } = params;
+  const { use: useOverrides, expect: expectOverrides, ...rest } = overrides;
+  const isCoverage = !!coverage;
+  if (isCoverage) (0, import_monocartCoverage.configureCoverage)();
+  const globalSetup = path.resolve(__dirname, "../global-setup/index.js");
+  const globalAuthConfig = globalAuth ? { globalSetup } : {};
+  const storageStateConfig = globalAuth ? { storageState: path.join(process.cwd(), import_global_setup.STORAGE_FILE) } : {};
+  const envConfig = process.env.CI ? CI_CONFIG : LOCAL_CONFIG;
+  const coverageReporter = isCoverage ? { reporter: (0, import_monocartCoverage.buildCoverageReporters)(coverage) } : {};
+  return (0, import_test.defineConfig)({
+    testMatch: "**/*Spec.ts",
+    fullyParallel: true,
+    ...envConfig,
+    ...coverageReporter,
+    projects: [
+      {
+        name: "chromium",
+        use: { ...import_test.devices["Desktop Chrome"] }
+      }
+    ],
+    outputDir: "test-results",
+    timeout: DEFAULT_TEST_TIMEOUT,
+    ...globalAuthConfig,
+    ...rest,
+    use: {
+      ...fastMode ? FAST_MODE_USE : DEFAULT_USE,
+      viewport: { width: 1280, height: 720 },
+      actionTimeout: DEFAULT_ACTION_TIMEOUT,
+      navigationTimeout: DEFAULT_NAVIGATION_TIMEOUT,
+      ...storageStateConfig,
+      ...useOverrides,
+      ...{
+        baseURL: process.env.BASE_URL ?? useOverrides?.baseURL ?? "http://localhost:3000"
+      }
+    },
+    expect: {
+      timeout: DEFAULT_EXPECT_TIMEOUT,
+      ...expectOverrides
+    }
+  });
+}

package/dist/cjs/routes/index.js

@@ -0,0 +1,27 @@
+"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);
+var routes_exports = {};
+__export(routes_exports, {
+  getRoutePath: () => getRoutePath
+});
+module.exports = __toCommonJS(routes_exports);
+function getRoutePath(routes, route) {
+  if (route in routes) return routes[route];
+  return route;
+}

package/dist/cjs/types.js

@@ -0,0 +1,16 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+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);
+var types_exports = {};
+module.exports = __toCommonJS(types_exports);

package/dist/esm/auth/index.js

@@ -0,0 +1,123 @@
+import * as fs from "fs";
+import * as path from "path";
+const AUTH_CAPTURE_TIMEOUT = 3e4;
+const LOGIN_PAGE_TIMEOUT = 9e4;
+const LOGIN_FIELD_TIMEOUT = 6e4;
+const LOGIN_BUTTON_TIMEOUT = 3e4;
+const AUTH_SHELL_TIMEOUT = 12e4;
+const AUTH_TTL_MS = 25 * 60 * 1e3;
+const AUTH_FILE = ".smoked-suite-auth.json";
+class AuthManager {
+  static authState = null;
+  /** Whether a cached session exists and is still valid. */
+  hasValidAuth() {
+    const state = AuthManager.authState;
+    if (!state) return false;
+    return Date.now() - state.capturedAt < AUTH_TTL_MS;
+  }
+  /** Expose current auth state (used by global setup to serialise). */
+  static getAuthState() {
+    return AuthManager.authState;
+  }
+  /**
+   * Load auth state from the file written by globalSetup.
+   * Returns `true` if a valid (non-expired) session was loaded.
+   */
+  static loadFromFile() {
+    const filePath = path.join(process.cwd(), AUTH_FILE);
+    try {
+      if (!fs.existsSync(filePath)) return false;
+      const raw = fs.readFileSync(filePath, "utf-8");
+      const state = JSON.parse(raw);
+      if (!state?.sessionEntries || !state?.capturedAt) return false;
+      if (Date.now() - state.capturedAt >= AUTH_TTL_MS) return false;
+      AuthManager.authState = state;
+      return true;
+    } catch {
+      return false;
+    }
+  }
+  /**
+   * Restore every session-storage entry that was captured after
+   * the initial login so encw and its micro-apps find the data
+   * they need (Authorization, cred, user, userSettings, etc.).
+   * @param page
+   */
+  async inject(page) {
+    const state = AuthManager.authState;
+    if (!state) {
+      throw new Error("No auth state available to inject");
+    }
+    await page.evaluate((entries) => {
+      for (const [key, value] of Object.entries(entries)) {
+        sessionStorage.setItem(key, value);
+      }
+    }, state.sessionEntries);
+  }
+  /**
+   * Snapshot every session-storage entry after a successful login.
+   * @param page
+   */
+  async capture(page) {
+    await page.waitForFunction(
+      () => sessionStorage.getItem("Authorization") !== null,
+      { timeout: AUTH_CAPTURE_TIMEOUT }
+    );
+    const sessionEntries = await page.evaluate(() => {
+      const entries = {};
+      for (let i = 0; i < sessionStorage.length; i++) {
+        const key = sessionStorage.key(i);
+        if (key) entries[key] = sessionStorage.getItem(key) ?? "";
+      }
+      return entries;
+    });
+    if (sessionEntries?.Authorization) {
+      AuthManager.authState = { sessionEntries, capturedAt: Date.now() };
+    }
+  }
+  /**
+   * Perform the encw login flow (Instance ID -> User / Password).
+   * @param page  - Playwright page to drive.
+   * @param creds - Credentials to use.
+   */
+  async login(page, creds) {
+    await page.goto("", { waitUntil: "load", timeout: LOGIN_PAGE_TIMEOUT });
+    const instanceIdField = page.getByPlaceholder("Instance ID");
+    await instanceIdField.waitFor({
+      state: "visible",
+      timeout: LOGIN_PAGE_TIMEOUT
+    });
+    await instanceIdField.click();
+    await instanceIdField.fill(creds.instanceId ?? "BE11226875");
+    const userIdField = page.getByPlaceholder("User ID");
+    await userIdField.waitFor({
+      state: "visible",
+      timeout: LOGIN_FIELD_TIMEOUT
+    });
+    await userIdField.click();
+    await userIdField.fill(creds.username);
+    await userIdField.press("Tab");
+    const passwordField = page.getByRole("textbox", { name: "Password" });
+    await passwordField.waitFor({
+      state: "visible",
+      timeout: LOGIN_BUTTON_TIMEOUT
+    });
+    await passwordField.fill(creds.password);
+    const loginButton = page.getByRole("button", { name: "Log In" });
+    await loginButton.waitFor({
+      state: "visible",
+      timeout: LOGIN_BUTTON_TIMEOUT
+    });
+    await loginButton.click();
+    await page.waitForLoadState("domcontentloaded", {
+      timeout: AUTH_SHELL_TIMEOUT
+    });
+    await page.waitForFunction(
+      () => sessionStorage.getItem("Authorization") !== null,
+      { polling: 1e3, timeout: AUTH_SHELL_TIMEOUT }
+    );
+  }
+}
+export {
+  AuthManager
+};

package/dist/esm/base-page/index.js

@@ -0,0 +1,38 @@
+class BasePage {
+  _contextProvider;
+  /** The current Page context, resolved lazily. */
+  get page() {
+    return typeof this._contextProvider === "function" ? this._contextProvider() : this._contextProvider;
+  }
+  constructor(context) {
+    this._contextProvider = context;
+  }
+  // ─── Locator helpers ─────────────────────────────────────────────────────────
+  getByTestId(testId) {
+    return this.page.getByTestId(testId);
+  }
+  locator(selector) {
+    return this.page.locator(selector);
+  }
+  getByRole(role, options) {
+    return this.page.getByRole(role, options);
+  }
+  getByText(text, options) {
+    return this.page.getByText(text, options);
+  }
+  getByLabel(text, options) {
+    return this.page.getByLabel(text, options);
+  }
+  getByPlaceholder(text, options) {
+    return this.page.getByPlaceholder(text, options);
+  }
+  getByAltText(text, options) {
+    return this.page.getByAltText(text, options);
+  }
+  getByTitle(text, options) {
+    return this.page.getByTitle(text, options);
+  }
+}
+export {
+  BasePage
+};

package/dist/esm/browserstack/index.js

@@ -0,0 +1,67 @@
+import * as fs from "fs";
+import * as path from "path";
+const DEFAULT_PLATFORMS = [
+  {
+    os: "OS X",
+    osVersion: "Sequoia",
+    browserName: "chrome",
+    browserVersion: "latest"
+  }
+];
+function createBrowserStackConfig(options = {}) {
+  const {
+    projectName = "encw-app",
+    buildName = "playwright-tests",
+    // eslint-disable-next-line no-template-curly-in-string
+    buildIdentifier = "#${BUILD_NUMBER}",
+    platforms = DEFAULT_PLATFORMS,
+    parallelsPerPlatform = 1,
+    browserstackLocal = true,
+    forceLocal = true,
+    debug = true,
+    networkLogs = true,
+    consoleLogs = "info"
+  } = options;
+  const platformsYaml = platforms.map((p) => {
+    const lines = [
+      `  - os: ${p.os}`,
+      `    osVersion: ${p.osVersion}`,
+      `    browserName: ${p.browserName}`
+    ];
+    if (p.browserVersion) {
+      lines.push(`    browserVersion: ${p.browserVersion}`);
+    }
+    return lines.join("\n");
+  }).join("\n");
+  return `userName: "\${BROWSERSTACK_USERNAME}"
+accessKey: "\${BROWSERSTACK_ACCESS_KEY}"
+
+projectName: ${projectName}
+buildName: ${buildName}
+buildIdentifier: "${buildIdentifier}"
+framework: playwright
+
+platforms:
+${platformsYaml}
+
+parallelsPerPlatform: ${parallelsPerPlatform}
+
+browserstackLocal: ${String(browserstackLocal)}
+browserStackLocalOptions:
+  forceLocal: ${String(forceLocal)}
+
+debug: ${String(debug)}
+networkLogs: ${String(networkLogs)}
+consoleLogs: ${consoleLogs}
+`;
+}
+function writeBrowserStackConfig(options = {}, targetDir = process.cwd()) {
+  const content = createBrowserStackConfig(options);
+  const filePath = path.join(targetDir, "browserstack.yml");
+  fs.writeFileSync(filePath, content, "utf-8");
+  return filePath;
+}
+export {
+  createBrowserStackConfig,
+  writeBrowserStackConfig
+};

package/dist/esm/global-setup/index.js

@@ -0,0 +1,41 @@
+import * as fs from "fs";
+import * as path from "path";
+import { chromium } from "@playwright/test";
+import { AuthManager } from "../auth/index.js";
+import { PageSetup } from "../page-setup/index.js";
+const AUTH_FILE = ".smoked-suite-auth.json";
+const STORAGE_FILE = ".smoked-suite-storage.json";
+async function globalSetup(config) {
+  const baseURL = config.projects[0]?.use?.baseURL ?? process.env.BASE_URL;
+  if (!baseURL) {
+    throw new Error(
+      "smoked-suite globalSetup: baseURL is required. Set BASE_URL env var or configure use.baseURL in createPlaywrightConfig."
+    );
+  }
+  const browser = await chromium.launch();
+  const context = await browser.newContext({ baseURL });
+  const page = await context.newPage();
+  const pageSetup = new PageSetup();
+  await pageSetup.apply(page);
+  const auth = new AuthManager();
+  const credentials = {
+    instanceId: process.env.ENCW_INSTANCE_ID ?? "BE11226875",
+    username: process.env.ENCW_USER_ID ?? "admin",
+    password: process.env.ENCW_PASSWORD ?? "Password#!23"
+  };
+  await auth.login(page, credentials);
+  await auth.capture(page);
+  const authState = AuthManager.getAuthState();
+  if (authState) {
+    const authPath = path.join(process.cwd(), AUTH_FILE);
+    fs.writeFileSync(authPath, JSON.stringify(authState), "utf-8");
+  }
+  const storagePath = path.join(process.cwd(), STORAGE_FILE);
+  await context.storageState({ path: storagePath });
+  await browser.close();
+}
+export {
+  AUTH_FILE,
+  STORAGE_FILE,
+  globalSetup as default
+};

package/dist/esm/index.js

@@ -0,0 +1,20 @@
+import { BasePage } from "./base-page/index.js";
+import { AuthManager } from "./auth/index.js";
+import { PageSetup } from "./page-setup/index.js";
+import { getRoutePath } from "./routes/index.js";
+import { createPlaywrightConfig } from "./playwright-config/index.js";
+import { default as default2 } from "./global-setup/index.js";
+import {
+  createBrowserStackConfig,
+  writeBrowserStackConfig
+} from "./browserstack/index.js";
+export {
+  AuthManager,
+  BasePage,
+  PageSetup,
+  createBrowserStackConfig,
+  createPlaywrightConfig,
+  getRoutePath,
+  default2 as globalSetup,
+  writeBrowserStackConfig
+};

package/dist/esm/monocartCoverage/index.js

@@ -0,0 +1,95 @@
+import { test } from "@playwright/test";
+let coverageConfigured = false;
+let coverageEnabled = false;
+const trackedPages = /* @__PURE__ */ new Set();
+function configureCoverage() {
+  coverageConfigured = true;
+}
+function startCoverage() {
+  if (!coverageConfigured) return;
+  coverageEnabled = true;
+  trackedPages.clear();
+}
+async function stopCoverage() {
+  if (!coverageEnabled) return;
+  await Promise.allSettled(
+    [...trackedPages].map((page) => flushPageCoverage(page))
+  );
+  trackedPages.clear();
+  coverageEnabled = false;
+}
+async function trackPage(page) {
+  if (!coverageEnabled) return;
+  trackedPages.add(page);
+  await page.coverage.startJSCoverage({ resetOnNavigation: false });
+}
+async function untrackPage(page) {
+  if (!coverageEnabled || !trackedPages.has(page)) return;
+  await flushPageCoverage(page);
+  trackedPages.delete(page);
+}
+async function flushPageCoverage(page) {
+  const entries = await page.coverage.stopJSCoverage();
+  const { addCoverageReport } = await import("monocart-reporter");
+  await addCoverageReport(entries, test.info());
+}
+function buildCoverageReporter(configs) {
+  const repoName = process.cwd().split("/").pop() ?? "";
+  const segments = configs.map(
+    (c) => c.sourceDir.replace(/^\.\//, "").replace(/\/$/, "")
+  );
+  const firstBase = configs[0].sourceDir.split("/").filter(Boolean).pop() ?? "app";
+  const reportName = configs.length === 1 ? `${toTitleCase(firstBase)} Coverage Report` : "Coverage Report";
+  const outputDir = configs[0].outputDir ?? `./coverage/${firstBase}`;
+  const fileFilter = {
+    "**/*.{ts,tsx}": true,
+    "**/*.test.*": false,
+    "**/*.spec.*": false,
+    "**/tests/**": false
+  };
+  const allEntries = configs.map((c) => ({
+    dir: c.sourceDir,
+    filter: fileFilter
+  }));
+  return [
+    "monocart-reporter",
+    {
+      name: reportName,
+      outputFile: `${outputDir}/report.html`,
+      coverage: {
+        reports: ["v8", "console-details", "lcovonly"],
+        all: allEntries.length === 1 ? allEntries[0] : allEntries,
+        sourcePath: (filePath) => {
+          let p = filePath;
+          if (repoName) {
+            p = p.replace(new RegExp(`^${repoName}/`), "");
+          }
+          p = p.replace(/-[0-9a-f]{4}$/, "");
+          return p;
+        },
+        sourceFilter: (sourcePath) => {
+          if (sourcePath.includes("node_modules")) return false;
+          return segments.some((seg) => sourcePath.includes(seg));
+        },
+        entryFilter: (entry) => {
+          if (entry.url.startsWith("http")) return false;
+          return segments.some((seg) => entry.url.includes(seg));
+        }
+      }
+    }
+  ];
+}
+function toTitleCase(s) {
+  return s.split("-").map((w) => w.charAt(0).toUpperCase() + w.slice(1)).join(" ");
+}
+function buildCoverageReporters(configs) {
+  return [["list"], buildCoverageReporter(configs)];
+}
+export {
+  buildCoverageReporters,
+  configureCoverage,
+  startCoverage,
+  stopCoverage,
+  trackPage,
+  untrackPage
+};

package/dist/esm/package.json

@@ -0,0 +1,7 @@
+{
+  "type": "module",
+  "sideEffects": false,
+  "publishConfig": {
+    "access": "public"
+  }
+}