@remix-run/test 0.0.0 → 0.2.0

package/dist/lib/reporters/index.js

@@ -0,0 +1,18 @@
+import { DotReporter } from "./dot.js";
+import { FilesReporter } from "./files.js";
+import { SpecReporter } from "./spec.js";
+import { TapReporter } from "./tap.js";
+export { DotReporter, FilesReporter, SpecReporter, TapReporter };
+export function createReporter(type) {
+    switch (type) {
+        case 'tap':
+            return new TapReporter();
+        case 'dot':
+            return new DotReporter();
+        case 'files':
+            return new FilesReporter();
+        case 'spec':
+        default:
+            return new SpecReporter();
+    }
+}

package/dist/lib/reporters/results.d.ts

@@ -0,0 +1,30 @@
+import type { V8CoverageEntry } from '../coverage';
+export interface TestResult {
+    name: string;
+    suiteName: string;
+    filePath?: string;
+    status: 'passed' | 'failed' | 'skipped' | 'todo';
+    error?: {
+        message: string;
+        stack?: string;
+    };
+    duration: number;
+}
+export interface TestResults {
+    passed: number;
+    failed: number;
+    skipped: number;
+    todo: number;
+    tests: TestResult[];
+    e2eBrowserCoverageEntries?: Array<{
+        entries: V8CoverageEntry[];
+        baseUrl: string;
+    }>;
+}
+export type Counts = {
+    passed: number;
+    failed: number;
+    skipped: number;
+    todo: number;
+};
+//# sourceMappingURL=results.d.ts.map

package/dist/lib/reporters/results.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"results.d.ts","sourceRoot":"","sources":["../../../src/lib/reporters/results.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,aAAa,CAAA;AAElD,MAAM,WAAW,UAAU;IACzB,IAAI,EAAE,MAAM,CAAA;IACZ,SAAS,EAAE,MAAM,CAAA;IACjB,QAAQ,CAAC,EAAE,MAAM,CAAA;IACjB,MAAM,EAAE,QAAQ,GAAG,QAAQ,GAAG,SAAS,GAAG,MAAM,CAAA;IAChD,KAAK,CAAC,EAAE;QACN,OAAO,EAAE,MAAM,CAAA;QACf,KAAK,CAAC,EAAE,MAAM,CAAA;KACf,CAAA;IACD,QAAQ,EAAE,MAAM,CAAA;CACjB;AAED,MAAM,WAAW,WAAW;IAC1B,MAAM,EAAE,MAAM,CAAA;IACd,MAAM,EAAE,MAAM,CAAA;IACd,OAAO,EAAE,MAAM,CAAA;IACf,IAAI,EAAE,MAAM,CAAA;IACZ,KAAK,EAAE,UAAU,EAAE,CAAA;IACnB,yBAAyB,CAAC,EAAE,KAAK,CAAC;QAAE,OAAO,EAAE,eAAe,EAAE,CAAC;QAAC,OAAO,EAAE,MAAM,CAAA;KAAE,CAAC,CAAA;CACnF;AAED,MAAM,MAAM,MAAM,GAAG;IACnB,MAAM,EAAE,MAAM,CAAA;IACd,MAAM,EAAE,MAAM,CAAA;IACd,OAAO,EAAE,MAAM,CAAA;IACf,IAAI,EAAE,MAAM,CAAA;CACb,CAAA"}

package/dist/lib/reporters/results.js

@@ -0,0 +1 @@
+export {};

package/dist/lib/reporters/spec.d.ts

@@ -0,0 +1,9 @@
+import type { Reporter } from './index.ts';
+import type { Counts, TestResults } from './results.ts';
+export declare class SpecReporter implements Reporter {
+    #private;
+    onSectionStart(label: string): void;
+    onResult(results: TestResults, env?: string): void;
+    onSummary(counts: Counts, durationMs: number): void;
+}
+//# sourceMappingURL=spec.d.ts.map

