@remix-run/test 0.0.0 → 0.1.0

package/dist/lib/framework.js

@@ -0,0 +1,198 @@
+// Holds lifecycle hooks registered at the top level (outside any describe).
+// Top-level describes inherit these hooks just like nested describes inherit
+// from their parent.
+const rootHooks = {};
+let currentSuite = null;
+const rootSuites = [];
+// Lazily-created suite for top-level it() calls outside any describe().
+// Name '' causes the reporter to display these tests under "Global".
+// We check rootSuites.includes() so the suite is re-created after the executor
+// clears rootSuites between files (suites.length = 0) or after captureRegistration splices it.
+let implicitRootSuite = null;
+function getImplicitRootSuite() {
+    if (!implicitRootSuite || !rootSuites.includes(implicitRootSuite)) {
+        implicitRootSuite = { name: '', tests: [], ...rootHooks };
+        rootSuites.push(implicitRootSuite);
+    }
+    return implicitRootSuite;
+}
+// Expose for executor.ts which reads this global
+;
+globalThis.__testSuites = rootSuites;
+function registerDescribe(name, fn, flags) {
+    // Nested describes are flattened: "Parent > Child"
+    let fullName = currentSuite ? `${currentSuite.name} > ${name}` : name;
+    if (rootSuites.some((s) => s.name === fullName)) {
+        throw new Error(`Duplicate suite name: "${fullName}"`);
+    }
+    let suite = { name: fullName, tests: [], ...flags };
+    // Inherit lifecycle hooks from parent suite (or root hooks if at top level)
+    let parent = currentSuite ?? rootHooks;
+    if (parent.beforeEach)
+        suite.beforeEach = parent.beforeEach;
+    if (parent.afterEach)
+        suite.afterEach = parent.afterEach;
+    if (parent.beforeAll)
+        suite.beforeAll = parent.beforeAll;
+    if (parent.afterAll)
+        suite.afterAll = parent.afterAll;
+    let insertedAt = rootSuites.length;
+    rootSuites.push(suite);
+    let prevSuite = currentSuite;
+    currentSuite = suite;
+    try {
+        fn();
+    }
+    catch (error) {
+        // Remove this suite and any suites registered during fn() so they don't
+        // end up in the executor after a failed registration call
+        rootSuites.splice(insertedAt);
+        throw error;
+    }
+    finally {
+        currentSuite = prevSuite;
+    }
+}
+/**
+ * Groups related tests into a named suite. Suites can be nested snd will be displayed
+ * as such or joined with ` > ` in reporter output. Lifecycle hooks registered inside
+ * a `describe` block apply only to tests within that block.
+ *
+ * @example
+ * describe('auth', () => {
+ *   it('logs in', async () => { ... })
+ * })
+ *
+ * // Modifiers
+ * describe.skip('skipped suite', () => { ... })
+ * describe.only('focused suite', () => { ... })
+ * describe.todo('planned suite')
+ *
+ * @param name - The suite name shown in reporter output.
+ * @param fn - A function that registers the tests and lifecycle hooks in this suite.
+ */
+export const describe = Object.assign((name, metaOrFn, fn) => {
+    let meta = typeof metaOrFn === 'function' ? {} : metaOrFn;
+    let suiteFn = typeof metaOrFn === 'function' ? metaOrFn : fn;
+    registerDescribe(name, suiteFn, meta);
+}, {
+    skip: (name, fn) => registerDescribe(name, fn, { skip: true }),
+    only: (name, fn) => registerDescribe(name, fn, { only: true }),
+    todo: (name) => {
+        let fullName = currentSuite ? `${currentSuite.name} > ${name}` : name;
+        if (rootSuites.some((s) => s.name === fullName)) {
+            throw new Error(`Duplicate suite name: "${fullName}"`);
+        }
+        rootSuites.push({ name: fullName, tests: [], todo: true });
+    },
+});
+function registerIt(name, fn, flags) {
+    let suite = currentSuite ?? getImplicitRootSuite();
+    if (suite.tests.some((t) => t.name === name)) {
+        throw new Error(`Duplicate test name: "${name}" in suite "${suite.name || 'Global'}"`);
+    }
+    suite.tests.push({ name, fn, suite, ...flags });
+}
+/**
+ * Defines a single test case. The optional `TestContext` argument `t` provides
+ * mock helpers and per-test cleanup registration.
+ *
+ * @example
+ * it('returns 200 for the home route', async () => {
+ *   const res = await router.fetch('/')
+ *   assert.equal(res.status, 200)
+ * })
+ *
+ * // Modifiers
+ * it.skip('not ready yet', () => { ... })
+ * it.only('focused test', () => { ... })
+ * it.todo('coming soon')
+ *
+ * @param name - The test name shown in reporter output.
+ * @param fn - The test body, receiving a {@link TestContext} as its first argument.
+ */
+export const it = Object.assign((name, metaOrFn, fn) => {
+    let meta = typeof metaOrFn === 'function' ? {} : metaOrFn;
+    let testFn = typeof metaOrFn === 'function' ? metaOrFn : fn;
+    registerIt(name, testFn, meta);
+}, {
+    skip: (name, fn) => registerIt(name, fn ?? (() => { }), { skip: true }),
+    only: (name, fn) => registerIt(name, fn, { only: true }),
+    todo: (name) => {
+        let suite = currentSuite ?? getImplicitRootSuite();
+        if (suite.tests.some((t) => t.name === name)) {
+            throw new Error(`Duplicate test name: "${name}" in suite "${suite.name || 'Global'}"`);
+        }
+        suite.tests.push({ name, fn: () => { }, suite, todo: true });
+    },
+});
+/** Alias for {@link describe}. */
+export const suite = describe;
+/** Alias for {@link it}. */
+export const test = it;
+function chainBefore(existing, fn) {
+    return existing
+        ? async () => {
+            await existing();
+            await fn();
+        }
+        : fn;
+}
+function chainAfter(existing, fn) {
+    // Child/later runs first, then earlier (reverse order)
+    return existing
+        ? async () => {
+            await fn();
+            await existing();
+        }
+        : fn;
+}
+/**
+ * Registers a hook that runs before **each** test in the current suite (or
+ * globally if called outside a `describe`). Multiple calls are chained in
+ * registration order.
+ *
+ * @param fn - The setup function to run before each test.
+ */
+export function beforeEach(fn) {
+    let target = currentSuite ?? rootHooks;
+    target.beforeEach = chainBefore(target.beforeEach, fn);
+}
+/**
+ * Registers a hook that runs after **each** test in the current suite (or
+ * globally if called outside a `describe`). Multiple calls are chained in
+ * reverse registration order.  To run logic after a singular test, use
+ * `t.after()` from the {@link TestContext}
+ *
+ * @param fn - The teardown function to run after each test.
+ */
+export function afterEach(fn) {
+    let target = currentSuite ?? rootHooks;
+    target.afterEach = chainAfter(target.afterEach, fn);
+}
+/**
+ * Registers a hook that runs once before **all** tests in the current suite
+ * (or globally if called outside a `describe`). Multiple calls are chained in
+ * registration order.
+ *
+ * @param fn - The setup function to run once before all tests in the suite.
+ */
+export function beforeAll(fn) {
+    let target = currentSuite ?? rootHooks;
+    target.beforeAll = chainBefore(target.beforeAll, fn);
+}
+/**
+ * Registers a hook that runs once after **all** tests in the current suite (or
+ * globally if called outside a `describe`). Multiple calls are chained in
+ * reverse registration order.
+ *
+ * @param fn - The teardown function to run once after all tests in the suite.
+ */
+export function afterAll(fn) {
+    let target = currentSuite ?? rootHooks;
+    target.afterAll = chainAfter(target.afterAll, fn);
+}
+/** Alias for {@link beforeAll} — matches the `node:test` API. */
+export const before = beforeAll;
+/** Alias for {@link afterAll} — matches the `node:test` API. */
+export const after = afterAll;

