@spoosh/angular 0.9.1 → 0.10.0

package/README.md

@@ -1,6 +1,6 @@
 # @spoosh/angular
 
-Angular signals integration for Spoosh - `injectRead`, `injectWrite`, and `injectInfiniteRead`.
+Angular signals integration for Spoosh - `injectRead`, `injectWrite`, and `injectPages`.
 
 **[Documentation](https://spoosh.dev/docs/angular)** · **Requirements:** TypeScript >= 5.0, Angular >= 16.0
 
@@ -23,7 +23,7 @@ const spoosh = new Spoosh<ApiSchema, Error>("/api").use([
   cachePlugin({ staleTime: 5000 }),
 ]);
 
-export const { injectRead, injectWrite, injectInfiniteRead } = create(spoosh);
+export const { injectRead, injectWrite, injectPages } = create(spoosh);
 ```
 
 ### injectRead
@@ -115,7 +115,7 @@ async updateUserName(userId: number, name: string) {
 }
 ```
 
-### injectInfiniteRead
+### injectPages
 
 Bidirectional paginated data fetching with infinite scroll support.
 
@@ -140,29 +140,26 @@ Bidirectional paginated data fetching with infinite scroll support.
   `,
 })
 export class PostListComponent {
-  posts = injectInfiniteRead(
-    (api) => api("posts").GET({ query: { page: 1 } }),
-    {
-      // Required: Check if next page exists
-      canFetchNext: ({ response }) => response?.meta.hasMore ?? false,
+  posts = injectPages((api) => api("posts").GET({ query: { page: 1 } }), {
+    // Required: Check if next page exists
+    canFetchNext: ({ lastPage }) => lastPage?.data?.meta.hasMore ?? false,
 
-      // Required: Build request for next page
-      nextPageRequest: ({ response, request }) => ({
-        query: { ...request.query, page: (response?.meta.page ?? 0) + 1 },
-      }),
+    // Required: Build request for next page
+    nextPageRequest: ({ lastPage }) => ({
+      query: { page: (lastPage?.data?.meta.page ?? 0) + 1 },
+    }),
 
-      // Required: Merge all responses into items
-      merger: (allResponses) => allResponses.flatMap((r) => r.items),
+    // Required: Merge all pages into items
+    merger: (pages) => pages.flatMap((p) => p.data?.items ?? []),
 
-      // Optional: Check if previous page exists
-      canFetchPrev: ({ response }) => (response?.meta.page ?? 1) > 1,
+    // Optional: Check if previous page exists
+    canFetchPrev: ({ firstPage }) => (firstPage?.data?.meta.page ?? 1) > 1,
 
-      // Optional: Build request for previous page
-      prevPageRequest: ({ response, request }) => ({
-        query: { ...request.query, page: (response?.meta.page ?? 2) - 1 },
-      }),
-    }
-  );
+    // Optional: Build request for previous page
+    prevPageRequest: ({ firstPage }) => ({
+      query: { page: (firstPage?.data?.meta.page ?? 2) - 1 },
+    }),
+  });
 }
 ```
 
@@ -203,42 +200,58 @@ export class PostListComponent {
 | `input`   | `TriggerOptions \| undefined` | Last trigger input                 |
 | `abort`   | `() => void`                  | Abort current request              |
 
-### injectInfiniteRead(readFn, options)
+### injectPages(readFn, options)
 
-| Option            | Type                                          | Required | Description                     |
-| ----------------- | --------------------------------------------- | -------- | ------------------------------- |
-| `canFetchNext`    | `(ctx) => boolean`                            | Yes      | Check if next page exists       |
-| `nextPageRequest` | `(ctx) => Partial<TRequest>`                  | Yes      | Build request for next page     |
-| `merger`          | `(allResponses) => TItem[]`                   | Yes      | Merge all responses into items  |
-| `canFetchPrev`    | `(ctx) => boolean`                            | No       | Check if previous page exists   |
-| `prevPageRequest` | `(ctx) => Partial<TRequest>`                  | No       | Build request for previous page |
-| `enabled`         | `boolean \| Signal<boolean> \| () => boolean` | No       | Whether to fetch automatically  |
+| Option            | Type                                          | Required | Description                                       |
+| ----------------- | --------------------------------------------- | -------- | ------------------------------------------------- |
+| `merger`          | `(pages) => TItem[]`                          | Yes      | Merge all pages into items                        |
+| `canFetchNext`    | `(ctx) => boolean`                            | No       | Check if next page exists. Default: `() => false` |
+| `nextPageRequest` | `(ctx) => Partial<TRequest>`                  | No       | Build request for next page                       |
+| `canFetchPrev`    | `(ctx) => boolean`                            | No       | Check if previous page exists                     |
+| `prevPageRequest` | `(ctx) => Partial<TRequest>`                  | No       | Build request for previous page                   |
+| `enabled`         | `boolean \| Signal<boolean> \| () => boolean` | No       | Whether to fetch automatically                    |
 
 **Context object passed to callbacks:**
 
 ```typescript
-type Context<TData, TRequest> = {
-  response: TData | undefined; // Latest response
-  allResponses: TData[]; // All fetched responses
-  request: TRequest; // Current request options
+// For canFetchNext and nextPageRequest
+type NextContext<TData, TRequest> = {
+  lastPage: InfinitePage<TData> | undefined;
+  pages: InfinitePage<TData>[];
+  request: TRequest;
+};
+
+// For canFetchPrev and prevPageRequest
+type PrevContext<TData, TRequest> = {
+  firstPage: InfinitePage<TData> | undefined;
+  pages: InfinitePage<TData>[];
+  request: TRequest;
+};
+
+// Each page in the pages array
+type InfinitePage<TData> = {
+  status: "pending" | "loading" | "success" | "error" | "stale";
+  data?: TData;
+  error?: TError;
+  meta?: TMeta;
+  input?: { query?; params?; body? };
 };
 ```
 
 **Returns:**
 
-| Property       | Type                           | Description                     |
-| -------------- | ------------------------------ | ------------------------------- |
-| `data`         | `Signal<TItem[] \| undefined>` | Merged items from all responses |
-| `allResponses` | `Signal<TData[] \| undefined>` | Array of all raw responses      |
-| `loading`      | `Signal<boolean>`              | True during initial load        |
-| `fetching`     | `Signal<boolean>`              | True during any fetch           |
-| `fetchingNext` | `Signal<boolean>`              | True while fetching next page   |
-| `fetchingPrev` | `Signal<boolean>`              | True while fetching previous    |
-| `canFetchNext` | `Signal<boolean>`              | Whether next page exists        |
-| `canFetchPrev` | `Signal<boolean>`              | Whether previous page exists    |
-| `meta`         | `Signal<PluginResults>`        | Plugin metadata                 |
-| `fetchNext`    | `() => Promise<void>`          | Fetch the next page             |
-| `fetchPrev`    | `() => Promise<void>`          | Fetch the previous page         |
-| `refetch`      | `() => Promise<void>`          | Refetch all pages               |
-| `abort`        | `() => void`                   | Abort current request           |
-| `error`        | `Signal<TError \| undefined>`  | Error if request failed         |
+| Property       | Type                            | Description                                     |
+| -------------- | ------------------------------- | ----------------------------------------------- |
+| `data`         | `Signal<TItem[] \| undefined>`  | Merged items from all pages                     |
+| `pages`        | `Signal<InfinitePage<TData>[]>` | Array of all pages with status, data, and meta  |
+| `loading`      | `Signal<boolean>`               | True during initial load                        |
+| `fetching`     | `Signal<boolean>`               | True during any fetch                           |
+| `fetchingNext` | `Signal<boolean>`               | True while fetching next page                   |
+| `fetchingPrev` | `Signal<boolean>`               | True while fetching previous                    |
+| `canFetchNext` | `Signal<boolean>`               | Whether next page exists                        |
+| `canFetchPrev` | `Signal<boolean>`               | Whether previous page exists                    |
+| `fetchNext`    | `() => Promise<void>`           | Fetch the next page                             |
+| `fetchPrev`    | `() => Promise<void>`           | Fetch the previous page                         |
+| `trigger`      | `(options?) => Promise<void>`   | Trigger fetch with optional new request options |
+| `abort`        | `() => void`                    | Abort current request                           |
+| `error`        | `Signal<TError \| undefined>`   | Error if request failed                         |

package/dist/index.d.mts

@@ -1,7 +1,115 @@
 import * as _spoosh_core from '@spoosh/core';
-import { PluginArray, StateManager, EventEmitter, PluginExecutor, MethodOptionsMap, CoreRequestOptionsBase, ReadClient, TagOptions, SpooshPlugin, PluginTypeConfig, SpooshResponse, InfiniteRequestOptions, ResolveTypes, ResolverContext, WriteSelectorClient, SpooshBody, ResolveResultTypes, MergePluginInstanceApi } from '@spoosh/core';
+import { QueueSelectorClient, SpooshResponse, QueueItem, QueueStats, SpooshBody, PluginArray, StateManager, EventEmitter, PluginExecutor, MethodOptionsMap, CoreRequestOptionsBase, SpooshPlugin, PluginTypeConfig, ResolveTypes, ResolverContext, ResolveResultTypes, ReadClient, TagOptions, InfiniteNextContext, InfinitePrevContext, InfinitePage, ExtractTriggerQuery as ExtractTriggerQuery$2, ExtractTriggerBody as ExtractTriggerBody$2, ExtractTriggerParams as ExtractTriggerParams$2, InfiniteRequestOptions, WriteSelectorClient, MergePluginInstanceApi } from '@spoosh/core';
 import { Signal } from '@angular/core';
 
+type TriggerAwaitedReturn$2<T> = T extends (...args: any[]) => infer R ? Awaited<R> : never;
+type ExtractInputFromResponse$3<T> = T extends {
+    input: infer I;
+} ? I : never;
+type ExtractTriggerQuery$1<I> = I extends {
+    query: infer Q;
+} ? undefined extends Q ? {
+    query?: Exclude<Q, undefined>;
+} : {
+    query: Q;
+} : unknown;
+type ExtractTriggerBody$1<I> = I extends {
+    body: infer B;
+} ? undefined extends B ? {
+    body?: Exclude<B, undefined> | SpooshBody<Exclude<B, undefined>>;
+} : {
+    body: B | SpooshBody<B>;
+} : unknown;
+type ExtractTriggerParams$1<I> = I extends {
+    params: infer P;
+} ? {
+    params: P;
+} : unknown;
+type QueueTriggerBase = {
+    /** Custom ID for this queue item. If not provided, one will be auto-generated. */
+    id?: string;
+};
+type QueueTriggerInput<T> = ExtractInputFromResponse$3<TriggerAwaitedReturn$2<T>> extends infer I ? [I] extends [never] ? QueueTriggerBase : QueueTriggerBase & ExtractTriggerQuery$1<I> & ExtractTriggerBody$1<I> & ExtractTriggerParams$1<I> : QueueTriggerBase;
+/**
+ * Options for injectQueue.
+ */
+interface InjectQueueOptions {
+    /** Maximum concurrent operations. Defaults to 3. */
+    concurrency?: number;
+}
+/**
+ * Result returned by injectQueue.
+ *
+ * @template TData - The response data type
+ * @template TError - The error type
+ * @template TTriggerInput - The trigger input type
+ * @template TMeta - Plugin-contributed metadata on queue items
+ */
+interface BaseQueueResult<TData, TError, TTriggerInput, TMeta = object> {
+    /** Add item to queue and execute. Returns promise for this item. */
+    trigger: (input?: TTriggerInput) => Promise<SpooshResponse<TData, TError>>;
+    /** All tasks in queue with their current status */
+    tasks: Signal<QueueItem<TData, TError, TMeta>[]>;
+    /** Queue statistics (pending/running/settled/success/failed/total/percentage) */
+    stats: Signal<QueueStats>;
+    /** Abort task by ID, or all tasks if no ID */
+    abort: (id?: string) => void;
+    /** Retry failed task by ID, or all failed if no ID */
+    retry: (id?: string) => Promise<void>;
+    /** Remove specific task by ID (aborts if active) */
+    remove: (id: string) => void;
+    /** Remove all settled tasks (success, error, aborted). Keeps pending/running. */
+    removeSettled: () => void;
+    /** Abort all and clear queue */
+    clear: () => void;
+    /** Update concurrency limit */
+    setConcurrency: (concurrency: number) => void;
+}
+/**
+ * API client type for queue selector.
+ * Supports all HTTP methods (GET, POST, PUT, PATCH, DELETE).
+ */
+type QueueApiClient<TSchema, TDefaultError> = QueueSelectorClient<TSchema, TDefaultError>;
+
+type SuccessResponse<T> = Extract<T, {
+    data: unknown;
+    error?: undefined;
+}>;
+type ErrorResponse<T> = Extract<T, {
+    error: unknown;
+    data?: undefined;
+}>;
+type ExtractMethodData<T> = T extends (...args: never[]) => infer R ? SuccessResponse<Awaited<R>> extends {
+    data: infer D;
+} ? D : unknown : unknown;
+type ExtractMethodError<T> = T extends (...args: never[]) => infer R ? ErrorResponse<Awaited<R>> extends {
+    error: infer E;
+} ? E : unknown : unknown;
+type ExtractMethodOptions<T> = T extends (options?: infer O) => Promise<unknown> ? O : never;
+type AwaitedReturnType<T> = T extends (...args: never[]) => infer R ? Awaited<R> : never;
+type SuccessReturnType<T> = SuccessResponse<AwaitedReturnType<T>>;
+type ExtractResponseQuery<T> = SuccessReturnType<T> extends {
+    input: {
+        query: infer Q;
+    };
+} ? Q : never;
+type ExtractResponseBody<T> = SuccessReturnType<T> extends {
+    input: {
+        body: infer B;
+    };
+} ? B : never;
+type ExtractResponseParamNames<T> = SuccessReturnType<T> extends {
+    input: {
+        params: Record<infer K, unknown>;
+    };
+} ? K extends string ? K : never : never;
+type ExtractMethodQuery<T> = ExtractMethodOptions<T> extends {
+    query: infer Q;
+} ? Q : never;
+type ExtractMethodBody<T> = ExtractMethodOptions<T> extends {
+    body: infer B;
+} ? B : never;
+
 interface SpooshInstanceShape<TApi, TSchema, TDefaultError, TPlugins extends PluginArray> {
     api: TApi;
     stateManager: StateManager;
@@ -18,48 +126,214 @@ type QueryRequestOptions = CoreRequestOptionsBase;
 type MutationRequestOptions = CoreRequestOptionsBase;
 type AngularOptionsMap = MethodOptionsMap<QueryRequestOptions, MutationRequestOptions>;
 
-type PageContext<TData, TRequest> = {
-    response: TData | undefined;
-    allResponses: TData[];
-    request: TRequest;
+declare function createInjectQueue<TSchema, TDefaultError, TPlugins extends readonly SpooshPlugin<PluginTypeConfig>[]>(options: Omit<SpooshInstanceShape<unknown, TSchema, TDefaultError, TPlugins>, "_types">): <TQueueFn extends (api: QueueApiClient<TSchema, TDefaultError>) => Promise<SpooshResponse<unknown, unknown>>>(queueFn: TQueueFn, queueOptions?: ResolveTypes<((TPlugins[number] extends infer T ? T extends TPlugins[number] ? T extends SpooshPlugin<infer Types extends PluginTypeConfig> ? Types extends {
+    queueOptions: infer Q;
+} ? Q : object : object : never : never) extends infer T_1 ? T_1 extends (TPlugins[number] extends infer T_2 ? T_2 extends TPlugins[number] ? T_2 extends SpooshPlugin<infer Types extends PluginTypeConfig> ? Types extends {
+    queueOptions: infer Q;
+} ? Q : object : object : never : never) ? T_1 extends unknown ? (x: T_1) => void : never : never : never) extends (x: infer I) => void ? I : never, ResolverContext<TSchema, TQueueFn extends (...args: any[]) => infer R ? Extract<Awaited<R>, {
+    data: unknown;
+    error?: undefined;
+}> extends {
+    data: infer D;
+} ? D : unknown : unknown, [TQueueFn extends (...args: any[]) => infer R_1 ? Extract<Awaited<R_1>, {
+    error: unknown;
+    data?: undefined;
+}> extends {
+    error: infer E;
+} ? E : unknown : unknown] extends [unknown] ? TDefaultError : TQueueFn extends (...args: any[]) => infer R_1 ? Extract<Awaited<R_1>, {
+    error: unknown;
+    data?: undefined;
+}> extends {
+    error: infer E;
+} ? E : unknown : unknown, ExtractMethodQuery<TQueueFn>, ExtractMethodBody<TQueueFn>, ExtractResponseParamNames<TQueueFn> extends never ? never : Record<ExtractResponseParamNames<TQueueFn>, string | number>>> & InjectQueueOptions) => BaseQueueResult<TQueueFn extends (...args: any[]) => infer R ? Extract<Awaited<R>, {
+    data: unknown;
+    error?: undefined;
+}> extends {
+    data: infer D;
+} ? D : unknown : unknown, [TQueueFn extends (...args: any[]) => infer R_1 ? Extract<Awaited<R_1>, {
+    error: unknown;
+    data?: undefined;
+}> extends {
+    error: infer E;
+} ? E : unknown : unknown] extends [unknown] ? TDefaultError : TQueueFn extends (...args: any[]) => infer R_1 ? Extract<Awaited<R_1>, {
+    error: unknown;
+    data?: undefined;
+}> extends {
+    error: infer E;
+} ? E : unknown : unknown, QueueTriggerInput<TQueueFn> & ResolveTypes<((TPlugins[number] extends infer T_3 ? T_3 extends TPlugins[number] ? T_3 extends SpooshPlugin<infer Types_1 extends PluginTypeConfig> ? Types_1 extends {
+    queueTriggerOptions: infer Q_1;
+} ? Q_1 : object : object : never : never) extends infer T_4 ? T_4 extends (TPlugins[number] extends infer T_5 ? T_5 extends TPlugins[number] ? T_5 extends SpooshPlugin<infer Types_1 extends PluginTypeConfig> ? Types_1 extends {
+    queueTriggerOptions: infer Q_1;
+} ? Q_1 : object : object : never : never) ? T_4 extends unknown ? (x: T_4) => void : never : never : never) extends (x: infer I) => void ? I : never, ResolverContext<TSchema, TQueueFn extends (...args: any[]) => infer R ? Extract<Awaited<R>, {
+    data: unknown;
+    error?: undefined;
+}> extends {
+    data: infer D;
+} ? D : unknown : unknown, [TQueueFn extends (...args: any[]) => infer R_1 ? Extract<Awaited<R_1>, {
+    error: unknown;
+    data?: undefined;
+}> extends {
+    error: infer E;
+} ? E : unknown : unknown] extends [unknown] ? TDefaultError : TQueueFn extends (...args: any[]) => infer R_1 ? Extract<Awaited<R_1>, {
+    error: unknown;
+    data?: undefined;
+}> extends {
+    error: infer E;
+} ? E : unknown : unknown, ExtractMethodQuery<TQueueFn>, ExtractMethodBody<TQueueFn>, ExtractResponseParamNames<TQueueFn> extends never ? never : Record<ExtractResponseParamNames<TQueueFn>, string | number>>>, ResolveResultTypes<((TPlugins[number] extends infer T_6 ? T_6 extends TPlugins[number] ? T_6 extends SpooshPlugin<infer Types_2 extends PluginTypeConfig> ? Types_2 extends {
+    queueResult: infer Q_2;
+} ? Q_2 : object : object : never : never) extends infer T_7 ? T_7 extends (TPlugins[number] extends infer T_8 ? T_8 extends TPlugins[number] ? T_8 extends SpooshPlugin<infer Types_2 extends PluginTypeConfig> ? Types_2 extends {
+    queueResult: infer Q_2;
+} ? Q_2 : object : object : never : never) ? T_7 extends unknown ? (x: T_7) => void : never : never : never) extends (x: infer I) => void ? I : never, ResolveTypes<((TPlugins[number] extends infer T_9 ? T_9 extends TPlugins[number] ? T_9 extends SpooshPlugin<infer Types extends PluginTypeConfig> ? Types extends {
+    queueOptions: infer Q;
+} ? Q : object : object : never : never) extends infer T_10 ? T_10 extends (TPlugins[number] extends infer T_11 ? T_11 extends TPlugins[number] ? T_11 extends SpooshPlugin<infer Types extends PluginTypeConfig> ? Types extends {
+    queueOptions: infer Q;
+} ? Q : object : object : never : never) ? T_10 extends unknown ? (x: T_10) => void : never : never : never) extends (x: infer I) => void ? I : never, ResolverContext<TSchema, TQueueFn extends (...args: any[]) => infer R ? Extract<Awaited<R>, {
+    data: unknown;
+    error?: undefined;
+}> extends {
+    data: infer D;
+} ? D : unknown : unknown, [TQueueFn extends (...args: any[]) => infer R_1 ? Extract<Awaited<R_1>, {
+    error: unknown;
+    data?: undefined;
+}> extends {
+    error: infer E;
+} ? E : unknown : unknown] extends [unknown] ? TDefaultError : TQueueFn extends (...args: any[]) => infer R_1 ? Extract<Awaited<R_1>, {
+    error: unknown;
+    data?: undefined;
+}> extends {
+    error: infer E;
+} ? E : unknown : unknown, ExtractMethodQuery<TQueueFn>, ExtractMethodBody<TQueueFn>, ExtractResponseParamNames<TQueueFn> extends never ? never : Record<ExtractResponseParamNames<TQueueFn>, string | number>>> & InjectQueueOptions>>;
+
+type TriggerAwaitedReturn$1<T> = T extends (...args: never[]) => infer R ? Awaited<R> : never;
+type ExtractInputFromResponse$2<T> = T extends {
+    input: infer I;
+} ? I : never;
+type BaseTriggerOptions = {
+    /** Bypass cache and force refetch. Default: true */
+    force?: boolean;
 };
-interface BaseInfiniteReadOptions<TData, TItem, TRequest> extends TagOptions {
+type PagesTriggerOptions<TReadFn> = ExtractInputFromResponse$2<TriggerAwaitedReturn$1<TReadFn>> extends infer I ? [I] extends [never] ? BaseTriggerOptions : ExtractTriggerQuery$2<I> & ExtractTriggerBody$2<I> & ExtractTriggerParams$2<I> & BaseTriggerOptions : BaseTriggerOptions;
+/**
+ * Options for `injectPages`.
+ *
+ * @template TData - The response data type for each page
+ * @template TItem - The item type after merging all pages
+ * @template TError - The error type
+ * @template TRequest - The request options type
+ * @template TMeta - Plugin metadata type
+ */
+interface BasePagesOptions<TData, TItem, TError = unknown, TRequest = object, TMeta = Record<string, unknown>> extends TagOptions {
     enabled?: EnabledOption;
-    canFetchNext: (ctx: PageContext<TData, TRequest>) => boolean;
-    canFetchPrev?: (ctx: PageContext<TData, TRequest>) => boolean;
-    nextPageRequest: (ctx: PageContext<TData, TRequest>) => Partial<TRequest>;
-    prevPageRequest?: (ctx: PageContext<TData, TRequest>) => Partial<TRequest>;
-    merger: (responses: TData[]) => TItem[];
+    /**
+     * Callback to determine if there's a next page to fetch.
+     * Receives the last page to check for pagination indicators.
+     * Default: `() => false` (no next page fetching)
+     *
+     * @example
+     * ```ts
+     * canFetchNext: ({ lastPage }) => lastPage?.data?.nextCursor != null
+     * ```
+     */
+    canFetchNext?: (ctx: InfiniteNextContext<TData, TError, TRequest, TMeta>) => boolean;
+    /**
+     * Callback to determine if there's a previous page to fetch.
+     * Receives the first page to check for pagination indicators.
+     * Default: `() => false` (no previous page fetching)
+     */
+    canFetchPrev?: (ctx: InfinitePrevContext<TData, TError, TRequest, TMeta>) => boolean;
+    /**
+     * Callback to build the request options for the next page.
+     * Return only the fields that change - they will be **merged** with the initial request.
+     * Default: `() => ({})` (no changes to request)
+     *
+     * @example
+     * ```ts
+     * // Initial: { query: { cursor: 0, limit: 10 } }
+     * // Only return cursor - limit is preserved automatically
+     * nextPageRequest: ({ lastPage }) => ({
+     *   query: { cursor: lastPage?.data?.nextCursor }
+     * })
+     * ```
+     */
+    nextPageRequest?: (ctx: InfiniteNextContext<TData, TError, TRequest, TMeta>) => Partial<TRequest>;
+    /**
+     * Callback to build the request options for the previous page.
+     * Return only the fields that change - they will be **merged** with the initial request.
+     */
+    prevPageRequest?: (ctx: InfinitePrevContext<TData, TError, TRequest, TMeta>) => Partial<TRequest>;
+    /**
+     * Callback to merge all pages into a single array of items.
+     *
+     * @example
+     * ```ts
+     * merger: (pages) => pages.flatMap(p => p.data?.items ?? [])
+     * ```
+     */
+    merger: (pages: InfinitePage<TData, TError, TMeta>[]) => TItem[];
 }
-interface BaseInfiniteReadResult<TData, TError, TItem, TPluginResult = Record<string, unknown>> {
+/**
+ * Result returned by `injectPages`.
+ *
+ * @template TData - The response data type for each page
+ * @template TError - The error type
+ * @template TItem - The item type after merging all pages
+ * @template TPluginResult - Plugin-provided result fields
+ * @template TTriggerOptions - Options that can be passed to trigger()
+ */
+interface BasePagesResult<TData, TError, TItem, TPluginResult = Record<string, unknown>, TTriggerOptions = object> {
+    /** Merged items from all fetched pages */
     data: Signal<TItem[] | undefined>;
-    allResponses: Signal<TData[] | undefined>;
+    /** Array of all pages with status, data, error, and meta per page */
+    pages: Signal<InfinitePage<TData, TError, TPluginResult>[]>;
+    /** Error from the last failed request */
     error: Signal<TError | undefined>;
+    /** True during the initial load (no data yet) */
     loading: Signal<boolean>;
+    /** True during any fetch operation */
     fetching: Signal<boolean>;
+    /** True while fetching the next page */
     fetchingNext: Signal<boolean>;
+    /** True while fetching the previous page */
     fetchingPrev: Signal<boolean>;
+    /** Whether there's a next page available to fetch */
     canFetchNext: Signal<boolean>;
+    /** Whether there's a previous page available to fetch */
     canFetchPrev: Signal<boolean>;
-    meta: Signal<TPluginResult>;
+    /** Fetch the next page */
     fetchNext: () => Promise<void>;
+    /** Fetch the previous page */
     fetchPrev: () => Promise<void>;
-    trigger: () => Promise<void>;
+    /** Trigger refetch of all pages from the beginning, optionally with new request options */
+    trigger: (options?: TTriggerOptions) => Promise<void>;
+    /** Abort the current fetch operation */
     abort: () => void;
 }
-type InfiniteReadApiClient<TSchema, TDefaultError> = ReadClient<TSchema, TDefaultError>;
+type PagesApiClient<TSchema, TDefaultError> = ReadClient<TSchema, TDefaultError>;
 
-type AnyInfiniteRequestOptions = InfiniteRequestOptions;
-declare function createInjectInfiniteRead<TSchema, TDefaultError, TPlugins extends readonly SpooshPlugin<PluginTypeConfig>[]>(options: Omit<SpooshInstanceShape<unknown, TSchema, TDefaultError, TPlugins>, "_types">): <TReadFn extends (api: InfiniteReadApiClient<TSchema, TDefaultError>) => Promise<SpooshResponse<unknown, unknown>>, TRequest extends AnyInfiniteRequestOptions = AnyInfiniteRequestOptions, TItem = unknown>(readFn: TReadFn, readOptions: BaseInfiniteReadOptions<TReadFn extends (...args: never[]) => infer R ? Extract<Awaited<R>, {
+declare function createInjectPages<TSchema, TDefaultError, TPlugins extends readonly SpooshPlugin<PluginTypeConfig>[]>(options: Omit<SpooshInstanceShape<unknown, TSchema, TDefaultError, TPlugins>, "_types">): <TReadFn extends (api: PagesApiClient<TSchema, TDefaultError>) => Promise<SpooshResponse<unknown, unknown>>, TRequest extends InfiniteRequestOptions = InfiniteRequestOptions, TItem = unknown>(readFn: TReadFn, readOptions: BasePagesOptions<TReadFn extends (...args: never[]) => infer R ? Extract<Awaited<R>, {
     data: unknown;
     error?: undefined;
 }> extends {
     data: infer D;
-} ? D : unknown : unknown, TItem, TRequest> & ResolveTypes<((TPlugins[number] extends infer T_3 ? T_3 extends TPlugins[number] ? T_3 extends SpooshPlugin<infer Types_1 extends PluginTypeConfig> ? Types_1 extends {
-    readOptions: infer R_3;
-} ? R_3 : object : object : never : never) extends infer T_4 ? T_4 extends (TPlugins[number] extends infer T_5 ? T_5 extends TPlugins[number] ? T_5 extends SpooshPlugin<infer Types_1 extends PluginTypeConfig> ? Types_1 extends {
-    readOptions: infer R_3;
-} ? R_3 : object : object : never : never) ? T_4 extends unknown ? (x: T_4) => void : never : never : never) extends (x: infer I) => void ? I : never, ResolverContext<TSchema, TReadFn extends (...args: never[]) => infer R ? Extract<Awaited<R>, {
+} ? D : unknown : unknown, TItem, [TReadFn extends (...args: never[]) => infer R_1 ? Extract<Awaited<R_1>, {
+    error: unknown;
+    data?: undefined;
+}> extends {
+    error: infer E;
+} ? E : unknown : unknown] extends [unknown] ? TDefaultError : TReadFn extends (...args: never[]) => infer R_1 ? Extract<Awaited<R_1>, {
+    error: unknown;
+    data?: undefined;
+}> extends {
+    error: infer E;
+} ? E : unknown : unknown, TRequest, ((TPlugins[number] extends infer T_3 ? T_3 extends TPlugins[number] ? T_3 extends SpooshPlugin<infer Types extends PluginTypeConfig> ? Types extends {
+    readResult: infer R_2;
+} ? R_2 : object : object : never : never) extends infer T_4 ? T_4 extends (TPlugins[number] extends infer T_5 ? T_5 extends TPlugins[number] ? T_5 extends SpooshPlugin<infer Types extends PluginTypeConfig> ? Types extends {
+    readResult: infer R_2;
+} ? R_2 : object : object : never : never) ? T_4 extends unknown ? (x: T_4) => void : never : never : never) extends (x: infer I) => void ? I : never> & ResolveTypes<((TPlugins[number] extends infer T_6 ? T_6 extends TPlugins[number] ? T_6 extends SpooshPlugin<infer Types_1 extends PluginTypeConfig> ? Types_1 extends {
+    pagesOptions: infer I_1;
+} ? I_1 : object : object : never : never) extends infer T_7 ? T_7 extends (TPlugins[number] extends infer T_8 ? T_8 extends TPlugins[number] ? T_8 extends SpooshPlugin<infer Types_1 extends PluginTypeConfig> ? Types_1 extends {
+    pagesOptions: infer I_1;
+} ? I_1 : object : object : never : never) ? T_7 extends unknown ? (x: T_7) => void : never : never : never) extends (x: infer I) => void ? I : never, ResolverContext<TSchema, TReadFn extends (...args: never[]) => infer R ? Extract<Awaited<R>, {
     data: unknown;
     error?: undefined;
 }> extends {
@@ -74,7 +348,7 @@ declare function createInjectInfiniteRead<TSchema, TDefaultError, TPlugins exten
     data?: undefined;
 }> extends {
     error: infer E;
-} ? E : unknown : unknown>>) => BaseInfiniteReadResult<TReadFn extends (...args: never[]) => infer R ? Extract<Awaited<R>, {
+} ? E : unknown : unknown>>) => BasePagesResult<TReadFn extends (...args: never[]) => infer R ? Extract<Awaited<R>, {
     data: unknown;
     error?: undefined;
 }> extends {
@@ -93,7 +367,7 @@ declare function createInjectInfiniteRead<TSchema, TDefaultError, TPlugins exten
     readResult: infer R_2;
 } ? R_2 : object : object : never : never) extends infer T_1 ? T_1 extends (TPlugins[number] extends infer T_2 ? T_2 extends TPlugins[number] ? T_2 extends SpooshPlugin<infer Types extends PluginTypeConfig> ? Types extends {
     readResult: infer R_2;
-} ? R_2 : object : object : never : never) ? T_1 extends unknown ? (x: T_1) => void : never : never : never) extends (x: infer I) => void ? I : never>;
+} ? R_2 : object : object : never : never) ? T_1 extends unknown ? (x: T_1) => void : never : never : never) extends (x: infer I) => void ? I : never, PagesTriggerOptions<TReadFn>>;
 
 type OptionalQueryField<TQuery> = [TQuery] extends [never] ? object : undefined extends TQuery ? {
     query?: Exclude<TQuery, undefined>;
@@ -126,67 +400,28 @@ type TriggerAwaitedReturn<T> = T extends (...args: any[]) => infer R ? Awaited<R
 type ExtractInputFromResponse$1<T> = T extends {
     input: infer I;
 } ? I : never;
-type ExtractTriggerQuery$1<I> = I extends {
+type ExtractTriggerQuery<I> = I extends {
     query: infer Q;
 } ? undefined extends Q ? {
     query?: Exclude<Q, undefined>;
 } : {
     query: Q;
 } : unknown;
-type ExtractTriggerBody$1<I> = I extends {
+type ExtractTriggerBody<I> = I extends {
     body: infer B;
 } ? undefined extends B ? {
     body?: Exclude<B, undefined> | SpooshBody<Exclude<B, undefined>>;
 } : {
     body: B | SpooshBody<B>;
 } : unknown;
-type ExtractTriggerParams$1<I> = I extends {
+type ExtractTriggerParams<I> = I extends {
     params: infer P;
 } ? {
     params: P;
 } : unknown;
-type WriteTriggerInput<T> = ExtractInputFromResponse$1<TriggerAwaitedReturn<T>> extends infer I ? [I] extends [never] ? object : ExtractTriggerQuery$1<I> & ExtractTriggerBody$1<I> & ExtractTriggerParams$1<I> : object;
+type WriteTriggerInput<T> = ExtractInputFromResponse$1<TriggerAwaitedReturn<T>> extends infer I ? [I] extends [never] ? object : ExtractTriggerQuery<I> & ExtractTriggerBody<I> & ExtractTriggerParams<I> : object;
 type WriteApiClient<TSchema, TDefaultError> = WriteSelectorClient<TSchema, TDefaultError>;
 
-type SuccessResponse<T> = Extract<T, {
-    data: unknown;
-    error?: undefined;
-}>;
-type ErrorResponse<T> = Extract<T, {
-    error: unknown;
-    data?: undefined;
-}>;
-type ExtractMethodData<T> = T extends (...args: never[]) => infer R ? SuccessResponse<Awaited<R>> extends {
-    data: infer D;
-} ? D : unknown : unknown;
-type ExtractMethodError<T> = T extends (...args: never[]) => infer R ? ErrorResponse<Awaited<R>> extends {
-    error: infer E;
-} ? E : unknown : unknown;
-type ExtractMethodOptions<T> = T extends (options?: infer O) => Promise<unknown> ? O : never;
-type AwaitedReturnType<T> = T extends (...args: never[]) => infer R ? Awaited<R> : never;
-type SuccessReturnType<T> = SuccessResponse<AwaitedReturnType<T>>;
-type ExtractResponseQuery<T> = SuccessReturnType<T> extends {
-    input: {
-        query: infer Q;
-    };
-} ? Q : never;
-type ExtractResponseBody<T> = SuccessReturnType<T> extends {
-    input: {
-        body: infer B;
-    };
-} ? B : never;
-type ExtractResponseParamNames<T> = SuccessReturnType<T> extends {
-    input: {
-        params: Record<infer K, unknown>;
-    };
-} ? K extends string ? K : never : never;
-type ExtractMethodQuery<T> = ExtractMethodOptions<T> extends {
-    query: infer Q;
-} ? Q : never;
-type ExtractMethodBody<T> = ExtractMethodOptions<T> extends {
-    body: infer B;
-} ? B : never;
-
 declare function createInjectWrite<TSchema, TDefaultError, TPlugins extends readonly SpooshPlugin<PluginTypeConfig>[]>(options: Omit<SpooshInstanceShape<unknown, TSchema, TDefaultError, TPlugins>, "_types">): <TWriteFn extends (api: WriteApiClient<TSchema, TDefaultError>) => Promise<SpooshResponse<unknown, unknown>>, TWriteOpts extends _spoosh_core.ResolveTypes<((TPlugins[number] extends infer T ? T extends TPlugins[number] ? T extends SpooshPlugin<infer Types extends PluginTypeConfig> ? Types extends {
     writeOptions: infer W;
 } ? W : object : object : never : never) extends infer T_1 ? T_1 extends (TPlugins[number] extends infer T_2 ? T_2 extends TPlugins[number] ? T_2 extends SpooshPlugin<infer Types extends PluginTypeConfig> ? Types extends {
@@ -293,24 +528,9 @@ type AwaitedReturnTypeTrigger<T> = T extends (...args: never[]) => infer R ? Awa
 type ExtractInputFromResponse<T> = T extends {
     input: infer I;
 } ? I : never;
-type ExtractTriggerQuery<I> = I extends {
-    query: infer Q;
-} ? {
-    query?: Q;
-} : unknown;
-type ExtractTriggerBody<I> = I extends {
-    body: infer B;
-} ? {
-    body?: B;
-} : unknown;
-type ExtractTriggerParams<I> = I extends {
-    params: infer P;
-} ? {
-    params?: P;
-} : unknown;
 type TriggerOptions<T> = ExtractInputFromResponse<AwaitedReturnTypeTrigger<T>> extends infer I ? [I] extends [never] ? {
     force?: boolean;
-} : ExtractTriggerQuery<I> & ExtractTriggerBody<I> & ExtractTriggerParams<I> & {
+} : ExtractTriggerQuery$2<I> & ExtractTriggerBody$2<I> & ExtractTriggerParams$2<I> & {
     /** Force refetch even if data is cached */
     force?: boolean;
 } : {
@@ -399,9 +619,10 @@ declare function createInjectRead<TSchema, TDefaultError, TPlugins extends reado
 type SpooshAngularFunctions<TDefaultError, TSchema, TPlugins extends PluginArray> = {
     injectRead: ReturnType<typeof createInjectRead<TSchema, TDefaultError, TPlugins>>;
     injectWrite: ReturnType<typeof createInjectWrite<TSchema, TDefaultError, TPlugins>>;
-    injectInfiniteRead: ReturnType<typeof createInjectInfiniteRead<TSchema, TDefaultError, TPlugins>>;
+    injectPages: ReturnType<typeof createInjectPages<TSchema, TDefaultError, TPlugins>>;
+    injectQueue: ReturnType<typeof createInjectQueue<TSchema, TDefaultError, TPlugins>>;
 } & MergePluginInstanceApi<TPlugins, TSchema>;
 
 declare function create<TSchema, TDefaultError, TPlugins extends PluginArray, TApi>(instance: SpooshInstanceShape<TApi, TSchema, TDefaultError, TPlugins>): SpooshAngularFunctions<TDefaultError, TSchema, TPlugins>;
 
-export { type AngularOptionsMap, type BaseInfiniteReadOptions, type BaseInfiniteReadResult, type BaseReadOptions, type BaseReadResult, type BaseWriteResult, type EnabledOption, type ExtractMethodBody, type ExtractMethodData, type ExtractMethodError, type ExtractMethodOptions, type ExtractMethodQuery, type ExtractResponseBody, type ExtractResponseParamNames, type ExtractResponseQuery, type InfiniteReadApiClient, type PageContext, type ReadApiClient, type ResponseInputFields, type SpooshInstanceShape, type TriggerOptions, type WriteApiClient, type WriteResponseInputFields, create };
+export { type AngularOptionsMap, type BasePagesOptions, type BasePagesResult, type BaseQueueResult, type BaseReadOptions, type BaseReadResult, type BaseWriteResult, type EnabledOption, type ExtractMethodBody, type ExtractMethodData, type ExtractMethodError, type ExtractMethodOptions, type ExtractMethodQuery, type ExtractResponseBody, type ExtractResponseParamNames, type ExtractResponseQuery, type InjectQueueOptions, type PagesApiClient, type PagesTriggerOptions, type QueueApiClient, type QueueTriggerInput, type ReadApiClient, type ResponseInputFields, type SpooshInstanceShape, type TriggerOptions, type WriteApiClient, type WriteResponseInputFields, create };