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

package/fesm2022/ethlete-query-testing.mjs

@@ -1,178 +1,557 @@
-import { DestroyRef, ErrorHandler, Injector } from '@angular/core';
-import { TestBed } from '@angular/core/testing';
-import { createBearerAuthProvider, withAuthenticationQuery, withRefreshQuery, createQueryClient, createDeleteQuery, createPatchQuery, createPutQuery, createPostQuery, createGetQuery } from '@ethlete/query';
-import { 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 = false, extractLoginTokens = (response) => ({
-        accessToken: response.accessToken,
-        refreshToken: response.refreshToken,
-    }), extractRefreshTokens = (response) => ({
-        accessToken: response.accessToken,
-        refreshToken: response.refreshToken,
-    }), features, bearerDecryptFn, multiTabSync = false, refreshStrategy, minRefreshInterval, refreshIfExpired, expiresInPropertyName, } = 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 [, injectAuth] = createBearerAuthProvider({
-        name: 'test-auth',
-        queryClientRef: querySetup.queryClientRef,
-        queries: [
-            withAuthenticationQuery('login', {
-                queryCreator: login,
-                extractTokens: extractLoginTokens,
-            }),
-            withRefreshQuery('refresh', {
-                queryCreator: refresh,
-                extractTokens: extractRefreshTokens,
-                autoRetryOn401,
-                refreshStrategy,
-                minRefreshInterval,
-                refreshIfExpired,
-                expiresInPropertyName,
-            }),
-        ],
-        features: (features ?? []),
-        bearerDecryptFn,
-        multiTabSync,
-    });
-    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({ 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,
-        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
+	};
 };
-
+const nodeSetImmediate = globalThis.setImmediate;
+const scheduleTask = nodeSetImmediate ? nodeSetImmediate.bind(globalThis) : setTimeout.bind(globalThis);
+const installFakeBroadcastChannel = () => {
+	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;
+		}
+	};
+};
+const installFakeWebLocks = () => {
+	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;
+		}
+	};
+};
+const flushMultiTabSync = () => new Promise((resolve) => scheduleTask(resolve));
+const quotaError = () => new DOMException("The quota has been exceeded.", "QuotaExceededError");
+const createFakeQueryPersistenceStore = () => {
+	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 installConsoleFilters = () => {
+	if (console.error !== filteredError) originalError = console.error;
+	console.error = filteredError;
+};
+const restoreConsole = () => {
+	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 setupQueryTest = (config) => {
-    const baseUrl = config?.baseUrl ?? 'https://api.test.com';
-    const name = config?.name ?? 'test';
-    const mockErrorHandler = config?.mockErrorHandler !== false;
-    // Suppress console.warn for auth-related warnings during tests
-    const originalWarn = console.warn;
-    console.warn = (...args) => {
-        const message = args[0];
-        if (typeof message === 'string' && message.includes('auto-refresh')) {
-            return; // Suppress auto-refresh warnings
-        }
-        originalWarn(...args);
-    };
-    // Suppress console.error for expected error scenarios during tests
-    const originalError = console.error;
-    console.error = (...args) => {
-        const message = args[0];
-        // Suppress HttpErrorResponse logs
-        if (message && typeof message === 'object' && 'name' in message && message.name === 'HttpErrorResponse') {
-            return;
-        }
-        // Suppress bearer token decryption errors
-        if (typeof message === 'string' && message.includes('Failed to decrypt bearer token')) {
-            return;
-        }
-        // Suppress token extraction errors
-        if (typeof message === 'string' && message.includes('Failed to extract tokens from')) {
-            return;
-        }
-        originalError(...args);
-    };
-    const providers = [
-        provideHttpClient(),
-        provideHttpClientTesting(),
-        provideRouter([]),
-    ];
-    if (mockErrorHandler) {
-        providers.push({
-            provide: ErrorHandler,
-            useValue: { handleError: () => undefined },
-        });
-    }
-    TestBed.configureTestingModule({ providers });
-    const queryClientRef = createQueryClient({ baseUrl, name });
-    const setup = TestBed.runInInjectionContext(() => {
-        const [, inject] = queryClientRef;
-        const queryClient = inject();
-        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),
-        };
-    });
-    // Restore console.warn and console.error when tests are done
-    const restoreConsole = () => {
-        console.warn = originalWarn;
-        console.error = originalError;
-    };
-    // Store the restore function for cleanup
-    setup._restoreConsole = restoreConsole;
-    return setup;
+	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
+		};
+	});
 };
+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 toBase64Url = (json) => {
+	return btoa(encodeURIComponent(json).replace(/%([0-9A-F]{2})/g, (_, hex) => String.fromCharCode(parseInt(hex, 16)))).replace(/\+/g, "-").replace(/\//g, "_").replace(/=+$/, "");
+};
+let mintCount = 0;
+const mintTestToken = (options = {}) => {
+	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
+	}))}.`;
+};
+export { createFakeQueryPersistenceStore, createWebSocketTestDouble, expectAndFlush, expectFlushAndWait, flushMultiTabSync, installFakeBroadcastChannel, installFakeWebLocks, mintTestToken, setupAuthTest, setupQueryTest };
 
-/**
- * Generated bundle index. Do not edit.
- */
-
-export { expectAndFlush, expectFlushAndWait, setupAuthTest, setupQueryTest };
-//# sourceMappingURL=ethlete-query-testing.mjs.map
+//# sourceMappingURL=ethlete-query-testing.mjs.map