react-native-nitro-storage 0.1.0

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

@@ -0,0 +1,68 @@
+#pragma once
+
+#include "NativeStorageAdapter.hpp"
+#include <fbjni/fbjni.h>
+#include <jni.h>
+
+namespace NitroStorage {
+
+struct JContext : facebook::jni::JavaClass<JContext> {
+  static constexpr auto kJavaDescriptor = "Landroid/content/Context;";
+};
+
+struct AndroidStorageAdapterJava : facebook::jni::JavaClass<AndroidStorageAdapterJava> {
+  static constexpr auto kJavaDescriptor = "Lcom/nitrostorage/AndroidStorageAdapter;";
+  
+  static facebook::jni::alias_ref<facebook::jni::JObject> getContext() {
+     static auto method = javaClassStatic()->getStaticMethod<facebook::jni::JObject()>("getContext", "()Landroid/content/Context;");
+     return method(javaClassStatic());
+  }
+
+  void setDisk(std::string key, std::string value) {
+      static auto method = javaClassStatic()->getMethod<void(std::string, std::string)>("setDisk");
+      method(self(), key, value);
+  }
+
+  std::string getDisk(std::string key) {
+      static auto method = javaClassStatic()->getMethod<jstring(std::string)>("getDisk");
+      auto result = method(self(), key);
+      return result ? result->toStdString() : "";
+  }
+  
+  void deleteDisk(std::string key) {
+      static auto method = javaClassStatic()->getMethod<void(std::string)>("deleteDisk");
+      method(self(), key);
+  }
+
+  void setSecure(std::string key, std::string value) {
+      static auto method = javaClassStatic()->getMethod<void(std::string, std::string)>("setSecure");
+      method(self(), key, value);
+  }
+
+  std::string getSecure(std::string key) {
+      static auto method = javaClassStatic()->getMethod<jstring(std::string)>("getSecure");
+      auto result = method(self(), key);
+      return result ? result->toStdString() : "";
+  }
+  
+  void deleteSecure(std::string key) {
+      static auto method = javaClassStatic()->getMethod<void(std::string)>("deleteSecure");
+      method(self(), key);
+  }
+};
+
+class AndroidStorageAdapterCpp : public NativeStorageAdapter {
+public:
+    explicit AndroidStorageAdapterCpp(facebook::jni::alias_ref<facebook::jni::JObject> context);
+    ~AndroidStorageAdapterCpp() override;
+    
+    void setDisk(const std::string& key, const std::string& value) override;
+    std::optional<std::string> getDisk(const std::string& key) override;
+    void deleteDisk(const std::string& key) override;
+    
+    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;
+};
+
+} // namespace NitroStorage

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

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

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

@@ -0,0 +1,94 @@
+package com.nitrostorage
+
+import android.content.Context
+import android.content.SharedPreferences
+import androidx.security.crypto.EncryptedSharedPreferences
+import androidx.security.crypto.MasterKey
+
+class AndroidStorageAdapter private constructor(private val context: Context) {
+    private val sharedPreferences: SharedPreferences = 
+        context.getSharedPreferences("NitroStorage", Context.MODE_PRIVATE)
+    
+    private val masterKey: MasterKey = MasterKey.Builder(context)
+        .setKeyScheme(MasterKey.KeyScheme.AES256_GCM)
+        .build()
+    
+    private val encryptedPreferences: SharedPreferences = try {
+        EncryptedSharedPreferences.create(
+            context,
+            "NitroStorageSecure",
+            masterKey,
+            EncryptedSharedPreferences.PrefKeyEncryptionScheme.AES256_SIV,
+            EncryptedSharedPreferences.PrefValueEncryptionScheme.AES256_GCM
+        )
+    } catch (e: Exception) {
+        throw RuntimeException(
+            "NitroStorage: Failed to initialize secure storage. " +
+            "This may be due to corrupted encryption keys. " +
+            "Try clearing app data or reinstalling the app.", e
+        )
+    }
+    
+    companion object {
+        @Volatile
+        private var instance: AndroidStorageAdapter? = null
+
+        @JvmStatic
+        fun init(context: Context) {
+            if (instance == null) {
+                synchronized(this) {
+                    if (instance == null) {
+                        instance = AndroidStorageAdapter(context.applicationContext)
+                    }
+                }
+            }
+        }
+
+        @JvmStatic
+        fun getContext(): Context {
+            return instance?.context 
+                ?: throw IllegalStateException(
+                    "NitroStorage not initialized. Call AndroidStorageAdapter.init(this) in your MainApplication.onCreate(), " +
+                    "or add 'react-native-nitro-storage' to your Expo plugins array in app.json."
+                )
+        }
+        
+        @JvmStatic
+        fun setDisk(key: String, value: String) {
+            instance?.sharedPreferences?.edit()?.putString(key, value)?.apply()
+                ?: throw IllegalStateException(
+                    "NitroStorage not initialized. Call AndroidStorageAdapter.init(this) in your MainApplication.onCreate(), " +
+                    "or add 'react-native-nitro-storage' to your Expo plugins array in app.json."
+                )
+        }
+        
+        @JvmStatic
+        fun getDisk(key: String): String? {
+            return instance?.sharedPreferences?.getString(key, null)
+        }
+        
+        @JvmStatic
+        fun deleteDisk(key: String) {
+            instance?.sharedPreferences?.edit()?.remove(key)?.apply()
+        }
+        
+        @JvmStatic
+        fun setSecure(key: String, value: String) {
+            instance?.encryptedPreferences?.edit()?.putString(key, value)?.apply()
+                ?: throw IllegalStateException(
+                    "NitroStorage not initialized. Call AndroidStorageAdapter.init(this) in your MainApplication.onCreate(), " +
+                    "or add 'react-native-nitro-storage' to your Expo plugins array in app.json."
+                )
+        }
+        
+        @JvmStatic
+        fun getSecure(key: String): String? {
+            return instance?.encryptedPreferences?.getString(key, null)
+        }
+        
+        @JvmStatic
+        fun deleteSecure(key: String) {
+            instance?.encryptedPreferences?.edit()?.remove(key)?.apply()
+        }
+    }
+}

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

