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

package/fesm2022/ethlete-query-ngrx-toolkit.mjs

@@ -1,393 +1,411 @@
-import * as i0 from '@angular/core';
-import { inject, ChangeDetectorRef, DestroyRef, Pipe, NgModule, signal, computed, effect, untracked, isDevMode, EnvironmentInjector, assertInInjectionContext } from '@angular/core';
-import { Subscription, combineLatest, startWith, map, Subject, defer, of, distinctUntilChanged, interval, takeUntil, finalize, filter } from 'rxjs';
-import { resolveQueryHeaders } from '@ethlete/query';
-
+import * as i0 from "@angular/core";
+import { ChangeDetectorRef, DestroyRef, EnvironmentInjector, NgModule, Pipe, assertInInjectionContext, computed, effect, inject, isDevMode, signal, untracked } from "@angular/core";
+import { Subject, Subscription, combineLatest, defer, distinctUntilChanged, filter, finalize, interval, map, of, startWith, takeUntil } from "rxjs";
+import { resolveQueryHeaders } from "@ethlete/query";
 const createToolkitPipeTransform = (options) => {
-    const cdr = inject(ChangeDetectorRef);
-    let subscription = Subscription.EMPTY;
-    let current = null;
-    let state = options.initialState;
-    const dispose = () => {
-        subscription.unsubscribe();
-        current = null;
-        state = options.disposedState;
-    };
-    const subscribe = (value) => {
-        current = value;
-        subscription = options.state$(value).subscribe((next) => {
-            state = next;
-            cdr.markForCheck();
-        });
-    };
-    inject(DestroyRef).onDestroy(dispose);
-    return (value) => {
-        if (!current && value)
-            subscribe(value);
-        if (current !== value) {
-            dispose();
-            if (value)
-                subscribe(value);
-        }
-        return state;
-    };
+	const cdr = inject(ChangeDetectorRef);
+	let subscription = Subscription.EMPTY;
+	let current = null;
+	let state = options.initialState;
+	const dispose = () => {
+		subscription.unsubscribe();
+		current = null;
+		state = options.disposedState;
+	};
+	const subscribe = (value) => {
+		current = value;
+		subscription = options.state$(value).subscribe((next) => {
+			state = next;
+			cdr.markForCheck();
+		});
+	};
+	inject(DestroyRef).onDestroy(dispose);
+	return (value) => {
+		if (!current && value) subscribe(value);
+		if (current !== value) {
+			dispose();
+			if (value) subscribe(value);
+		}
+		return state;
+	};
 };
-
-const noop = () => undefined;
+const noop = () => void 0;
 const DEFAULT_STATE = {
-    args: null,
-    cachedResponse: null,
-    callState: null,
-    error: null,
-    isError: false,
-    isInit: false,
-    isLoading: false,
-    isSuccess: false,
-    response: null,
-    timestamp: null,
-    refresh: noop,
-    remove: noop,
-    startPolling: noop,
-    stopPolling: noop,
+	args: null,
+	cachedResponse: null,
+	callState: null,
+	error: null,
+	isError: false,
+	isInit: false,
+	isLoading: false,
+	isSuccess: false,
+	response: null,
+	timestamp: null,
+	refresh: noop,
+	remove: noop,
+	startPolling: noop,
+	stopPolling: noop
 };
 const suspenseState$ = (handle) => combineLatest({
-    args: handle.args$,
-    cachedResponse: handle.cachedResponse$.pipe(startWith(null)),
-    callState: handle.callState$,
-    error: handle.error$,
-    isError: handle.isError$,
-    isInit: handle.isInit$,
-    isLoading: handle.isLoading$,
-    isSuccess: handle.isSuccess$,
-    response: handle.response$,
-    timestamp: handle.timestamp$,
+	args: handle.args$,
+	cachedResponse: handle.cachedResponse$.pipe(startWith(null)),
+	callState: handle.callState$,
+	error: handle.error$,
+	isError: handle.isError$,
+	isInit: handle.isInit$,
+	isLoading: handle.isLoading$,
+	isSuccess: handle.isSuccess$,
+	response: handle.response$,
+	timestamp: handle.timestamp$
 }).pipe(map((values) => ({
-    ...values,
-    refresh: handle.refresh,
-    remove: handle.remove,
-    startPolling: handle.startPolling,
-    stopPolling: handle.stopPolling,
+	...values,
+	refresh: handle.refresh,
+	remove: handle.remove,
+	startPolling: handle.startPolling,
+	stopPolling: handle.stopPolling
 })));