package/dist/lib/reporters/spec.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"spec.d.ts","sourceRoot":"","sources":["../../../src/lib/reporters/spec.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,YAAY,CAAA;AAC1C,OAAO,KAAK,EAAE,MAAM,EAAc,WAAW,EAAE,MAAM,cAAc,CAAA;AAEnE,qBAAa,YAAa,YAAW,QAAQ;;IAG3C,cAAc,CAAC,KAAK,EAAE,MAAM,QAE3B;IAED,QAAQ,CAAC,OAAO,EAAE,WAAW,EAAE,GAAG,CAAC,EAAE,MAAM,QA8H1C;IAED,SAAS,CAAC,MAAM,EAAE,MAAM,EAAE,UAAU,EAAE,MAAM,QAgC3C;CACF"}

package/dist/lib/reporters/spec.js

@@ -0,0 +1,153 @@
+import { colors } from "../colors.js";
+import { normalizeLine } from "../normalize.js";
+export class SpecReporter {
+    #failures = [];
+    onSectionStart(label) {
+        console.log(label);
+    }
+    onResult(results, env) {
+        let suiteMap = new Map();
+        for (let test of results.tests) {
+            let suite = test.suiteName || 'Global';
+            if (!suiteMap.has(suite))
+                suiteMap.set(suite, []);
+            suiteMap.get(suite).push(test);
+        }
+        let envLabel = env ? ` ${colors.dim(`[${env}]`)}` : '';
+        let lastParts = [];
+        // Pre-compute aggregate test results for each path prefix so non-leaf
+        // suite headings can be colored the same way as leaf headings.
+        let prefixTests = new Map();
+        for (let [suiteName, tests] of suiteMap) {
+            let parts = suiteName.split(' > ');
+            for (let i = 0; i < parts.length; i++) {
+                let prefix = parts.slice(0, i + 1).join(' > ');
+                if (!prefixTests.has(prefix))
+                    prefixTests.set(prefix, []);
+                prefixTests.get(prefix).push(...tests);
+            }
+        }
+        for (let [suiteName, suiteTests] of suiteMap) {
+            let parts = suiteName.split(' > ');
+            // Find where this path diverges from the last rendered path
+            let commonLen = 0;
+            while (commonLen < lastParts.length &&
+                commonLen < parts.length &&
+                lastParts[commonLen] === parts[commonLen]) {
+                commonLen++;
+            }
+            // Print each new path component
+            for (let i = commonLen; i < parts.length; i++) {
+                let indent = '  '.repeat(i);
+                let isLeaf = i === parts.length - 1;
+                if (isLeaf) {
+                    let totalDuration = suiteTests.reduce((sum, t) => sum + t.duration, 0);
+                    let suiteHasFailed = suiteTests.some((t) => t.status === 'failed');
+                    let suiteAllSkipped = suiteTests.every((t) => t.status === 'skipped');
+                    let suiteAllTodo = suiteTests.every((t) => t.status === 'todo');
+                    let label = suiteHasFailed
+                        ? colors.red(parts[i])
+                        : suiteAllSkipped
+                            ? colors.dim(parts[i])
+                            : suiteAllTodo
+                                ? colors.yellow(parts[i])
+                                : colors.green(parts[i]);
+                    let suiteComment = suiteAllSkipped
+                        ? colors.dim(' # skipped')
+                        : suiteAllTodo
+                            ? colors.yellow(' # todo')
+                            : '';
+                    let duration = suiteComment ? '' : ` (${totalDuration.toFixed(2)}ms)`;
+                    let label2 = envLabel;
+                    console.log(`${indent}${colors.dim('▶')} ${label}${duration}${suiteComment}${label2}`);
+                }
+                else {
+                    let prefix = parts.slice(0, i + 1).join(' > ');
+                    let prefixTestList = prefixTests.get(prefix) ?? [];
+                    let prefixHasFailed = prefixTestList.some((t) => t.status === 'failed');
+                    let prefixAllSkipped = prefixTestList.length > 0 && prefixTestList.every((t) => t.status === 'skipped');
+                    let prefixAllTodo = prefixTestList.length > 0 && prefixTestList.every((t) => t.status === 'todo');
+                    let nameColor = prefixHasFailed
+                        ? colors.red
+                        : prefixAllSkipped
+                            ? colors.dim
+                            : prefixAllTodo
+                                ? colors.yellow
+                                : colors.green;
+                    let prefixDuration = prefixTestList.reduce((sum, t) => sum + t.duration, 0);
+                    let prefixComment = prefixAllSkipped
+                        ? colors.dim(' # skipped')
+                        : prefixAllTodo
+                            ? colors.yellow(' # todo')
+                            : '';
+                    let prefixDurationStr = prefixComment ? '' : ` (${prefixDuration.toFixed(2)}ms)`;
+                    console.log(`${indent}${colors.dim('▶')} ${nameColor(parts[i])}${prefixDurationStr}${prefixComment}${envLabel}`);
+                }
+            }
+            lastParts = parts;
+            // Print tests indented to the suite's depth
+            let testIndent = '  '.repeat(parts.length);
+            for (let test of suiteTests) {
+                if (test.status === 'passed') {
+                    console.log(`${testIndent}${colors.green('✓')} ${test.name} (${test.duration.toFixed(2)}ms)`);
+                }
+                else if (test.status === 'failed') {
+                    console.log(`${testIndent}${colors.red('✗')} ${test.name} (${test.duration.toFixed(2)}ms)`);
+                    if (test.error) {
+                        console.log(`${testIndent}  ${colors.red(`Error: ${test.error.message}`)}`);
+                        if (test.error.stack) {
+                            let stack = test.error.stack
+                                .split('\n')
+                                .map((line) => normalizeLine(line))
+                                .join('\n');
+                            console.log(`${testIndent}    ${stack.split('\n').slice(1, 5).join(`\n${testIndent}    `)}`);
+                        }
+                    }
+                    this.#failures.push({ suiteName: test.suiteName, name: test.name, error: test.error });
+                }
+                else if (test.status === 'skipped') {
+                    if (test.name)
+                        console.log(`${testIndent}${colors.dim('↓')} ${colors.dim(`${test.name} # skipped`)}`);
+                }
+                else if (test.status === 'todo') {
+                    if (test.name)
+                        console.log(`${testIndent}${colors.yellow('…')} ${colors.yellow(`${test.name} # todo`)}`);
+                }
+            }
+        }
+    }
+    onSummary(counts, durationMs) {
+        if (this.#failures.length > 0) {
+            console.log();
+            console.log(colors.red('Failed tests:'));
+            for (let i = 0; i < this.#failures.length; i++) {
+                let { suiteName, name, error } = this.#failures[i];
+                let fullName = name ? `${suiteName} > ${name}` : suiteName;
+                console.log(`\n  ${colors.red(`${i + 1})`)} ${fullName}`);
+                if (error) {
+                    console.log(`     ${colors.red(error.message)}`);
+                    if (error.stack) {
+                        let frames = error.stack
+                            .split('\n')
+                            .slice(1, 4)
+                            .map((l) => `     ${normalizeLine(l).trim()}`)
+                            .join('\n');
+                        console.log(frames);
+                    }
+                }
+            }
+        }
+        let { passed, failed, skipped, todo } = counts;
+        let info = colors.cyan('ℹ');
+        console.log();
+        console.log(`${info} tests ${passed + failed + skipped + todo}`);
+        console.log(`${info} pass ${passed}`);
+        console.log(`${info} fail ${failed}`);
+        if (skipped > 0)
+            console.log(`${info} skipped ${skipped}`);
+        if (todo > 0)
+            console.log(`${info} todo ${todo}`);
+        console.log(`${info} duration_ms ${durationMs.toFixed(5)}`);
+        console.log();
+    }
+}

package/dist/lib/reporters/tap.d.ts

@@ -0,0 +1,9 @@
+import type { Reporter } from './index.ts';
+import type { Counts, TestResults } from './results.ts';
+export declare class TapReporter implements Reporter {
+    #private;
+    onSectionStart(_label: string): void;
+    onResult(results: TestResults, env?: string): void;
+    onSummary(counts: Counts, durationMs: number): void;
+}
+//# sourceMappingURL=tap.d.ts.map

package/dist/lib/reporters/tap.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"tap.d.ts","sourceRoot":"","sources":["../../../src/lib/reporters/tap.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,YAAY,CAAA;AAC1C,OAAO,KAAK,EAAE,MAAM,EAAE,WAAW,EAAE,MAAM,cAAc,CAAA;AAEvD,qBAAa,WAAY,YAAW,QAAQ;;IAI1C,cAAc,CAAC,MAAM,EAAE,MAAM,QAAI;IAEjC,QAAQ,CAAC,OAAO,EAAE,WAAW,EAAE,GAAG,CAAC,EAAE,MAAM,QAmC1C;IAED,SAAS,CAAC,MAAM,EAAE,MAAM,EAAE,UAAU,EAAE,MAAM,QAS3C;CACF"}

package/dist/lib/reporters/tap.js

@@ -0,0 +1,54 @@
+import { normalizeLine } from "../normalize.js";
+export class TapReporter {
+    #counter = 0;
+    #total = 0;
+    onSectionStart(_label) { }
+    onResult(results, env) {
+        if (this.#counter === 0) {
+            console.log('TAP version 14');
+        }
+        let envComment = env ? ` # ${env}` : '';
+        for (let test of results.tests) {
+            this.#counter++;
+            this.#total++;
+            let fullName = test.name
+                ? `${test.suiteName} > ${test.name}${envComment}`
+                : `${test.suiteName}${envComment}`;
+            if (test.status === 'passed') {
+                console.log(`ok ${this.#counter} - ${fullName}`);
+            }
+            else if (test.status === 'skipped') {
+                console.log(`ok ${this.#counter} - ${fullName} # SKIP`);
+            }
+            else if (test.status === 'todo') {
+                console.log(`ok ${this.#counter} - ${fullName} # TODO`);
+            }
+            else {
+                console.log(`not ok ${this.#counter} - ${fullName}`);
+                console.log('  ---');
+                console.log(`  message: ${test.error?.message ?? 'unknown error'}`);
+                if (test.error?.stack) {
+                    let frames = test.error.stack
+                        .split('\n')
+                        .slice(1, 4)
+                        .map((l) => normalizeLine(l).trim())
+                        .join('\n    ');
+                    console.log(`  stack: |\n    ${frames}`);
+                }
+                console.log('  ...');
+            }
+        }
+    }
+    onSummary(counts, durationMs) {
+        let { passed, failed, skipped, todo } = counts;
+        console.log(`1..${this.#total}`);
+        console.log(`# tests ${passed + failed + skipped + todo}`);
+        console.log(`# pass ${passed}`);
+        console.log(`# fail ${failed}`);
+        if (skipped > 0)
+            console.log(`# skipped ${skipped}`);
+        if (todo > 0)
+            console.log(`# todo ${todo}`);
+        console.log(`# duration_ms ${durationMs.toFixed(5)}`);
+    }
+}

package/dist/lib/runner-browser.d.ts

@@ -0,0 +1,21 @@
+import { type CoverageMap } from './coverage.ts';
+import { type PlaywrightUseOpts } from './playwright.ts';
+import type { Reporter } from './reporters/index.ts';
+import type { TestResults } from './reporters/results.ts';
+export interface TestRunOptions {
+    baseUrl: string;
+    console?: boolean;
+    coverage?: boolean;
+    open?: boolean;
+    playwrightUseOpts?: PlaywrightUseOpts;
+    projectName?: string;
+    reporter: Reporter;
+    testFiles?: string[];
+}
+export declare function runBrowserTests(options: TestRunOptions): Promise<{
+    results: TestResults;
+    coverageMap: CoverageMap | null;
+    close: () => Promise<void>;
+    disconnected: Promise<void>;
+}>;
+//# sourceMappingURL=runner-browser.d.ts.map

package/dist/lib/runner-browser.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"runner-browser.d.ts","sourceRoot":"","sources":["../../src/lib/runner-browser.ts"],"names":[],"mappings":"AAIA,OAAO,EAEL,KAAK,WAAW,EAEjB,MAAM,eAAe,CAAA;AACtB,OAAO,EAIL,KAAK,iBAAiB,EACvB,MAAM,iBAAiB,CAAA;AACxB,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,sBAAsB,CAAA;AACpD,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,wBAAwB,CAAA;AAWzD,MAAM,WAAW,cAAc;IAC7B,OAAO,EAAE,MAAM,CAAA;IACf,OAAO,CAAC,EAAE,OAAO,CAAA;IACjB,QAAQ,CAAC,EAAE,OAAO,CAAA;IAClB,IAAI,CAAC,EAAE,OAAO,CAAA;IACd,iBAAiB,CAAC,EAAE,iBAAiB,CAAA;IACrC,WAAW,CAAC,EAAE,MAAM,CAAA;IACpB,QAAQ,EAAE,QAAQ,CAAA;IAGlB,SAAS,CAAC,EAAE,MAAM,EAAE,CAAA;CACrB;AAED,wBAAsB,eAAe,CAAC,OAAO,EAAE,cAAc,GAAG,OAAO,CAAC;IACtE,OAAO,EAAE,WAAW,CAAA;IACpB,WAAW,EAAE,WAAW,GAAG,IAAI,CAAA;IAC/B,KAAK,EAAE,MAAM,OAAO,CAAC,IAAI,CAAC,CAAA;IAC1B,YAAY,EAAE,OAAO,CAAC,IAAI,CAAC,CAAA;CAC5B,CAAC,CAuHD"}