package/dist/lib/framework.test.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=framework.test.d.ts.map

package/dist/lib/framework.test.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"framework.test.d.ts","sourceRoot":"","sources":["../../src/lib/framework.test.tsx"],"names":[],"mappings":""}

package/dist/lib/framework.test.e2e.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=framework.test.e2e.d.ts.map

package/dist/lib/framework.test.e2e.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"framework.test.e2e.d.ts","sourceRoot":"","sources":["../../src/lib/framework.test.e2e.tsx"],"names":[],"mappings":""}

package/dist/lib/framework.test.e2e.js

@@ -0,0 +1,29 @@
+import { jsx as _jsx, jsxs as _jsxs } from "@remix-run/component/jsx-runtime";
+import assert from '@remix-run/assert';
+import { renderToString } from '@remix-run/component/server';
+import { createRouter } from '@remix-run/fetch-router';
+import { route } from '@remix-run/fetch-router/routes';
+import { describe, it } from "./framework.js";
+const html = async (n) => new Response(await renderToString(n), {
+    headers: { 'Content-Type': 'text/html' },
+});
+describe('e2e tests', () => {
+    it('runs playwright against a fetch-router instance', async (t) => {
+        function Doc() {
+            return ({ children }) => (_jsxs("html", { children: [
+                    _jsx("head", { children: _jsx("title", { children: "Test" }) }), _jsx("body", { children: children })
+                ] }));
+        }
+        let routes = route({ home: '/', about: '/about' });
+        let router = createRouter();
+        router.get(routes.home, async () => html(_jsxs(Doc, { children: [
+                _jsx("h1", { children: "Hello Remix" }), _jsx("a", { href: "/about", children: "About" })
+            ] })));
+        router.get(routes.about, async () => html(_jsx(Doc, { children: _jsx("h1", { children: "About Remix" }) })));
+        let page = await t.serve(router.fetch);
+        await page.goto('/');
+        assert.equal(await page.locator('h1').textContent(), 'Hello Remix');
+        await page.click('[href="/about"]');
+        assert.equal(await page.locator('h1').textContent(), 'About Remix');
+    });
+});

