react-native-nitro-storage 0.1.0 → 0.1.2

package/README.md

@@ -35,7 +35,11 @@ Familiar, elegant API with `createStorageItem` and `useStorage`. Works inside an
 
 ### **Production-Ready**
 
-Thread-safe C++ core, comprehensive test coverage, and battle-tested on iOS and Android.
+Thread-safe C++ core, comprehensive test coverage, and battle-tested on iOS, Android, and **Web**.
+
+### **Web Support**
+
+Fully functional on the web via `localStorage` and `sessionStorage`. All hooks and storage atoms are fully reactive across all platforms.
 
 ---
 
@@ -139,17 +143,25 @@ const value = counterAtom.get(); // 42, instantly
 
 _Replaces: Zustand, Jotai, Redux_
 
-Fast, in-memory state. Perfect for global app state that doesn't need persistence.
+Fast, in-memory state. **Now Pure JS** - can store complex objects, functions, and React nodes!
 
 ```typescript
-const userAtom = createStorageItem<User | null>({
-  key: "current-user",
+// Store a function
+const callbackAtom = createStorageItem({
+  key: "on-click",
   scope: StorageScope.Memory,
-  defaultValue: null,
+  defaultValue: () => console.log("Clicked!"),
+});
+
+// Store a React Component
+const modalAtom = createStorageItem({
+  key: "active-modal",
+  scope: StorageScope.Memory,
+  defaultValue: <View />,
 });
 ```
 
-**Performance:** < 0.001ms per operation
+**Performance:** < 0.001ms per operation (Zero JSI overhead)
 
 ### **Disk Storage**
 