package/dist/lib/runner-browser.js

@@ -0,0 +1,117 @@
+import * as path from 'node:path';
+import { colors } from "./colors.js";
+import { getBrowserTestRootDir } from "./config.js";
+import { collectCoverageMapFromPlaywright, } from "./coverage.js";
+import { getBrowserLauncher, getPlaywrightLaunchOptions, getPlaywrightPageOptions, } from "./playwright.js";
+// The harness reports each test result with `filePath` set to the
+// `/scripts/<rel>` URL the iframe loaded. Reporters expect a real filesystem
+// path so they can compute `path.relative(cwd, ...)` cleanly; otherwise they
+// produce noisy `../../../scripts/...` strings.
+function urlPathToFilePath(urlPath, rootDir) {
+    if (!urlPath.startsWith('/scripts/'))
+        return urlPath;
+    return path.resolve(rootDir, urlPath.slice('/scripts/'.length));
+}
+export async function runBrowserTests(options) {
+    let envLabel = options.projectName ? `browser:${options.projectName}` : 'browser';
+    let browser;
+    let page;
+    let close = async () => {
+        await page?.close();
+        await browser?.close();
+        browser = undefined;
+        page = undefined;
+    };
+    let results;
+    let coverageMap = null;
+    try {
+        browser = await getBrowserLauncher(options.playwrightUseOpts).launch(getPlaywrightLaunchOptions(options.playwrightUseOpts));
+        page = await browser.newPage(getPlaywrightPageOptions(options.playwrightUseOpts));
+        if (options.console) {
+            page.on('console', (msg) => console.log(`${colors.dim('[browser console]')} ${msg.text()}`));
+        }
+        // Playwright's JS coverage is Chromium-only. Start before navigation so
+        // the harness scripts and test modules are instrumented from first parse.
+        let coverageEnabled = options.coverage && browser.browserType().name() === 'chromium';
+        if (coverageEnabled) {
+            await page.coverage.startJSCoverage({ resetOnNavigation: false });
+        }
+        let totalPassed = 0;
+        let totalFailed = 0;
+        let totalSkipped = 0;
+        let totalTodo = 0;
+        let rootDir = getBrowserTestRootDir();
+        await page.route('**/file-results', async (route) => {
+            let results = route.request().postDataJSON();
+            for (let test of results.tests) {
+                if (test.filePath)
+                    test.filePath = urlPathToFilePath(test.filePath, rootDir);
+            }
+            options.reporter.onResult(results, envLabel);
+            totalPassed += results.passed;
+            totalFailed += results.failed;
+            totalSkipped += results.skipped;
+            totalTodo += results.todo;
+            await route.fulfill({ status: 200 });
+        });
+        // Fail the tests if any /scripts/ request fails (harness scripts, test
+        // modules, or their transitive imports — all served via the same prefix).
+        let errorPromise = new Promise((_, reject) => {
+            let isScriptRequest = (request) => new URL(request.url()).pathname.startsWith('/scripts/');
+            page.on('response', (response) => {
+                if (!response.ok() && isScriptRequest(response.request())) {
+                    reject(new Error(`Failed to load script: ${response.request().url()}`));
+                }
+            });
+            page.on('requestfailed', (request) => {
+                if (isScriptRequest(request)) {
+                    reject(new Error(`Failed to load script: ${request.url()}`));
+                }
+            });
+        });
+        // Prevent unhandled rejection if we fail before setting up the listener
+        errorPromise.catch(() => { });
+        await page.goto(options.baseUrl);
+        await Promise.race([page.waitForFunction('window.__testsDone'), errorPromise]);
+        if (coverageEnabled) {
+            let entries = (await page.coverage.stopJSCoverage());
+            if (entries.length > 0) {
+                coverageMap = await collectCoverageMapFromPlaywright(entries, getBrowserTestRootDir(), new Set(options.testFiles ?? []), async (urlPath) => urlPath.startsWith('/scripts/') ? urlPath.slice('/scripts/'.length) : null);
+            }
+        }
+        results = {
+            passed: totalPassed,
+            failed: totalFailed,
+            skipped: totalSkipped,
+            todo: totalTodo,
+            tests: [],
+        };
+    }
+    catch (error) {
+        console.error('Browser tests failed to run:', error);
+        results = {
+            passed: 0,
+            failed: 1,
+            skipped: 0,
+            todo: 0,
+            tests: [],
+        };
+    }
+    if (options.open) {
+        return {
+            results,
+            coverageMap,
+            close,
+            disconnected: new Promise((r) => browser.on('disconnected', () => r())),
+        };
+    }
+    else {
+        await close();
+        return {
+            results,
+            coverageMap,
+            close,
+            disconnected: Promise.resolve(),
+        };
+    }
+}