package/dist/lib/framework.test.js

@@ -0,0 +1,283 @@
+import * as assert from '@remix-run/assert';
+import { afterAll, afterEach, beforeAll, beforeEach, describe, it, suite, test, } from "./framework.js";
+// During test execution, currentSuite is null so describe() can be called freely.
+// captureRegistration() splices any newly-registered suites back out of __testSuites
+// so the executor doesn't run them — we just inspect their shape.
+function captureRegistration(fn) {
+    let suites = globalThis.__testSuites;
+    let before = suites.length;
+    fn();
+    return suites.splice(before);
+}
+// ── describe ──────────────────────────────────────────────────────────────────
+describe('describe', () => {
+    it('has skip, only, and todo sub-functions', () => {
+        assert.equal(typeof describe.skip, 'function');
+        assert.equal(typeof describe.only, 'function');
+        assert.equal(typeof describe.todo, 'function');
+    });
+    it('registers a suite with the given name', () => {
+        let [s] = captureRegistration(() => describe('my suite', () => { }));
+        assert.equal(s.name, 'my suite');
+    });
+    it('calls fn to register tests', () => {
+        let called = false;
+        captureRegistration(() => describe('suite', () => {
+            called = true;
+        }));
+        assert.equal(called, true);
+    });
+    it('registers tests added inside fn', () => {
+        let [s] = captureRegistration(() => describe('suite', () => {
+            it('test one', () => { });
+            it('test two', () => { });
+        }));
+        assert.equal(s.tests.length, 2);
+        assert.equal(s.tests[0].name, 'test one');
+        assert.equal(s.tests[1].name, 'test two');
+    });
+    it('flattens nested describes into "Outer > Inner" names', () => {
+        let [outer, inner] = captureRegistration(() => {
+            describe('outer', () => {
+                describe('inner', () => { });
+            });
+        });
+        assert.equal(outer.name, 'outer');
+        assert.equal(inner.name, 'outer > inner');
+    });
+});
+describe('describe.skip', () => {
+    it('marks the suite as skipped', () => {
+        let [s] = captureRegistration(() => describe.skip('suite', () => { }));
+        assert.equal(s.skip, true);
+    });
+    it('still calls fn to register tests', () => {
+        let [s] = captureRegistration(() => describe.skip('suite', () => {
+            it('test', () => { });
+        }));
+        assert.equal(s.tests.length, 1);
+    });
+});
+describe('describe.only', () => {
+    it('marks the suite as only', () => {
+        let [s] = captureRegistration(() => describe.only('suite', () => { }));
+        assert.equal(s.only, true);
+    });
+});
+describe('describe.todo', () => {
+    it('marks the suite as todo', () => {
+        let [s] = captureRegistration(() => describe.todo('suite'));
+        assert.equal(s.todo, true);
+    });
+    it('registers with no tests', () => {
+        let [s] = captureRegistration(() => describe.todo('suite'));
+        assert.equal(s.tests.length, 0);
+    });
+});
+// ── it ────────────────────────────────────────────────────────────────────────
+describe('it', () => {
+    it('has skip, only, and todo sub-functions', () => {
+        assert.equal(typeof it.skip, 'function');
+        assert.equal(typeof it.only, 'function');
+        assert.equal(typeof it.todo, 'function');
+    });
+    it('can be called outside describe (registers on implicit root suite)', () => {
+        let fn = () => { };
+        let captured = captureRegistration(() => it('orphan', fn));
+        let root = captured.find((s) => s.name === '');
+        assert.equal(root?.tests.some((t) => t.fn === fn), true);
+    });
+    it('registers a test with the given name and fn', () => {
+        let fn = () => { };
+        let [s] = captureRegistration(() => describe('suite', () => {
+            it('my test', fn);
+        }));
+        assert.equal(s.tests[0].name, 'my test');
+        assert.equal(s.tests[0].fn, fn);
+    });
+});
+describe('it.skip', () => {
+    it('marks the test as skipped', () => {
+        let [s] = captureRegistration(() => describe('suite', () => {
+            it.skip('skipped test', () => { });
+        }));
+        assert.equal(s.tests[0].skip, true);
+    });
+    it('accepts an optional fn', () => {
+        let [s] = captureRegistration(() => describe('suite', () => {
+            it.skip('no fn');
+        }));
+        assert.equal(s.tests[0].skip, true);
+        assert.equal(typeof s.tests[0].fn, 'function');
+    });
+});
+describe('it.only', () => {
+    it('marks the test as only', () => {
+        let [s] = captureRegistration(() => describe('suite', () => {
+            it.only('only test', () => { });
+        }));
+        assert.equal(s.tests[0].only, true);
+    });
+});
+describe('it.todo', () => {
+    it('marks the test as todo', () => {
+        let [s] = captureRegistration(() => describe('suite', () => {
+            it.todo('todo test');
+        }));
+        assert.equal(s.tests[0].todo, true);
+        assert.equal(s.tests[0].name, 'todo test');
+    });
+    it('can be called outside describe (registers on implicit root suite)', () => {
+        let captured = captureRegistration(() => it.todo('orphan'));
+        let root = captured.find((s) => s.name === '');
+        assert.equal(root?.tests[0]?.name, 'orphan');
+        assert.equal(root?.tests[0]?.todo, true);
+    });
+});
+// ── Duplicate detection ───────────────────────────────────────────────────────
+describe('duplicate detection', () => {
+    it('throws on duplicate suite name', () => {
+        let suites = globalThis.__testSuites;
+        let before = suites.length;
+        try {
+            assert.throws(() => {
+                describe('__dup-suite__', () => { });
+                describe('__dup-suite__', () => { });
+            }, /Duplicate suite name: "__dup-suite__"/);
+        }
+        finally {
+            suites.splice(before);
+        }
+    });
+    it('throws on duplicate describe.todo name', () => {
+        let suites = globalThis.__testSuites;
+        let before = suites.length;
+        try {
+            assert.throws(() => {
+                describe.todo('__dup-todo-suite__');
+                describe.todo('__dup-todo-suite__');
+            }, /Duplicate suite name: "__dup-todo-suite__"/);
+        }
+        finally {
+            suites.splice(before);
+        }
+    });
+    it('throws on duplicate test name within a suite', () => {
+        assert.throws(() => captureRegistration(() => describe('suite', () => {
+            it('same name', () => { });
+            it('same name', () => { });
+        })), /Duplicate test name: "same name" in suite "suite"/);
+    });
+    it('throws on duplicate it.todo name within a suite', () => {
+        assert.throws(() => captureRegistration(() => describe('suite', () => {
+            it.todo('same name');
+            it.todo('same name');
+        })), /Duplicate test name: "same name" in suite "suite"/);
+    });
+});
+// ── Aliases ───────────────────────────────────────────────────────────────────
+describe('suite alias', () => {
+    it('is an alias for describe', () => {
+        assert.equal(suite, describe);
+    });
+});
+describe('test alias', () => {
+    it('is an alias for it', () => {
+        assert.equal(test, it);
+    });
+});
+// ── Lifecycle hooks ───────────────────────────────────────────────────────────
+describe('lifecycle hooks', () => {
+    it('beforeEach registers on the current suite', () => {
+        let fn = () => { };
+        let [s] = captureRegistration(() => describe('suite', () => {
+            beforeEach(fn);
+        }));
+        assert.equal(s.beforeEach, fn);
+    });
+    it('afterEach registers on the current suite', () => {
+        let fn = () => { };
+        let [s] = captureRegistration(() => describe('suite', () => {
+            afterEach(fn);
+        }));
+        assert.equal(s.afterEach, fn);
+    });
+    it('beforeAll registers on the current suite', () => {
+        let fn = () => { };
+        let [s] = captureRegistration(() => describe('suite', () => {
+            beforeAll(fn);
+        }));
+        assert.equal(s.beforeAll, fn);
+    });
+    it('afterAll registers on the current suite', () => {
+        let fn = () => { };
+        let [s] = captureRegistration(() => describe('suite', () => {
+            afterAll(fn);
+        }));
+        assert.equal(s.afterAll, fn);
+    });
+    it('beforeEach can be called outside describe (registers on root hooks)', () => {
+        // Just verify it doesn't throw — root-level hooks are tested via inheritance
+        assert.doesNotThrow(() => {
+            let [s] = captureRegistration(() => {
+                beforeEach(() => { });
+                describe('suite', () => { });
+            });
+            assert.equal(typeof s.beforeEach, 'function');
+        });
+    });
+    it('afterEach can be called outside describe (registers on root hooks)', () => {
+        assert.doesNotThrow(() => {
+            let [s] = captureRegistration(() => {
+                afterEach(() => { });
+                describe('suite', () => { });
+            });
+            assert.equal(typeof s.afterEach, 'function');
+        });
+    });
+    it('beforeAll can be called outside describe (registers on root hooks)', () => {
+        assert.doesNotThrow(() => {
+            let [s] = captureRegistration(() => {
+                beforeAll(() => { });
+                describe('suite', () => { });
+            });
+            assert.equal(typeof s.beforeAll, 'function');
+        });
+    });
+    it('afterAll can be called outside describe (registers on root hooks)', () => {
+        assert.doesNotThrow(() => {
+            let [s] = captureRegistration(() => {
+                afterAll(() => { });
+                describe('suite', () => { });
+            });
+            assert.equal(typeof s.afterAll, 'function');
+        });
+    });
+});
+describe('Example Test Suite', () => {
+    it('passes basic equality', () => {
+        assert.equal(1 + 1, 2);
+    });
+    it('passes deep equality', () => {
+        assert.deepEqual({ a: 1, b: 2 }, { a: 1, b: 2 });
+    });
+    it('can test async code', async () => {
+        let result = await Promise.resolve(42);
+        assert.equal(result, 42);
+    });
+    it('can assert throws', () => {
+        assert.throws(() => {
+            throw new Error('test error');
+        }, /test error/);
+    });
+    it.skip('skip: can skip tests', () => {
+        assert.equal(true, false);
+    });
+    it.todo('todo: can mark tests as todo');
+});
+describe.skip('skip: Skipped Test Suite', () => {
+    it('would fail', () => {
+        assert.equal(true, false);
+    });
+});
+describe.todo('todo: Test Suite');

