@ethlete/query 6.0.0-next.59 → 6.0.0-next.60

package/fesm2022/ethlete-query-testing.mjs

@@ -1,644 +1,557 @@
-import { DestroyRef, ErrorHandler, Injector } from '@angular/core';
-import { TestBed } from '@angular/core/testing';
-import { createBearerAuthProvider, withAuthenticationQuery, withRefreshQuery, isQueryErrorResponse, createQueryClient, createDeleteQuery, createPatchQuery, createPutQuery, createPostQuery, createGetQuery } from '@ethlete/query';
-import { HttpErrorResponse, provideHttpClient, HttpClient } from '@angular/common/http';
-import { provideHttpClientTesting, HttpTestingController } from '@angular/common/http/testing';
-import { provideRouter } from '@angular/router';
-
-/* eslint-disable @typescript-eslint/no-explicit-any */
+import { DestroyRef, ErrorHandler, Injector } from "@angular/core";
+import { TestBed } from "@angular/core/testing";
+import { createBearerAuthProvider, createDeleteQuery, createGetQuery, createPatchQuery, createPostQuery, createPutQuery, createQueryClient, isQueryErrorResponse, withAuthenticationQuery, withRefreshQuery } from "@ethlete/query";
+import { HttpClient, HttpErrorResponse, provideHttpClient } from "@angular/common/http";
+import { HttpTestingController, provideHttpClientTesting } from "@angular/common/http/testing";
+import { provideRouter } from "@angular/router";
 const expectAndFlush = (httpTesting, url, response, statusOpts) => {
-    const req = httpTesting.expectOne(url);
-    if (statusOpts) {
-        req.flush(response, statusOpts);
-    }
-    else {
-        req.flush(response);
-    }
+	const req = httpTesting.expectOne(url);
+	if (statusOpts) req.flush(response, statusOpts);
+	else req.flush(response);
 };
 const expectFlushAndWait = (httpTesting, url, response, statusOpts) => {
-    expectAndFlush(httpTesting, url, response, statusOpts);
-    TestBed.tick();
+	expectAndFlush(httpTesting, url, response, statusOpts);
+	TestBed.tick();
 };
-
 const setupAuthTest = (config) => {
-    const { querySetup, loginPath = '/auth/login', refreshPath = '/auth/refresh', autoRetryOn401 = true, extractLoginTokens = (response) => ({
-        accessToken: response.accessToken,
-        refreshToken: response.refreshToken,
-    }), extractRefreshTokens = (response) => ({
-        accessToken: response.accessToken,
-        refreshToken: response.refreshToken,
-    }), buildRefreshArgs, features, bearerDecryptFn, refreshStrategy, minRefreshInterval, refreshIfExpired, expiresInPropertyName, onRefreshFailure, } = config;
-    // eslint-disable-next-line @typescript-eslint/no-explicit-any
-    const login = querySetup.createPost(loginPath, {});
-    // eslint-disable-next-line @typescript-eslint/no-explicit-any
-    const refresh = querySetup.createPost(refreshPath, {});
-    const { inject: injectAuth } = createBearerAuthProvider({
-        name: 'test-auth',
-        queryClientRef: querySetup.queryClientRef,
-        queries: [
-            withAuthenticationQuery('login', {
-                queryCreator: login,
-                extractTokens: extractLoginTokens,
-            }),
-            withRefreshQuery('refresh', {
-                queryCreator: refresh,
-                extractTokens: extractRefreshTokens,
-                buildArgs: buildRefreshArgs,
-                autoRetryOn401,
-                refreshStrategy,
-                minRefreshInterval,
-                refreshIfExpired,
-                expiresInPropertyName,
-                onRefreshFailure,
-            }),
-        ],
-        features: (features ?? []),
-        bearerDecryptFn,
-    });
-    const auth = TestBed.runInInjectionContext(() => {
-        const provider = injectAuth();
-        if (!provider) {
-            throw new Error('Failed to create auth provider in test setup');
-        }
-        return provider;
-    });
-    const loginHelper = (credentials, response) => {
-        TestBed.runInInjectionContext(() => {
-            // eslint-disable-next-line @typescript-eslint/no-explicit-any
-            auth.queries.login.execute({ body: credentials });
-        });
-        const fullUrl = `${querySetup.baseUrl}${loginPath}`;
-        expectFlushAndWait(querySetup.httpTesting, fullUrl, response);
-    };
-    const refreshHelper = (token, response) => {
-        TestBed.runInInjectionContext(() => {
-            // eslint-disable-next-line @typescript-eslint/no-explicit-any
-            auth.queries.refresh.execute((buildRefreshArgs?.(token) ?? { body: { token } }));
-        });
-        const fullUrl = `${querySetup.baseUrl}${refreshPath}`;
-        expectFlushAndWait(querySetup.httpTesting, fullUrl, response);
-    };
-    const makeSecureRequest = (route) => {
-        TestBed.runInInjectionContext(() => {
-            querySetup.queryClient.repository.request({
-                // eslint-disable-next-line @typescript-eslint/no-explicit-any
-                route: route,
-                method: 'GET',
-                isSecure: true,
-                consumerDestroyRef: TestBed.inject(DestroyRef),
-            });
-        });
-    };
-    return {
-        auth: auth,
-        login: loginHelper,
-        refresh: refreshHelper,
-        makeSecureRequest,
-    };
+	const { querySetup, loginPath = "/auth/login", refreshPath = "/auth/refresh", autoRetryOn401 = true, extractLoginTokens = (response) => ({
+		accessToken: response.accessToken,
+		refreshToken: response.refreshToken
+	}), extractRefreshTokens = (response) => ({
+		accessToken: response.accessToken,
+		refreshToken: response.refreshToken
+	}), buildRefreshArgs, features, bearerDecryptFn, refreshStrategy, minRefreshInterval, refreshIfExpired, expiresInPropertyName, onRefreshFailure } = config;
+	const login = querySetup.createPost(loginPath, {});
+	const refresh = querySetup.createPost(refreshPath, {});
+	const { inject: injectAuth } = createBearerAuthProvider({
+		name: "test-auth",
+		queryClientRef: querySetup.queryClientRef,
+		queries: [withAuthenticationQuery("login", {
+			queryCreator: login,
+			extractTokens: extractLoginTokens
+		}), withRefreshQuery("refresh", {
+			queryCreator: refresh,
+			extractTokens: extractRefreshTokens,
+			buildArgs: buildRefreshArgs,
+			autoRetryOn401,
+			refreshStrategy,
+			minRefreshInterval,
+			refreshIfExpired,
+			expiresInPropertyName,
+			onRefreshFailure
+		})],
+		features: features ?? [],
+		bearerDecryptFn
+	});
+	const auth = TestBed.runInInjectionContext(() => {
+		const provider = injectAuth();
+		if (!provider) throw new Error("Failed to create auth provider in test setup");
+		return provider;
+	});
+	const loginHelper = (credentials, response) => {
+		TestBed.runInInjectionContext(() => {
+			auth.queries.login.execute({ body: credentials });
+		});
+		const fullUrl = `${querySetup.baseUrl}${loginPath}`;
+		expectFlushAndWait(querySetup.httpTesting, fullUrl, response);
+	};
+	const refreshHelper = (token, response) => {
+		TestBed.runInInjectionContext(() => {
+			auth.queries.refresh.execute(buildRefreshArgs?.(token) ?? { body: { token } });
+		});
+		const fullUrl = `${querySetup.baseUrl}${refreshPath}`;
+		expectFlushAndWait(querySetup.httpTesting, fullUrl, response);
+	};
+	const makeSecureRequest = (route) => {
+		TestBed.runInInjectionContext(() => {
+			querySetup.queryClient.repository.request({
+				route,
+				method: "GET",
+				isSecure: true,
+				consumerDestroyRef: TestBed.inject(DestroyRef)
+			});
+		});
+	};
+	return {
+		auth,
+		login: loginHelper,
+		refresh: refreshHelper,
+		makeSecureRequest
+	};
 };