package/dist/lib/runner.d.ts

@@ -0,0 +1,14 @@
+import { type CoverageConfig, type CoverageMap } from './coverage.ts';
+import { type PlaywrightUseOpts } from './playwright.ts';
+import type { Reporter } from './reporters/index.ts';
+import type { Counts } from './reporters/results.ts';
+export declare function runServerTests(files: string[], reporter: Reporter, concurrency: number, type: 'server' | 'e2e', options?: {
+    cwd?: string;
+    open?: boolean;
+    playwrightUseOpts?: PlaywrightUseOpts;
+    projectName?: string;
+    coverage?: CoverageConfig;
+}): Promise<Counts & {
+    coverageMap: CoverageMap | null;
+}>;
+//# sourceMappingURL=runner.d.ts.map

package/dist/lib/runner.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"runner.d.ts","sourceRoot":"","sources":["../../src/lib/runner.ts"],"names":[],"mappings":"AAKA,OAAO,EAGL,KAAK,cAAc,EACnB,KAAK,WAAW,EAEjB,MAAM,eAAe,CAAA;AACtB,OAAO,EAAE,KAAK,iBAAiB,EAAE,MAAM,iBAAiB,CAAA;AACxD,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,sBAAsB,CAAA;AACpD,OAAO,KAAK,EAAE,MAAM,EAAe,MAAM,wBAAwB,CAAA;AAQjE,wBAAsB,cAAc,CAClC,KAAK,EAAE,MAAM,EAAE,EACf,QAAQ,EAAE,QAAQ,EAClB,WAAW,EAAE,MAAM,EACnB,IAAI,EAAE,QAAQ,GAAG,KAAK,EACtB,OAAO,GAAE;IACP,GAAG,CAAC,EAAE,MAAM,CAAA;IACZ,IAAI,CAAC,EAAE,OAAO,CAAA;IACd,iBAAiB,CAAC,EAAE,iBAAiB,CAAA;IACrC,WAAW,CAAC,EAAE,MAAM,CAAA;IACpB,QAAQ,CAAC,EAAE,cAAc,CAAA;CACrB,GACL,OAAO,CAAC,MAAM,GAAG;IAAE,WAAW,EAAE,WAAW,GAAG,IAAI,CAAA;CAAE,CAAC,CAwEvD"}