package/dist/lib/mock.d.ts

@@ -0,0 +1,52 @@
+/** Records the arguments, return value, and any thrown error for a single call. */
+export interface MockCall<Args extends unknown[] = unknown[], Result = unknown> {
+    arguments: Args;
+    result?: Result;
+    error?: unknown;
+}
+/**
+ * Metadata attached to every mock/spy function via its `.mock` property.
+ * `restore` is present on spies and reverts the original method when called.
+ */
+export interface MockContext<Args extends unknown[] = unknown[], Result = unknown> {
+    calls: MockCall<Args, Result>[];
+    restore?: () => void;
+}
+/** A function augmented with a `.mock` property for inspecting recorded calls. */
+export type MockFunction<T extends (...args: any[]) => any = (...args: any[]) => any> = T & {
+    mock: MockContext<Parameters<T>, ReturnType<T>>;
+};
+declare function createMockFn<T extends (...args: any[]) => any>(impl?: T): MockFunction<T>;
+declare function createMethodMock<T extends object, K extends keyof T>(obj: T, method: K, impl?: T[K] extends (...args: any[]) => any ? (...args: Parameters<T[K]>) => any : never): MockFunction;
+/**
+ * Utilities for creating mock functions and method spies. Mirrors the names
+ * on Node.js's built-in `MockTracker` from `node:test`.
+ *
+ * @example
+ * // Standalone mock
+ * const fn = mock.fn((x: number) => x * 2)
+ * fn(3)
+ * assert.equal(fn.mock.calls[0].result, 6)
+ *
+ * // Mock an existing method
+ * const spy = mock.method(console, 'log')
+ * console.log('hello')
+ * assert.equal(spy.mock.calls.length, 1)
+ * spy.mock.restore?.()
+ */
+export declare const mock: {
+    /**
+     * Creates a mock function that records every call. If `impl` is provided it
+     * is used as the underlying implementation; otherwise the mock returns
+     * `undefined`.
+     */
+    fn: typeof createMockFn;
+    /**
+     * Replaces `obj[methodName]` with a mock and records every call. The
+     * original method is used as the implementation unless `impl` is provided.
+     * Call `mockFn.mock.restore()` to revert.
+     */
+    method: typeof createMethodMock;
+};
+export {};
+//# sourceMappingURL=mock.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"mock.d.ts","sourceRoot":"","sources":["../../src/lib/mock.ts"],"names":[],"mappings":"AAAA,mFAAmF;AACnF,MAAM,WAAW,QAAQ,CAAC,IAAI,SAAS,OAAO,EAAE,GAAG,OAAO,EAAE,EAAE,MAAM,GAAG,OAAO;IAC5E,SAAS,EAAE,IAAI,CAAA;IACf,MAAM,CAAC,EAAE,MAAM,CAAA;IACf,KAAK,CAAC,EAAE,OAAO,CAAA;CAChB;AAED;;;GAGG;AACH,MAAM,WAAW,WAAW,CAAC,IAAI,SAAS,OAAO,EAAE,GAAG,OAAO,EAAE,EAAE,MAAM,GAAG,OAAO;IAC/E,KAAK,EAAE,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAC,EAAE,CAAA;IAC/B,OAAO,CAAC,EAAE,MAAM,IAAI,CAAA;CACrB;AAED,kFAAkF;AAClF,MAAM,MAAM,YAAY,CAAC,CAAC,SAAS,CAAC,GAAG,IAAI,EAAE,GAAG,EAAE,KAAK,GAAG,GAAG,CAAC,GAAG,IAAI,EAAE,GAAG,EAAE,KAAK,GAAG,IAAI,CAAC,GAAG;IAC1F,IAAI,EAAE,WAAW,CAAC,UAAU,CAAC,CAAC,CAAC,EAAE,UAAU,CAAC,CAAC,CAAC,CAAC,CAAA;CAChD,CAAA;AAED,iBAAS,YAAY,CAAC,CAAC,SAAS,CAAC,GAAG,IAAI,EAAE,GAAG,EAAE,KAAK,GAAG,EAAE,IAAI,CAAC,EAAE,CAAC,GAAG,YAAY,CAAC,CAAC,CAAC,CAqBlF;AAED,iBAAS,gBAAgB,CAAC,CAAC,SAAS,MAAM,EAAE,CAAC,SAAS,MAAM,CAAC,EAC3D,GAAG,EAAE,CAAC,EACN,MAAM,EAAE,CAAC,EACT,IAAI,CAAC,EAAE,CAAC,CAAC,CAAC,CAAC,SAAS,CAAC,GAAG,IAAI,EAAE,GAAG,EAAE,KAAK,GAAG,GAAG,CAAC,GAAG,IAAI,EAAE,UAAU,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,KAAK,GAAG,GAAG,KAAK,GACvF,YAAY,CASd;AAED;;;;;;;;;;;;;;;GAeG;AACH,eAAO,MAAM,IAAI;IACf;;;;OAIG;;IAEH;;;;OAIG;;CAEJ,CAAA"}