-
-/* eslint-disable @typescript-eslint/no-explicit-any */
-// Captured at import, before a spec can call `vi.useFakeTimers()`: delivery must not wait on a faked clock.
 const nodeSetImmediate = globalThis.setImmediate;
-const scheduleTask = nodeSetImmediate
-    ? nodeSetImmediate.bind(globalThis)
-    : setTimeout.bind(globalThis);
-/**
- * Replaces `globalThis.BroadcastChannel` with an in-memory bus.
- *
- * Messages are structured-cloned at post time (so a non-cloneable payload throws exactly like the
- * real API does), delivered as a task (never synchronously, and after every pending microtask), and
- * never delivered back to the channel that posted them - all three matching browser behavior. Delivery
- * does not depend on fake timers; `await flushMultiTabSync()` in a spec flushes it.
- */
+const scheduleTask = nodeSetImmediate ? nodeSetImmediate.bind(globalThis) : setTimeout.bind(globalThis);
 const installFakeBroadcastChannel = () => {
-    const original = globalThis.BroadcastChannel;
-    const instances = new Set();
-    const posted = [];
-    class FakeBroadcastChannel {
-        constructor(name) {
-            this.name = name;
-            this.closed = false;
-            this.onmessage = null;
-            instances.add(this);
-        }
-        postMessage(data) {
-            if (this.closed)
-                throw new DOMException('Channel is closed', 'InvalidStateError');
-            const clone = structuredClone(data);
-            posted.push({ channel: this.name, data: clone });
-            for (const instance of instances) {
-                if (instance === this || instance.closed || instance.name !== this.name)
-                    continue;
-                scheduleTask(() => {
-                    if (instance.closed)
-                        return;
-                    instance.onmessage?.({ data: structuredClone(clone) });
-                });
-            }
-        }
-        close() {
-            this.closed = true;
-            instances.delete(this);
-        }
-        addEventListener() {
-            throw new Error('The fake BroadcastChannel only supports `onmessage`.');
-        }
-    }
-    globalThis.BroadcastChannel = FakeBroadcastChannel;
-    return {
-        posted,
-        restore: () => {
-            for (const instance of [...instances]) {
-                instance.closed = true;
-            }
-            instances.clear();
-            globalThis.BroadcastChannel = original;
-        },
-    };
+	const original = globalThis.BroadcastChannel;
+	const instances = /* @__PURE__ */ new Set();
+	const posted = [];
+	class FakeBroadcastChannel {
+		constructor(name) {
+			this.name = name;
+			this.closed = false;
+			this.onmessage = null;
+			instances.add(this);
+		}
+		postMessage(data) {
+			if (this.closed) throw new DOMException("Channel is closed", "InvalidStateError");
+			const clone = structuredClone(data);
+			posted.push({
+				channel: this.name,
+				data: clone
+			});
+			for (const instance of instances) {
+				if (instance === this || instance.closed || instance.name !== this.name) continue;
+				scheduleTask(() => {
+					if (instance.closed) return;
+					instance.onmessage?.({ data: structuredClone(clone) });
+				});
+			}
+		}
+		close() {
+			this.closed = true;
+			instances.delete(this);
+		}
+		addEventListener() {
+			throw new Error("The fake BroadcastChannel only supports `onmessage`.");
+		}
+	}
+	globalThis.BroadcastChannel = FakeBroadcastChannel;
+	return {
+		posted,
+		restore: () => {
+			for (const instance of [...instances]) instance.closed = true;
+			instances.clear();
+			globalThis.BroadcastChannel = original;
+		}
+	};
 };
