@unrift/core 0.3.0 → 0.5.0

package/dist/esm/mock/module.d.ts

@@ -0,0 +1,99 @@
+/**
+ * Module mocking - main-thread registry and public API (Tier A).
+ *
+ * Tier A scope:
+ *   - `mock.doMock(spec, factory)` registers a mock for an external module
+ *     specifier (bare package name or `node:*` built-in).
+ *   - Subsequent `await import(spec)` calls return the factory's result.
+ *   - Static imports are NOT supported in Tier A; see the docs / ISSUES.md
+ *     for the planned Tier B (hoisted `mock.module`) work.
+ *
+ * Architecture:
+ *   - bin/unrift.mjs registers `module-loader.js` via `module.register()` and
+ *     pipes a MessagePort into the loader thread.
+ *   - The main-side port is stashed on `globalThis.__unriftLoaderPort` before
+ *     the test runner starts.
+ *   - `doMock()` invokes the factory once, caches the result on
+ *     `globalThis.__unriftMocks`, and posts a `register` message with the
+ *     spec + export-key list to the loader.
+ *   - The loader (see module-loader.ts) drains pending messages on every
+ *     resolve() and short-circuits matched specs to a synthetic module that
+ *     reads back from `globalThis.__unriftMocks`.
+ *
+ * Future tiers will reuse the same registry shape and IPC protocol -
+ * adding `register-hoisted` (Tier B) and `register-relative` (Tier C)
+ * message types without breaking the existing surface.
+ */
+/**
+ * Sentinel field name on globalThis. Loader-generated synthetic source
+ * reads back through this same name, so it must stay stable.
+ */
+export declare const MOCKS_GLOBAL_KEY = "__unriftMocks";
+/** Sentinel field name for the IPC port set by bin/unrift.mjs. */
+export declare const LOADER_PORT_GLOBAL_KEY = "__unriftLoaderPort";
+/** URL prefix the loader uses for mocked modules. Public so tests can assert. */
+export declare const MOCK_URL_PREFIX = "unrift-mock:";
+/**
+ * Message contract between main thread and loader thread. Stable across
+ * future tiers - new message types extend this union.
+ *
+ * `registrationId` is a monotonically increasing number embedded in the
+ * synthetic mock URL. It defeats Node's URL-keyed module cache so that
+ * re-mocking the same spec in a later test yields a fresh module (rather
+ * than returning the previous test's cached mock).
+ */
+export type LoaderMessage = {
+    type: "register";
+    spec: string;
+    registrationId: number;
+    exportKeys: readonly string[];
+} | {
+    type: "unregister";
+    spec: string;
+};
+type ModuleFactory = () => Record<string, unknown>;
+/**
+ * Register a mock for `spec`. Subsequent `await import(spec)` calls will
+ * resolve to the factory's return value instead of the real module.
+ *
+ * Tier A constraints (planned to be lifted in Tier B and beyond):
+ *   - Only **dynamic** imports (`await import(spec)`) hit the mock; static
+ *     `import { x } from "spec"` is hoisted by ESM above this call and
+ *     will see the real module.
+ *   - Only **external** specifiers work - bare package names (`"react"`)
+ *     and Node built-ins (`"node:fs"`). Relative specs (`"./bar"`) are
+ *     bundled inline by esbuild and can't be intercepted at runtime.
+ *   - The factory is invoked **once** at registration time. Its return
+ *     value is reused for every subsequent import.
+ *
+ * Throws if the Unrift CLI loader isn't attached (i.e., tests were run
+ * with raw `node` instead of `unrift`).
+ */
+export declare function doMock(spec: string, factory: ModuleFactory): void;
+/**
+ * Remove a previously registered mock. Subsequent `await import(spec)`
+ * calls fall through to the real module.
+ */
+export declare function unmock(spec: string): void;
+/** Returns the current set of mocked specs. Useful for tests / debugging. */
+export declare function listMockedSpecs(): readonly string[];
+/**
+ * Convenience helper: imports the real module, builds a version with every
+ * function export wrapped in a spy, registers it via `mock.doMock`, and
+ * returns the mocked exports.
+ *
+ * Non-function exports are passed through unchanged. Tests can customize
+ * individual spies with `.mockReturnValue`, `.mockImplementation`, etc.
+ *
+ * Subject to the same Tier A limits as `doMock` - only affects
+ * `await import(spec)` after the call. Static imports of `spec` see the
+ * real module.
+ *
+ * @example
+ *   const fs = await mock.fromModule("node:fs");
+ *   fs.readFileSync.mockReturnValue("fake content");
+ *   // ... test code that does `await import("node:fs")` now gets the spies
+ */
+export declare function fromModule<T extends Record<string, unknown>>(spec: string): Promise<T>;
+export {};
+//# sourceMappingURL=module.d.ts.map

