import { F as Func } from './types-BM3BcWj1.js';
export { W as WebStorageKey, a as WebStorageStub, b as WebStorageStubOptions, s as stubWebStorage } from './web-storage-dwQ9E7Lm.js';
import 'vitest';

/**
 * A host-runner mock function: a callable spy (Vitest `vi.fn()`, Bun `mock()`,
 * `node:test` `mock.fn()`). The host's own richer surface (`.mock`,
 * `mockReturnValue`, …) lives on the concrete object; the core treats it as a
 * plain callable and reads/resets it only through the adapter.
 */
type MockFn = Func;

/** The readable state of one stubbed media element. */
interface MediaElementState {
    /** Seconds. Starts at the stub's `duration` option (`0` by default), not at the platform's `NaN`. */
    duration: number;
    currentTime: number;
    paused: boolean;
    ended: boolean;
    /** `HAVE_NOTHING` (0) … `HAVE_ENOUGH_DATA` (4), as the platform numbers them. */
    readyState: number;
    error: MediaError | null;
}
/** What {@link stubMediaElement} installs beyond the defaults. */
interface MediaElementStubOptions {
    /** Duration every element reports until a spec sets its own. Default `0`. */
    duration?: number;
    /** Answer for `canPlayType(type)`. Default `() => 'probably'`, the opposite of jsdom's blanket `''`. */
    canPlayType?: (type: string) => CanPlayTypeResult;
}
/** The handle a spec drives the stubbed elements through. */
interface MediaElementStub {
    /** The `play()` spy — shared by every media element, so `mock.instances[0]` identifies which one played. */
    readonly play: MockFn;
    /** The `pause()` spy. */
    readonly pause: MockFn;
    /** The `load()` spy. */
    readonly load: MockFn;
    /** The `canPlayType()` spy — reconfigure it per test to make one codec unsupported. */
    readonly canPlayType: MockFn;
    /** The current state of one element, as the code under test reads it. */
    state(element: HTMLMediaElement): MediaElementState;
    /**
     * Move an element to a new state and fire the events the browser fires with it.
     *
     * `duration` → `durationchange`, `currentTime` → `timeupdate`, `ended: true` → `ended`,
     * `error` → `error`, `readyState` ≥ 1 → `loadedmetadata`. Several fields in one call produce
     * several events, in that order.
     */
    set(element: HTMLMediaElement, state: Partial<MediaElementState>): void;
}
/**
 * Make every `<video>` and `<audio>` in the test answer like a real one.
 *
 * ```ts
 * const media = stubMediaElement({ duration: 120 });
 *
 * const fixture = TestBed.createComponent(PlayerComponent);
 * fixture.detectChanges();
 *
 * const video = fixture.nativeElement.querySelector('video');
 *
 * media.set(video, { readyState: 1 });          // fires `loadedmetadata`
 * media.set(video, { currentTime: 119 });       // fires `timeupdate`
 * media.set(video, { ended: true });            // fires `ended`
 *
 * expect(media.play).toHaveBeenCalledTimes(1);
 * expect(component.finished()).toBe(true);
 * ```
 *
 * The patch is on the prototype, so it also covers the element production code creates itself with
 * `document.createElement('video')` — which is the case a per-instance stub cannot reach.
 */
declare function stubMediaElement(options?: MediaElementStubOptions): MediaElementStub;

/**
 * Replace `AbortController` / `AbortSignal` with realm-consistent stand-ins.
 *
 * Belongs in the setup file next to the observer stubs, for the same reason they do: the code under
 * test constructs its own controller and a spec has no seam to reach it. Installation goes through
 * {@link mockValueProp}, so `restoreMockedProps()` puts the platform's own back.
 *
 * ```ts
 * beforeEach(() => {
 *   stubAbortController();
 * });
 * ```
 */
declare function stubAbortController(): void;