@@ -0,0 +1,27 @@
+package com.nitrostorage
+
+import com.facebook.react.TurboReactPackage
+import com.facebook.react.bridge.NativeModule
+import com.facebook.react.bridge.ReactApplicationContext
+import com.facebook.react.module.model.ReactModuleInfo
+import com.facebook.react.module.model.ReactModuleInfoProvider
+import java.util.HashMap
+
+class NitroStoragePackage : TurboReactPackage() {
+  override fun getModule(name: String, reactContext: ReactApplicationContext): NativeModule? {
+    return null
+  }
+
+  override fun getReactModuleInfoProvider(): ReactModuleInfoProvider {
+    return ReactModuleInfoProvider {
+      val moduleInfos: MutableMap<String, ReactModuleInfo> = HashMap()
+      moduleInfos
+    }
+  }
+
+  companion object {
+    init {
+      System.loadLibrary("NitroStorage")
+    }
+  }
+}

package/app.plugin.js

@@ -0,0 +1,106 @@
+const {
+  withInfoPlist,
+  withAndroidManifest,
+  withMainApplication,
+  createRunOncePlugin,
+} = require("@expo/config-plugins");
+
+const withNitroStorage = (config, props = {}) => {
+  const {
+    faceIDPermission = "Allow $(PRODUCT_NAME) to use Face ID for secure authentication",
+  } = props;
+
+  config = withInfoPlist(config, (config) => {
+    config.modResults.NSFaceIDUsageDescription =
+      faceIDPermission || config.modResults.NSFaceIDUsageDescription;
+    return config;
+  });
+
+  config = withAndroidManifest(config, (config) => {
+    const mainApplication = config.modResults.manifest.application?.[0];
+    if (!mainApplication) {
+      return config;
+    }
+
+    if (!config.modResults.manifest["uses-permission"]) {
+      config.modResults.manifest["uses-permission"] = [];
+    }
+
+    const permissions = config.modResults.manifest["uses-permission"];
+
+    const biometricPermission = {
+      $: { "android:name": "android.permission.USE_BIOMETRIC" },
+    };
+    const fingerprintPermission = {
+      $: { "android:name": "android.permission.USE_FINGERPRINT" },
+    };
+
+    const hasBiometric = permissions.some(
+      (p) => p.$?.["android:name"] === "android.permission.USE_BIOMETRIC"
+    );
+    const hasFingerprint = permissions.some(
+      (p) => p.$?.["android:name"] === "android.permission.USE_FINGERPRINT"
+    );
+
+    if (!hasBiometric) {
+      permissions.push(biometricPermission);
+    }
+    if (!hasFingerprint) {
+      permissions.push(fingerprintPermission);
+    }
+
+    return config;
+  });
+
+  config = withMainApplication(config, (config) => {
+    const { modResults } = config;
+    const { language, contents } = modResults;
+
+    if (language === "java") {
+      if (!contents.includes("AndroidStorageAdapter.init")) {
+        const importStatement =
+          "import com.nitrostorage.AndroidStorageAdapter;";
+        const initStatement = "    AndroidStorageAdapter.init(this);";
+
+        if (!contents.includes(importStatement)) {
+          modResults.contents = contents.replace(
+            /(package .*;\n)/,
+            `$1\n${importStatement}\n`
+          );
+        }
+
+        modResults.contents = modResults.contents.replace(
+          /(super\.onCreate\(\);)/,
+          `$1\n${initStatement}`
+        );
+      }
+    } else if (language === "kt") {
+      if (!contents.includes("AndroidStorageAdapter.init")) {
+        const importStatement = "import com.nitrostorage.AndroidStorageAdapter";
+        const initStatement = "    AndroidStorageAdapter.init(this)";
+
+        if (!contents.includes(importStatement)) {
+          modResults.contents = contents.replace(
+            /(package .*\n)/,
+            `$1\n${importStatement}\n`
+          );
+        }
+
+        modResults.contents = modResults.contents.replace(
+          /(super\.onCreate\(\))/,
+          `$1\n${initStatement}`
+        );
+      }
+    }
+
+    return config;
+  });
+
+  return config;
+};
+
+module.exports = createRunOncePlugin(
+  withNitroStorage,
+  "react-native-nitro-storage",
+  "1.0.0"
+);