-/** Subscribes to a toolkit handle and renders its current state, like the `suspense` pipe of `@tomtomb/ngrx-toolkit`. */
-class SuspensePipe {
-    constructor() {
-        this.transform = createToolkitPipeTransform({
-            initialState: DEFAULT_STATE,
-            disposedState: null,
-            state$: suspenseState$,
-        });
-    }
-    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "22.1.6", ngImport: i0, type: SuspensePipe, deps: [], target: i0.ɵɵFactoryTarget.Pipe }); }
-    static { this.ɵpipe = i0.ɵɵngDeclarePipe({ minVersion: "14.0.0", version: "22.1.6", ngImport: i0, type: SuspensePipe, isStandalone: true, name: "suspense", pure: false }); }
-}
-i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "22.1.6", ngImport: i0, type: SuspensePipe, decorators: [{
-            type: Pipe,
-            args: [{ name: 'suspense', pure: false }]
-        }] });
-
+var SuspensePipe = class SuspensePipe {
+	constructor() {
+		this.transform = createToolkitPipeTransform({
+			initialState: DEFAULT_STATE,
+			disposedState: null,
+			state$: suspenseState$
+		});
+	}
+	static {
+		this.ɵfac = i0.ɵɵngDeclareFactory({
+			minVersion: "12.0.0",
+			version: "22.2.3",
+			ngImport: i0,
+			type: SuspensePipe,
+			deps: [],
+			target: i0.ɵɵFactoryTarget.Pipe
+		});
+	}
+	static {
+		this.ɵpipe = i0.ɵɵngDeclarePipe({
+			minVersion: "14.0.0",
+			version: "22.2.3",
+			ngImport: i0,
+			type: SuspensePipe,
+			isStandalone: true,
+			name: "suspense",
+			pure: false
+		});
+	}
+};
+i0.ɵɵngDeclareClassMetadata({
+	minVersion: "12.0.0",
+	version: "22.2.3",
+	ngImport: i0,
+	type: SuspensePipe,
+	decorators: [{
+		type: Pipe,
+		args: [{
+			name: "suspense",
+			pure: false
+		}]
+	}]
+});
 const suspenseMultiState$ = (handles) => combineLatest(Object.entries(handles).flatMap(([key, handle]) => handle ? [suspenseState$(handle).pipe(map((state) => [key, state]))] : [])).pipe(map((states) => Object.fromEntries(states)));