package/dist/lib/runner.js

@@ -0,0 +1,118 @@
+import * as fsp from 'node:fs/promises';
+import * as path from 'node:path';
+import { pathToFileURL } from 'node:url';
+import { Worker } from 'node:worker_threads';
+import { IS_RUNNING_FROM_SRC } from "./config.js";
+import { collectCoverageMapFromPlaywright, collectServerCoverageMap, } from "./coverage.js";
+import {} from "./playwright.js";
+// Ensure we load the right file whether we're running in the monorepo (TS) or
+// from a published package (JS)
+const ext = IS_RUNNING_FROM_SRC ? '.ts' : '.js';
+const workerUrl = new URL(`./worker${ext}`, import.meta.url);
+const workerE2EUrl = new URL(`./worker-e2e${ext}`, import.meta.url);
+export async function runServerTests(files, reporter, concurrency, type, options = {}) {
+    let counts = { passed: 0, failed: 0, skipped: 0, todo: 0 };
+    let coverageMap = null;
+    let cwd = options.cwd ?? process.cwd();
+    let envLabel = options.projectName ? `${type}:${options.projectName}` : type;
+    function accumulate(results, file) {
+        reporter.onResult({ ...results, tests: results.tests.map((t) => ({ ...t, filePath: file })) }, envLabel);
+        counts.passed += results.passed;
+        counts.failed += results.failed;
+        counts.skipped += results.skipped;
+        counts.todo += results.todo;
+    }
+    if (type === 'e2e') {
+        let allBrowserCoverageEntries = [];
+        await runInConcurrentWorkers(files, concurrency, (file) => runFileInWorker(file, type, (results) => {
+            accumulate(results, file);
+            if (results.e2eBrowserCoverageEntries) {
+                allBrowserCoverageEntries.push(...results.e2eBrowserCoverageEntries);
+            }
+        }, {
+            ...options,
+            playwrightUseOpts: options.playwrightUseOpts,
+        }), () => counts.failed++);
+        if (options.coverage && allBrowserCoverageEntries.length > 0) {
+            coverageMap = await collectCoverageMapFromPlaywright(allBrowserCoverageEntries.flatMap((e) => e.entries), cwd, new Set(files), async (urlPath) => (urlPath.startsWith('/') ? urlPath.slice(1) : urlPath));
+        }
+    }
+    else {
+        let coverageDataDir;
+        if (options.coverage) {
+            coverageDataDir = path.resolve(cwd, options.coverage.dir);
+            await fsp.mkdir(coverageDataDir, { recursive: true });
+            process.env.NODE_V8_COVERAGE = coverageDataDir;
+        }
+        await runInConcurrentWorkers(files, concurrency, (file) => runFileInWorker(file, type, (results) => accumulate(results, file), options), () => counts.failed++);
+        if (coverageDataDir) {
+            delete process.env.NODE_V8_COVERAGE;
+            let serverMap = await collectServerCoverageMap(coverageDataDir, cwd, new Set(files));
+            coverageMap = serverMap;
+        }
+    }
+    return { ...counts, coverageMap };
+}
+async function runInConcurrentWorkers(files, concurrency, runFile, onError) {
+    let index = 0;
+    let active = 0;
+    await new Promise((resolve) => {
+        function dispatch() {
+            while (active < concurrency && index < files.length) {
+                let file = files[index];
+                index++;
+                active++;
+                runFile(file).then(() => {
+                    active--;
+                    if (index < files.length) {
+                        dispatch();
+                    }
+                    else if (active === 0) {
+                        resolve();
+                    }
+                }, (err) => {
+                    console.error(`Error running ${file}:`, err.message);
+                    console.error(err);
+                    onError();
+                    active--;
+                    if (active === 0 && index >= files.length)
+                        resolve();
+                    else
+                        dispatch();
+                });
+            }
+            if (index >= files.length && active === 0)
+                resolve();
+        }
+        dispatch();
+    });
+}
+function runFileInWorker(file, type, onResults, options = {}) {
+    return new Promise((resolve, reject) => {
+        let worker = type === 'e2e'
+            ? new Worker(workerE2EUrl, {
+                workerData: {
+                    file: pathToFileURL(file).href,
+                    type,
+                    coverage: options.coverage,
+                    open: options.open,
+                    playwrightUseOpts: options.playwrightUseOpts,
+                },
+            })
+            : new Worker(workerUrl, {
+                workerData: {
+                    file: pathToFileURL(file).href,
+                    type,
+                    coverage: options.coverage,
+                },
+            });
+        worker.once('message', (msg) => onResults(msg));
+        worker.once('error', reject);
+        worker.once('exit', (code) => {
+            if (code !== 0)
+                reject(new Error(`Worker exited with code ${code}`));
+            else
+                resolve();
+        });
+    });
+}