package/dist/esm/mock/module.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"module.d.ts","sourceRoot":"","sources":["../../../src/mock/module.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;GAyBG;AASH;;;GAGG;AACH,eAAO,MAAM,gBAAgB,kBAAkB,CAAC;AAEhD,kEAAkE;AAClE,eAAO,MAAM,sBAAsB,uBAAuB,CAAC;AAE3D,iFAAiF;AACjF,eAAO,MAAM,eAAe,iBAAiB,CAAC;AAE9C;;;;;;;;GAQG;AACH,MAAM,MAAM,aAAa,GACrB;IACE,IAAI,EAAE,UAAU,CAAC;IACjB,IAAI,EAAE,MAAM,CAAC;IACb,cAAc,EAAE,MAAM,CAAC;IACvB,UAAU,EAAE,SAAS,MAAM,EAAE,CAAC;CAC/B,GACD;IAAE,IAAI,EAAE,YAAY,CAAC;IAAC,IAAI,EAAE,MAAM,CAAA;CAAE,CAAC;AAEzC,KAAK,aAAa,GAAG,MAAM,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC;AAwFnD;;;;;;;;;;;;;;;;GAgBG;AACH,wBAAgB,MAAM,CAAC,IAAI,EAAE,MAAM,EAAE,OAAO,EAAE,aAAa,GAAG,IAAI,CAqCjE;AAED;;;GAGG;AACH,wBAAgB,MAAM,CAAC,IAAI,EAAE,MAAM,GAAG,IAAI,CAQzC;AAED,6EAA6E;AAC7E,wBAAgB,eAAe,IAAI,SAAS,MAAM,EAAE,CAEnD;AAED;;;;;;;;;;;;;;;;GAgBG;AACH,wBAAsB,UAAU,CAAC,CAAC,SAAS,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,EAChE,IAAI,EAAE,MAAM,GACX,OAAO,CAAC,CAAC,CAAC,CAyBZ"}

package/dist/esm/mock/module.js