-/**
- * Subscribes to a record of toolkit handles and renders each one's current state, like the `suspenseMulti` pipe of
- * `@tomtomb/ngrx-toolkit`. Nothing renders until every non-null handle has emitted.
- */
-class SuspenseMultiPipe {
-    constructor() {
-        this.transform = createToolkitPipeTransform({
-            initialState: {},
-            disposedState: {},
-            state$: suspenseMultiState$,
-        });
-    }
-    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "22.1.6", ngImport: i0, type: SuspenseMultiPipe, deps: [], target: i0.ɵɵFactoryTarget.Pipe }); }
-    static { this.ɵpipe = i0.ɵɵngDeclarePipe({ minVersion: "14.0.0", version: "22.1.6", ngImport: i0, type: SuspenseMultiPipe, isStandalone: true, name: "suspenseMulti", pure: false }); }
-}
-i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "22.1.6", ngImport: i0, type: SuspenseMultiPipe, decorators: [{
-            type: Pipe,
-            args: [{ name: 'suspenseMulti', pure: false }]
-        }] });
-
-/** Exports the `suspense` and `suspenseMulti` pipes, like the `NgRxToolkitModule` of `@tomtomb/ngrx-toolkit`. */
-class NgRxToolkitModule {
-    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "22.1.6", ngImport: i0, type: NgRxToolkitModule, deps: [], target: i0.ɵɵFactoryTarget.NgModule }); }
-    static { this.ɵmod = i0.ɵɵngDeclareNgModule({ minVersion: "14.0.0", version: "22.1.6", ngImport: i0, type: NgRxToolkitModule, imports: [SuspensePipe, SuspenseMultiPipe], exports: [SuspensePipe, SuspenseMultiPipe] }); }
-    static { this.ɵinj = i0.ɵɵngDeclareInjector({ minVersion: "12.0.0", version: "22.1.6", ngImport: i0, type: NgRxToolkitModule }); }
-}
-i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "22.1.6", ngImport: i0, type: NgRxToolkitModule, decorators: [{
-            type: NgModule,
-            args: [{
-                    imports: [SuspensePipe, SuspenseMultiPipe],
-                    exports: [SuspensePipe, SuspenseMultiPipe],
-                }]
-        }] });
-
-/** The call state of a toolkit handle, as `@tomtomb/ngrx-toolkit` names it. */
+var SuspenseMultiPipe = class SuspenseMultiPipe {
+	constructor() {
+		this.transform = createToolkitPipeTransform({
+			initialState: {},
+			disposedState: {},
+			state$: suspenseMultiState$
+		});
+	}
+	static {
+		this.ɵfac = i0.ɵɵngDeclareFactory({
+			minVersion: "12.0.0",
+			version: "22.2.3",
+			ngImport: i0,
+			type: SuspenseMultiPipe,
+			deps: [],
+			target: i0.ɵɵFactoryTarget.Pipe
+		});
+	}
+	static {
+		this.ɵpipe = i0.ɵɵngDeclarePipe({
+			minVersion: "14.0.0",
+			version: "22.2.3",
+			ngImport: i0,
+			type: SuspenseMultiPipe,
+			isStandalone: true,
+			name: "suspenseMulti",
+			pure: false
+		});
+	}
+};
+i0.ɵɵngDeclareClassMetadata({
+	minVersion: "12.0.0",
+	version: "22.2.3",
+	ngImport: i0,
+	type: SuspenseMultiPipe,
+	decorators: [{
+		type: Pipe,
+		args: [{
+			name: "suspenseMulti",
+			pure: false
+		}]
+	}]
+});
+var NgRxToolkitModule = class NgRxToolkitModule {
+	static {
+		this.ɵfac = i0.ɵɵngDeclareFactory({
+			minVersion: "12.0.0",
+			version: "22.2.3",
+			ngImport: i0,
+			type: NgRxToolkitModule,
+			deps: [],
+			target: i0.ɵɵFactoryTarget.NgModule
+		});
+	}
+	static {
+		this.ɵmod = i0.ɵɵngDeclareNgModule({
+			minVersion: "14.0.0",
+			version: "22.2.3",
+			ngImport: i0,
+			type: NgRxToolkitModule,
+			imports: [SuspensePipe, SuspenseMultiPipe],
+			exports: [SuspensePipe, SuspenseMultiPipe]
+		});
+	}
+	static {
+		this.ɵinj = i0.ɵɵngDeclareInjector({
+			minVersion: "12.0.0",
+			version: "22.2.3",
+			ngImport: i0,
+			type: NgRxToolkitModule
+		});
+	}
+};
+i0.ɵɵngDeclareClassMetadata({
+	minVersion: "12.0.0",
+	version: "22.2.3",
+	ngImport: i0,
+	type: NgRxToolkitModule,
+	decorators: [{
+		type: NgModule,
+		args: [{
+			imports: [SuspensePipe, SuspenseMultiPipe],
+			exports: [SuspensePipe, SuspenseMultiPipe]
+		}]
+	}]
+});
 const CallState = {
-    INIT: 'INIT',
-    LOADING: 'LOADING',
-    SUCCESS: 'SUCCESS',
-    ERROR: 'ERROR',
+	INIT: "INIT",
+	LOADING: "LOADING",
+	SUCCESS: "SUCCESS",
+	ERROR: "ERROR"
 };
-
 const EMPTY_SNAPSHOT = {
-    args: null,
-    callState: null,
-    response: null,
-    error: null,
-    timestamp: null,
+	args: null,
+	callState: null,
+	response: null,
+	error: null,
+	timestamp: null
 };
 const toCallState = (state) => {
-    switch (state?.type) {
-        case 'success':
-            return CallState.SUCCESS;
-        case 'failure':
-            return CallState.ERROR;
-        default:
-            return CallState.LOADING;
-    }
+	switch (state?.type) {
+		case "success": return CallState.SUCCESS;
+		case "failure": return CallState.ERROR;
+		default: return CallState.LOADING;
+	}
 };
 const toToolkitError = (error) => ({
-    status: error.raw.status,
-    message: error.raw.message,
-    data: error.raw.error ?? null,
+	status: error.raw.status,
+	message: error.raw.message,
+	data: error.raw.error ?? null
 });