package/dist/lib/mock.js

@@ -0,0 +1,61 @@
+function createMockFn(impl) {
+    let calls = [];
+    let fn = function (...args) {
+        let call = { arguments: args };
+        calls.push(call);
+        if (impl) {
+            try {
+                let result = impl.apply(this, args);
+                call.result = result;
+                return result;
+            }
+            catch (error) {
+                call.error = error;
+                throw error;
+            }
+        }
+        return undefined;
+    };
+    fn.mock = { calls };
+    return fn;
+}
+function createMethodMock(obj, method, impl) {
+    let original = obj[method];
+    let effectiveImpl = (impl ?? original);
+    let mockFn = createMockFn(effectiveImpl);
+    obj[method] = mockFn;
+    mockFn.mock.restore = () => {
+        obj[method] = original;
+    };
+    return mockFn;
+}
+/**
+ * Utilities for creating mock functions and method spies. Mirrors the names
+ * on Node.js's built-in `MockTracker` from `node:test`.
+ *
+ * @example
+ * // Standalone mock
+ * const fn = mock.fn((x: number) => x * 2)
+ * fn(3)
+ * assert.equal(fn.mock.calls[0].result, 6)
+ *
+ * // Mock an existing method
+ * const spy = mock.method(console, 'log')
+ * console.log('hello')
+ * assert.equal(spy.mock.calls.length, 1)
+ * spy.mock.restore?.()
+ */
+export const mock = {
+    /**
+     * Creates a mock function that records every call. If `impl` is provided it
+     * is used as the underlying implementation; otherwise the mock returns
+     * `undefined`.
+     */
+    fn: createMockFn,
+    /**
+     * Replaces `obj[methodName]` with a mock and records every call. The
+     * original method is used as the implementation unless `impl` is provided.
+     * Call `mockFn.mock.restore()` to revert.
+     */
+    method: createMethodMock,
+};