@@ -0,0 +1,198 @@
+/**
+ * Module mocking - main-thread registry and public API (Tier A).
+ *
+ * Tier A scope:
+ *   - `mock.doMock(spec, factory)` registers a mock for an external module
+ *     specifier (bare package name or `node:*` built-in).
+ *   - Subsequent `await import(spec)` calls return the factory's result.
+ *   - Static imports are NOT supported in Tier A; see the docs / ISSUES.md
+ *     for the planned Tier B (hoisted `mock.module`) work.
+ *
+ * Architecture:
+ *   - bin/unrift.mjs registers `module-loader.js` via `module.register()` and
+ *     pipes a MessagePort into the loader thread.
+ *   - The main-side port is stashed on `globalThis.__unriftLoaderPort` before
+ *     the test runner starts.
+ *   - `doMock()` invokes the factory once, caches the result on
+ *     `globalThis.__unriftMocks`, and posts a `register` message with the
+ *     spec + export-key list to the loader.
+ *   - The loader (see module-loader.ts) drains pending messages on every
+ *     resolve() and short-circuits matched specs to a synthetic module that
+ *     reads back from `globalThis.__unriftMocks`.
+ *
+ * Future tiers will reuse the same registry shape and IPC protocol -
+ * adding `register-hoisted` (Tier B) and `register-relative` (Tier C)
+ * message types without breaking the existing surface.
+ */
+import { activeRestorers, spy } from "./spy.js";
+// The mock registry and loader port below live on globalThis, which is
+// process-global. This is correct under unrift's sequential single-process
+// execution; parallel per-file execution (see ISSUES.md) would need the
+// registry keyed/isolated per worker.
+/**
+ * Sentinel field name on globalThis. Loader-generated synthetic source
+ * reads back through this same name, so it must stay stable.
+ */
+export const MOCKS_GLOBAL_KEY = "__unriftMocks";
+/** Sentinel field name for the IPC port set by bin/unrift.mjs. */
+export const LOADER_PORT_GLOBAL_KEY = "__unriftLoaderPort";
+/** URL prefix the loader uses for mocked modules. Public so tests can assert. */
+export const MOCK_URL_PREFIX = "unrift-mock:";
+function globals() {
+    return globalThis;
+}
+function ensureMocksMap() {
+    const slots = globals();
+    let map = slots[MOCKS_GLOBAL_KEY];
+    if (!map) {
+        map = new Map();
+        slots[MOCKS_GLOBAL_KEY] = map;
+    }
+    return map;
+}
+function getLoaderPort() {
+    return globals()[LOADER_PORT_GLOBAL_KEY];
+}
+/**
+ * JS identifier check. ESM `export const <key>` requires a valid identifier;
+ * keys that fail this check are skipped with a console.warn so the user
+ * isn't surprised by a silently-missing export.
+ */
+const IDENT_RE = /^[A-Za-z_$][A-Za-z0-9_$]*$/;
+function partitionExportKeys(spec, result) {
+    const validKeys = [];
+    const skippedKeys = [];
+    for (const key of Object.keys(result)) {
+        if (key === "default" || IDENT_RE.test(key)) {
+            validKeys.push(key);
+        }
+        else {
+            skippedKeys.push(key);
+        }
+    }
+    if (skippedKeys.length > 0) {
+        console.warn(`[unrift] mock.doMock("${spec}"): factory returned ${skippedKeys.length} key(s) that are not valid ` +
+            `JS identifiers and will not be exported: ${skippedKeys.join(", ")}`);
+    }
+    return { validKeys, skippedKeys };
+}
+/**
+ * Track every spec that's currently mocked so `unmock()` can find them
+ * and `restoreAll()` can clean them all up at once.
+ */
+const mockedSpecs = new Set();
+/**
+ * Monotonically increasing counter - every `doMock()` call gets a unique
+ * ID embedded in its synthetic module URL, defeating Node's module cache
+ * across re-registrations.
+ */
+let nextRegistrationId = 0;
+/**
+ * Restore hook registered with the spy/stub bulk-restore registry so
+ * `mock.restoreAll()` cleans up module mocks too.
+ */
+const restoreAllMockedSpecs = () => {
+    for (const spec of [...mockedSpecs]) {
+        unmock(spec);
+    }
+    activeRestorers.delete(restoreAllMockedSpecs);
+};
+/**
+ * Register a mock for `spec`. Subsequent `await import(spec)` calls will
+ * resolve to the factory's return value instead of the real module.
+ *
+ * Tier A constraints (planned to be lifted in Tier B and beyond):
+ *   - Only **dynamic** imports (`await import(spec)`) hit the mock; static
+ *     `import { x } from "spec"` is hoisted by ESM above this call and
+ *     will see the real module.
+ *   - Only **external** specifiers work - bare package names (`"react"`)
+ *     and Node built-ins (`"node:fs"`). Relative specs (`"./bar"`) are
+ *     bundled inline by esbuild and can't be intercepted at runtime.
+ *   - The factory is invoked **once** at registration time. Its return
+ *     value is reused for every subsequent import.
+ *
+ * Throws if the Unrift CLI loader isn't attached (i.e., tests were run
+ * with raw `node` instead of `unrift`).
+ */
+export function doMock(spec, factory) {
+    if (typeof spec !== "string" || spec.length === 0) {
+        throw new TypeError("mock.doMock() requires a non-empty string specifier");
+    }
+    if (typeof factory !== "function") {
+        throw new TypeError("mock.doMock() requires a factory function returning an exports object");
+    }
+    const port = getLoaderPort();
+    if (!port) {
+        throw new Error("mock.doMock() requires the Unrift CLI loader to be installed. " +
+            "Run tests via the `unrift` binary (or `node bin/unrift.mjs`), not raw `node`.");
+    }
+    const result = factory();
+    if (result === null || typeof result !== "object") {
+        throw new TypeError(`mock.doMock("${spec}"): factory must return an object; got ${typeof result}`);
+    }
+    const { validKeys } = partitionExportKeys(spec, result);
+    ensureMocksMap().set(spec, result);
+    mockedSpecs.add(spec);
+    activeRestorers.add(restoreAllMockedSpecs);
+    port.postMessage({
+        type: "register",
+        spec,
+        registrationId: ++nextRegistrationId,
+        exportKeys: validKeys,
+    });
+}
+/**
+ * Remove a previously registered mock. Subsequent `await import(spec)`
+ * calls fall through to the real module.
+ */
+export function unmock(spec) {
+    const port = getLoaderPort();
+    if (port) {
+        port.postMessage({ type: "unregister", spec });
+    }
+    ensureMocksMap().delete(spec);
+    mockedSpecs.delete(spec);
+}
+/** Returns the current set of mocked specs. Useful for tests / debugging. */
+export function listMockedSpecs() {
+    return [...mockedSpecs];
+}
+/**
+ * Convenience helper: imports the real module, builds a version with every
+ * function export wrapped in a spy, registers it via `mock.doMock`, and
+ * returns the mocked exports.
+ *
+ * Non-function exports are passed through unchanged. Tests can customize
+ * individual spies with `.mockReturnValue`, `.mockImplementation`, etc.
+ *
+ * Subject to the same Tier A limits as `doMock` - only affects
+ * `await import(spec)` after the call. Static imports of `spec` see the
+ * real module.
+ *
+ * @example
+ *   const fs = await mock.fromModule("node:fs");
+ *   fs.readFileSync.mockReturnValue("fake content");
+ *   // ... test code that does `await import("node:fs")` now gets the spies
+ */
+export async function fromModule(spec) {
+    if (typeof spec !== "string" || spec.length === 0) {
+        throw new TypeError("mock.fromModule() requires a non-empty string specifier");
+    }
+    const real = (await import(spec));
+    const mocked = {};
+    for (const key of Object.keys(real)) {
+        const value = real[key];
+        if (typeof value === "function") {
+            // Auto-mock: create a spy with NO implementation, so unconfigured
+            // exports record calls and return undefined rather than executing the
+            // real function (which could fire real side effects). Tests opt in to
+            // behavior per export via .mockReturnValue / .mockImplementation.
+            mocked[key] = spy();
+        }
+        else {
+            mocked[key] = value;
+        }
+    }
+    doMock(spec, () => mocked);
+    return mocked;
+}