package/dist/lib/runtime.d.ts

@@ -0,0 +1,2 @@
+export declare const IS_BUN: boolean;
+//# sourceMappingURL=runtime.d.ts.map

package/dist/lib/runtime.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"runtime.d.ts","sourceRoot":"","sources":["../../src/lib/runtime.ts"],"names":[],"mappings":"AACA,eAAO,MAAM,MAAM,SAA2C,CAAA"}

package/dist/lib/runtime.js

@@ -0,0 +1,2 @@
+// https://bun.com/docs/guides/util/detect-bun
+export const IS_BUN = typeof process.versions.bun === 'string';

package/dist/lib/ts-transform.d.ts

@@ -0,0 +1,4 @@
+export declare function transformTypeScript(source: string, filePath: string): Promise<{
+    code: string;
+}>;
+//# sourceMappingURL=ts-transform.d.ts.map

package/dist/lib/ts-transform.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"ts-transform.d.ts","sourceRoot":"","sources":["../../src/lib/ts-transform.ts"],"names":[],"mappings":"AAmBA,wBAAsB,mBAAmB,CACvC,MAAM,EAAE,MAAM,EACd,QAAQ,EAAE,MAAM,GACf,OAAO,CAAC;IAAE,IAAI,EAAE,MAAM,CAAA;CAAE,CAAC,CAa3B"}