-const handleReleasedMessage = (method) => `${method}() was called on a toolkit handle that a newer toolkitCall() released. Args that cannot be hashed ` +
-    `(FormData, Blob, Map, ...) never share a handle, so the next call for the same creator releases the previous ` +
-    `handle once its request settles. The call was ignored - call toolkitCall() again with the args instead of ` +
-    `reusing the old handle. This warning is shown once per handle.`;
+const handleReleasedMessage = (method) => `${method}() was called on a toolkit handle that a newer toolkitCall() released. Args that cannot be hashed (FormData, Blob, Map, ...) never share a handle, so the next call for the same creator releases the previous handle once its request settles. The call was ignored - call toolkitCall() again with the args instead of reusing the old handle. This warning is shown once per handle.`;
 const toQueryArgs = (args) => {
-    const actionOptions = args['actionOptions'];
-    const queryArgs = {};
-    if (args['queryParams'] !== undefined)
-        queryArgs['pathParams'] = args['queryParams'];
-    if (args['params'] !== undefined)
-        queryArgs['queryParams'] = args['params'];
-    if (args['body'] !== undefined)
-        queryArgs['body'] = args['body'];
-    if (actionOptions?.headers !== undefined)
-        queryArgs['headers'] = actionOptions.headers;
-    return queryArgs;
+	const actionOptions = args["actionOptions"];
+	const queryArgs = {};
+	if (args["queryParams"] !== void 0) queryArgs["pathParams"] = args["queryParams"];
+	if (args["params"] !== void 0) queryArgs["queryParams"] = args["params"];
+	if (args["body"] !== void 0) queryArgs["body"] = args["body"];
+	if (actionOptions?.headers !== void 0) queryArgs["headers"] = actionOptions.headers;
+	return queryArgs;
 };
 const createToolkitHandle = (creator, injector) => {
-    const query = creator({ injector, onlyManualExecution: true, silenceMissingWithArgsFeatureError: true });
-    const calledArgs = signal(null, /* @ts-ignore */
-    ...(ngDevMode ? [{ debugName: "calledArgs" }] : /* istanbul ignore next */ []));
-    const toolkitError = computed(() => {
-        const error = query.error();
-        return error ? toToolkitError(error) : null;
-    }, /* @ts-ignore */
-    ...(ngDevMode ? [{ debugName: "toolkitError" }] : /* istanbul ignore next */ []));
-    const snapshot = computed(() => {
-        const currentArgs = calledArgs();
-        if (!currentArgs)
-            return EMPTY_SNAPSHOT;
-        const state = query.executionState();
-        const callState = toCallState(state);
-        return {
-            args: currentArgs,
-            callState,
-            response: state?.type === 'success' ? state.response : null,
-            error: callState === CallState.ERROR ? toolkitError() : null,
-            timestamp: Date.now(),
-        };
-    }, /* @ts-ignore */
-    ...(ngDevMode ? [{ debugName: "snapshot" }] : /* istanbul ignore next */ []));
-    const changes = new Subject();
-    const changesEffect = effect(() => {
-        const current = snapshot();
-        untracked(() => changes.next(current));
-    }, { ...(ngDevMode ? { debugName: "changesEffect" } : /* istanbul ignore next */ {}), injector });
-    let releasedSnapshot = null;
-    let warnedAboutRelease = false;
-    const ignoredAfterRelease = (method) => {
-        if (!releasedSnapshot)
-            return false;
-        if (isDevMode() && !warnedAboutRelease) {
-            warnedAboutRelease = true;
-            console.warn(handleReleasedMessage(method));
-        }
-        return true;
-    };
-    const select = (pick) => defer(() => (releasedSnapshot ? of(releasedSnapshot) : changes.pipe(startWith(untracked(snapshot))))).pipe(map(pick), distinctUntilChanged());
-    const call = (args) => {
-        calledArgs.set(args);
-        query.execute({ args: toQueryArgs(args) });
-    };
-    const refresh = () => {
-        if (ignoredAfterRelease('refresh'))
-            return;
-        const lastArgs = untracked(calledArgs);
-        if (lastArgs)
-            call(lastArgs);
-    };
-    let pollingSubscription = Subscription.EMPTY;
-    const stopPolling = () => pollingSubscription.unsubscribe();
-    const startPolling = ({ intervalDuration, killSwitch }) => {
-        if (ignoredAfterRelease('startPolling') || !pollingSubscription.closed)
-            return;
-        pollingSubscription = interval(intervalDuration)
-            .pipe(takeUntil(killSwitch), finalize(() => (pollingSubscription = Subscription.EMPTY)))
-            .subscribe(() => refresh());
-    };
-    const remove = () => {
-        stopPolling();
-        calledArgs.set(null);
-        query.reset();
-    };
-    const removeDestroyListener = injector.get(DestroyRef).onDestroy(() => {
-        stopPolling();
-        changes.complete();
-    });
-    const release = () => {
-        releasedSnapshot = untracked(snapshot);
-        stopPolling();
-        changesEffect.destroy();
-        removeDestroyListener();
-        changes.complete();
-        query.subtle.destroy();
-    };
-    const releaseWhenSettled = () => {
-        const releaseEffect = effect(() => {
-            if (snapshot().callState === CallState.LOADING)
-                return;
-            releaseEffect.destroy();
-            untracked(release);
-        }, { ...(ngDevMode ? { debugName: "releaseEffect" } : /* istanbul ignore next */ {}), injector });
-    };
-    const response$ = select((current) => current.response);
-    const handle = {
-        response$,
-        cachedResponse$: response$.pipe(filter((response) => !!response)),
-        error$: select((current) => current.error),
-        args$: select((current) => current.args),
-        isInit$: select((current) => current.callState === CallState.INIT),
-        isLoading$: select((current) => current.callState === CallState.LOADING),
-        isSuccess$: select((current) => current.callState === CallState.SUCCESS),
-        isError$: select((current) => current.callState === CallState.ERROR),
-        timestamp$: select((current) => current.timestamp),
-        callState$: select((current) => current.callState),
-        refresh,
-        remove,
-        startPolling,
-        stopPolling,
-    };
-    return { handle, call, releaseWhenSettled };
+	const query = creator({
+		injector,
+		onlyManualExecution: true,
+		silenceMissingWithArgsFeatureError: true
+	});
+	const calledArgs = signal(null, ...ngDevMode ? [{ debugName: "calledArgs" }] : /* istanbul ignore next */ []);
+	const toolkitError = computed(() => {
+		const error = query.error();
+		return error ? toToolkitError(error) : null;
+	}, ...ngDevMode ? [{ debugName: "toolkitError" }] : /* istanbul ignore next */ []);
+	const snapshot = computed(() => {
+		const currentArgs = calledArgs();
+		if (!currentArgs) return EMPTY_SNAPSHOT;
+		const state = query.executionState();
+		const callState = toCallState(state);
+		return {
+			args: currentArgs,
+			callState,
+			response: state?.type === "success" ? state.response : null,
+			error: callState === CallState.ERROR ? toolkitError() : null,
+			timestamp: Date.now()
+		};
+	}, ...ngDevMode ? [{ debugName: "snapshot" }] : /* istanbul ignore next */ []);
+	const changes = new Subject();
+	const changesEffect = effect(() => {
+		const current = snapshot();
+		untracked(() => changes.next(current));
+	}, {
+		...ngDevMode ? { debugName: "changesEffect" } : /* istanbul ignore next */ {},
+		injector
+	});
+	let releasedSnapshot = null;
+	let warnedAboutRelease = false;
+	const ignoredAfterRelease = (method) => {
+		if (!releasedSnapshot) return false;
+		if (isDevMode() && !warnedAboutRelease) {
+			warnedAboutRelease = true;
+			console.warn(handleReleasedMessage(method));
+		}
+		return true;
+	};
+	const select = (pick) => defer(() => releasedSnapshot ? of(releasedSnapshot) : changes.pipe(startWith(untracked(snapshot)))).pipe(map(pick), distinctUntilChanged());
+	const call = (args) => {
+		calledArgs.set(args);
+		query.execute({ args: toQueryArgs(args) });
+	};
+	const refresh = () => {
+		if (ignoredAfterRelease("refresh")) return;
+		const lastArgs = untracked(calledArgs);
+		if (lastArgs) call(lastArgs);
+	};
+	let pollingSubscription = Subscription.EMPTY;
+	const stopPolling = () => pollingSubscription.unsubscribe();
+	const startPolling = ({ intervalDuration, killSwitch }) => {
+		if (ignoredAfterRelease("startPolling") || !pollingSubscription.closed) return;
+		pollingSubscription = interval(intervalDuration).pipe(takeUntil(killSwitch), finalize(() => pollingSubscription = Subscription.EMPTY)).subscribe(() => refresh());
+	};
+	const remove = () => {
+		stopPolling();
+		calledArgs.set(null);
+		query.reset();
+	};
+	const removeDestroyListener = injector.get(DestroyRef).onDestroy(() => {
+		stopPolling();
+		changes.complete();
+	});
+	const release = () => {
+		releasedSnapshot = untracked(snapshot);
+		stopPolling();
+		changesEffect.destroy();
+		removeDestroyListener();
+		changes.complete();
+		query.subtle.destroy();
+	};
+	const releaseWhenSettled = () => {
+		const releaseEffect = effect(() => {
+			if (snapshot().callState === CallState.LOADING) return;
+			releaseEffect.destroy();
+			untracked(release);
+		}, {
+			...ngDevMode ? { debugName: "releaseEffect" } : /* istanbul ignore next */ {},
+			injector
+		});
+	};
+	const response$ = select((current) => current.response);
+	return {
+		handle: {
+			response$,
+			cachedResponse$: response$.pipe(filter((response) => !!response)),
+			error$: select((current) => current.error),
+			args$: select((current) => current.args),
+			isInit$: select((current) => current.callState === CallState.INIT),
+			isLoading$: select((current) => current.callState === CallState.LOADING),
+			isSuccess$: select((current) => current.callState === CallState.SUCCESS),
+			isError$: select((current) => current.callState === CallState.ERROR),
+			timestamp$: select((current) => current.timestamp),
+			callState$: select((current) => current.callState),
+			refresh,
+			remove,
+			startPolling,
+			stopPolling
+		},
+		call,
+		releaseWhenSettled
+	};
 };