package/dist/esm/mock/register-loader.d.ts

@@ -0,0 +1,17 @@
+/**
+ * Registers the Node module-customization hook that powers module mocking
+ * (mock.doMock / mock.fs / mock.fromModule).
+ *
+ * This is called once, early in the CLI startup (see cli.ts) - before any
+ * test file is dynamically imported. Because it lives in @unrift/core next to
+ * the loader, both the `@unrift/core` bin and the `unrift` wrapper bin get it
+ * "for free" by going through the shared CLI; neither bin needs its own
+ * bootstrap logic.
+ *
+ * The loader runs in a worker thread and receives a MessagePort over which
+ * the main thread posts register/unregister messages. The main-side port is
+ * stashed on globalThis so mock.doMock() can reach it without a circular
+ * import back into the CLI.
+ */
+export declare function registerModuleLoader(): void;
+//# sourceMappingURL=register-loader.d.ts.map

package/dist/esm/mock/register-loader.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"register-loader.d.ts","sourceRoot":"","sources":["../../../src/mock/register-loader.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;GAcG;AASH,wBAAgB,oBAAoB,IAAI,IAAI,CAyB3C"}

package/dist/esm/mock/register-loader.js

@@ -0,0 +1,45 @@
+/**
+ * Registers the Node module-customization hook that powers module mocking
+ * (mock.doMock / mock.fs / mock.fromModule).
+ *
+ * This is called once, early in the CLI startup (see cli.ts) - before any
+ * test file is dynamically imported. Because it lives in @unrift/core next to
+ * the loader, both the `@unrift/core` bin and the `unrift` wrapper bin get it
+ * "for free" by going through the shared CLI; neither bin needs its own
+ * bootstrap logic.
+ *
+ * The loader runs in a worker thread and receives a MessagePort over which
+ * the main thread posts register/unregister messages. The main-side port is
+ * stashed on globalThis so mock.doMock() can reach it without a circular
+ * import back into the CLI.
+ */
+import { register } from "node:module";
+import { MessageChannel } from "node:worker_threads";
+import { LOADER_PORT_GLOBAL_KEY } from "./module.js";
+let done = false;
+export function registerModuleLoader() {
+    if (done)
+        return;
+    done = true;
+    // `module.register()` was added in 18.19.0 / 20.6.0. On older Node, module
+    // mocking simply isn't available - doMock() throws a clear error if used.
+    if (typeof register !== "function")
+        return;
+    try {
+        const { port1, port2 } = new MessageChannel();
+        globalThis[LOADER_PORT_GLOBAL_KEY] = port1;
+        // Resolve the loader relative to this module - it's a sibling file, so no
+        // package export or cross-package specifier is involved.
+        register("./module-loader.js", import.meta.url, {
+            data: { port: port2 },
+            transferList: [port2],
+        });
+    }
+    catch (err) {
+        // Best-effort: a failure here must not crash test runs that don't use
+        // module mocking.
+        if (process.env.UNRIFT_DEBUG === "1") {
+            console.warn("[unrift] module loader registration failed:", err);
+        }
+    }
+}

