@mmstack/resource 20.2.10 → 20.3.0

package/fesm2022/mmstack-resource.mjs

@@ -1,10 +1,9 @@
-import { isDevMode, untracked, computed, InjectionToken, inject, signal, effect, Injector, linkedSignal, DestroyRef } from '@angular/core';
+import * as i0 from '@angular/core';
+import { isDevMode, untracked, computed, InjectionToken, inject, signal, effect, Injector, linkedSignal, Injectable, DestroyRef } from '@angular/core';
 import { takeUntilDestroyed, toObservable } from '@angular/core/rxjs-interop';
 import { of, tap, map, finalize, shareReplay, interval, firstValueFrom, catchError, combineLatestWith, filter } from 'rxjs';
 import { HttpHeaders, HttpResponse, HttpContextToken, HttpContext, HttpParams, httpResource, HttpClient } from '@angular/common/http';
-import { mutable, toWritable } from '@mmstack/primitives';
-import { v7 } from 'uuid';
-import { keys, hash, entries } from '@mmstack/object';
+import { mutable, toWritable, sensor } from '@mmstack/primitives';
 
 function createNoopDB() {
     return {
@@ -93,6 +92,12 @@ function createSingleStoreDB(name, getStoreName, version = 1) {
     });
 }
 
+function generateID() {
+    if (globalThis.crypto?.randomUUID) {
+        return globalThis.crypto.randomUUID();
+    }
+    return Math.random().toString(36).substring(2);
+}
 function isSyncMessage(msg) {
     return (typeof msg === 'object' &&
         msg !== null &&
@@ -117,7 +122,7 @@ class Cache {
     db;
     internal = mutable(new Map());
     cleanupOpt;
-    id = v7();
+    id = generateID();
     /**
      * Destroys the cache instance, cleaning up any resources used by the cache.
      * This method is called automatically when the cache instance is garbage collected.
@@ -926,6 +931,77 @@ function createDedupeRequestsInterceptor(allowed = ['GET', 'DELETE', 'HEAD', 'OP
     };
 }
 
+/**
+ * Checks if `value` is a plain JavaScript object (e.g., `{}` or `new Object()`).
+ * Distinguishes from arrays, null, and class instances. Acts as a type predicate,
+ * narrowing `value` to `UnknownObject` if `true`.
+ *
+ * @param value The value to check.
+ * @returns {value is UnknownObject} `true` if `value` is a plain object, otherwise `false`.
+ * @example
+ * isPlainObject({}) // => true
+ * isPlainObject([]) // => false
+ * isPlainObject(null) // => false
+ * isPlainObject(new Date()) // => false
+ */
+function isPlainObject(value) {
+    return (typeof value === 'object' && value !== null && value.constructor === Object);
+}
+/**
+ * Internal helper to generate a stable JSON string from an array.
+ * Sorts keys of plain objects within the array alphabetically before serialization
+ * to ensure hash stability regardless of key order.
+ *
+ * @param queryKey The array of values to serialize.
+ * @returns A stable JSON string representation.
+ * @internal
+ */
+function hashKey(queryKey) {
+    return JSON.stringify(queryKey, (_, val) => isPlainObject(val)
+        ? Object.keys(val)
+            .toSorted()
+            .reduce((result, key) => {
+            result[key] = val[key];
+            return result;
+        }, {})
+        : val);
+}
+/**
+ * Generates a stable, unique string hash from one or more arguments.
+ * Useful for creating cache keys or identifiers where object key order shouldn't matter.
+ *
+ * How it works:
+ * - Plain objects within the arguments have their keys sorted alphabetically before hashing.
+ * This ensures that `{ a: 1, b: 2 }` and `{ b: 2, a: 1 }` produce the same hash.
+ * - Uses `JSON.stringify` internally with custom sorting for plain objects via `hashKey`.
+ * - Non-plain objects (arrays, Dates, etc.) and primitives are serialized naturally.
+ *
+ * @param {...unknown} args Values to include in the hash.
+ * @returns A stable string hash representing the input arguments.
+ * @example
+ * const userQuery = (id: number) => ['user', { id, timestamp: Date.now() }];
+ *
+ * const obj1 = { a: 1, b: 2 };
+ * const obj2 = { b: 2, a: 1 }; // Same keys/values, different order
+ *
+ * hash('posts', 10);
+ * // => '["posts",10]'
+ *
+ * hash('config', obj1);
+ * // => '["config",{"a":1,"b":2}]'
+ *
+ * hash('config', obj2);
+ * // => '["config",{"a":1,"b":2}]' (Same as above due to key sorting)
+ *
+ * hash(['todos', { status: 'done', owner: obj1 }]);
+ * // => '[["todos",{"owner":{"a":1,"b":2},"status":"done"}]]'
+ *
+ * // Be mindful of values JSON.stringify cannot handle (functions, undefined, Symbols)
+ * // hash('a', undefined, function() {}) => '["a",null,null]'
+ */
+function hash(...args) {
+    return hashKey(args);
+}
 function equalTransferCache(a, b) {
     if (!a && !b)
         return true;
@@ -992,8 +1068,8 @@ function equalParams(a, b) {
         return false;
     const aObj = a instanceof HttpParams ? paramToObject(a) : a;
     const bObj = b instanceof HttpParams ? paramToObject(b) : b;
-    const aKeys = keys(aObj);
-    const bKeys = keys(bObj);
+    const aKeys = Object.keys(aObj);
+    const bKeys = Object.keys(bObj);
     if (aKeys.length !== bKeys.length)
         return false;
     return aKeys.every((key) => {
@@ -1017,8 +1093,8 @@ function equalHeaders(a, b) {
         return false;
     const aObj = a instanceof HttpHeaders ? headersToObject(a) : a;
     const bObj = b instanceof HttpHeaders ? headersToObject(b) : b;
-    const aKeys = keys(aObj);
-    const bKeys = keys(bObj);
+    const aKeys = Object.keys(aObj);
+    const bKeys = Object.keys(bObj);
     if (aKeys.length !== bKeys.length)
         return false;
     return aKeys.every((key) => {
@@ -1028,16 +1104,31 @@ function equalHeaders(a, b) {
         return aObj[key] === bObj[key];
     });
 }
+function toHttpContextEntries(ctx) {
+    if (!ctx)
+        return [];
+    if (ctx instanceof HttpContext) {
+        const tokens = Array.from(ctx.keys());
+        return tokens.map((key) => [key.toString(), ctx.get(key)]);
+    }
+    if (typeof ctx === 'object') {
+        return Object.entries(ctx);
+    }
+    return [];
+}
 function equalContext(a, b) {
     if (!a && !b)
         return true;
     if (!a || !b)
         return false;
-    const aKeys = keys(a);
-    const bKeys = keys(b);
-    if (aKeys.length !== bKeys.length)
+    const aEntries = toHttpContextEntries(a);
+    const bEntries = toHttpContextEntries(b);
+    if (aEntries.length !== bEntries.length)
         return false;
-    return aKeys.every((key) => a[key] === b[key]);
+    if (aEntries.length === 0)
+        return true;
+    const bMap = new Map(bEntries);
+    return aEntries.every(([key, value]) => value === bMap.get(key));
 }
 function createEqualRequest(equalResult) {
     const eqb = equalResult ?? equalBody;
@@ -1173,6 +1264,21 @@ function retryOnError(res, opt) {
     };
 }
 
+class ResourceSensors {
+    networkStatus = sensor('networkStatus');
+    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "20.1.0", ngImport: i0, type: ResourceSensors, deps: [], target: i0.ɵɵFactoryTarget.Injectable });
+    static ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "20.1.0", ngImport: i0, type: ResourceSensors, providedIn: 'root' });
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "20.1.0", ngImport: i0, type: ResourceSensors, decorators: [{
+            type: Injectable,
+            args: [{
+                    providedIn: 'root',
+                }]
+        }] });
+function injectNetworkStatus() {
+    return inject(ResourceSensors).networkStatus;
+}
+
 function toResourceObject(res) {
     return {
         asReadonly: () => res.asReadonly(),
@@ -1195,7 +1301,7 @@ function normalizeParams(params) {
     if (params instanceof HttpParams)
         return params.toString();
     const paramMap = new Map();
-    for (const [key, value] of entries(params)) {
+    for (const [key, value] of Object.entries(params)) {
         if (Array.isArray(value)) {
             paramMap.set(key, value.map(encodeURIComponent).join(','));
         }
@@ -1222,16 +1328,24 @@ function queryResource(request, options) {
     const cb = createCircuitBreaker(options?.circuitBreaker === true
         ? undefined
         : (options?.circuitBreaker ?? false), options?.injector);
+    const networkAvailable = injectNetworkStatus();
+    const eq = options?.triggerOnSameRequest
+        ? undefined
+        : createEqualRequest(options?.equal);
     const stableRequest = computed(() => {
-        if (cb.isOpen())
+        if (!networkAvailable() || cb.isOpen())
             return undefined;
         return request() ?? undefined;
-    }, ...(ngDevMode ? [{ debugName: "stableRequest", equal: options?.triggerOnSameRequest
-                ? undefined
-                : createEqualRequest(options?.equal) }] : [{
-            equal: options?.triggerOnSameRequest
-                ? undefined
-                : createEqualRequest(options?.equal),
+    }, ...(ngDevMode ? [{ debugName: "stableRequest", equal: (a, b) => {
+                if (eq)
+                    return eq(a, b);
+                return a === b;
+            } }] : [{
+            equal: (a, b) => {
+                if (eq)
+                    return eq(a, b);
+                return a === b;
+            },
         }]));
     const hashFn = typeof options?.cache === 'object'
         ? (options.cache.hash ?? urlWithParams)
@@ -1301,6 +1415,7 @@ function queryResource(request, options) {
     resource = persistResourceValues(resource, options?.keepPrevious, options?.equal);
     const value = options?.cache
         ? toWritable(computed(() => {
+            resource.value();
             return cacheEntry()?.value ?? resource.value();
         }), resource.value.set, resource.value.update)
         : resource.value;
@@ -1447,6 +1562,17 @@ function mutationResource(request, options = {}) {
                 return eq(a, b);
             },
         }]));
+    const queue = signal([], ...(ngDevMode ? [{ debugName: "queue" }] : []));
+    let ctx = undefined;
+    const queueRef = effect(() => {
+        const nextInQueue = queue().at(0);
+        if (!nextInQueue || next() !== null)
+            return;
+        queue.update((q) => q.slice(1));
+        const [value, ictx] = nextInQueue;
+        ctx = onMutate?.(value, ictx);
+        next.set(value);
+    }, ...(ngDevMode ? [{ debugName: "queueRef" }] : []));
     const req = computed(() => {
         const nr = next();
         if (!nr)
@@ -1479,7 +1605,6 @@ function mutationResource(request, options = {}) {
         circuitBreaker: cb,
         defaultValue: null, // doesnt matter since .value is not accessible
     });
-    let ctx = undefined;
     const destroyRef = options.injector
         ? options.injector.get(DestroyRef)
         : inject(DestroyRef);
@@ -1510,15 +1635,22 @@ function mutationResource(request, options = {}) {
         ctx = undefined;
         next.set(null);
     });
+    const shouldQueue = options.queue ?? false;
     return {
         ...resource,
         destroy: () => {
             statusSub.unsubscribe();
             resource.destroy();
+            queueRef.destroy();
         },
         mutate: (value, ictx) => {
-            ctx = onMutate?.(value, ictx);
-            next.set(value);
+            if (shouldQueue) {
+                return queue.update((q) => [...q, [value, ictx]]);
+            }
+            else {
+                ctx = onMutate?.(value, ictx);
+                next.set(value);
+            }
         },
         current: next,
         // redeclare disabled with last value so that it is not affected by the resource's internal disablement logic