package/dist/lib/playwright.d.ts

@@ -0,0 +1,15 @@
+import type { BrowserContextOptions, LaunchOptions } from 'playwright';
+import type { PlaywrightTestConfig } from 'playwright/test';
+export type PlaywrightUseOpts = PlaywrightTestConfig['use'];
+export declare function loadPlaywrightConfig(input: string | undefined): Promise<PlaywrightTestConfig | undefined>;
+export declare function getBrowserLauncher(playwrightUseOpts?: PlaywrightUseOpts): import("playwright").BrowserType<{}>;
+export declare function resolveProjects(config?: PlaywrightTestConfig): Array<{
+    name?: string;
+    playwrightUseOpts: PlaywrightUseOpts;
+}>;
+export declare function getPlaywrightLaunchOptions(playwrightUseOpts?: PlaywrightUseOpts): LaunchOptions;
+export declare function getPlaywrightPageOptions(playwrightUseOpts?: PlaywrightUseOpts): BrowserContextOptions & {
+    navigationTimeout?: number;
+    actionTimeout?: number;
+};
+//# sourceMappingURL=playwright.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"playwright.d.ts","sourceRoot":"","sources":["../../src/lib/playwright.ts"],"names":[],"mappings":"AAGA,OAAO,KAAK,EAAE,qBAAqB,EAAE,aAAa,EAAE,MAAM,YAAY,CAAA;AACtE,OAAO,KAAK,EAAE,oBAAoB,EAAE,MAAM,iBAAiB,CAAA;AAG3D,MAAM,MAAM,iBAAiB,GAAG,oBAAoB,CAAC,KAAK,CAAC,CAAA;AAE3D,wBAAsB,oBAAoB,CACxC,KAAK,EAAE,MAAM,GAAG,SAAS,GACxB,OAAO,CAAC,oBAAoB,GAAG,SAAS,CAAC,CAiB3C;AAQD,wBAAgB,kBAAkB,CAAC,iBAAiB,CAAC,EAAE,iBAAiB,wCAavE;AAED,wBAAgB,eAAe,CAC7B,MAAM,CAAC,EAAE,oBAAoB,GAC5B,KAAK,CAAC;IAAE,IAAI,CAAC,EAAE,MAAM,CAAC;IAAC,iBAAiB,EAAE,iBAAiB,CAAA;CAAE,CAAC,CAahE;AAED,wBAAgB,0BAA0B,CAAC,iBAAiB,CAAC,EAAE,iBAAiB,GAAG,aAAa,CAK/F;AAED,wBAAgB,wBAAwB,CACtC,iBAAiB,CAAC,EAAE,iBAAiB,GACpC,qBAAqB,GAAG;IAAE,iBAAiB,CAAC,EAAE,MAAM,CAAC;IAAC,aAAa,CAAC,EAAE,MAAM,CAAA;CAAE,CAwBhF"}