-/**
- * Installs an in-memory `navigator.locks` implementing exclusive locks: one holder per name, the
- * rest queued FIFO, granted on a microtask (never synchronously), released when the callback's
- * promise settles. `signal` is honored for queued requests and - as in the real API - ignored once a
- * request has been granted.
- *
- * `ifAvailable` is a try-lock: a request that cannot be granted straight away runs its callback with
- * `null` instead of queueing, exactly as the real API does. `steal` releases the current holder -
- * rejecting its request with an `AbortError` - and is granted ahead of everything queued.
- *
- * `mode: 'shared'` is not implemented; nothing in the library uses it.
- */
 const installFakeWebLocks = () => {
-    const originalDescriptor = Object.getOwnPropertyDescriptor(navigator, 'locks');
-    const holders = new Map();
-    const queues = new Map();
-    const abortError = () => new DOMException('The lock request was aborted', 'AbortError');
-    const pump = (name) => {
-        if (holders.has(name))
-            return;
-        const waiter = queues.get(name)?.shift();
-        if (!waiter)
-            return;
-        waiter.granted = true;
-        holders.set(name, waiter);
-        const settle = (settleWaiter) => {
-            // Only if this waiter is still the holder: a stolen lock already has a new one, and the callback
-            // of the tab it was taken from settles afterwards.
-            if (holders.get(name) === waiter)
-                holders.delete(name);
-            waiter.releaseSignal();
-            settleWaiter();
-            pump(name);
-        };
-        // `pump` itself only ever runs from a microtask, so calling the callback right here keeps the
-        // grant exactly one microtask away from the `request()` call - which is what makes a single
-        // `flushMultiTabSync()` per hop enough in specs.
-        try {
-            Promise.resolve(waiter.callback({ name, mode: 'exclusive' })).then((value) => settle(() => waiter.resolve(value)), (error) => settle(() => waiter.reject(error)));
-        }
-        catch (error) {
-            settle(() => waiter.reject(error));
-        }
-    };
-    const request = (name, optionsOrCallback, maybeCallback) => {
-        const options = (typeof optionsOrCallback === 'function' ? {} : (optionsOrCallback ?? {}));
-        const callback = (typeof optionsOrCallback === 'function' ? optionsOrCallback : maybeCallback);
-        return new Promise((resolve, reject) => {
-            if (options.signal?.aborted) {
-                reject(abortError());
-                return;
-            }
-            const waiter = { callback, resolve, reject, granted: false, releaseSignal: () => undefined };
-            const signal = options.signal;
-            if (signal) {
-                const onAbort = () => {
-                    waiter.releaseSignal();
-                    if (waiter.granted)
-                        return;
-                    const queue = queues.get(name);
-                    if (queue)
-                        queues.set(name, queue.filter((entry) => entry !== waiter));
-                    reject(abortError());
-                };
-                signal.addEventListener('abort', onAbort);
-                waiter.releaseSignal = () => {
-                    waiter.releaseSignal = () => undefined;
-                    signal.removeEventListener('abort', onAbort);
-                };
-            }
-            if (options.steal) {
-                queueMicrotask(() => {
-                    const holder = holders.get(name);
-                    if (holder) {
-                        holders.delete(name);
-                        holder.reject(abortError());
-                    }
-                    queues.set(name, [waiter, ...(queues.get(name) ?? [])]);
-                    pump(name);
-                });
-                return;
-            }
-            // Availability is decided a microtask out, not here: that is when the real API decides it too, so
-            // two try-locks requested in the same tick still resolve to one winner and one `null`.
-            if (options.ifAvailable) {
-                queueMicrotask(() => {
-                    if (holders.has(name) || (queues.get(name)?.length ?? 0) > 0) {
-                        waiter.releaseSignal();
-                        Promise.resolve(callback(null)).then(resolve, reject);
-                        return;
-                    }
-                    queues.set(name, [waiter]);
-                    pump(name);
-                });
-                return;
-            }
-            queues.set(name, [...(queues.get(name) ?? []), waiter]);
-            queueMicrotask(() => pump(name));
-        });
-    };
-    // Both lists are reported, because a queued request is how a tab that is *not* the holder still
-    // shows up - which is what the auth leader election counts its tabs by.
-    const query = () => Promise.resolve({
-        held: [...holders.keys()].map((name) => ({ name, mode: 'exclusive' })),
-        pending: [...queues.entries()].flatMap(([name, waiters]) => waiters.map(() => ({ name, mode: 'exclusive' }))),
-    });
-    Object.defineProperty(navigator, 'locks', {
-        value: {
-            request,
-            query,
-        },
-        configurable: true,
-        writable: true,
-    });
-    return {
-        heldNames: () => [...holders.keys()],
-        pendingNames: () => [...queues.entries()].filter(([, queue]) => queue.length > 0).map(([name]) => name),
-        restore: () => {
-            for (const waiter of [...holders.values(), ...[...queues.values()].flat()])
-                waiter.releaseSignal();
-            holders.clear();
-            queues.clear();
-            if (originalDescriptor) {
-                Object.defineProperty(navigator, 'locks', originalDescriptor);
-            }
-            else {
-                delete navigator.locks;
-            }
-        },
-    };
+	const originalDescriptor = Object.getOwnPropertyDescriptor(navigator, "locks");
+	const holders = /* @__PURE__ */ new Map();
+	const queues = /* @__PURE__ */ new Map();
+	const abortError = () => new DOMException("The lock request was aborted", "AbortError");
+	const pump = (name) => {
+		if (holders.has(name)) return;
+		const waiter = queues.get(name)?.shift();
+		if (!waiter) return;
+		waiter.granted = true;
+		holders.set(name, waiter);
+		const settle = (settleWaiter) => {
+			if (holders.get(name) === waiter) holders.delete(name);
+			waiter.releaseSignal();
+			settleWaiter();
+			pump(name);
+		};
+		try {
+			Promise.resolve(waiter.callback({
+				name,
+				mode: "exclusive"
+			})).then((value) => settle(() => waiter.resolve(value)), (error) => settle(() => waiter.reject(error)));
+		} catch (error) {
+			settle(() => waiter.reject(error));
+		}
+	};
+	const request = (name, optionsOrCallback, maybeCallback) => {
+		const options = typeof optionsOrCallback === "function" ? {} : optionsOrCallback ?? {};
+		const callback = typeof optionsOrCallback === "function" ? optionsOrCallback : maybeCallback;
+		return new Promise((resolve, reject) => {
+			if (options.signal?.aborted) {
+				reject(abortError());
+				return;
+			}
+			const waiter = {
+				callback,
+				resolve,
+				reject,
+				granted: false,
+				releaseSignal: () => void 0
+			};
+			const signal = options.signal;
+			if (signal) {
+				const onAbort = () => {
+					waiter.releaseSignal();
+					if (waiter.granted) return;
+					const queue = queues.get(name);
+					if (queue) queues.set(name, queue.filter((entry) => entry !== waiter));
+					reject(abortError());
+				};
+				signal.addEventListener("abort", onAbort);
+				waiter.releaseSignal = () => {
+					waiter.releaseSignal = () => void 0;
+					signal.removeEventListener("abort", onAbort);
+				};
+			}
+			if (options.steal) {
+				queueMicrotask(() => {
+					const holder = holders.get(name);
+					if (holder) {
+						holders.delete(name);
+						holder.reject(abortError());
+					}
+					queues.set(name, [waiter, ...queues.get(name) ?? []]);
+					pump(name);
+				});
+				return;
+			}
+			if (options.ifAvailable) {
+				queueMicrotask(() => {
+					if (holders.has(name) || (queues.get(name)?.length ?? 0) > 0) {
+						waiter.releaseSignal();
+						Promise.resolve(callback(null)).then(resolve, reject);
+						return;
+					}
+					queues.set(name, [waiter]);
+					pump(name);
+				});
+				return;
+			}
+			queues.set(name, [...queues.get(name) ?? [], waiter]);
+			queueMicrotask(() => pump(name));
+		});
+	};
+	const query = () => Promise.resolve({
+		held: [...holders.keys()].map((name) => ({
+			name,
+			mode: "exclusive"
+		})),
+		pending: [...queues.entries()].flatMap(([name, waiters]) => waiters.map(() => ({
+			name,
+			mode: "exclusive"
+		})))
+	});
+	Object.defineProperty(navigator, "locks", {
+		value: {
+			request,
+			query
+		},
+		configurable: true,
+		writable: true
+	});
+	return {
+		heldNames: () => [...holders.keys()],
+		pendingNames: () => [...queues.entries()].filter(([, queue]) => queue.length > 0).map(([name]) => name),
+		restore: () => {
+			for (const waiter of [...holders.values(), ...[...queues.values()].flat()]) waiter.releaseSignal();
+			holders.clear();
+			queues.clear();
+			if (originalDescriptor) Object.defineProperty(navigator, "locks", originalDescriptor);
+			else delete navigator.locks;
+		}
+	};
 };