package/dist/lib/ts-transform.js

@@ -0,0 +1,29 @@
+import { transform } from 'esbuild';
+import { getTsconfig } from 'get-tsconfig';
+import * as path from 'node:path';
+const tsconfigCache = new Map();
+/*
+ * Transform a TypeScript file to JavaScript using esbuild with an inline
+ * source map and no minification. Used by the coverage ESM loader hook (so V8
+ * instruments readable JS), the coverage collector (so byte offsets can be
+ * re-derived and mapped back to TypeScript lines), and the browser harness
+ * server (so the bytes V8 sees in the browser match what the collector
+ * re-derives). Identical inputs must produce identical outputs across all
+ * call sites or coverage offsets won't line up.
+ *
+ * Compiler options (notably JSX) are taken from the nearest `tsconfig.json`
+ * walking up from the file's directory, so each project picks up its own
+ * `jsxImportSource` etc. Discovery results are cached by directory.
+ */
+export async function transformTypeScript(source, filePath) {
+    let loader = filePath.endsWith('.tsx') ? 'tsx' : 'ts';
+    let tsConfig = getTsconfig(path.dirname(filePath), 'tsconfig.json', tsconfigCache);
+    let result = await transform(source, {
+        loader,
+        sourcemap: 'inline',
+        sourcesContent: true,
+        sourcefile: filePath,
+        tsconfigRaw: { compilerOptions: tsConfig?.config.compilerOptions ?? {} },
+    });
+    return { code: result.code };
+}

package/dist/lib/watcher.d.ts

@@ -0,0 +1,5 @@
+export declare function createWatcher(onChange: (file: string) => void): {
+    update: (files: string[]) => void;
+    close: () => void;
+};
+//# sourceMappingURL=watcher.d.ts.map

package/dist/lib/watcher.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"watcher.d.ts","sourceRoot":"","sources":["../../src/lib/watcher.ts"],"names":[],"mappings":"AAUA,wBAAgB,aAAa,CAAC,QAAQ,EAAE,CAAC,IAAI,EAAE,MAAM,KAAK,IAAI;;;EAmC7D"}