/** One observer the code under test constructed. */
interface ObserverInstance<TEntry, TTarget = unknown> {
    /**
     * The init object the code under test passed to the constructor — `{ rootMargin, threshold }`,
     * `{ childList, subtree }`, and so on.
     *
     * A component that builds one observer per configuration is asserting a contract ("one observer
     * per unique root margin"), and without this the only thing a spec can count is constructions.
     */
    readonly options: unknown;
    /**
     * The object the code under test holds: what `new IntersectionObserver(…)` returned, and what its
     * callback is handed as the second argument.
     *
     * Production code reaches for it — `(entries, observer) => { observer.disconnect(); }`,
     * `if (observer !== this.observer) return;` — so a spec that needs to compare against what the
     * component kept compares against this.
     */
    readonly host: object;
    /** Everything passed to `observe`, in order, including repeats. */
    readonly targets: TTarget[];
    /** The spy behind `observe` — for asserting *that* something was observed, and with what options. */
    readonly observe: MockFn;
    /** The spy behind `unobserve`. */
    readonly unobserve: MockFn;
    /** The spy behind `disconnect`, which is how a spec checks that teardown ran. */
    readonly disconnect: MockFn;
    /** Whether `disconnect()` has been called — the readable form of the assertion above. */
    readonly disconnected: boolean;
    /**
     * Invoke the observer's callback with `entries`, exactly as the browser would: one call, one
     * batch. A fast scroll or a resize storm delivers several entries at once, and code that assumes
     * one entry per call is a real bug this makes reachable.
     */
    emit(entries: TEntry[]): void;
}
/** The handle an installer returns: the observers built so far, and the newest one. */
interface ObserverStub<TEntry, TTarget = unknown> {
    /** Every observer constructed since the stub was installed, in construction order. */
    readonly instances: ObserverInstance<TEntry, TTarget>[];
    /**
     * The most recently constructed observer — the usual case, where a component builds exactly one.
     *
     * Throws when the code under test has not constructed any, because the alternative is an
     * assertion failing against `undefined` several lines later with nothing to say about the cause.
     */
    readonly last: ObserverInstance<TEntry, TTarget>;
}
/** Name of a global observer constructor this module can stand in for. */
type ObserverGlobal = 'IntersectionObserver' | 'MutationObserver' | 'ResizeObserver';
/** How an installed stub behaves beyond recording — see {@link stubObserver}. */
interface ObserverStubOptions<TEntry, TTarget> {
    /**
     * Deliver an entry synchronously from every `observe(target)` call, built by this function.
     *
     * The default (omitted) stub is inert, which is right when the spec wants to choose the moment.
     * It is wrong for a suite ported from Jest, where the hand-written global mock reported
     * everything as visible immediately: with an inert observer those specs quietly assert against a
     * component that never loaded its data, and the fix is one option here rather than a rewrite of
     * every spec.
     */
    autoEmit?: (target: TTarget) => TEntry;
}
/**
 * Replace a global observer constructor with one whose instances a spec controls.
 *
 * ```ts
 * const observers = stubObserver<IntersectionObserverEntry>('IntersectionObserver');
 *
 * fixture.detectChanges();                       // the directive constructs its observer
 * observers.last.emit([{ isIntersecting: true } as IntersectionObserverEntry]);
 * ```
 *
 * The replacement is registered with {@link restoreMockedProps}, so a suite running
 * {@link setupAutoSpy} gets the real constructor back after the test without doing anything else.
 *
 * @param name Which global to replace.
 * @returns A handle over the observers the code under test constructs from now on.
 */
declare function stubObserver<TEntry, TTarget = unknown>(name: ObserverGlobal, options?: ObserverStubOptions<TEntry, TTarget>): ObserverStub<TEntry, TTarget>;
/**
 * Stand in for `IntersectionObserver`, with the entry shape spelled out.
 *
 * ```ts
 * const observers = stubIntersectionObserver();
 *
 * const fixture = TestBed.createComponent(RevealDirectiveHost);
 * fixture.detectChanges();
 *
 * observers.last.emit([intersectionEntry(element, true)]);
 * await fixture.whenStable();
 *
 * expect(element.classList).toContain('is-visible');
 * ```
 */
