@ethlete/query 6.0.0-next.10 → 6.0.0-next.11

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@ethlete/query",
-  "version": "6.0.0-next.10",
+  "version": "6.0.0-next.11",
   "license": "MIT",
   "sideEffects": false,
   "peerDependencies": {

package/types/ethlete-query.d.ts

@@ -1,5 +1,5 @@
 import * as _angular_core from '@angular/core';
-import { Signal, Injector, CreateComputedOptions, InjectionToken, TrackByFunction, PipeTransform, OnInit, OnDestroy, DestroyRef, EnvironmentInjector, ɵEffectScheduler as _EffectScheduler, ErrorHandler, WritableSignal, CreateEffectOptions } from '@angular/core';
+import { Signal, Injector, CreateComputedOptions, InjectionToken, TrackByFunction, PipeTransform, OnInit, OnDestroy, DestroyRef, EnvironmentInjector, ErrorHandler, WritableSignal, CreateEffectOptions } from '@angular/core';
 import * as _ethlete_core from '@ethlete/core';
 import { ProviderResult, RuntimeError } from '@ethlete/core';
 import * as rxjs from 'rxjs';
@@ -1981,8 +1981,6 @@ type QueryDependencies = {
     client: QueryClient;
     /** The injector of the query */
     injector: EnvironmentInjector;
-    /** The effect scheduler */
-    effectScheduler: _EffectScheduler;
     /** The error handler */
     ngErrorHandler: ErrorHandler;
     /** The http client */
@@ -2052,6 +2050,18 @@ type SetupQueryStateOptions<TArgs extends QueryArgs> = {
 type QueryStateSubtle<TArgs extends QueryArgs> = {
     request: WritableSignal<HttpRequest<TArgs> | null>;
     rawResponse: WritableSignal<RawResponseType<TArgs> | null>;
+    /**
+     * Forwards the given request's discrete event stream onto the query-level `events$`.
+     * Called by `queryExecute` whenever a request is (re-)executed.
+     */
+    bindRequestEvents: (request: HttpRequest<TArgs>) => void;
+    /**
+     * Installs the reactive source that backs `state.args`. The `withArgs` feature uses this so that
+     * `state.args` always reflects the latest args (pulled from the reactive source on read) instead
+     * of being push-updated by an effect that may not have run yet. Without a `withArgs` feature the
+     * default source returns `null`.
+     */
+    setArgsSource: (source: () => RequestArgs<TArgs> | null) => void;
 };
 type QueryState<TArgs extends QueryArgs> = {
     rawResponse: WritableSignal<RawResponseType<TArgs> | null>;
@@ -2063,6 +2073,14 @@ type QueryState<TArgs extends QueryArgs> = {
     lastTimeExecutedAt: WritableSignal<number | null>;
     lastTriggeredBy: WritableSignal<string | null>;
     executionState: Signal<QueryExecutionState<TArgs> | null>;
+    /**
+     * A discrete, query-level stream of every request event, fed synchronously from the current
+     * request's `events$` at the moment each event occurs. Side-effect features
+     * (success/error/logging) subscribe to this instead of edge-detecting on the shared, resettable
+     * `response`/`error`/`latestHttpEvent` signals — so they cannot miss a transition when the next
+     * execution swaps the underlying request.
+     */
+    events$: Observable<RequestHttpEvent<TArgs>>;
     subtle: QueryStateSubtle<TArgs>;
 };
 type QueryExecutionStateSuccess<TArgs extends QueryArgs> = {
@@ -2560,6 +2578,13 @@ type HttpRequest<TArgs extends QueryArgs> = {
     response: Signal<ResponseType<TArgs> | null>;
     /** The current event of the request */
     currentEvent: Signal<RequestHttpEvent<TArgs> | null>;
+    /**
+     * A discrete stream of every event of this request, emitted synchronously at the moment the
+     * event is processed (including the terminal Response / error event). Unlike the `currentEvent`
+     * signal, this never coalesces or gets reset, so consumers cannot miss a transition. Completes
+     * when the request is destroyed.
+     */
+    events$: Observable<RequestHttpEvent<TArgs>>;
     /** Whether the request is stale or not aka the cache header has expired */
     isStale: Signal<boolean>;
 };