-/**
- * Waits for the fakes' pending work - message delivery (a task) and lock grants (a microtask) - even
- * under fake timers. Awaiting it once is enough for a single hop; a grant that has to wait for another
- * tab's release, or a reply to a delivered message, needs one await per hop.
- */
 const flushMultiTabSync = () => new Promise((resolve) => scheduleTask(resolve));
-
-const quotaError = () => new DOMException('The quota has been exceeded.', 'QuotaExceededError');
+const quotaError = () => new DOMException("The quota has been exceeded.", "QuotaExceededError");
 const createFakeQueryPersistenceStore = () => {
-    const store = new Map();
-    const calls = { loadIndex: 0, read: 0, write: 0, remove: 0, clear: 0 };
-    const deferredReads = [];
-    const deferredLoadIndexes = [];
-    let failingWrites = 0;
-    let writeError = null;
-    let failingRemoves = 0;
-    let removeError = null;
-    let loadIndexError = null;
-    let isDeferringReads = false;
-    let isDeferringLoadIndex = false;
-    // Cloning on the way in and on the way out is not pedantry: a real store hands back a copy, so a
-    // spec (or the engine) mutating a hydrated body must not be able to change what is "on disk".
-    const clone = (value) => structuredClone(value);
-    const loadIndex = async () => {
-        calls.loadIndex++;
-        if (loadIndexError !== null) {
-            const error = loadIndexError;
-            loadIndexError = null;
-            throw error;
-        }
-        // Taken before the gate, not after: a real store answers with what it held when the read started,
-        // so anything that empties it while a deferred load is held must not change what that load returns.
-        const snapshot = Array.from(store.values()).map(({ body: _body, ...meta }) => clone(meta));
-        if (isDeferringLoadIndex) {
-            await new Promise((resolve) => deferredLoadIndexes.push(resolve));
-        }
-        return snapshot;
-    };
-    const read = async (key) => {
-        calls.read++;
-        const entry = store.get(key);
-        const snapshot = entry ? { body: clone(entry.body), version: entry.version } : null;
-        if (isDeferringReads) {
-            await new Promise((resolve) => deferredReads.push(resolve));
-        }
-        return snapshot;
-    };
-    const write = async (entries) => {
-        calls.write++;
-        if (failingWrites > 0) {
-            failingWrites--;
-            throw writeError ?? quotaError();
-        }
-        for (const entry of entries) {
-            store.set(entry.key, clone(entry));
-        }
-    };
-    const remove = async (keys) => {
-        calls.remove++;
-        if (failingRemoves > 0) {
-            failingRemoves--;
-            throw removeError ?? new Error('The removal failed.');
-        }
-        for (const key of keys) {
-            store.delete(key);
-        }
-    };
-    const clear = async () => {
-        calls.clear++;
-        store.clear();
-    };
-    return {
-        adapter: { loadIndex, read, write, remove, clear, isSupported: true },
-        seed: (entries) => {
-            for (const entry of entries) {
-                store.set(entry.key, clone(entry));
-            }
-        },
-        entries: () => Array.from(store.values()).map(clone),
-        entry: (key) => {
-            const entry = store.get(key);
-            return entry ? clone(entry) : undefined;
-        },
-        calls: () => ({ ...calls }),
-        failNextWrites: (count, error) => {
-            failingWrites = count;
-            writeError = error ?? null;
-        },
-        failNextRemoves: (count, error) => {
-            failingRemoves = count;
-            removeError = error ?? null;
-        },
-        failNextLoadIndex: (error) => {
-            loadIndexError = error ?? quotaError();
-        },
-        deferReads: () => {
-            isDeferringReads = true;
-        },
-        flushReads: async () => {
-            isDeferringReads = false;
-            const pending = deferredReads.splice(0, deferredReads.length);
-            for (const resolve of pending) {
-                resolve();
-            }
-            await Promise.resolve();
-        },
-        deferLoadIndex: () => {
-            isDeferringLoadIndex = true;
-        },
-        flushLoadIndex: async () => {
-            isDeferringLoadIndex = false;
-            const pending = deferredLoadIndexes.splice(0, deferredLoadIndexes.length);
-            for (const resolve of pending) {
-                resolve();
-            }
-            await Promise.resolve();
-        },
-    };
+	const store = /* @__PURE__ */ new Map();
+	const calls = {
+		loadIndex: 0,
+		read: 0,
+		write: 0,
+		remove: 0,
+		clear: 0
+	};
+	const deferredReads = [];
+	const deferredLoadIndexes = [];
+	let failingWrites = 0;
+	let writeError = null;
+	let failingRemoves = 0;
+	let removeError = null;
+	let loadIndexError = null;
+	let isDeferringReads = false;
+	let isDeferringLoadIndex = false;
+	const clone = (value) => structuredClone(value);
+	const loadIndex = async () => {
+		calls.loadIndex++;
+		if (loadIndexError !== null) {
+			const error = loadIndexError;
+			loadIndexError = null;
+			throw error;
+		}
+		const snapshot = Array.from(store.values()).map(({ body: _body, ...meta }) => clone(meta));
+		if (isDeferringLoadIndex) await new Promise((resolve) => deferredLoadIndexes.push(resolve));
+		return snapshot;
+	};
+	const read = async (key) => {
+		calls.read++;
+		const entry = store.get(key);
+		const snapshot = entry ? {
+			body: clone(entry.body),
+			version: entry.version
+		} : null;
+		if (isDeferringReads) await new Promise((resolve) => deferredReads.push(resolve));
+		return snapshot;
+	};
+	const write = async (entries) => {
+		calls.write++;
+		if (failingWrites > 0) {
+			failingWrites--;
+			throw writeError ?? quotaError();
+		}
+		for (const entry of entries) store.set(entry.key, clone(entry));
+	};
+	const remove = async (keys) => {
+		calls.remove++;
+		if (failingRemoves > 0) {
+			failingRemoves--;
+			throw removeError ?? /* @__PURE__ */ new Error("The removal failed.");
+		}
+		for (const key of keys) store.delete(key);
+	};
+	const clear = async () => {
+		calls.clear++;
+		store.clear();
+	};
+	return {
+		adapter: {
+			loadIndex,
+			read,
+			write,
+			remove,
+			clear,
+			isSupported: true
+		},
+		seed: (entries) => {
+			for (const entry of entries) store.set(entry.key, clone(entry));
+		},
+		entries: () => Array.from(store.values()).map(clone),
+		entry: (key) => {
+			const entry = store.get(key);
+			return entry ? clone(entry) : void 0;
+		},
+		calls: () => ({ ...calls }),
+		failNextWrites: (count, error) => {
+			failingWrites = count;
+			writeError = error ?? null;
+		},
+		failNextRemoves: (count, error) => {
+			failingRemoves = count;
+			removeError = error ?? null;
+		},
+		failNextLoadIndex: (error) => {
+			loadIndexError = error ?? quotaError();
+		},
+		deferReads: () => {
+			isDeferringReads = true;
+		},
+		flushReads: async () => {
+			isDeferringReads = false;
+			const pending = deferredReads.splice(0, deferredReads.length);
+			for (const resolve of pending) resolve();
+			await Promise.resolve();
+		},
+		deferLoadIndex: () => {
+			isDeferringLoadIndex = true;
+		},
+		flushLoadIndex: async () => {
+			isDeferringLoadIndex = false;
+			const pending = deferredLoadIndexes.splice(0, deferredLoadIndexes.length);
+			for (const resolve of pending) resolve();
+			await Promise.resolve();
+		}
+	};
 };