declare function stubIntersectionObserver(options?: IntersectionObserverStubOptions): ObserverStub<IntersectionObserverEntry, Element>;
/** How {@link stubIntersectionObserver} behaves beyond recording. */
interface IntersectionObserverStubOptions {
    /**
     * Report every observed target as fully in view, synchronously, from `observe()`.
     *
     * The mode a suite carried over from Jest needs: there the global mock fired its callback with
     * `isIntersecting: true` right away, so lazily-loading sections and cards fetched their data
     * during `detectChanges()`. Against the default inert observer those specs assert on an empty
     * component and fail with something unrelated to intersection.
     */
    autoEmit?: boolean;
}
/** Stand in for `ResizeObserver`. See {@link stubObserver}. */
declare function stubResizeObserver(options?: ObserverStubOptions<ResizeObserverEntry, Element>): ObserverStub<ResizeObserverEntry, Element>;
/** Stand in for `MutationObserver`. See {@link stubObserver}. */
declare function stubMutationObserver(options?: ObserverStubOptions<MutationRecord, Node>): ObserverStub<MutationRecord, Node>;
/**
 * Build one `IntersectionObserverEntry` without spelling out the six fields nothing reads.
 *
 * `intersectionRatio` is derived rather than accepted, because the two disagreeing is not a state
 * the browser produces, and a spec that sets them apart is testing something that cannot happen.
 *
 * @param target The element the entry is about.
 * @param isIntersecting Whether it is in view.
 * @param overrides Any field a particular component does read — `boundingClientRect`, `time`, …
 */
declare function intersectionEntry(target: Element, isIntersecting: boolean, overrides?: Partial<IntersectionObserverEntry>): IntersectionObserverEntry;
/** The parts of a `MutationRecord` a spec actually chooses. */
interface MutationRecordInit {
    /** Defaults to `'childList'`, or to `'attributes'` when `attributeName` is given. */
    type?: MutationRecordType;
    addedNodes?: readonly Node[];
    removedNodes?: readonly Node[];
    attributeName?: string;
    oldValue?: string;
}
/**
 * Build one `MutationRecord` without hand-rolling a `NodeList`.
 *
 * The counterpart of {@link intersectionEntry}, and the reason it is needed is sharper: a
 * `MutationRecord` cannot be written as an object literal at all, because `addedNodes` and
 * `removedNodes` are `NodeList`s. Every spec that drives {@link stubMutationObserver} therefore
 * either writes a fragment-based helper of its own or reaches for a double type assertion.
 *
 * ```ts
 * const observers = stubMutationObserver();
 *
 * observers.last.emit([mutationRecord(host, { addedNodes: [span] })]);
 * ```
 *
 * @param target The node the mutation is about.
 * @param init Which nodes moved, and what kind of mutation it was.
 */
declare function mutationRecord(target: Node, init?: MutationRecordInit): MutationRecord;
/** The box a {@link resizeEntry} reports. Only the fields a component reads need supplying. */
interface ResizeEntryRect {
    width?: number;
    height?: number;
    x?: number;
    y?: number;
}
/**
 * Build one `ResizeObserverEntry` from the size a component reads.
 *
 * `contentRect` and the three box-size arrays are all derived from the same numbers, because a
 * browser never reports them disagreeing — a spec that sets them apart is testing a state that
 * cannot happen.
 */
declare function resizeEntry(target: Element, rect?: ResizeEntryRect): ResizeObserverEntry;

export { type IntersectionObserverStubOptions, type MediaElementState, type MediaElementStub, type MediaElementStubOptions, type MutationRecordInit, type ObserverGlobal, type ObserverInstance, type ObserverStub, type ObserverStubOptions, type ResizeEntryRect, intersectionEntry, mutationRecord, resizeEntry, stubAbortController, stubIntersectionObserver, stubMediaElement, stubMutationObserver, stubObserver, stubResizeObserver };