@mmstack/resource 19.2.0 → 19.3.1

package/lib/mutation-resource.d.ts

@@ -6,10 +6,10 @@ import { type QueryResourceOptions, type QueryResourceRef } from './query-resour
  * Helper type for inferring the request body type based on the HTTP method.
  */
 type NextRequest<TMethod extends HttpResourceRequest['method'], TMutation> = TMethod extends 'DELETE' | 'delete' ? Omit<HttpResourceRequest, 'body' | 'method'> & {
-    method?: TMethod;
+    method: TMethod;
 } : Omit<HttpResourceRequest, 'body' | 'method'> & {
     body: TMutation;
-    method?: TMethod;
+    method: TMethod;
 };
 /**
  * Options for configuring a `mutationResource`.
@@ -18,7 +18,7 @@ type NextRequest<TMethod extends HttpResourceRequest['method'], TMutation> = TMe
  * @typeParam TRaw - The raw response type from the HTTP request (defaults to TResult).
  * @typeParam TCTX - The type of the context value returned by `onMutate`.
  */
-export type MutationResourceOptions<TResult, TRaw = TResult, TMutation = TResult, TCTX = void, TICTX = TCTX> = Omit<QueryResourceOptions<TResult, TRaw>, 'equal' | 'onError' | 'keepPrevious' | 'refresh' | 'cache'> & {
+export type MutationResourceOptions<TResult, TRaw = TResult, TMutation = TResult, TCTX = void, TICTX = TCTX, TError = unknown> = Omit<QueryResourceOptions<TResult, TRaw>, 'equal' | 'onError' | 'keepPrevious' | 'refresh' | 'cache'> & {
     /**
      * A callback function that is called before the mutation request is made.
      * @param value The value being mutated (the `body` of the request).
@@ -31,18 +31,23 @@ export type MutationResourceOptions<TResult, TRaw = TResult, TMutation = TResult
      * @param error The error that occurred.
      * @param ctx The context value returned by the `onMutate` callback (or `undefined` if `onMutate` was not provided or returned `undefined`).
      */
-    onError?: (error: unknown, ctx: NoInfer<TCTX>) => void;
+    onError?: (error: TError, ctx: NoInfer<TCTX>) => void;
     /**
      * A callback function that is called if the mutation request succeeds.
      * @param value The result of the mutation (the parsed response body).
      * @param ctx The context value returned by the `onMutate` callback (or `undefined` if `onMutate` was not provided or returned `undefined`).
      */
-    onSuccess?: (value: NoInfer<TResult>, ctx: NoInfer<TCTX>) => void;
+    onSuccess?: (value: TResult, ctx: NoInfer<TCTX>) => void;
     /**
      * A callback function that is called when the mutation request settles (either succeeds or fails).
      * @param ctx The context value returned by the `onMutate` callback (or `undefined` if `onMutate` was not provided or returned `undefined`).
      */
     onSettled?: (ctx: NoInfer<TCTX>) => void;
+    /**
+     * Whether to queue the mutation requests and execute them in series. For example if network is unavailable or circuit breaker is open.
+     * @default false
+     */
+    queue?: boolean;
     equal?: ValueEqualityFn<TMutation>;
 };
 /**
@@ -51,22 +56,19 @@ export type MutationResourceOptions<TResult, TRaw = TResult, TMutation = TResult
  *
  * @typeParam TResult - The type of the expected result from the mutation.
  */
-export type MutationResourceRef<TResult, TMutation = TResult, TICTX = void, TMethod extends HttpResourceRequest['method'] = HttpResourceRequest['method']> = Omit<QueryResourceRef<TResult>, 'prefetch' | 'value' | 'hasValue' | 'set' | 'update'> & {
+export type MutationResourceRef<TResult, TMutation = TResult, TICTX = void> = Omit<QueryResourceRef<TResult>, 'prefetch' | 'value' | 'hasValue' | 'set' | 'update'> & {
     /**
      * Executes the mutation.
      *
-     * @param value The request body and any other request parameters to use for the mutation.  The `body` property is *required*.
+     * @param value The mutation value (usually the request body).
+     * @param ctx An optional initial context value that will be passed to the `onMutate` callback.
      */
-    mutate: (value: Omit<NextRequest<TMethod, TMutation>, 'url'> & {
-        url?: string;
-    }, ctx?: TICTX) => void;
+    mutate: (value: TMutation, ctx?: TICTX) => void;
     /**
      * A signal that holds the current mutation request, or `null` if no mutation is in progress.
      * This can be useful for tracking the state of the mutation or for displaying loading indicators.
      */
-    current: Signal<(Omit<NextRequest<TMethod, TMutation>, 'url'> & {
-        url?: string;
-    }) | null>;
+    current: Signal<TMutation | null>;
 };
 /**
  * Creates a resource for performing mutations (e.g., POST, PUT, PATCH, DELETE requests).
@@ -75,18 +77,17 @@ export type MutationResourceRef<TResult, TMutation = TResult, TICTX = void, TMet
  * managing the mutation lifecycle (pending, error, success) and provides callbacks for handling
  * these states.
  *
- * @param request A function that returns the base `HttpResourceRequest` to be made.  This
- *               function is called reactively.  Unlike `queryResource`, the `body` property
- *               of the request is provided when `mutate` is called, *not* here.  If the
- *               function returns `undefined`, the mutation is considered "disabled." All properties,
- *               except the body, can be set here.
+ * @param request A function that returns the base `HttpResourceRequest` to be made. This function is called reactively. The parameter is the mutation value provided by the `mutate` method.
  * @param options Configuration options for the mutation resource.  This includes callbacks
  *               for `onMutate`, `onError`, `onSuccess`, and `onSettled`.
  * @typeParam TResult - The type of the expected result from the mutation.
  * @typeParam TRaw - The raw response type from the HTTP request (defaults to TResult).
+ * @typeParam TMutation - The type of the mutation value (the request body).
+ * @typeParam TICTX - The type of the initial context value passed to `onMutate`.
  * @typeParam TCTX - The type of the context value returned by `onMutate`.
+ * @typeParam TMethod - The HTTP method to be used for the mutation (defaults to `HttpResourceRequest['method']`).
  * @returns A `MutationResourceRef` instance, which provides methods for triggering the mutation
  *          and observing its status.
  */
-export declare function mutationResource<TResult, TRaw = TResult, TMutation = TResult, TCTX = void, TICTX = TCTX, TMethod extends HttpResourceRequest['method'] = HttpResourceRequest['method']>(request: () => Omit<NextRequest<TMethod, TMutation>, 'body'> | undefined | void, options?: MutationResourceOptions<TResult, TRaw, TMutation, TCTX, TICTX>): MutationResourceRef<TResult, TMutation, TICTX, TMethod>;
+export declare function mutationResource<TResult, TRaw = TResult, TMutation = TResult, TCTX = void, TICTX = TCTX, TMethod extends HttpResourceRequest['method'] = HttpResourceRequest['method']>(request: (params: TMutation) => Omit<NextRequest<TMethod, TMutation>, 'body'> | undefined | void, options?: MutationResourceOptions<TResult, TRaw, TMutation, TCTX, TICTX>): MutationResourceRef<TResult, TMutation, TICTX>;
 export {};

package/lib/query-resource.d.ts

@@ -1,5 +1,5 @@
-import { type HttpResourceOptions, type HttpResourceRef, type HttpResourceRequest } from '@angular/common/http';
-import { Signal } from '@angular/core';
+import { HttpHeaders, type HttpResourceOptions, type HttpResourceRef, type HttpResourceRequest } from '@angular/common/http';
+import { Signal, WritableSignal } from '@angular/core';
 import { CircuitBreakerOptions, type RetryOptions } from './util';
 /**
  * Options for configuring caching behavior of a `queryResource`.
@@ -23,6 +23,25 @@ type ResourceCacheOptions = true | {
      * for instance, to ignore certain query parameters or to use request body for the cache key.
      */
     hash?: (req: HttpResourceRequest) => string;
+    /**
+     * Whether to bust the browser cache by appending a unique query parameter to the request URL.
+     * This is useful for ensuring that the latest data is fetched from the server, bypassing any
+     * cached responses in the browser. The unique parameter is removed before calling the cache function, so it does not affect the cache key.
+     * @default false - By default, the resource will not bust the browser cache.
+     */
+    bustBrowserCache?: boolean;
+    /**
+     * Whether to ignore the `Cache-Control` headers from the server when caching responses.
+     * If set to `true`, the resource will not respect any cache directives from the server,
+     * allowing you to control caching behavior entirely through the resource options.
+     * @default false - By default the resource will respect `Cache-Control` headers.
+     */
+    ignoreCacheControl?: boolean;
+    /**
+     * Whether to persist the cache entry in the local DB instance.
+     * @default false - By default, the cache entry is not persisted.
+     */
+    persist?: boolean;
 };
 /**
  * Options for configuring a `queryResource`.
@@ -55,11 +74,24 @@ export type QueryResourceOptions<TResult, TRaw = TResult> = HttpResourceOptions<
      * Options for enabling and configuring caching for the resource.
      */
     cache?: ResourceCacheOptions;
+    /**
+     * Trigger a request every time the request function is triggered, even if the request parameters are the same.
+     * @default false
+     */
+    triggerOnSameRequest?: boolean;
 };
 /**
  * Represents a resource created by `queryResource`. Extends `HttpResourceRef` with additional properties.
  */