-
 let originalError = null;
 const filteredError = (...args) => {
-    const message = args[0];
-    if (message && typeof message === 'object' && 'name' in message && message.name === 'HttpErrorResponse') {
-        return;
-    }
-    if (typeof message === 'string' && message.includes('Failed to decrypt bearer token')) {
-        return;
-    }
-    if (typeof message === 'string' && message.includes('Failed to extract tokens from')) {
-        return;
-    }
-    originalError?.(...args);
+	const message = args[0];
+	if (message && typeof message === "object" && "name" in message && message.name === "HttpErrorResponse") return;
+	if (typeof message === "string" && message.includes("Failed to decrypt bearer token")) return;
+	if (typeof message === "string" && message.includes("Failed to extract tokens from")) return;
+	originalError?.(...args);
 };
-// Capture only what is not already the wrapper, so repeated calls reinstall the one filter instead
-// of nesting a new closure over the previous one and stranding the pristine handlers.
 const installConsoleFilters = () => {
-    if (console.error !== filteredError)
-        originalError = console.error;
-    console.error = filteredError;
+	if (console.error !== filteredError) originalError = console.error;
+	console.error = filteredError;
 };
 const restoreConsole = () => {
-    if (originalError && console.error === filteredError)
-        console.error = originalError;
-    originalError = null;
+	if (originalError && console.error === filteredError) console.error = originalError;
+	originalError = null;
 };
 const isFailedRequestError = (error) => error instanceof HttpErrorResponse || isQueryErrorResponse(error);