-
 const registries = /* @__PURE__ */ new WeakMap();
-class UnhashableValueError extends Error {
-}
+var UnhashableValueError = class extends Error {};
 const isPlainObject = (value) => {
-    const prototype = Object.getPrototypeOf(value);
-    return prototype === Object.prototype || prototype === null;
+	const prototype = Object.getPrototypeOf(value);
+	return prototype === Object.prototype || prototype === null;
 };
 const hashableValue = (value) => {
-    if (Array.isArray(value))
-        return value.map(hashableValue);
-    if (typeof value !== 'object' || value === null)
-        return value;
-    if (value instanceof Date)
-        return { '\u0000date': value.getTime() };
-    if (!isPlainObject(value))
-        throw new UnhashableValueError();
-    return Object.fromEntries(Object.keys(value)
-        .sort()
-        .map((key) => [key, hashableValue(value[key])]));
+	if (Array.isArray(value)) return value.map(hashableValue);
+	if (typeof value !== "object" || value === null) return value;
+	if (value instanceof Date) return { "\0date": value.getTime() };
+	if (!isPlainObject(value)) throw new UnhashableValueError();
+	return Object.fromEntries(Object.keys(value).sort().map((key) => [key, hashableValue(value[key])]));
 };
 const hashableHeaders = (headers) => {
-    const resolved = resolveQueryHeaders(headers);
-    return resolved
-        ?.keys()
-        .map((name) => name.toLowerCase())
-        .sort()
-        .map((name) => [name, resolved.getAll(name)]);
+	const resolved = resolveQueryHeaders(headers);
+	return resolved?.keys().map((name) => name.toLowerCase()).sort().map((name) => [name, resolved.getAll(name)]);
 };