@@ -299,6 +311,78 @@ const unsubscribe = counterAtom.subscribe(() => {
 unsubscribe();
 ```
 
+### Batch Operations
+
+Read or write multiple items at once. This is highly optimized on the native side for minimum overhead.
+
+```typescript
+import { getBatch, setBatch, removeBatch } from "react-native-nitro-storage";
+
+// Write multiple items
+setBatch(
+  [
+    { item: item1, value: "v1" },
+    { item: item2, value: "v2" },
+  ],
+  StorageScope.Disk
+);
+
+// Read multiple items
+const [v1, v2] = getBatch([item1, item2], StorageScope.Disk);
+
+// Remove multiple items
+removeBatch([item1, item2], StorageScope.Disk);
+```
+
+### Functional Updates
+
+Update state based on the previous value, just like `useState`.
+
+```typescript
+// Increment counter
+counterAtom.set((prev) => prev + 1);
+```
+
+### Optimized Writes
+
+Use `useSetStorage` to set values without subscribing to updates (avoids re-renders).
+
+```typescript
+import { useSetStorage } from "react-native-nitro-storage";
+
+function IncrementButton() {
+  const setCount = useSetStorage(counterAtom);
+  return <Button onPress={() => setCount((c) => c + 1)} title="+" />;
+}
+```
+
+### Clearing Data
+
+Clear entire storage scopes at once.
+
+```typescript
+import { storage } from "react-native-nitro-storage";
+
+// Clear all storage (all scopes)
+storage.clearAll();
+
+// Clear specific scope
+storage.clear(StorageScope.Memory);
+storage.clear(StorageScope.Disk);
+storage.clear(StorageScope.Secure);
+```
+
+### Migration from MMKV
+
+Easily migrate data from `react-native-mmkv` to Nitro Storage.
+
+```typescript
+import { migrateFromMMKV } from "react-native-nitro-storage/src/migration";
+
+// Migrate 'user-settings' and delete from MMKV
+migrateFromMMKV(mmkvInstance, settingsAtom, true);
+```
+
 ---
 
 ## 📊 Performance Benchmarks
@@ -344,7 +428,7 @@ Creates a storage atom.
 **Methods:**
 
 - `get(): T` - Get current value (synchronous)
-- `set(value: T): void` - Set new value (synchronous)
+- `set(value: T | ((prev: T) => T)): void` - Set new value (synchronous)
 - `delete(): void` - Remove value (synchronous)
 - `subscribe(callback: () => void): () => void` - Subscribe to changes
 
@@ -352,7 +436,24 @@ Creates a storage atom.
 
 React hook using `useSyncExternalStore` for automatic re-renders.
 
-**Returns:** `[value: T, setValue: (value: T) => void]`
+**Returns:** `[value: T, setValue: (value: T | ((prev: T) => T)) => void]`
+
+### `useSetStorage<T>(item: StorageItem<T>)`
+
+Returns the setter function only. Does not subscribe to updates.
+
+**Returns:** `(value: T | ((prev: T) => T)) => void`
+
+### `storage` Object
+
+- `clearAll()`: Clears all storage across all scopes.
+- `clear(scope)`: Clears a specific storage scope.
+
+### Batch Operations
+
+- `getBatch(items, scope)`: Returns an array of values for the given items.
+- `setBatch(items, scope)`: Sets multiple values at once.
+- `removeBatch(items, scope)`: Removes multiple items at once.
 
 ---
 
@@ -420,27 +521,13 @@ Built on [Nitro Modules](https://nitro.margelo.com) for maximum performance:
 | Type-Safe        | ✅            | ⚠️   | ⚠️           | ✅      | ⚠️                |
 | Unified API      | ✅            | ❌   | ❌           | ❌      | ❌                |
 | React Hooks      | ✅            | ❌   | ❌           | ✅      | ❌                |
+| Web Support      | ✅            | ❌   | ✅           | ✅      | ❌                |
 
 ---
 
 ## 📄 License
 
-MIT © [Your Name]
-
----
-
-## 🙏 Acknowledgments
-
-Built with ❤️ using [Nitro Modules](https://nitro.margelo.com) by [Marc Rousavy](https://github.com/mrousavy)
-
----
-
-## 📚 Learn More
-
-- [Nitro Modules Documentation](https://nitro.margelo.com)
-- [Example App](./apps/example)
-- [API Reference](#-api-reference)
-- [Performance Benchmarks](#-performance-benchmarks)
+MIT
 
 ---
 

package/android/CMakeLists.txt

@@ -1,33 +1,39 @@
-cmake_minimum_required(VERSION 3.22.1)
+cmake_minimum_required(VERSION 3.18.0)
+
 project(NitroStorage)
 
+set(CMAKE_VERBOSE_MAKEFILE ON)
 set(CMAKE_CXX_STANDARD 20)
-set(CMAKE_CXX_STANDARD_REQUIRED ON)
-set(CMAKE_C_STANDARD 11)
-set(CMAKE_C_STANDARD_REQUIRED ON)
-
-# Define the path to our C++ sources
-set(CPP_ROOT "${CMAKE_CURRENT_SOURCE_DIR}/../cpp")
 
-# Collect source files
-file(GLOB CORE_SOURCES "${CPP_ROOT}/core/*.cpp")
-file(GLOB BINDING_SOURCES "${CPP_ROOT}/bindings/*.cpp")
+# 1. Define source files (Manual implementation)
+file(GLOB SOURCES
+  "../cpp/bindings/*.cpp"
+  "../cpp/core/*.cpp"
+  "./src/main/cpp/*.cpp"
+)
 
-# Create the shared library with our sources
-add_library(${PROJECT_NAME} SHARED
-    ${CORE_SOURCES}
-    ${BINDING_SOURCES}
-    # JNI adapter
-    src/main/cpp/cpp-adapter.cpp
-    src/main/cpp/AndroidStorageAdapterCpp.cpp
+# 2. Create the library target
+add_library(
+  NitroStorage
+  SHARED
+  ${SOURCES}
 )
 
-# Include directories
-target_include_directories(${PROJECT_NAME} PRIVATE
-    "${CPP_ROOT}/core"
-    "${CPP_ROOT}/bindings"
-    "src/main/cpp"
+# 3. Include directories for manual sources
+target_include_directories(
+  NitroStorage
+  PRIVATE
+  "../cpp/core"
+  "../cpp/bindings"
+  "./src/main/cpp"
 )
 
-# Include Nitro autolinking (adds nitrogen sources, definitions, and links)
-include(${CMAKE_CURRENT_SOURCE_DIR}/../nitrogen/generated/android/NitroStorage+autolinking.cmake)
+# 4. Include Nitrogen Autolinking (adds generated sources, finding packages, linking libs)
+include("../nitrogen/generated/android/NitroStorage+autolinking.cmake")
+
+# 5. Link standard Android libraries
+target_link_libraries(
+  NitroStorage
+  android
+  log
+)

package/android/src/main/cpp/AndroidStorageAdapterCpp.cpp

@@ -46,4 +46,14 @@ void AndroidStorageAdapterCpp::deleteSecure(const std::string& key) {
     method(AndroidStorageAdapterJava::javaClassStatic(), key);
 }
 
+void AndroidStorageAdapterCpp::clearDisk() {
+    static auto method = AndroidStorageAdapterJava::javaClassStatic()->getStaticMethod<void()>("clearDisk");
+    method(AndroidStorageAdapterJava::javaClassStatic());
+}
+
+void AndroidStorageAdapterCpp::clearSecure() {
+    static auto method = AndroidStorageAdapterJava::javaClassStatic()->getStaticMethod<void()>("clearSecure");
+    method(AndroidStorageAdapterJava::javaClassStatic());
+}
+
 } // namespace NitroStorage

package/android/src/main/cpp/AndroidStorageAdapterCpp.hpp

@@ -49,6 +49,16 @@ struct AndroidStorageAdapterJava : facebook::jni::JavaClass<AndroidStorageAdapte
       static auto method = javaClassStatic()->getMethod<void(std::string)>("deleteSecure");
       method(self(), key);
   }
+
+  void clearDisk() {
+      static auto method = javaClassStatic()->getStaticMethod<void()>("clearDisk");
+      method(javaClassStatic());
+  }
+
+  void clearSecure() {
+      static auto method = javaClassStatic()->getStaticMethod<void()>("clearSecure");
+      method(javaClassStatic());
+  }
 };
 
 class AndroidStorageAdapterCpp : public NativeStorageAdapter {
@@ -63,6 +73,9 @@ public:
     void setSecure(const std::string& key, const std::string& value) override;
     std::optional<std::string> getSecure(const std::string& key) override;
     void deleteSecure(const std::string& key) override;
+    
+    void clearDisk() override;
+    void clearSecure() override;
 };
 
 } // namespace NitroStorage

package/android/src/main/cpp/cpp-adapter.cpp

@@ -1,6 +1,7 @@
 #include <jni.h>
-#include "NitroStorageOnLoad.hpp"
+#include <fbjni/fbjni.h>
+#include "../../../nitrogen/generated/android/NitroStorageOnLoad.hpp"
 
-JNIEXPORT jint JNICALL JNI_OnLoad(JavaVM* vm, void* reserved) {
+JNIEXPORT jint JNICALL JNI_OnLoad(JavaVM* vm, void*) {
   return margelo::nitro::NitroStorage::initialize(vm);
 }

package/android/src/main/java/com/nitrostorage/AndroidStorageAdapter.kt

@@ -90,5 +90,15 @@ class AndroidStorageAdapter private constructor(private val context: Context) {
         fun deleteSecure(key: String) {
             instance?.encryptedPreferences?.edit()?.remove(key)?.apply()
         }
+
+        @JvmStatic
+        fun clearDisk() {
+            instance?.sharedPreferences?.edit()?.clear()?.apply()
+        }
+
+        @JvmStatic
+        fun clearSecure() {
+            instance?.encryptedPreferences?.edit()?.clear()?.apply()
+        }
     }
 }

package/cpp/bindings/HybridStorage.cpp

@@ -24,14 +24,7 @@ HybridStorage::HybridStorage(std::shared_ptr<::NitroStorage::NativeStorageAdapte
     : HybridObject(TAG), HybridStorageSpec(), nativeAdapter_(std::move(adapter)) {}
 
 HybridStorage::Scope HybridStorage::toScope(double scopeValue) {
-    int intScope = static_cast<int>(scopeValue);
-    if (intScope < 0 || intScope > 2) {
-        throw std::invalid_argument(
-            "Invalid storage scope: " + std::to_string(intScope) + 
-            ". Must be 0 (Memory), 1 (Disk), or 2 (Secure)"
-        );
-    }
-    return static_cast<Scope>(intScope);
+    return static_cast<Scope>(static_cast<int>(scopeValue));
 }
 
 void HybridStorage::set(const std::string& key, const std::string& value, double scope) {
@@ -100,8 +93,8 @@ std::function<void()> HybridStorage::addOnChange(
     const std::function<void(const std::string&, const std::optional<std::string>&)>& callback
 ) {
     int intScope = static_cast<int>(scope);
-    
     size_t listenerId;
+
     {
         std::lock_guard<std::mutex> lock(listenersMutex_);
         listenerId = nextListenerId_++;
@@ -111,17 +104,65 @@ std::function<void()> HybridStorage::addOnChange(
     return [this, intScope, listenerId]() {
         std::lock_guard<std::mutex> lock(listenersMutex_);
         auto& scopeListeners = listeners_[intScope];
-        scopeListeners.erase(
-            std::remove_if(
-                scopeListeners.begin(),
-                scopeListeners.end(),
-                [listenerId](const Listener& l) { return l.id == listenerId; }
-            ),
-            scopeListeners.end()
-        );
+        for (auto it = scopeListeners.begin(); it != scopeListeners.end(); ++it) {
+            if (it->id == listenerId) {
+                scopeListeners.erase(it);
+                break;
+            }
+        }
     };
 }
 
+void HybridStorage::clear(double scope) {
+    Scope s = toScope(scope);
+    
+    switch (s) {
+        case Scope::Memory: {
+            std::lock_guard<std::mutex> lock(memoryMutex_);
+            memoryStore_.clear();
+            break;
+        }
+        case Scope::Disk:
+            nativeAdapter_->clearDisk();
+            break;
+        case Scope::Secure:
+            nativeAdapter_->clearSecure();
+            break;
+    }
+    
+    notifyListeners(static_cast<int>(s), "", std::nullopt);
+}
+
+void HybridStorage::setBatch(const std::vector<std::string>& keys, const std::vector<std::string>& values, double scope) {
+    if (keys.size() != values.size()) {
+        throw std::runtime_error("NitroStorage: Keys and values size mismatch in setBatch");
+    }
+    
+    for (size_t i = 0; i < keys.size(); ++i) {
+        set(keys[i], values[i], scope);
+    }
+}
+
+
+std::vector<std::string> HybridStorage::getBatch(const std::vector<std::string>& keys, double scope) {
+    std::vector<std::string> results;
+    results.reserve(keys.size());
+    
+    for (const auto& key : keys) {
+        auto val = get(key, scope);
+        results.push_back(val.value_or(""));
+    }
+    
+    return results;
+}
+
+
+void HybridStorage::removeBatch(const std::vector<std::string>& keys, double scope) {
+    for (const auto& key : keys) {
+        remove(key, scope);
+    }
+}
+
 void HybridStorage::notifyListeners(
     int scope,
     const std::string& key,
@@ -132,6 +173,7 @@ void HybridStorage::notifyListeners(
         std::lock_guard<std::mutex> lock(listenersMutex_);
         auto it = listeners_.find(scope);
         if (it != listeners_.end()) {
+            listenersCopy.reserve(it->second.size());
             listenersCopy = it->second;
         }
     }

package/cpp/bindings/HybridStorage.hpp

@@ -19,6 +19,10 @@ public:
     void set(const std::string& key, const std::string& value, double scope) override;
     std::optional<std::string> get(const std::string& key, double scope) override;
     void remove(const std::string& key, double scope) override;
+    void clear(double scope) override;
+    void setBatch(const std::vector<std::string>& keys, const std::vector<std::string>& values, double scope) override;
+    std::vector<std::string> getBatch(const std::vector<std::string>& keys, double scope) override;
+    void removeBatch(const std::vector<std::string>& keys, double scope) override;
     std::function<void()> addOnChange(
         double scope,
         const std::function<void(const std::string&, const std::optional<std::string>&)>& callback

package/cpp/core/NativeStorageAdapter.hpp

@@ -16,6 +16,9 @@ public:
     virtual void setSecure(const std::string& key, const std::string& value) = 0;
     virtual std::optional<std::string> getSecure(const std::string& key) = 0;
     virtual void deleteSecure(const std::string& key) = 0;
+    
+    virtual void clearDisk() = 0;
+    virtual void clearSecure() = 0;
 };
 
 } // namespace NitroStorage

package/ios/IOSStorageAdapterCpp.hpp

@@ -16,6 +16,9 @@ public:
     void setSecure(const std::string& key, const std::string& value) override;
     std::optional<std::string> getSecure(const std::string& key) override;
     void deleteSecure(const std::string& key) override;
+    
+    void clearDisk() override;
+    void clearSecure() override;
 };
 
 } // namespace NitroStorage

package/ios/IOSStorageAdapterCpp.mm

@@ -4,124 +4,88 @@
 
 namespace NitroStorage {
 
-IOSStorageAdapterCpp::IOSStorageAdapterCpp() {}
+static NSString* const kKeychainService = @"com.nitrostorage.keychain";
 
+IOSStorageAdapterCpp::IOSStorageAdapterCpp() {}
 IOSStorageAdapterCpp::~IOSStorageAdapterCpp() {}
 
 void IOSStorageAdapterCpp::setDisk(const std::string& key, const std::string& value) {
-    NSString* nsKey = [NSString stringWithUTF8String:key.c_str()];
-    NSString* nsValue = [NSString stringWithUTF8String:value.c_str()];
-    [[NSUserDefaults standardUserDefaults] setObject:nsValue forKey:nsKey];
+    [[NSUserDefaults standardUserDefaults] setObject:[NSString stringWithUTF8String:value.c_str()]
+                                              forKey:[NSString stringWithUTF8String:key.c_str()]];
 }
 
 std::optional<std::string> IOSStorageAdapterCpp::getDisk(const std::string& key) {
-    NSString* nsKey = [NSString stringWithUTF8String:key.c_str()];
-    NSString* result = [[NSUserDefaults standardUserDefaults] stringForKey:nsKey];
-    
-    if (result) {
-        const char* utf8String = [result UTF8String];
-        if (utf8String) {
-            std::string value;
-            value.reserve([result lengthOfBytesUsingEncoding:NSUTF8StringEncoding]);
-            value.assign(utf8String);
-            return value;
-        }
-    }
-    return std::nullopt;
+    NSString* result = [[NSUserDefaults standardUserDefaults] stringForKey:[NSString stringWithUTF8String:key.c_str()]];
+    if (!result) return std::nullopt;
+    return std::string([result UTF8String]);
 }
 
 void IOSStorageAdapterCpp::deleteDisk(const std::string& key) {
-    NSString* nsKey = [NSString stringWithUTF8String:key.c_str()];
-    [[NSUserDefaults standardUserDefaults] removeObjectForKey:nsKey];
+    [[NSUserDefaults standardUserDefaults] removeObjectForKey:[NSString stringWithUTF8String:key.c_str()]];
 }
 
 void IOSStorageAdapterCpp::setSecure(const std::string& key, const std::string& value) {
     NSString* nsKey = [NSString stringWithUTF8String:key.c_str()];
-    NSString* nsValue = [NSString stringWithUTF8String:value.c_str()];
-    NSData* data = [nsValue dataUsingEncoding:NSUTF8StringEncoding];
-    
-    NSString* service = @"com.nitrostorage.keychain";
-    
+    NSData* data = [[NSString stringWithUTF8String:value.c_str()] dataUsingEncoding:NSUTF8StringEncoding];
+
     NSDictionary* query = @{
         (__bridge id)kSecClass: (__bridge id)kSecClassGenericPassword,
-        (__bridge id)kSecAttrService: service,
+        (__bridge id)kSecAttrService: kKeychainService,
         (__bridge id)kSecAttrAccount: nsKey
     };
-    
+
     NSDictionary* updateAttributes = @{
         (__bridge id)kSecValueData: data
     };
+
+    OSStatus status = SecItemUpdate((__bridge CFDictionaryRef)query, (__bridge CFDictionaryRef)updateAttributes);
     
-    // Try to update first (atomic operation)
-    OSStatus updateStatus = SecItemUpdate((__bridge CFDictionaryRef)query, (__bridge CFDictionaryRef)updateAttributes);
-    
-    if (updateStatus == errSecItemNotFound) {
-        // Item doesn't exist, add it
-        NSDictionary* addQuery = @{
-            (__bridge id)kSecClass: (__bridge id)kSecClassGenericPassword,
-            (__bridge id)kSecAttrService: service,
-            (__bridge id)kSecAttrAccount: nsKey,
-            (__bridge id)kSecValueData: data,
-            (__bridge id)kSecAttrAccessible: (__bridge id)kSecAttrAccessibleWhenUnlocked
-        };
-        
-        OSStatus addStatus = SecItemAdd((__bridge CFDictionaryRef)addQuery, NULL);
-        if (addStatus != errSecSuccess) {
-            NSLog(@"NitroStorage: Failed to add to Keychain for key '%@'. Error: %d", nsKey, (int)addStatus);
-        }
-    } else if (updateStatus != errSecSuccess) {
-        NSLog(@"NitroStorage: Failed to update Keychain item '%@'. Error: %d", nsKey, (int)updateStatus);
+    if (status == errSecItemNotFound) {
+        NSMutableDictionary* addQuery = [query mutableCopy];
+        addQuery[(__bridge id)kSecValueData] = data;
+        addQuery[(__bridge id)kSecAttrAccessible] = (__bridge id)kSecAttrAccessibleWhenUnlocked;
+        SecItemAdd((__bridge CFDictionaryRef)addQuery, NULL);
     }
 }
 
 std::optional<std::string> IOSStorageAdapterCpp::getSecure(const std::string& key) {
-    NSString* nsKey = [NSString stringWithUTF8String:key.c_str()];
-    NSString* service = @"com.nitrostorage.keychain";
-    
     NSDictionary* query = @{
         (__bridge id)kSecClass: (__bridge id)kSecClassGenericPassword,
-        (__bridge id)kSecAttrService: service,
-        (__bridge id)kSecAttrAccount: nsKey,
+        (__bridge id)kSecAttrService: kKeychainService,
+        (__bridge id)kSecAttrAccount: [NSString stringWithUTF8String:key.c_str()],
         (__bridge id)kSecReturnData: @YES,
         (__bridge id)kSecMatchLimit: (__bridge id)kSecMatchLimitOne
     };
-    
+
     CFTypeRef result = NULL;
-    OSStatus status = SecItemCopyMatching((__bridge CFDictionaryRef)query, &result);
-    
-    if (status == errSecSuccess && result) {
+    if (SecItemCopyMatching((__bridge CFDictionaryRef)query, &result) == errSecSuccess && result) {
         NSData* data = (__bridge_transfer NSData*)result;
-        NSString* nsValue = [[NSString alloc] initWithData:data encoding:NSUTF8StringEncoding];
-        if (nsValue) {
-            const char* utf8String = [nsValue UTF8String];
-            if (utf8String) {
-                std::string value;
-                value.reserve([nsValue lengthOfBytesUsingEncoding:NSUTF8StringEncoding]);
-                value.assign(utf8String);
-                return value;
-            }
-        }
-    } else if (status != errSecItemNotFound) {
-        NSLog(@"NitroStorage: Failed to read from Keychain for key '%@'. Error: %d", nsKey, (int)status);
+        NSString* str = [[NSString alloc] initWithData:data encoding:NSUTF8StringEncoding];
+        if (str) return std::string([str UTF8String]);
     }
-    
     return std::nullopt;
 }
 
 void IOSStorageAdapterCpp::deleteSecure(const std::string& key) {
-    NSString* nsKey = [NSString stringWithUTF8String:key.c_str()];
-    NSString* service = @"com.nitrostorage.keychain";
-    
     NSDictionary* query = @{
         (__bridge id)kSecClass: (__bridge id)kSecClassGenericPassword,
-        (__bridge id)kSecAttrService: service,
-        (__bridge id)kSecAttrAccount: nsKey
+        (__bridge id)kSecAttrService: kKeychainService,
+        (__bridge id)kSecAttrAccount: [NSString stringWithUTF8String:key.c_str()]
     };
-    
-    OSStatus status = SecItemDelete((__bridge CFDictionaryRef)query);
-    if (status != errSecSuccess && status != errSecItemNotFound) {
-        NSLog(@"NitroStorage: Failed to delete from Keychain for key '%@'. Error: %d", nsKey, (int)status);
-    }
+    SecItemDelete((__bridge CFDictionaryRef)query);
+}
+
+void IOSStorageAdapterCpp::clearDisk() {
+    NSString* appDomain = [[NSBundle mainBundle] bundleIdentifier];
+    [[NSUserDefaults standardUserDefaults] removePersistentDomainForName:appDomain];
+}
+
+void IOSStorageAdapterCpp::clearSecure() {
+    NSDictionary* query = @{
+        (__bridge id)kSecClass: (__bridge id)kSecClassGenericPassword,
+        (__bridge id)kSecAttrService: kKeychainService
+    };
+    SecItemDelete((__bridge CFDictionaryRef)query);
 }
 
 } // namespace NitroStorage

package/lib/commonjs/Storage.nitro.js

@@ -3,11 +3,4 @@
 Object.defineProperty(exports, "__esModule", {
   value: true
 });
-exports.StorageScope = void 0;
-let StorageScope = exports.StorageScope = /*#__PURE__*/function (StorageScope) {
-  StorageScope[StorageScope["Memory"] = 0] = "Memory";
-  StorageScope[StorageScope["Disk"] = 1] = "Disk";
-  StorageScope[StorageScope["Secure"] = 2] = "Secure";
-  return StorageScope;
-}({});
 //# sourceMappingURL=Storage.nitro.js.map

package/lib/commonjs/Storage.nitro.js.map

@@ -1 +1 @@
-{"version":3,"names":["StorageScope","exports"],"sourceRoot":"../../src","sources":["Storage.nitro.ts"],"mappings":";;;;;;IAEYA,YAAY,GAAAC,OAAA,CAAAD,YAAA,0BAAZA,YAAY;EAAZA,YAAY,CAAZA,YAAY;EAAZA,YAAY,CAAZA,YAAY;EAAZA,YAAY,CAAZA,YAAY;EAAA,OAAZA,YAAY;AAAA","ignoreList":[]}
+{"version":3,"names":[],"sourceRoot":"../../src","sources":["Storage.nitro.ts"],"mappings":"","ignoreList":[]}

package/lib/commonjs/Storage.types.js

@@ -0,0 +1,13 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.StorageScope = void 0;
+let StorageScope = exports.StorageScope = /*#__PURE__*/function (StorageScope) {
+  StorageScope[StorageScope["Memory"] = 0] = "Memory";
+  StorageScope[StorageScope["Disk"] = 1] = "Disk";
+  StorageScope[StorageScope["Secure"] = 2] = "Secure";
+  return StorageScope;
+}({});
+//# sourceMappingURL=Storage.types.js.map

package/lib/commonjs/Storage.types.js.map

@@ -0,0 +1 @@
+{"version":3,"names":["StorageScope","exports"],"sourceRoot":"../../src","sources":["Storage.types.ts"],"mappings":";;;;;;IAAYA,YAAY,GAAAC,OAAA,CAAAD,YAAA,0BAAZA,YAAY;EAAZA,YAAY,CAAZA,YAAY;EAAZA,YAAY,CAAZA,YAAY;EAAZA,YAAY,CAAZA,YAAY;EAAA,OAAZA,YAAY;AAAA","ignoreList":[]}