-const requestErrorHandler = {
-    handleError: (error) => {
-        if (isFailedRequestError(error))
-            return;
-        throw error;
-    },
-};
+const requestErrorHandler = { handleError: (error) => {
+	if (isFailedRequestError(error)) return;
+	throw error;
+} };
 const setupQueryTest = (config) => {
-    const baseUrl = config?.baseUrl ?? 'https://api.test.com';
-    const name = config?.name ?? 'test';
-    const mockErrorHandler = config?.mockErrorHandler ?? true;
-    installConsoleFilters();
-    const providers = [
-        provideHttpClient(),
-        provideHttpClientTesting(),
-        provideRouter([]),
-    ];
-    if (mockErrorHandler) {
-        providers.push({
-            provide: ErrorHandler,
-            useValue: mockErrorHandler === 'all' ? { handleError: () => undefined } : requestErrorHandler,
-        });
-    }
-    TestBed.configureTestingModule({ providers });
-    const queryClientRef = createQueryClient({ baseUrl, name });
-    return TestBed.runInInjectionContext(() => {
-        const { inject } = queryClientRef;
-        const queryClient = inject();
-        TestBed.inject(DestroyRef).onDestroy(restoreConsole);
-        if (!queryClient) {
-            throw new Error('Failed to create query client in test setup');
-        }
-        return {
-            queryClient,
-            queryClientRef,
-            httpClient: TestBed.inject(HttpClient),
-            httpTesting: TestBed.inject(HttpTestingController),
-            injector: TestBed.inject(Injector),
-            baseUrl,
-            createGet: createGetQuery(queryClientRef),
-            createPost: createPostQuery(queryClientRef),
-            createPut: createPutQuery(queryClientRef),
-            createPatch: createPatchQuery(queryClientRef),
-            createDelete: createDeleteQuery(queryClientRef),
-            restoreConsole,
-        };
-    });
+	const baseUrl = config?.baseUrl ?? "https://api.test.com";
+	const name = config?.name ?? "test";
+	const mockErrorHandler = config?.mockErrorHandler ?? true;
+	installConsoleFilters();
+	const providers = [
+		provideHttpClient(),
+		provideHttpClientTesting(),
+		provideRouter([])
+	];
+	if (mockErrorHandler) providers.push({
+		provide: ErrorHandler,
+		useValue: mockErrorHandler === "all" ? { handleError: () => void 0 } : requestErrorHandler
+	});
+	TestBed.configureTestingModule({ providers });
+	const queryClientRef = createQueryClient({
+		baseUrl,
+		name
+	});
+	return TestBed.runInInjectionContext(() => {
+		const { inject } = queryClientRef;
+		const queryClient = inject();
+		TestBed.inject(DestroyRef).onDestroy(restoreConsole);
+		if (!queryClient) throw new Error("Failed to create query client in test setup");
+		return {
+			queryClient,
+			queryClientRef,
+			httpClient: TestBed.inject(HttpClient),
+			httpTesting: TestBed.inject(HttpTestingController),
+			injector: TestBed.inject(Injector),
+			baseUrl,
+			createGet: createGetQuery(queryClientRef),
+			createPost: createPostQuery(queryClientRef),
+			createPut: createPutQuery(queryClientRef),
+			createPatch: createPatchQuery(queryClientRef),
+			createDelete: createDeleteQuery(queryClientRef),
+			restoreConsole
+		};
+	});
 };