-/**
- * Returns `null` for args holding a value JSON cannot represent (FormData, Blob, Map, ...). Those never share a handle,
- * and each one is released once the next one for the same creator starts and its own call has settled.
- */
 const hashArgs = (args) => {
-    const { headers, ...rest } = args;
-    try {
-        return JSON.stringify([hashableValue(rest), hashableHeaders(headers) ?? null]);
-    }
-    catch (error) {
-        if (error instanceof UnhashableValueError)
-            return null;
-        throw error;
-    }
+	const { headers, ...rest } = args;
+	try {
+		return JSON.stringify([hashableValue(rest), hashableHeaders(headers) ?? null]);
+	} catch (error) {
+		if (error instanceof UnhashableValueError) return null;
+		throw error;
+	}
 };
 const resolveEnvironmentInjector = (fn, options) => {
-    if (options?.injector)
-        return options.injector.get(EnvironmentInjector);
-    assertInInjectionContext(fn);
-    return inject(EnvironmentInjector);
+	if (options?.injector) return options.injector.get(EnvironmentInjector);
+	assertInInjectionContext(fn);
+	return inject(EnvironmentInjector);
 };
 const resolveEntry = (creator, args, injector) => {
-    let registry = registries.get(injector);
-    if (!registry) {
-        registry = { shared: new WeakMap(), latestUnshared: new WeakMap() };
-        registries.set(injector, registry);
-    }
-    const key = hashArgs(toQueryArgs(args));
-    if (key === null) {
-        const entry = createToolkitHandle(creator, injector);
-        registry.latestUnshared.get(creator)?.releaseWhenSettled();
-        registry.latestUnshared.set(creator, entry);
-        return entry;
-    }
-    let entries = registry.shared.get(creator);
-    if (!entries) {
-        entries = new Map();
-        registry.shared.set(creator, entries);
-    }
-    let entry = entries.get(key);
-    if (!entry) {
-        entry = createToolkitHandle(creator, injector);
-        entries.set(key, entry);
-    }
-    return entry;
+	let registry = registries.get(injector);
+	if (!registry) {
+		registry = {
+			shared: /* @__PURE__ */ new WeakMap(),
+			latestUnshared: /* @__PURE__ */ new WeakMap()
+		};
+		registries.set(injector, registry);
+	}
+	const key = hashArgs(toQueryArgs(args));
+	if (key === null) {
+		const entry = createToolkitHandle(creator, injector);
+		registry.latestUnshared.get(creator)?.releaseWhenSettled();
+		registry.latestUnshared.set(creator, entry);
+		return entry;
+	}
+	let entries = registry.shared.get(creator);
+	if (!entries) {
+		entries = /* @__PURE__ */ new Map();
+		registry.shared.set(creator, entries);
+	}
+	let entry = entries.get(key);
+	if (!entry) {
+		entry = createToolkitHandle(creator, injector);
+		entries.set(key, entry);
+	}
+	return entry;
 };