package/cpp/bindings/HybridStorage.cpp

@@ -0,0 +1,144 @@
+#include "HybridStorage.hpp"
+#include <stdexcept>
+
+#if __APPLE__
+#include "../../ios/IOSStorageAdapterCpp.hpp"
+#elif __ANDROID__
+#include "../../android/src/main/cpp/AndroidStorageAdapterCpp.hpp"
+#include <fbjni/fbjni.h>
+#endif
+
+namespace margelo::nitro::NitroStorage {
+
+HybridStorage::HybridStorage()
+    : HybridObject(TAG), HybridStorageSpec() {
+#if __APPLE__
+    nativeAdapter_ = std::make_shared<::NitroStorage::IOSStorageAdapterCpp>();
+#elif __ANDROID__
+    auto context = ::NitroStorage::AndroidStorageAdapterJava::getContext();
+    nativeAdapter_ = std::make_shared<::NitroStorage::AndroidStorageAdapterCpp>(context);
+#endif
+}
+
+HybridStorage::HybridStorage(std::shared_ptr<::NitroStorage::NativeStorageAdapter> adapter)
+    : 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);
+}
+
+void HybridStorage::set(const std::string& key, const std::string& value, double scope) {
+    Scope s = toScope(scope);
+    
+    switch (s) {
+        case Scope::Memory: {
+            std::lock_guard<std::mutex> lock(memoryMutex_);
+            memoryStore_[key] = value;
+            break;
+        }
+        case Scope::Disk:
+            nativeAdapter_->setDisk(key, value);
+            break;
+        case Scope::Secure:
+            nativeAdapter_->setSecure(key, value);
+            break;
+    }
+    
+    notifyListeners(static_cast<int>(s), key, value);
+}
+
+std::optional<std::string> HybridStorage::get(const std::string& key, double scope) {
+    Scope s = toScope(scope);
+    
+    switch (s) {
+        case Scope::Memory: {
+            std::lock_guard<std::mutex> lock(memoryMutex_);
+            auto it = memoryStore_.find(key);
+            if (it != memoryStore_.end()) {
+                return it->second;
+            }
+            return std::nullopt;
+        }
+        case Scope::Disk:
+            return nativeAdapter_->getDisk(key);
+        case Scope::Secure:
+            return nativeAdapter_->getSecure(key);
+    }
+    
+    return std::nullopt;
+}
+
+void HybridStorage::remove(const std::string& key, double scope) {
+    Scope s = toScope(scope);
+    
+    switch (s) {
+        case Scope::Memory: {
+            std::lock_guard<std::mutex> lock(memoryMutex_);
+            memoryStore_.erase(key);
+            break;
+        }
+        case Scope::Disk:
+            nativeAdapter_->deleteDisk(key);
+            break;
+        case Scope::Secure:
+            nativeAdapter_->deleteSecure(key);
+            break;
+    }
+    
+    notifyListeners(static_cast<int>(s), key, std::nullopt);
+}
+
+std::function<void()> HybridStorage::addOnChange(
+    double scope,
+    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_++;
+        listeners_[intScope].push_back({listenerId, callback});
+    }
+    
+    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()
+        );
+    };
+}
+
+void HybridStorage::notifyListeners(
+    int scope,
+    const std::string& key,
+    const std::optional<std::string>& value
+) {
+    std::vector<Listener> listenersCopy;
+    {
+        std::lock_guard<std::mutex> lock(listenersMutex_);
+        auto it = listeners_.find(scope);
+        if (it != listeners_.end()) {
+            listenersCopy = it->second;
+        }
+    }
+    
+    for (const auto& listener : listenersCopy) {
+        listener.callback(key, value);
+    }
+}
+
+} // namespace margelo::nitro::NitroStorage