-
-/**
- * A socket io test double, for specs around `createWebSocketClient` - which takes its `io` factory as
- * an option precisely so a spec (or an app that never opens a socket) needs no `socket.io-client`.
- *
- * Nothing here connects on its own: the client's own `connect()` only flips
- * {@link WebSocketTestDouble.state}, and it is {@link WebSocketTestDouble.serverConnect} that fires
- * the `connect` listener. That split is what makes "joined a room while disconnected, and it was
- * re-joined after a reconnect" testable.
- */
 const createWebSocketTestDouble = () => {
-    const sent = [];
-    const delivered = [];
-    const buffered = [];
-    const listeners = {
-        connect: [],
-        disconnect: [],
-        connect_error: [],
-    };
-    const anyListeners = [];
-    const outgoingListeners = [];
-    let connection = null;
-    let withCredentials = null;
-    let auth;
-    const handshakes = [];
-    let connectRequested = false;
-    let disconnected = false;
-    let connected = false;
-    let active = false;
-    let connectCalls = 0;
-    let pingExpired = false;
-    let recovered = false;
-    const deliver = (message) => {
-        for (const listener of outgoingListeners)
-            listener(message.event, message.data);
-        delivered.push(message);
-    };
-    const recordHandshake = () => {
-        if (auth)
-            auth((data) => handshakes.push(data));
-        else
-            handshakes.push(null);
-    };
-    const disconnect = (reason) => {
-        connected = false;
-        pingExpired = false;
-        for (const listener of listeners.disconnect)
-            listener(reason);
-    };
-    const socket = {
-        connect: () => {
-            connectRequested = true;
-            active = true;
-            connectCalls++;
-        },
-        disconnect: () => {
-            disconnected = true;
-            active = false;
-            if (connected)
-                disconnect('io client disconnect');
-        },
-        emit: (event, data) => {
-            sent.push({ event, data });
-            if (connected && !pingExpired)
-                deliver({ event, data });
-            else
-                buffered.push({ event, data });
-        },
-        on: (event, listener) => void listeners[event].push(listener),
-        onAny: (listener) => void anyListeners.push(listener),
-        onAnyOutgoing: (listener) => void outgoingListeners.push(listener),
-        get recovered() {
-            return recovered;
-        },
-        get active() {
-            return active;
-        },
-        get sendBuffer() {
-            return buffered;
-        },
-    };
-    return {
-        io: (url, options) => {
-            connection = { url, transports: options.transports };
-            withCredentials = options.withCredentials;
-            auth = options.auth;
-            return socket;
-        },
-        connection: () => connection,
-        withCredentials: () => withCredentials,
-        handshakes: () => [...handshakes],
-        sent: () => [...sent],
-        delivered: () => [...delivered],
-        state: () => ({ connectRequested, disconnected, active, connectCalls }),
-        serverConnect: (options) => {
-            recordHandshake();
-            active = true;
-            recovered = options?.recovered ?? false;
-            connected = true;
-            pingExpired = false;
-            for (const message of buffered.splice(0))
-                deliver(message);
-            for (const listener of listeners.connect)
-                listener();
-        },
-        serverDisconnect: (options) => {
-            const reason = options?.reason ?? 'transport close';
-            if (reason === 'io server disconnect')
-                active = false;
-            disconnect(reason);
-        },
-        serverRejectHandshake: (message) => {
-            recordHandshake();
-            active = false;
-            for (const listener of listeners.connect_error)
-                listener(new Error(message ?? 'unauthorized'));
-        },
-        serverPingExpire: () => void (pingExpired = true),
-        serverSend: (message) => {
-            const frame = JSON.stringify(message);
-            for (const listener of anyListeners)
-                listener('message', frame);
-        },
-        serverSendRaw: (frame) => {
-            for (const listener of anyListeners)
-                listener('message', frame);
-        },
-    };
+	const sent = [];
+	const delivered = [];
+	const buffered = [];
+	const listeners = {
+		connect: [],
+		disconnect: [],
+		connect_error: []
+	};
+	const anyListeners = [];
+	const outgoingListeners = [];
+	let connection = null;
+	let withCredentials = null;
+	let auth;
+	const handshakes = [];
+	let connectRequested = false;
+	let disconnected = false;
+	let connected = false;
+	let active = false;
+	let connectCalls = 0;
+	let pingExpired = false;
+	let recovered = false;
+	const deliver = (message) => {
+		for (const listener of outgoingListeners) listener(message.event, message.data);
+		delivered.push(message);
+	};
+	const recordHandshake = () => {
+		if (auth) auth((data) => handshakes.push(data));
+		else handshakes.push(null);
+	};
+	const disconnect = (reason) => {
+		connected = false;
+		pingExpired = false;
+		for (const listener of listeners.disconnect) listener(reason);
+	};
+	const socket = {
+		connect: () => {
+			connectRequested = true;
+			active = true;
+			connectCalls++;
+		},
+		disconnect: () => {
+			disconnected = true;
+			active = false;
+			if (connected) disconnect("io client disconnect");
+		},
+		emit: (event, data) => {
+			sent.push({
+				event,
+				data
+			});
+			if (connected && !pingExpired) deliver({
+				event,
+				data
+			});
+			else buffered.push({
+				event,
+				data
+			});
+		},
+		on: (event, listener) => void listeners[event].push(listener),
+		onAny: (listener) => void anyListeners.push(listener),
+		onAnyOutgoing: (listener) => void outgoingListeners.push(listener),
+		get recovered() {
+			return recovered;
+		},
+		get active() {
+			return active;
+		},
+		get sendBuffer() {
+			return buffered;
+		}
+	};
+	return {
+		io: (url, options) => {
+			connection = {
+				url,
+				transports: options.transports
+			};
+			withCredentials = options.withCredentials;
+			auth = options.auth;
+			return socket;
+		},
+		connection: () => connection,
+		withCredentials: () => withCredentials,
+		handshakes: () => [...handshakes],
+		sent: () => [...sent],
+		delivered: () => [...delivered],
+		state: () => ({
+			connectRequested,
+			disconnected,
+			active,
+			connectCalls
+		}),
+		serverConnect: (options) => {
+			recordHandshake();
+			active = true;
+			recovered = options?.recovered ?? false;
+			connected = true;
+			pingExpired = false;
+			for (const message of buffered.splice(0)) deliver(message);
+			for (const listener of listeners.connect) listener();
+		},
+		serverDisconnect: (options) => {
+			const reason = options?.reason ?? "transport close";
+			if (reason === "io server disconnect") active = false;
+			disconnect(reason);
+		},
+		serverRejectHandshake: (message) => {
+			recordHandshake();
+			active = false;
+			for (const listener of listeners.connect_error) listener(new Error(message ?? "unauthorized"));
+		},
+		serverPingExpire: () => void (pingExpired = true),
+		serverSend: (message) => {
+			const frame = JSON.stringify(message);
+			for (const listener of anyListeners) listener("message", frame);
+		},
+		serverSendRaw: (frame) => {
+			for (const listener of anyListeners) listener("message", frame);
+		}
+	};
 };
