@elliemae/smoked-suite 26.2.15

package/README.md

@@ -0,0 +1,58 @@
+# smoked-suite
+
+> Shared Playwright test infrastructure for ICE micro-frontend apps running inside encw (Encompass Web).
+
+Part of the [encw-libraries](https://git.elliemae.io/EncompassWeb/encw-libraries) monorepo.
+
+Previously maintained at [EncompassWeb/smoked-suite](https://git.elliemae.io/EncompassWeb/smoked-suite) (now archived).
+
+## Installation
+
+```bash
+pnpm add -D @elliemae/smoked-suite @playwright/test
+```
+
+## Quick Start
+
+```typescript
+import { BaseTest } from '@elliemae/smoked-suite';
+import { SelectSettingsPage } from '../page-objects';
+
+class SelectSettingsSpec extends BaseTest {
+  private settingsPage!: SelectSettingsPage;
+
+  async beforeEach() {
+    await this.goToEmAdminUI();
+    this.settingsPage = new SelectSettingsPage(() => this.appFrame);
+  }
+
+  async testPageLoads() {
+    await this.goto('/admin/oneadmin/migrate');
+    await this.expect(this.settingsPage.container).toBeVisible();
+  }
+}
+
+SelectSettingsSpec.run();
+```
+
+## What It Provides
+
+- **BaseTest** — Test runner orchestrator with auth, iframe resolution, micro-app navigation
+- **BasePage** — Page object base class with ContextProvider pattern and locator helpers
+- **AuthManager** — encw login, session-storage capture/inject, TTL caching
+- **PageSetup** — Init scripts, error-overlay suppression, analytics blocking
+- **createPlaywrightConfig** — Config factory with sensible defaults, coverage support
+- **globalSetup** — Worker-level auth setup function
+- **getRoutePath** — Route resolution utility
+- **BrowserStack** — Integration utilities for BrowserStack cloud testing
+- **Coverage** — V8 code coverage collection via monocart-reporter
+
+## Development
+
+```bash
+# From monorepo root
+pnpm --filter @elliemae/smoked-suite build    # Production build
+pnpm --filter @elliemae/smoked-suite test     # Run unit tests
+pnpm --filter @elliemae/smoked-suite lint     # Lint
+pnpm --filter @elliemae/smoked-suite tscheck  # TypeScript check
+```

package/dist/cjs/auth/index.js

@@ -0,0 +1,153 @@
+"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 auth_exports = {};
+__export(auth_exports, {
+  AuthManager: () => AuthManager
+});
+module.exports = __toCommonJS(auth_exports);
+var fs = __toESM(require("fs"), 1);
+var path = __toESM(require("path"), 1);
+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 }
+    );
+  }
+}

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

@@ -0,0 +1,58 @@
+"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 base_page_exports = {};
+__export(base_page_exports, {
+  BasePage: () => BasePage
+});
+module.exports = __toCommonJS(base_page_exports);
+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);
+  }
+}

package/dist/cjs/browserstack/index.js

@@ -0,0 +1,97 @@
+"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 browserstack_exports = {};
+__export(browserstack_exports, {
+  createBrowserStackConfig: () => createBrowserStackConfig,
+  writeBrowserStackConfig: () => writeBrowserStackConfig
+});
+module.exports = __toCommonJS(browserstack_exports);
+var fs = __toESM(require("fs"), 1);
+var path = __toESM(require("path"), 1);
+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;
+}

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

@@ -0,0 +1,71 @@
+"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 global_setup_exports = {};
+__export(global_setup_exports, {
+  AUTH_FILE: () => AUTH_FILE,
+  STORAGE_FILE: () => STORAGE_FILE,
+  default: () => globalSetup
+});
+module.exports = __toCommonJS(global_setup_exports);
+var fs = __toESM(require("fs"), 1);
+var path = __toESM(require("path"), 1);
+var import_test = require("@playwright/test");
+var import_auth = require("../auth/index.js");
+var import_page_setup = require("../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 import_test.chromium.launch();
+  const context = await browser.newContext({ baseURL });
+  const page = await context.newPage();
+  const pageSetup = new import_page_setup.PageSetup();
+  await pageSetup.apply(page);
+  const auth = new import_auth.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 = import_auth.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();
+}

package/dist/cjs/index.js

@@ -0,0 +1,47 @@
+"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 index_exports = {};
+__export(index_exports, {
+  AuthManager: () => import_auth.AuthManager,
+  BasePage: () => import_base_page.BasePage,
+  PageSetup: () => import_page_setup.PageSetup,
+  createBrowserStackConfig: () => import_browserstack.createBrowserStackConfig,
+  createPlaywrightConfig: () => import_playwright_config.createPlaywrightConfig,
+  getRoutePath: () => import_routes.getRoutePath,
+  globalSetup: () => import_global_setup.default,
+  writeBrowserStackConfig: () => import_browserstack.writeBrowserStackConfig
+});
+module.exports = __toCommonJS(index_exports);
+var import_base_page = require("./base-page/index.js");
+var import_auth = require("./auth/index.js");
+var import_page_setup = require("./page-setup/index.js");
+var import_routes = require("./routes/index.js");
+var import_playwright_config = require("./playwright-config/index.js");
+var import_global_setup = __toESM(require("./global-setup/index.js"), 1);
+var import_browserstack = require("./browserstack/index.js");

package/dist/cjs/monocartCoverage/index.js

@@ -0,0 +1,125 @@
+"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 monocartCoverage_exports = {};
+__export(monocartCoverage_exports, {
+  buildCoverageReporters: () => buildCoverageReporters,
+  configureCoverage: () => configureCoverage,
+  startCoverage: () => startCoverage,
+  stopCoverage: () => stopCoverage,
+  trackPage: () => trackPage,
+  untrackPage: () => untrackPage
+});
+module.exports = __toCommonJS(monocartCoverage_exports);
+var import_test = require("@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, import_test.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)];
+}

package/dist/cjs/package.json

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