package/cpp/bindings/HybridStorage.hpp

@@ -0,0 +1,52 @@
+#pragma once
+
+#include "HybridStorageSpec.hpp"
+#include "../core/NativeStorageAdapter.hpp"
+#include <unordered_map>
+#include <mutex>
+#include <functional>
+#include <memory>
+#include <vector>
+
+namespace margelo::nitro::NitroStorage {
+
+class HybridStorage : public HybridStorageSpec {
+public:
+    HybridStorage();
+    explicit HybridStorage(std::shared_ptr<::NitroStorage::NativeStorageAdapter> adapter);
+    ~HybridStorage() override = default;
+
+    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;
+    std::function<void()> addOnChange(
+        double scope,
+        const std::function<void(const std::string&, const std::optional<std::string>&)>& callback
+    ) override;
+
+private:
+    enum class Scope {
+        Memory = 0,
+        Disk = 1,
+        Secure = 2
+    };
+
+    struct Listener {
+        size_t id;
+        std::function<void(const std::string&, const std::optional<std::string>&)> callback;
+    };
+
+    std::unordered_map<std::string, std::string> memoryStore_;
+    std::mutex memoryMutex_;
+    
+    std::shared_ptr<::NitroStorage::NativeStorageAdapter> nativeAdapter_;
+    
+    std::unordered_map<int, std::vector<Listener>> listeners_;
+    std::mutex listenersMutex_;
+    size_t nextListenerId_ = 0;
+
+    void notifyListeners(int scope, const std::string& key, const std::optional<std::string>& value);
+    Scope toScope(double scopeValue);
+};
+
+} // namespace margelo::nitro::NitroStorage

package/cpp/core/NativeStorageAdapter.hpp

@@ -0,0 +1,21 @@
+#pragma once
+
+#include <string>
+#include <optional>
+
+namespace NitroStorage {
+
+class NativeStorageAdapter {
+public:
+    virtual ~NativeStorageAdapter() = default;
+    
+    virtual void setDisk(const std::string& key, const std::string& value) = 0;
+    virtual std::optional<std::string> getDisk(const std::string& key) = 0;
+    virtual void deleteDisk(const std::string& key) = 0;
+    
+    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;
+};
+
+} // namespace NitroStorage

package/ios/IOSStorageAdapterCpp.hpp

@@ -0,0 +1,21 @@
+#pragma once
+
+#include "../core/NativeStorageAdapter.hpp"
+
+namespace NitroStorage {
+
+class IOSStorageAdapterCpp : public NativeStorageAdapter {
+public:
+    IOSStorageAdapterCpp();
+    ~IOSStorageAdapterCpp() override;
+    
+    void setDisk(const std::string& key, const std::string& value) override;
+    std::optional<std::string> getDisk(const std::string& key) override;
+    void deleteDisk(const std::string& key) override;
+    
+    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;
+};
+
+} // namespace NitroStorage

package/ios/IOSStorageAdapterCpp.mm

@@ -0,0 +1,127 @@
+#import "IOSStorageAdapterCpp.hpp"
+#import <Foundation/Foundation.h>
+#import <Security/Security.h>
+
+namespace NitroStorage {
+
+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];
+}
+
+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;
+}
+
+void IOSStorageAdapterCpp::deleteDisk(const std::string& key) {
+    NSString* nsKey = [NSString stringWithUTF8String:key.c_str()];
+    [[NSUserDefaults standardUserDefaults] removeObjectForKey:nsKey];
+}
+
+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";
+    
+    NSDictionary* query = @{
+        (__bridge id)kSecClass: (__bridge id)kSecClassGenericPassword,
+        (__bridge id)kSecAttrService: service,
+        (__bridge id)kSecAttrAccount: nsKey
+    };
+    
+    NSDictionary* updateAttributes = @{
+        (__bridge id)kSecValueData: data
+    };
+    
+    // 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);
+    }
+}
+
+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)kSecReturnData: @YES,
+        (__bridge id)kSecMatchLimit: (__bridge id)kSecMatchLimitOne
+    };
+    
+    CFTypeRef result = NULL;
+    OSStatus status = SecItemCopyMatching((__bridge CFDictionaryRef)query, &result);
+    
+    if (status == 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);
+    }
+    
+    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
+    };
+    
+    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);
+    }
+}
+
+} // namespace NitroStorage

package/lib/commonjs/Storage.nitro.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.nitro.js.map

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

@@ -0,0 +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":[]}