-
 const toBase64Url = (json) => {
-    const encoded = btoa(encodeURIComponent(json).replace(/%([0-9A-F]{2})/g, (_, hex) => String.fromCharCode(parseInt(hex, 16))));
-    return encoded.replace(/\+/g, '-').replace(/\//g, '_').replace(/=+$/, '');
+	return btoa(encodeURIComponent(json).replace(/%([0-9A-F]{2})/g, (_, hex) => String.fromCharCode(parseInt(hex, 16)))).replace(/\+/g, "-").replace(/\//g, "_").replace(/=+$/, "");
 };
 let mintCount = 0;
-/**
- * Mints an unsigned JWT the bearer auth provider can decode, with `iat`, `exp` and a unique `jti`.
- * Hand it to `setTokens()` to put the app's own provider into a session.
- *
- * @example
- * ```ts
- * TestBed.runInInjectionContext(() => authProviderRef.inject().setTokens(mintTestToken({ claims: { sub: '1' } }), 'refresh'));
- * ```
- */
 const mintTestToken = (options = {}) => {
-    const { expiresInMs = 15 * 60 * 1000, claims = {} } = options;
-    const iat = Math.floor(Date.now() / 1000);
-    const exp = Math.floor((Date.now() + expiresInMs) / 1000);
-    const header = toBase64Url(JSON.stringify({ alg: 'none', typ: 'JWT' }));
-    const payload = toBase64Url(JSON.stringify({ iat, exp, jti: ++mintCount, ...claims }));
-    return `${header}.${payload}.`;
+	const { expiresInMs = 9e5, claims = {} } = options;
+	const iat = Math.floor(Date.now() / 1e3);
+	const exp = Math.floor((Date.now() + expiresInMs) / 1e3);
+	return `${toBase64Url(JSON.stringify({
+		alg: "none",
+		typ: "JWT"
+	}))}.${toBase64Url(JSON.stringify({
+		iat,
+		exp,
+		jti: ++mintCount,
+		...claims
+	}))}.`;
 };
-
-/**
- * Generated bundle index. Do not edit.
- */
-
 export { createFakeQueryPersistenceStore, createWebSocketTestDouble, expectAndFlush, expectFlushAndWait, flushMultiTabSync, installFakeBroadcastChannel, installFakeWebLocks, mintTestToken, setupAuthTest, setupQueryTest };
-//# sourceMappingURL=ethlete-query-testing.mjs.map
+
+//# sourceMappingURL=ethlete-query-testing.mjs.map