package/dist/esm/mock/spy.d.ts

@@ -0,0 +1,73 @@
+/**
+ * Spy / Mock function primitive.
+ *
+ * Both `spy()` and `mock.fn()` produce the same object - a callable that
+ * records every invocation, supports configurable implementations, and can
+ * be restored to the original (when created via `spyOn`).
+ */
+export declare const SPY_BRAND: unique symbol;
+export type AnyFn = (...args: any[]) => any;
+export interface MockResult {
+    type: "return" | "throw";
+    value: unknown;
+}
+export interface MockState {
+    calls: unknown[][];
+    results: MockResult[];
+    contexts: unknown[];
+    instances: unknown[];
+    lastCall: unknown[] | undefined;
+}
+export interface Spy<T extends AnyFn = AnyFn> {
+    (...args: Parameters<T>): ReturnType<T>;
+    mock: MockState;
+    mockName(name: string): Spy<T>;
+    getMockName(): string;
+    mockImplementation(impl: T): Spy<T>;
+    mockImplementationOnce(impl: T): Spy<T>;
+    mockReturnValue(value: ReturnType<T>): Spy<T>;
+    mockReturnValueOnce(value: ReturnType<T>): Spy<T>;
+    mockResolvedValue(value: Awaited<ReturnType<T>>): Spy<T>;
+    mockResolvedValueOnce(value: Awaited<ReturnType<T>>): Spy<T>;
+    mockRejectedValue(error: unknown): Spy<T>;
+    mockRejectedValueOnce(error: unknown): Spy<T>;
+    mockClear(): Spy<T>;
+    mockReset(): Spy<T>;
+    mockRestore(): void;
+    readonly [SPY_BRAND]: true;
+}
+/**
+ * Internal registries. Used by `mock.clearAll()`, `mock.resetAll()`,
+ * and `mock.restoreAll()` to operate on every spy created so far.
+ */
+export declare const activeSpies: Set<Spy<AnyFn>>;
+export declare const activeRestorers: Set<() => void>;
+/**
+ * Returns true if the value is a spy created by `spy()` or `spyOn()`.
+ * Used by mock matchers to validate their `received` argument.
+ */
+export declare function isSpy(value: unknown): value is Spy;
+/**
+ * Creates a standalone spy / mock function. Records every invocation and
+ * supports configurable behavior via `.mockReturnValue`, `.mockImplementation`, etc.
+ */
+export declare function spy<T extends AnyFn = AnyFn>(impl?: T): Spy<T>;
+/**
+ * Replaces `obj[key]` with a spy that wraps the original method. Calling
+ * `.mockRestore()` (or `mock.restoreAll()`) puts the original back.
+ *
+ * The original is the default implementation - calls pass through unless
+ * the user provides an override via `.mockReturnValue` / `.mockImplementation`.
+ *
+ * The 3-arg form `spyOn(obj, "prop", "get")` / `spyOn(obj, "prop", "set")`
+ * wraps the accessor instead of a method. Setter spies record the assigned
+ * value as the first call argument; getter spies record the returned value
+ * in `mock.results`.
+ */
+export declare function spyOn<T extends object, K extends keyof T & (string | symbol)>(obj: T, key: K): T[K] extends AnyFn ? Spy<T[K]> : never;
+export declare function spyOn<T extends object, K extends keyof T & (string | symbol)>(obj: T, key: K, accessor: "get"): Spy<() => T[K]>;
+export declare function spyOn<T extends object, K extends keyof T & (string | symbol)>(obj: T, key: K, accessor: "set"): Spy<(value: T[K]) => void>;
+export declare function clearAllMocks(): void;
+export declare function resetAllMocks(): void;
+export declare function restoreAllMocks(): void;
+//# sourceMappingURL=spy.d.ts.map

package/dist/esm/mock/spy.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"spy.d.ts","sourceRoot":"","sources":["../../../src/mock/spy.ts"],"names":[],"mappings":"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"}