-export type QueryResourceRef<TResult> = HttpResourceRef<TResult> & {
+export type QueryResourceRef<TResult> = Omit<HttpResourceRef<TResult>, 'headers' | 'statusCode'> & {
+    /**
+     * Linkedsignal of the response headers, when available.
+     */
+    readonly headers: WritableSignal<HttpHeaders | undefined>;
+    /**
+     * Linkedsignal of the response status code, when available.
+     */
+    readonly statusCode: WritableSignal<number | undefined>;
     /**
      * A signal indicating whether the resource is currently disabled (due to circuit breaker or undefined request).
      */
@@ -71,16 +103,27 @@ export type QueryResourceRef<TResult> = HttpResourceRef<TResult> & {
      * @param req - Optional partial request parameters to use for the prefetch.  This allows you
      *              to prefetch data with different parameters than the main resource request.
      */
-    prefetch: (req?: Partial<HttpResourceRequest>) => Promise<void>;
+    prefetch: (req?: Partial<HttpResourceRequest> | string) => Promise<void>;
 };
-export declare function queryResource<TResult, TRaw = TResult>(request: () => HttpResourceRequest | undefined | void, options: QueryResourceOptions<TResult, TRaw> & {
+/**
+ * Creates an HTTP resource with features like caching, retries, refresh intervals, circuit breaker, and optimistic updates. Without additional options it is equivalent to simply calling `httpResource`.
+ * This overload is for when a `defaultValue` is provided, ensuring that the resource's value is always defined.
+ * @param request A function that returns the `HttpResourceRequest` or a URL string to be made.  This function
+ *               is called reactively, so the request can change over time.  If the function
+ *              returns `undefined`, the resource is considered "disabled" and no request will be made.
+ * @param options Configuration options for the resource.  These options extend the basic
+ *               `HttpResourceOptions` and add features like `keepPrevious`, `refresh`, `retry`,
+ *                `onError`, `circuitBreaker`, and `cache`.  Additionally, when a `defaultValue` is provided, the resource's value will always be defined, even if the underlying HTTP request fails or is disabled.
+ * @returns An `QueryResourceRef` instance, which extends the basic `HttpResourceRef` with additional features.
+ */
+export declare function queryResource<TResult, TRaw = TResult>(request: () => HttpResourceRequest | string | undefined | void, options: QueryResourceOptions<TResult, TRaw> & {
     defaultValue: NoInfer<TResult>;
 }): QueryResourceRef<TResult>;
 /**
  * Creates an extended HTTP resource with features like caching, retries, refresh intervals,
  * circuit breaker, and optimistic updates. Without additional options it is equivalent to simply calling `httpResource`.
  *
- * @param request A function that returns the `HttpResourceRequest` to be made.  This function
+ * @param request A function that returns the `HttpResourceRequest` or a URL string to be made.  This function
  *                is called reactively, so the request can change over time.  If the function
  *                returns `undefined`, the resource is considered "disabled" and no request will be made.
  * @param options Configuration options for the resource.  These options extend the basic
@@ -88,5 +131,5 @@ export declare function queryResource<TResult, TRaw = TResult>(request: () => Ht
  *                `onError`, `circuitBreaker`, and `cache`.
  * @returns An `QueryResourceRef` instance, which extends the basic `HttpResourceRef` with additional features.
  */
-export declare function queryResource<TResult, TRaw = TResult>(request: () => HttpResourceRequest | undefined | void, options?: QueryResourceOptions<TResult, TRaw>): QueryResourceRef<TResult | undefined>;
+export declare function queryResource<TResult, TRaw = TResult>(request: () => HttpResourceRequest | string | undefined | void, options?: QueryResourceOptions<TResult, TRaw>): QueryResourceRef<TResult | undefined>;
 export {};

package/lib/util/cache/{cache.interceptor.d.ts → cache-interceptor.d.ts}

@@ -4,6 +4,10 @@ type CacheEntryOptions = {
     ttl?: number;
     staleTime?: number;
     cache: boolean;
+    bustBrowserCache?: boolean;
+    ignoreCacheControl?: boolean;
+    parse?: (val: unknown) => unknown;
+    persist?: boolean;
 };
 export declare function setCacheContext(ctx: HttpContext | undefined, opt: Omit<CacheEntryOptions, 'cache' | 'key'> & {
     key: Required<CacheEntryOptions>['key'];

package/lib/util/cache/cache.d.ts

@@ -1,5 +1,6 @@
-import type { HttpResponse } from '@angular/common/http';
+import { HttpResponse } from '@angular/common/http';
 import { Injector, type Provider, type Signal } from '@angular/core';
+import { CacheDB } from './persistence';
 /**
  * Options for configuring the Least Recently Used (LRU) cache cleanup strategy.
  * @internal
@@ -36,13 +37,15 @@ type OldsetCleanupType = {
  * Represents an entry in the cache.
  * @internal
  */
-type CacheEntry<T> = {
+export type CacheEntry<T> = {
     value: T;
     created: number;
+    updated: number;
     stale: number;
     useCount: number;
     expiresAt: number;
     timeout: ReturnType<typeof setTimeout>;
+    key: string;
 };
 /**
  * Defines the types of cleanup strategies available for the cache.
@@ -58,8 +61,16 @@ export type CleanupType = LRUCleanupType | OldsetCleanupType;
 export declare class Cache<T> {
     protected readonly ttl: number;
     protected readonly staleTime: number;
+    private readonly db;
     private readonly internal;
     private readonly cleanupOpt;
+    private readonly id;
+    /**
+     * Destroys the cache instance, cleaning up any resources used by the cache.
+     * This method is called automatically when the cache instance is garbage collected.
+     */
+    readonly destroy: () => void;
+    private readonly broadcast;
     /**
      * Creates a new `Cache` instance.
      *
@@ -68,8 +79,14 @@ export declare class Cache<T> {
      *                    stale but can still be used while revalidation occurs in the background. Defaults to 1 hour.
      * @param cleanupOpt - Options for configuring the cache cleanup strategy.  Defaults to LRU with a
      *                     `maxSize` of 200 and a `checkInterval` of one hour.
+     * @param syncTabs - If provided, the cache will use the options a BroadcastChannel to send updates between tabs.
+     *                   Defaults to `undefined`, meaning no synchronization across tabs.
      */
-    constructor(ttl?: number, staleTime?: number, cleanupOpt?: Partial<CleanupType>);
+    constructor(ttl?: number, staleTime?: number, cleanupOpt?: Partial<CleanupType>, syncTabs?: {
+        id: string;
+        serialize: (value: T) => string;
+        deserialize: (value: string) => T | null;
+    }, db?: Promise<CacheDB<T>>);
     /** @internal */
     private getInternal;
     /**
@@ -92,6 +109,16 @@ export declare class Cache<T> {
     get(key: () => string | null): Signal<(CacheEntry<T> & {
         isStale: boolean;
     }) | null>;
+    /**
+     * Retrieves a cache entry or an object with the key if not found.
+     *
+     * @param key - A function that returns the cache key. The key is a signal, allowing for dynamic keys. If the function returns null the value is also null.
+     * @returns  A signal that holds the cache entry or an object with the key if not found. The signal
+     *          updates whenever the cache entry changes (e.g., due to revalidation or expiration).
+     */
+    getEntryOrKey(key: () => string | null): Signal<(CacheEntry<T> & {
+        isStale: boolean;
+    }) | string | null>;
     /**
      * Stores a value in the cache.
      *
@@ -100,13 +127,15 @@ export declare class Cache<T> {
      * @param staleTime - (Optional) The stale time for this entry, in milliseconds. Overrides the default `staleTime`.
      * @param ttl - (Optional) The TTL for this entry, in milliseconds. Overrides the default `ttl`.
      */
-    store(key: string, value: T, staleTime?: number, ttl?: number): void;
+    store(key: string, value: T, staleTime?: number, ttl?: number, persist?: boolean): void;
+    private storeInternal;
     /**
      * Invalidates (removes) a cache entry.
      *
      * @param key - The key of the entry to invalidate.
      */
     invalidate(key: string): void;
+    private invalidateInternal;
     /** @internal */
     private cleanup;
 }
@@ -127,6 +156,23 @@ type CacheOptions = {
      * Options for configuring the cache cleanup strategy.
      */
     cleanup?: Partial<CleanupType>;
+    /**
+     * Whether to synchronize cache across tabs. If true, the cache will use a BroadcastChannel to send updates between tabs.
+     */
+    syncTabs?: boolean;
+    /**
+     * Globally disable persistence of cache entries.
+     * If set to `false`, cache entries will not be persisted to the database.
+     * `true` means, cache entries can be persisted, they must still be opted into on the resource level & allowed by server headers.
+     * @default true
+     */
+    persist?: boolean;
+    /**
+     * Version of the caches database, increment this if the interfaces change, this will cause the old data to be deleted.
+     * Minimum value is 1, so first increment should be 2.
+     * @default 1
+     */
+    version?: number;
 };
 /**
  * Provides the instance of the QueryCache for queryResource. This should probably be called
@@ -173,5 +219,5 @@ export declare function provideQueryCache(opt?: CacheOptions): Provider;
  *   }
  * }
  */
-export declare function injectQueryCache(injector?: Injector): Cache<HttpResponse<unknown>>;
+export declare function injectQueryCache<TRaw = unknown>(injector?: Injector): Cache<HttpResponse<TRaw>>;
 export {};

package/lib/util/cache/index.d.ts

@@ -1,2 +1,2 @@
 export { Cache, injectQueryCache, provideQueryCache } from './cache';
-export * from './cache.interceptor';
+export * from './cache-interceptor';

package/lib/util/cache/persistence.d.ts

@@ -0,0 +1,10 @@
+import { CacheEntry } from './cache';
+type StoredEntry<T> = Omit<CacheEntry<T>, 'timeout'>;
+export type CacheDB<T> = {
+    getAll: () => Promise<StoredEntry<T>[]>;
+    store: (value: StoredEntry<T>) => Promise<void>;
+    remove: (key: string) => Promise<void>;
+};
+export declare function createNoopDB<T>(): CacheDB<T>;
+export declare function createSingleStoreDB<T>(name: string, getStoreName: (version: number) => string, version?: number): Promise<CacheDB<T>>;
+export {};

package/lib/util/cache/public_api.d.ts

@@ -1,2 +1,2 @@
 export { Cache, injectQueryCache, provideQueryCache } from './cache';
-export { createCacheInterceptor } from './cache.interceptor';
+export { createCacheInterceptor } from './cache-interceptor';

package/lib/util/catch-value-error.d.ts

@@ -0,0 +1,2 @@
+import { HttpResourceRef } from '@angular/common/http';
+export declare function catchValueError<T>(resource: HttpResourceRef<T>, fallback: T): HttpResourceRef<T>;

package/lib/util/circuit-breaker.d.ts

@@ -1,4 +1,4 @@
-import { Signal } from '@angular/core';
+import { Injector, Provider, Signal } from '@angular/core';
 /**
  * Represents the possible states of a circuit breaker.
  * - `CLOSED`: The circuit breaker is closed, and operations are allowed to proceed.
@@ -14,6 +14,12 @@ export type CircuitBreaker = {
      * A signal indicating whether the circuit breaker is currently closed (allowing operations).
      */
     isClosed: Signal<boolean>;
+    /**
+     *  A signal indicating whether the circuit breaker is either open or in a half-open state.
+     * This is useful for checking if operations are blocked.
+     * If the circuit breaker is open, operations should not proceed.
+     */
+    isOpen: Signal<boolean>;
     /**
      * A signal representing the current state of the circuit breaker.
      */
@@ -21,7 +27,7 @@ export type CircuitBreaker = {
     /**
      * Signals a failure to the circuit breaker.  This may cause the circuit breaker to open.
      */
-    fail: () => void;
+    fail: (err?: Error) => void;
     /**
      * Signals a success to the circuit breaker.  This may cause the circuit breaker to close.
      */
@@ -36,6 +42,31 @@ export type CircuitBreaker = {
      */
     destroy: () => void;
 };
+/**
+ * Options for creating a circuit breaker.
+ */
+type CreateCircuitBreakerOptions = {
+    /**
+     * The number of failures that will cause the circuit breaker to open.
+     * @default 5
+     */
+    treshold?: number;
+    /**
+     * The time in milliseconds after which the circuit breaker will reset and allow operations to proceed again.
+     * @default 30000 (30 seconds)
+     */
+    timeout?: number;
+    /**
+     * A function that determines whether an error should cause the circuit breaker to increment the failure count.
+     * @default Always returns true
+     */
+    shouldFail?: (err?: Error) => boolean;
+    /**
+     * A function that determines whether an error should cause the circuit breaker to be open forever.
+     * @default Always returns false
+     */
+    shouldFailForever?: (err?: Error) => boolean;
+};
 /**
  * Options for creating a circuit breaker.
  *  - `false`: Disables circuit breaker functionality (always open).
@@ -43,10 +74,8 @@ export type CircuitBreaker = {
  *  - `CircuitBreaker`: Provides an existing `CircuitBreaker` instance to use.
  *  - `{ treshold?: number; timeout?: number; }`: Creates a new circuit breaker with the specified options.
  */
-export type CircuitBreakerOptions = false | CircuitBreaker | {
-    treshold?: number;
-    timeout?: number;
-};
+export type CircuitBreakerOptions = false | CircuitBreaker | CreateCircuitBreakerOptions;
+export declare function provideCircuitBreakerDefaultOptions(options: CircuitBreakerOptions): Provider;
 /**
  * Creates a circuit breaker instance.
  *
@@ -70,5 +99,5 @@ export type CircuitBreakerOptions = false | CircuitBreaker | {
  * const resource1 = queryResource(..., { circuitBreaker: sharedBreaker });
  * const resource2 = mutationResource(..., { circuitBreaker: sharedBreaker });
  */
-export declare function createCircuitBreaker(opt?: CircuitBreakerOptions): CircuitBreaker;
+export declare function createCircuitBreaker(opt?: CircuitBreakerOptions, injector?: Injector): CircuitBreaker;
 export {};

package/lib/util/index.d.ts

@@ -1,9 +1,12 @@
 export * from './cache';
+export * from './catch-value-error';
 export * from './circuit-breaker';
-export * from './dedupe.interceptor';
+export * from './dedupe-interceptor';
 export * from './equality';
 export * from './has-slow-connection';
 export * from './persist';
 export * from './refresh';
 export * from './retry-on-error';
+export * from './sensors';
+export * from './to-resource-object';
 export * from './url-with-params';

package/lib/util/persist.d.ts

@@ -1,3 +1,3 @@
 import { type HttpResourceRef } from '@angular/common/http';
 import { type ValueEqualityFn } from '@angular/core';
-export declare function persistResourceValues<T>(resource: HttpResourceRef<T>, persist?: boolean, equal?: ValueEqualityFn<T>): HttpResourceRef<T>;
+export declare function persistResourceValues<T>(resource: HttpResourceRef<T>, shouldPersist?: boolean, equal?: ValueEqualityFn<T>): HttpResourceRef<T>;

package/lib/util/public_api.d.ts

@@ -1,3 +1,3 @@
 export * from './cache/public_api';
-export { createCircuitBreaker } from './circuit-breaker';
-export { createDedupeRequestsInterceptor, noDedupe, } from './dedupe.interceptor';
+export { createCircuitBreaker, provideCircuitBreakerDefaultOptions, } from './circuit-breaker';
+export { createDedupeRequestsInterceptor, noDedupe, } from './dedupe-interceptor';

package/lib/util/sensors.d.ts

@@ -0,0 +1,7 @@
+import * as i0 from "@angular/core";
+export declare class ResourceSensors {
+    readonly networkStatus: import("@mmstack/primitives").NetworkStatusSignal;
+    static ɵfac: i0.ɵɵFactoryDeclaration<ResourceSensors, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<ResourceSensors>;
+}
+export declare function injectNetworkStatus(): import("@mmstack/primitives").NetworkStatusSignal;

package/lib/util/to-resource-object.d.ts

@@ -0,0 +1,2 @@
+import { HttpResourceRef } from '@angular/common/http';
+export declare function toResourceObject<T>(res: HttpResourceRef<T>): HttpResourceRef<T>;

package/lib/util/url-with-params.d.ts

@@ -1,2 +1,2 @@
-import { HttpResourceRequest } from '@angular/common/http';
+import { type HttpResourceRequest } from '@angular/common/http';
 export declare function urlWithParams(req: HttpResourceRequest): string;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@mmstack/resource",
-  "version": "19.2.0",
+  "version": "19.3.1",
   "keywords": [
     "angular",
     "signals",
@@ -17,14 +17,12 @@
   },
   "homepage": "https://github.com/mihajm/mmstack/blob/master/packages/resource",
   "dependencies": {
-    "uuid": "~11.1.0",
-    "@mmstack/primitives": "^19.2.1",
-    "@mmstack/object": "^19.2.0",
+    "@mmstack/primitives": "^19.3.0",
     "tslib": "^2.3.0"
   },
   "peerDependencies": {
-    "@angular/common": "~19.2.3",
-    "@angular/core": "~19.2.3",
+    "@angular/common": ">=19 <20",
+    "@angular/core": ">=19 <20",
     "rxjs": "~7.8.2"
   },
   "sideEffects": false,

package/lib/public_api.d.ts

@@ -1,3 +0,0 @@
-export * from './mutation-resource';
-export * from './query-resource';
-export * from './util/public_api';