react-native-nitro-storage 0.5.0 → 0.5.1

package/lib/commonjs/index.web.js

@@ -76,6 +76,7 @@ var _Storage = require("./Storage.types");
 var _internal = require("./internal");
 var _webStorageBackend = require("./web-storage-backend");
 var _storageRuntime = require("./storage-runtime");
+var _storageEvents = require("./storage-events");
 var _migration = require("./migration");
 var _storageHooks = require("./storage-hooks");
 var _indexeddbBackend = require("./indexeddb-backend");
@@ -110,7 +111,9 @@ const BIOMETRIC_WEB_PREFIX = "__bio_";
 let hasWarnedAboutWebBiometricFallback = false;
 let hasWindowStorageEventSubscription = false;
 let metricsObserver;
+let eventObserver;
 const metricsCounters = new Map();
+const storageEvents = new _storageEvents.StorageEventRegistry();
 function recordMetric(operation, scope, durationMs, keysCount = 1) {
   const existing = metricsCounters.get(operation);
   if (!existing) {
@@ -235,6 +238,7 @@ function applyExternalChangeEvent(scope, key, newValue) {
   }
   if (scope === _Storage.StorageScope.Secure && key.startsWith(SECURE_WEB_PREFIX)) {
     const plainKey = fromSecureStorageKey(key);
+    const oldValue = readCachedRawValue(_Storage.StorageScope.Secure, plainKey);
     if (newValue === null) {
       ensureWebScopeKeyIndex(_Storage.StorageScope.Secure).delete(plainKey);
       cacheRawValue(_Storage.StorageScope.Secure, plainKey, undefined);
@@ -243,10 +247,12 @@ function applyExternalChangeEvent(scope, key, newValue) {
       cacheRawValue(_Storage.StorageScope.Secure, plainKey, newValue);
     }
     notifyKeyListeners(getScopedListeners(_Storage.StorageScope.Secure), plainKey);
+    emitKeyChange(_Storage.StorageScope.Secure, plainKey, oldValue, newValue ?? undefined, "external", "external");
     return;
   }
   if (scope === _Storage.StorageScope.Secure && key.startsWith(BIOMETRIC_WEB_PREFIX)) {
     const plainKey = fromBiometricStorageKey(key);
+    const oldValue = readCachedRawValue(_Storage.StorageScope.Secure, plainKey);
     if (newValue === null) {
       if (withWebBackendOperation(_Storage.StorageScope.Secure, "external-sync:getItem", backend => backend.getItem(toSecureStorageKey(plainKey))) === null) {
         ensureWebScopeKeyIndex(_Storage.StorageScope.Secure).delete(plainKey);
@@ -257,8 +263,10 @@ function applyExternalChangeEvent(scope, key, newValue) {
       cacheRawValue(_Storage.StorageScope.Secure, plainKey, newValue);
     }
     notifyKeyListeners(getScopedListeners(_Storage.StorageScope.Secure), plainKey);
+    emitKeyChange(_Storage.StorageScope.Secure, plainKey, oldValue, newValue ?? undefined, "external", "external");
     return;
   }
+  const oldValue = readCachedRawValue(scope, key);
   if (newValue === null) {
     ensureWebScopeKeyIndex(scope).delete(key);
     cacheRawValue(scope, key, undefined);
@@ -267,6 +275,7 @@ function applyExternalChangeEvent(scope, key, newValue) {
     cacheRawValue(scope, key, newValue);
   }
   notifyKeyListeners(getScopedListeners(scope), key);
+  emitKeyChange(scope, key, oldValue, newValue ?? undefined, "external", "external");
 }
 function handleWebStorageEvent(event) {
   const key = event.key;
@@ -357,6 +366,46 @@ function addKeyListener(registry, key, listener) {
     }
   };
 }
+function getEventRawValue(scope, key) {
+  if (scope === _Storage.StorageScope.Memory) {
+    const value = memoryStore.get(key);
+    return typeof value === "string" ? value : undefined;
+  }
+  return getRawValue(key, scope);
+}
+function createKeyChange(scope, key, oldValue, newValue, operation, source) {
+  return {
+    type: "key",
+    scope,
+    key,
+    oldValue,
+    newValue,
+    operation,
+    source
+  };
+}
+function hasStorageChangeObservers(scope) {
+  return storageEvents.hasListeners(scope) || eventObserver !== undefined;
+}
+function emitKeyChange(scope, key, oldValue, newValue, operation, source) {
+  const event = createKeyChange(scope, key, oldValue, newValue, operation, source);
+  storageEvents.emitKey(event);
+  eventObserver?.(event);
+}
+function emitBatchChange(scope, operation, source, changes) {
+  if (changes.length === 0) {
+    return;
+  }
+  const event = {
+    type: "batch",
+    scope,
+    operation,
+    source,
+    changes
+  };
+  storageEvents.emitBatch(event);
+  eventObserver?.(event);
+}
 function readPendingSecureWrite(key) {
   return pendingSecureWrites.get(key)?.value;
 }
@@ -606,13 +655,10 @@ const WebStorage = {
     return () => {};
   },
   has: (key, scope) => {
-    if (scope === _Storage.StorageScope.Secure) {
-      return withWebBackendOperation(scope, "has", backend => backend.getItem(toSecureStorageKey(key))) !== null || withWebBackendOperation(scope, "has", backend => backend.getItem(toBiometricStorageKey(key))) !== null;
-    }
-    if (scope !== _Storage.StorageScope.Disk) {
-      return false;
+    if (scope === _Storage.StorageScope.Disk || scope === _Storage.StorageScope.Secure) {
+      return ensureWebScopeKeyIndex(scope).has(key);
     }
-    return withWebBackendOperation(scope, "has", backend => backend.getItem(key)) !== null;
+    return false;
   },
   getAllKeys: scope => {
     if (scope !== _Storage.StorageScope.Disk && scope !== _Storage.StorageScope.Secure) {
@@ -703,15 +749,18 @@ function getRawValue(key, scope) {
 }
 function setRawValue(key, value, scope) {
   (0, _internal.assertValidScope)(scope);
+  const oldValue = scope === _Storage.StorageScope.Memory ? getEventRawValue(scope, key) : undefined;
   if (scope === _Storage.StorageScope.Memory) {
     memoryStore.set(key, value);
     notifyKeyListeners(memoryListeners, key);
+    emitKeyChange(scope, key, oldValue, value, "set", "memory");
     return;
   }
   if (scope === _Storage.StorageScope.Disk) {
     cacheRawValue(scope, key, value);
     if (diskWritesAsync) {
       scheduleDiskWrite(key, value);
+      emitKeyChange(scope, key, oldValue, value, "set", "web");
       return;
     }
     flushDiskWrites();
@@ -723,18 +772,22 @@ function setRawValue(key, value, scope) {
   }
   WebStorage.set(key, value, scope);
   cacheRawValue(scope, key, value);
+  emitKeyChange(scope, key, oldValue, value, "set", "web");
 }
 function removeRawValue(key, scope) {
   (0, _internal.assertValidScope)(scope);
+  const oldValue = getEventRawValue(scope, key);
   if (scope === _Storage.StorageScope.Memory) {
     memoryStore.delete(key);
     notifyKeyListeners(memoryListeners, key);
+    emitKeyChange(scope, key, oldValue, undefined, "remove", "memory");
     return;
   }
   if (scope === _Storage.StorageScope.Disk) {
     cacheRawValue(scope, key, undefined);
     if (diskWritesAsync) {
       scheduleDiskWrite(key, undefined);
+      emitKeyChange(scope, key, oldValue, undefined, "remove", "web");
       return;
     }
     flushDiskWrites();
@@ -746,6 +799,7 @@ function removeRawValue(key, scope) {
   }
   WebStorage.remove(key, scope);
   cacheRawValue(scope, key, undefined);
+  emitKeyChange(scope, key, oldValue, undefined, "remove", "web");
 }
 function readMigrationVersion(scope) {
   const raw = getRawValue(_internal.MIGRATION_VERSION_KEY, scope);
@@ -759,11 +813,43 @@ function writeMigrationVersion(scope, version) {
   setRawValue(_internal.MIGRATION_VERSION_KEY, String(version), scope);
 }
 const storage = exports.storage = {
+  subscribe: (scope, listener) => {
+    (0, _internal.assertValidScope)(scope);
+    if (scope !== _Storage.StorageScope.Memory) {
+      ensureExternalSyncSubscriptions();
+    }
+    return storageEvents.subscribe(scope, listener);
+  },
+  subscribeKey: (scope, key, listener) => {
+    (0, _internal.assertValidScope)(scope);
+    if (scope !== _Storage.StorageScope.Memory) {
+      ensureExternalSyncSubscriptions();
+    }
+    return storageEvents.subscribeKey(scope, key, listener);
+  },
+  subscribePrefix: (scope, prefix, listener) => {
+    (0, _internal.assertValidScope)(scope);
+    if (scope !== _Storage.StorageScope.Memory) {
+      ensureExternalSyncSubscriptions();
+    }
+    return storageEvents.subscribePrefix(scope, prefix, listener);
+  },
+  subscribeNamespace: (namespace, scope, listener) => {
+    return storage.subscribePrefix(scope, (0, _internal.prefixKey)(namespace, ""), listener);
+  },
+  setEventObserver: observer => {
+    eventObserver = observer;
+    if (observer) {
+      ensureExternalSyncSubscriptions();
+    }
+  },
   clear: scope => {
     measureOperation("storage:clear", scope, () => {
+      const previousValues = hasStorageChangeObservers(scope) ? storage.getAll(scope) : {};
       if (scope === _Storage.StorageScope.Memory) {
         memoryStore.clear();
         notifyAllListeners(memoryListeners);
+        emitBatchChange(scope, "clear", "memory", Object.keys(previousValues).map(key => createKeyChange(scope, key, previousValues[key], undefined, "clear", "memory")));
         return;
       }
       if (scope === _Storage.StorageScope.Disk) {
@@ -776,6 +862,7 @@ const storage = exports.storage = {
       }
       clearScopeRawCache(scope);
       WebStorage.clear(scope);
+      emitBatchChange(scope, "clear", "web", Object.keys(previousValues).map(key => createKeyChange(scope, key, previousValues[key], undefined, "clear", "web")));
     });
   },
   clearAll: () => {
@@ -789,15 +876,26 @@ const storage = exports.storage = {
     measureOperation("storage:clearNamespace", scope, () => {
       (0, _internal.assertValidScope)(scope);
       if (scope === _Storage.StorageScope.Memory) {
-        for (const key of memoryStore.keys()) {
-          if ((0, _internal.isNamespaced)(key, namespace)) {
-            memoryStore.delete(key);
-          }
+        const affectedKeys = Array.from(memoryStore.keys()).filter(key => (0, _internal.isNamespaced)(key, namespace));
+        const previousValues = affectedKeys.map(key => ({
+          key,
+          value: getEventRawValue(scope, key)
+        }));
+        if (affectedKeys.length === 0) {
+          return;
         }
-        notifyAllListeners(memoryListeners);
+        affectedKeys.forEach(key => {
+          memoryStore.delete(key);
+        });
+        affectedKeys.forEach(key => notifyKeyListeners(memoryListeners, key));
+        emitBatchChange(scope, "clearNamespace", "memory", previousValues.map(({
+          key,
+          value
+        }) => createKeyChange(scope, key, value, undefined, "clearNamespace", "memory")));
         return;
       }
       const keyPrefix = (0, _internal.prefixKey)(namespace, "");
+      const previousValues = hasStorageChangeObservers(scope) ? storage.getByPrefix(keyPrefix, scope) : {};
       if (scope === _Storage.StorageScope.Disk) {
         flushDiskWrites();
       }
@@ -811,6 +909,7 @@ const storage = exports.storage = {
         }
       }
       WebStorage.removeByPrefix(keyPrefix, scope);
+      emitBatchChange(scope, "clearNamespace", "web", Object.keys(previousValues).map(key => createKeyChange(scope, key, previousValues[key], undefined, "clearNamespace", "web")));
     });
   },
   clearBiometric: () => {
@@ -919,6 +1018,9 @@ const storage = exports.storage = {
       return result;
     });
   },
+  export: scope => {
+    return measureOperation("storage:export", scope, () => storage.getAll(scope));
+  },
   size: scope => {
     return measureOperation("storage:size", scope, () => {
       (0, _internal.assertValidScope)(scope);
@@ -1062,11 +1164,13 @@ const storage = exports.storage = {
       (0, _internal.assertValidScope)(scope);
       if (keys.length === 0) return;
       const values = keys.map(k => data[k]);
+      const changes = keys.map((key, index) => createKeyChange(scope, key, getEventRawValue(scope, key), values[index], "import", scope === _Storage.StorageScope.Memory ? "memory" : "web"));
       if (scope === _Storage.StorageScope.Memory) {
         keys.forEach((key, index) => {
           memoryStore.set(key, values[index]);
         });
         keys.forEach(key => notifyKeyListeners(memoryListeners, key));
+        emitBatchChange(scope, "import", "memory", changes);
         return;
       }
       if (scope === _Storage.StorageScope.Secure) {
@@ -1078,6 +1182,7 @@ const storage = exports.storage = {
       }
       WebStorage.setBatch(keys, values, scope);
       keys.forEach((key, index) => cacheRawValue(scope, key, values[index]));
+      emitBatchChange(scope, "import", "web", changes);
     }, keys.length);
   }
 };
@@ -1219,56 +1324,68 @@ function createStorageItem(config) {
     return raw;
   };
   const writeStoredRaw = rawValue => {
+    const oldValue = config.scope === _Storage.StorageScope.Memory ? getEventRawValue(config.scope, storageKey) : undefined;
     if (isBiometric) {
       WebStorage.setSecureBiometricWithLevel(storageKey, rawValue, resolvedBiometricLevel);
+      emitKeyChange(config.scope, storageKey, oldValue, rawValue, "set", "web");
       return;
     }
     cacheRawValue(nonMemoryScope, storageKey, rawValue);
     if (nonMemoryScope === _Storage.StorageScope.Disk) {
       if (coalesceDiskWrites || diskWritesAsync) {
         scheduleDiskWrite(storageKey, rawValue);
+        emitKeyChange(config.scope, storageKey, oldValue, rawValue, "set", "web");
         return;
       }
       clearPendingDiskWrite(storageKey);
     }
     if (coalesceSecureWrites) {
       scheduleSecureWrite(storageKey, rawValue, secureAccessControl ?? secureDefaultAccessControl);
+      emitKeyChange(config.scope, storageKey, oldValue, rawValue, "set", "web");
       return;
     }
     if (nonMemoryScope === _Storage.StorageScope.Secure) {
       clearPendingSecureWrite(storageKey);
     }
     WebStorage.set(storageKey, rawValue, config.scope);
+    emitKeyChange(config.scope, storageKey, oldValue, rawValue, "set", "web");
   };
   const removeStoredRaw = () => {
+    const oldValue = getEventRawValue(config.scope, storageKey);
     if (isBiometric) {
       WebStorage.deleteSecureBiometric(storageKey);
+      emitKeyChange(config.scope, storageKey, oldValue, undefined, "remove", "web");
       return;
     }
     cacheRawValue(nonMemoryScope, storageKey, undefined);
     if (nonMemoryScope === _Storage.StorageScope.Disk) {
       if (coalesceDiskWrites || diskWritesAsync) {
         scheduleDiskWrite(storageKey, undefined);
+        emitKeyChange(config.scope, storageKey, oldValue, undefined, "remove", "web");
         return;
       }
       clearPendingDiskWrite(storageKey);
     }
     if (coalesceSecureWrites) {
       scheduleSecureWrite(storageKey, undefined, secureAccessControl ?? secureDefaultAccessControl);
+      emitKeyChange(config.scope, storageKey, oldValue, undefined, "remove", "web");
       return;
     }
     if (nonMemoryScope === _Storage.StorageScope.Secure) {
       clearPendingSecureWrite(storageKey);
     }
     WebStorage.remove(storageKey, config.scope);
+    emitKeyChange(config.scope, storageKey, oldValue, undefined, "remove", "web");
   };
   const writeValueWithoutValidation = value => {
     if (isMemory) {
+      const oldValue = getEventRawValue(config.scope, storageKey);
       if (memoryExpiration) {
         memoryExpiration.set(storageKey, Date.now() + (expirationTtlMs ?? 0));
       }
       memoryStore.set(storageKey, value);
       notifyKeyListeners(memoryListeners, storageKey);
+      emitKeyChange(config.scope, storageKey, oldValue, typeof value === "string" ? value : undefined, "set", "memory");
       return;
     }
     const serialized = serialize(value);
@@ -1400,11 +1517,13 @@ function createStorageItem(config) {
     measureOperation("item:delete", config.scope, () => {
       invalidateParsedCache();
       if (isMemory) {
+        const oldValue = getEventRawValue(config.scope, storageKey);
         if (memoryExpiration) {
           memoryExpiration.delete(storageKey);
         }
         memoryStore.delete(storageKey);
         notifyKeyListeners(memoryListeners, storageKey);
+        emitKeyChange(config.scope, storageKey, oldValue, undefined, "remove", "memory");
         return;
       }
       removeStoredRaw();
@@ -1438,6 +1557,22 @@ function createStorageItem(config) {
       }
     };
   };
+  const subscribeSelector = (selector, listener, options = {}) => {
+    const isEqual = options.isEqual ?? Object.is;
+    let currentValue = selector(getInternal());
+    if (options.fireImmediately === true) {
+      listener(currentValue, currentValue);
+    }
+    return subscribe(() => {
+      const nextValue = selector(getInternal());
+      if (isEqual(currentValue, nextValue)) {
+        return;
+      }
+      const previousValue = currentValue;
+      currentValue = nextValue;
+      listener(nextValue, previousValue);
+    });
+  };
   const storageItem = {
     get,
     getWithVersion,
@@ -1446,6 +1581,7 @@ function createStorageItem(config) {
     delete: deleteItem,
     has: hasItem,
     subscribe,
+    subscribeSelector,
     serialize,
     deserialize,
     _triggerListeners: () => {
@@ -1546,6 +1682,10 @@ function setBatch(items, scope) {
         }) => item.set(value));
         return;
       }
+      const changes = items.map(({
+        item,
+        value
+      }) => createKeyChange(scope, item.key, getEventRawValue(scope, item.key), typeof value === "string" ? value : undefined, "setBatch", "memory"));
 
       // Atomic write: update all values in memoryStore, invalidate caches, then batch-notify
       items.forEach(({
@@ -1558,6 +1698,7 @@ function setBatch(items, scope) {
       items.forEach(({
         item
       }) => notifyKeyListeners(memoryListeners, item.key));
+      emitBatchChange(scope, "setBatch", "memory", changes);
       return;
     }
     if (scope === _Storage.StorageScope.Secure) {
@@ -1580,6 +1721,10 @@ function setBatch(items, scope) {
         return;
       }
       flushSecureWrites();
+      const keys = secureEntries.map(({
+        item
+      }) => item.key);
+      const oldValues = hasStorageChangeObservers(scope) ? WebStorage.getBatch(keys, scope) : [];
       const groupedByAccessControl = new Map();
       secureEntries.forEach(({
         item,
@@ -1603,6 +1748,10 @@ function setBatch(items, scope) {
         WebStorage.setBatch(group.keys, group.values, scope);
         group.keys.forEach((key, index) => cacheRawValue(scope, key, group.values[index]));
       });
+      emitBatchChange(scope, "setBatch", "web", secureEntries.map(({
+        item,
+        value
+      }, index) => createKeyChange(scope, item.key, oldValues[index], item.serialize(value), "setBatch", "web")));
       return;
     }
     flushDiskWrites();
@@ -1618,15 +1767,19 @@ function setBatch(items, scope) {
     }
     const keys = items.map(entry => entry.item.key);
     const values = items.map(entry => entry.item.serialize(entry.value));
+    const oldValues = hasStorageChangeObservers(scope) ? WebStorage.getBatch(keys, scope) : [];
     WebStorage.setBatch(keys, values, scope);
     keys.forEach((key, index) => cacheRawValue(scope, key, values[index]));
+    emitBatchChange(scope, "setBatch", "web", keys.map((key, index) => createKeyChange(scope, key, oldValues[index], values[index], "setBatch", "web")));
   }, items.length);
 }
 function removeBatch(items, scope) {
   measureOperation("batch:remove", scope, () => {
     (0, _internal.assertBatchScope)(items, scope);
     if (scope === _Storage.StorageScope.Memory) {
+      const changes = items.map(item => createKeyChange(scope, item.key, getEventRawValue(scope, item.key), undefined, "removeBatch", "memory"));
       items.forEach(item => item.delete());
+      emitBatchChange(scope, "removeBatch", "memory", changes);
       return;
     }
     const keys = items.map(item => item.key);
@@ -1636,8 +1789,10 @@ function removeBatch(items, scope) {
     if (scope === _Storage.StorageScope.Secure) {
       flushSecureWrites();
     }
+    const oldValues = hasStorageChangeObservers(scope) ? WebStorage.getBatch(keys, scope) : [];
     WebStorage.removeBatch(keys, scope);
     keys.forEach(key => cacheRawValue(scope, key, undefined));
+    emitBatchChange(scope, "removeBatch", "web", keys.map((key, index) => createKeyChange(scope, key, oldValues[index], undefined, "removeBatch", "web")));
   }, items.length);
 }
 function registerMigration(version, migration) {