-/**
- * Returns the handle for a creator and args without executing it - the `FacadeBase.select(group, actionId)` of
- * `@tomtomb/ngrx-toolkit`. Args that build the same request (in any key order, other keys ignored) give the same
- * handle `toolkitCall` returns, so `toolkitSelect(getTeam, args, { injector }).refresh()` re-runs a request another
- * component started.
- */
 const toolkitSelect = (creator, args, options) => resolveEntry(creator, args, resolveEnvironmentInjector(toolkitSelect, options)).handle;
-/**
- * Executes a query creator with toolkit-shaped args and returns its handle - the `FacadeBase.call(group, args)` of
- * `@tomtomb/ngrx-toolkit`. Every call sends the request again, unless one with equal args is still in flight, which it
- * joins; equal args return the same handle, which lives as long as the injector.
- *
- * @example
- * ```ts
- * @Injectable({ providedIn: 'root' })
- * export class TeamFacade {
- *   private injector = inject(Injector);
- *
- *   getTeam(args: ActionCallArgs<typeof getTeam>) {
- *     return toolkitCall(getTeam, args, { injector: this.injector });
- *   }
- * }
- * ```
- */
 const toolkitCall = (creator, args, options) => {
-    const entry = resolveEntry(creator, args, resolveEnvironmentInjector(toolkitCall, options));
-    entry.call(args);
-    return entry.handle;
+	const entry = resolveEntry(creator, args, resolveEnvironmentInjector(toolkitCall, options));
+	entry.call(args);
+	return entry.handle;
 };
-
-/** Emits `true` while any of the given loading streams is `true`. Nullish entries are skipped. */
 const joinLoading = (observables) => combineLatest(observables.filter((o) => !!o)).pipe(map((values) => values.some((value) => !!value)));
-/** Emits every non-null error of the given error streams, or `null` when there is none. Nullish entries are skipped. */
 const joinErrors = (observables) => combineLatest(observables.filter((o) => !!o)).pipe(map((values) => {
-    const errors = values.filter((value) => !!value);
-    return errors.length ? errors : null;
+	const errors = values.filter((value) => !!value);
+	return errors.length ? errors : null;
 }));
-
-/**
- * Generated bundle index. Do not edit.
- */
-
 export { CallState, NgRxToolkitModule, SuspenseMultiPipe, SuspensePipe, joinErrors, joinLoading, toolkitCall, toolkitSelect };
-//# sourceMappingURL=ethlete-query-ngrx-toolkit.mjs.map
+
+//# sourceMappingURL=ethlete-query-ngrx-toolkit.mjs.map