@mmstack/resource 20.2.11 → 20.3.0

package/fesm2022/mmstack-resource.mjs

@@ -4,8 +4,6 @@ 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, sensor } from '@mmstack/primitives';
-import { v7 } from 'uuid';
-import { keys, hash, entries } from '@mmstack/object';
 
 function createNoopDB() {
     return {
@@ -94,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 &&
@@ -118,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.
@@ -927,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;
@@ -993,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) => {
@@ -1018,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) => {
@@ -1029,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;
@@ -1211,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(','));
         }