react-native-mmkv 4.0.0-beta.0 → 4.0.0-beta.10

package/nitrogen/generated/ios/NitroMmkvAutolinking.mm

@@ -0,0 +1,43 @@
+///
+/// NitroMmkvAutolinking.mm
+/// This file was generated by nitrogen. DO NOT MODIFY THIS FILE.
+/// https://github.com/mrousavy/nitro
+/// Copyright © 2025 Marc Rousavy @ Margelo
+///
+
+#import <Foundation/Foundation.h>
+#import <NitroModules/HybridObjectRegistry.hpp>
+#import "NitroMmkv-Swift-Cxx-Umbrella.hpp"
+#import <type_traits>
+
+#include "HybridMMKVFactory.hpp"
+#include "HybridMMKVPlatformContextSpecSwift.hpp"
+
+@interface NitroMmkvAutolinking : NSObject
+@end
+
+@implementation NitroMmkvAutolinking
+
++ (void) load {
+  using namespace margelo::nitro;
+  using namespace margelo::nitro::mmkv;
+
+  HybridObjectRegistry::registerHybridObjectConstructor(
+    "MMKVFactory",
+    []() -> std::shared_ptr<HybridObject> {
+      static_assert(std::is_default_constructible_v<HybridMMKVFactory>,
+                    "The HybridObject \"HybridMMKVFactory\" is not default-constructible! "
+                    "Create a public constructor that takes zero arguments to be able to autolink this HybridObject.");
+      return std::make_shared<HybridMMKVFactory>();
+    }
+  );
+  HybridObjectRegistry::registerHybridObjectConstructor(
+    "MMKVPlatformContext",
+    []() -> std::shared_ptr<HybridObject> {
+      std::shared_ptr<HybridMMKVPlatformContextSpec> hybridObject = NitroMmkv::NitroMmkvAutolinking::createMMKVPlatformContext();
+      return hybridObject;
+    }
+  );
+}
+
+@end

package/nitrogen/generated/ios/NitroMmkvAutolinking.swift

@@ -0,0 +1,25 @@
+///
+/// NitroMmkvAutolinking.swift
+/// This file was generated by nitrogen. DO NOT MODIFY THIS FILE.
+/// https://github.com/mrousavy/nitro
+/// Copyright © 2025 Marc Rousavy @ Margelo
+///
+
+public final class NitroMmkvAutolinking {
+  public typealias bridge = margelo.nitro.mmkv.bridge.swift
+
+  /**
+   * Creates an instance of a Swift class that implements `HybridMMKVPlatformContextSpec`,
+   * and wraps it in a Swift class that can directly interop with C++ (`HybridMMKVPlatformContextSpec_cxx`)
+   *
+   * This is generated by Nitrogen and will initialize the class specified
+   * in the `"autolinking"` property of `nitro.json` (in this case, `HybridMMKVPlatformContext`).
+   */
+  public static func createMMKVPlatformContext() -> bridge.std__shared_ptr_HybridMMKVPlatformContextSpec_ {
+    let hybridObject = HybridMMKVPlatformContext()
+    return { () -> bridge.std__shared_ptr_HybridMMKVPlatformContextSpec_ in
+      let __cxxWrapped = hybridObject.getCxxWrapper()
+      return __cxxWrapped.getCxxPart()
+    }()
+  }
+}

package/nitrogen/generated/ios/c++/HybridMMKVPlatformContextSpecSwift.cpp

@@ -0,0 +1,11 @@
+///
+/// HybridMMKVPlatformContextSpecSwift.cpp
+/// This file was generated by nitrogen. DO NOT MODIFY THIS FILE.
+/// https://github.com/mrousavy/nitro
+/// Copyright © 2025 Marc Rousavy @ Margelo
+///
+
+#include "HybridMMKVPlatformContextSpecSwift.hpp"
+
+namespace margelo::nitro::mmkv {
+} // namespace margelo::nitro::mmkv

package/nitrogen/generated/ios/c++/HybridMMKVPlatformContextSpecSwift.hpp

@@ -0,0 +1,82 @@
+///
+/// HybridMMKVPlatformContextSpecSwift.hpp
+/// This file was generated by nitrogen. DO NOT MODIFY THIS FILE.
+/// https://github.com/mrousavy/nitro
+/// Copyright © 2025 Marc Rousavy @ Margelo
+///
+
+#pragma once
+
+#include "HybridMMKVPlatformContextSpec.hpp"
+
+// Forward declaration of `HybridMMKVPlatformContextSpec_cxx` to properly resolve imports.
+namespace NitroMmkv { class HybridMMKVPlatformContextSpec_cxx; }
+
+
+
+#include <string>
+#include <optional>
+
+#include "NitroMmkv-Swift-Cxx-Umbrella.hpp"
+
+namespace margelo::nitro::mmkv {
+
+  /**
+   * The C++ part of HybridMMKVPlatformContextSpec_cxx.swift.
+   *
+   * HybridMMKVPlatformContextSpecSwift (C++) accesses HybridMMKVPlatformContextSpec_cxx (Swift), and might
+   * contain some additional bridging code for C++ <> Swift interop.
+   *
+   * Since this obviously introduces an overhead, I hope at some point in
+   * the future, HybridMMKVPlatformContextSpec_cxx can directly inherit from the C++ class HybridMMKVPlatformContextSpec
+   * to simplify the whole structure and memory management.
+   */
+  class HybridMMKVPlatformContextSpecSwift: public virtual HybridMMKVPlatformContextSpec {
+  public:
+    // Constructor from a Swift instance
+    explicit HybridMMKVPlatformContextSpecSwift(const NitroMmkv::HybridMMKVPlatformContextSpec_cxx& swiftPart):
+      HybridObject(HybridMMKVPlatformContextSpec::TAG),
+      _swiftPart(swiftPart) { }
+
+  public:
+    // Get the Swift part
+    inline NitroMmkv::HybridMMKVPlatformContextSpec_cxx& getSwiftPart() noexcept {
+      return _swiftPart;
+    }
+
+  public:
+    inline size_t getExternalMemorySize() noexcept override {
+      return _swiftPart.getMemorySize();
+    }
+    void dispose() noexcept override {
+      _swiftPart.dispose();
+    }
+
+  public:
+    // Properties
+    
+
+  public:
+    // Methods
+    inline std::string getBaseDirectory() override {
+      auto __result = _swiftPart.getBaseDirectory();
+      if (__result.hasError()) [[unlikely]] {
+        std::rethrow_exception(__result.error());
+      }
+      auto __value = std::move(__result.value());
+      return __value;
+    }
+    inline std::optional<std::string> getAppGroupDirectory() override {
+      auto __result = _swiftPart.getAppGroupDirectory();
+      if (__result.hasError()) [[unlikely]] {
+        std::rethrow_exception(__result.error());
+      }
+      auto __value = std::move(__result.value());
+      return __value;
+    }
+
+  private:
+    NitroMmkv::HybridMMKVPlatformContextSpec_cxx _swiftPart;
+  };
+
+} // namespace margelo::nitro::mmkv

package/nitrogen/generated/ios/swift/HybridMMKVPlatformContextSpec.swift

@@ -0,0 +1,50 @@
+///
+/// HybridMMKVPlatformContextSpec.swift
+/// This file was generated by nitrogen. DO NOT MODIFY THIS FILE.
+/// https://github.com/mrousavy/nitro
+/// Copyright © 2025 Marc Rousavy @ Margelo
+///
+
+import Foundation
+import NitroModules
+
+/// See ``HybridMMKVPlatformContextSpec``
+public protocol HybridMMKVPlatformContextSpec_protocol: HybridObject {
+  // Properties
+  
+
+  // Methods
+  func getBaseDirectory() throws -> String
+  func getAppGroupDirectory() throws -> String?
+}
+
+/// See ``HybridMMKVPlatformContextSpec``
+open class HybridMMKVPlatformContextSpec_base {
+  private weak var cxxWrapper: HybridMMKVPlatformContextSpec_cxx? = nil
+  public init() { }
+  public func getCxxWrapper() -> HybridMMKVPlatformContextSpec_cxx {
+  #if DEBUG
+    guard self is HybridMMKVPlatformContextSpec else {
+      fatalError("`self` is not a `HybridMMKVPlatformContextSpec`! Did you accidentally inherit from `HybridMMKVPlatformContextSpec_base` instead of `HybridMMKVPlatformContextSpec`?")
+    }
+  #endif
+    if let cxxWrapper = self.cxxWrapper {
+      return cxxWrapper
+    } else {
+      let cxxWrapper = HybridMMKVPlatformContextSpec_cxx(self as! HybridMMKVPlatformContextSpec)
+      self.cxxWrapper = cxxWrapper
+      return cxxWrapper
+    }
+  }
+}
+
+/**
+ * A Swift base-protocol representing the MMKVPlatformContext HybridObject.
+ * Implement this protocol to create Swift-based instances of MMKVPlatformContext.
+ * ```swift
+ * class HybridMMKVPlatformContext : HybridMMKVPlatformContextSpec {
+ *   // ...
+ * }
+ * ```
+ */
+public typealias HybridMMKVPlatformContextSpec = HybridMMKVPlatformContextSpec_protocol & HybridMMKVPlatformContextSpec_base

package/nitrogen/generated/ios/swift/HybridMMKVPlatformContextSpec_cxx.swift

@@ -0,0 +1,141 @@
+///
+/// HybridMMKVPlatformContextSpec_cxx.swift
+/// This file was generated by nitrogen. DO NOT MODIFY THIS FILE.
+/// https://github.com/mrousavy/nitro
+/// Copyright © 2025 Marc Rousavy @ Margelo
+///
+
+import Foundation
+import NitroModules
+
+/**
+ * A class implementation that bridges HybridMMKVPlatformContextSpec over to C++.
+ * In C++, we cannot use Swift protocols - so we need to wrap it in a class to make it strongly defined.
+ *
+ * Also, some Swift types need to be bridged with special handling:
+ * - Enums need to be wrapped in Structs, otherwise they cannot be accessed bi-directionally (Swift bug: https://github.com/swiftlang/swift/issues/75330)
+ * - Other HybridObjects need to be wrapped/unwrapped from the Swift TCxx wrapper
+ * - Throwing methods need to be wrapped with a Result<T, Error> type, as exceptions cannot be propagated to C++
+ */
+open class HybridMMKVPlatformContextSpec_cxx {
+  /**
+   * The Swift <> C++ bridge's namespace (`margelo::nitro::mmkv::bridge::swift`)
+   * from `NitroMmkv-Swift-Cxx-Bridge.hpp`.
+   * This contains specialized C++ templates, and C++ helper functions that can be accessed from Swift.
+   */
+  public typealias bridge = margelo.nitro.mmkv.bridge.swift
+
+  /**
+   * Holds an instance of the `HybridMMKVPlatformContextSpec` Swift protocol.
+   */
+  private var __implementation: any HybridMMKVPlatformContextSpec
+
+  /**
+   * Holds a weak pointer to the C++ class that wraps the Swift class.
+   */
+  private var __cxxPart: bridge.std__weak_ptr_HybridMMKVPlatformContextSpec_
+
+  /**
+   * Create a new `HybridMMKVPlatformContextSpec_cxx` that wraps the given `HybridMMKVPlatformContextSpec`.
+   * All properties and methods bridge to C++ types.
+   */
+  public init(_ implementation: any HybridMMKVPlatformContextSpec) {
+    self.__implementation = implementation
+    self.__cxxPart = .init()
+    /* no base class */
+  }
+
+  /**
+   * Get the actual `HybridMMKVPlatformContextSpec` instance this class wraps.
+   */
+  @inline(__always)
+  public func getHybridMMKVPlatformContextSpec() -> any HybridMMKVPlatformContextSpec {
+    return __implementation
+  }
+
+  /**
+   * Casts this instance to a retained unsafe raw pointer.
+   * This acquires one additional strong reference on the object!
+   */
+  public func toUnsafe() -> UnsafeMutableRawPointer {
+    return Unmanaged.passRetained(self).toOpaque()
+  }
+
+  /**
+   * Casts an unsafe pointer to a `HybridMMKVPlatformContextSpec_cxx`.
+   * The pointer has to be a retained opaque `Unmanaged<HybridMMKVPlatformContextSpec_cxx>`.
+   * This removes one strong reference from the object!
+   */
+  public class func fromUnsafe(_ pointer: UnsafeMutableRawPointer) -> HybridMMKVPlatformContextSpec_cxx {
+    return Unmanaged<HybridMMKVPlatformContextSpec_cxx>.fromOpaque(pointer).takeRetainedValue()
+  }
+
+  /**
+   * Gets (or creates) the C++ part of this Hybrid Object.
+   * The C++ part is a `std::shared_ptr<HybridMMKVPlatformContextSpec>`.
+   */
+  public func getCxxPart() -> bridge.std__shared_ptr_HybridMMKVPlatformContextSpec_ {
+    let cachedCxxPart = self.__cxxPart.lock()
+    if cachedCxxPart.__convertToBool() {
+      return cachedCxxPart
+    } else {
+      let newCxxPart = bridge.create_std__shared_ptr_HybridMMKVPlatformContextSpec_(self.toUnsafe())
+      __cxxPart = bridge.weakify_std__shared_ptr_HybridMMKVPlatformContextSpec_(newCxxPart)
+      return newCxxPart
+    }
+  }
+
+  
+
+  /**
+   * Get the memory size of the Swift class (plus size of any other allocations)
+   * so the JS VM can properly track it and garbage-collect the JS object if needed.
+   */
+  @inline(__always)
+  public var memorySize: Int {
+    return MemoryHelper.getSizeOf(self.__implementation) + self.__implementation.memorySize
+  }
+
+  /**
+   * Call dispose() on the Swift class.
+   * This _may_ be called manually from JS.
+   */
+  @inline(__always)
+  public func dispose() {
+    self.__implementation.dispose()
+  }
+
+  // Properties
+  
+
+  // Methods
+  @inline(__always)
+  public final func getBaseDirectory() -> bridge.Result_std__string_ {
+    do {
+      let __result = try self.__implementation.getBaseDirectory()
+      let __resultCpp = std.string(__result)
+      return bridge.create_Result_std__string_(__resultCpp)
+    } catch (let __error) {
+      let __exceptionPtr = __error.toCpp()
+      return bridge.create_Result_std__string_(__exceptionPtr)
+    }
+  }
+  
+  @inline(__always)
+  public final func getAppGroupDirectory() -> bridge.Result_std__optional_std__string__ {
+    do {
+      let __result = try self.__implementation.getAppGroupDirectory()
+      let __resultCpp = { () -> bridge.std__optional_std__string_ in
+        if let __unwrappedValue = __result {
+          return bridge.create_std__optional_std__string_(std.string(__unwrappedValue))
+        } else {
+          return .init()
+        }
+      }()
+      return bridge.create_Result_std__optional_std__string__(__resultCpp)
+    } catch (let __error) {
+      let __exceptionPtr = __error.toCpp()
+      return bridge.create_Result_std__optional_std__string__(__exceptionPtr)
+    }
+  }
+}

package/nitrogen/generated/shared/c++/Configuration.hpp

@@ -0,0 +1,86 @@
+///
+/// Configuration.hpp
+/// This file was generated by nitrogen. DO NOT MODIFY THIS FILE.
+/// https://github.com/mrousavy/nitro
+/// Copyright © 2025 Marc Rousavy @ Margelo
+///
+
+#pragma once
+
+#if __has_include(<NitroModules/JSIConverter.hpp>)
+#include <NitroModules/JSIConverter.hpp>
+#else
+#error NitroModules cannot be found! Are you sure you installed NitroModules properly?
+#endif
+#if __has_include(<NitroModules/NitroDefines.hpp>)
+#include <NitroModules/NitroDefines.hpp>
+#else
+#error NitroModules cannot be found! Are you sure you installed NitroModules properly?
+#endif
+
+// Forward declaration of `Mode` to properly resolve imports.
+namespace margelo::nitro::mmkv { enum class Mode; }
+
+#include <string>
+#include <optional>
+#include "Mode.hpp"
+
+namespace margelo::nitro::mmkv {
+
+  /**
+   * A struct which can be represented as a JavaScript object (Configuration).
+   */
+  struct Configuration {
+  public:
+    std::string id     SWIFT_PRIVATE;
+    std::optional<std::string> path     SWIFT_PRIVATE;
+    std::optional<std::string> encryptionKey     SWIFT_PRIVATE;
+    std::optional<Mode> mode     SWIFT_PRIVATE;
+    std::optional<bool> readOnly     SWIFT_PRIVATE;
+
+  public:
+    Configuration() = default;
+    explicit Configuration(std::string id, std::optional<std::string> path, std::optional<std::string> encryptionKey, std::optional<Mode> mode, std::optional<bool> readOnly): id(id), path(path), encryptionKey(encryptionKey), mode(mode), readOnly(readOnly) {}
+  };
+
+} // namespace margelo::nitro::mmkv
+
+namespace margelo::nitro {
+
+  // C++ Configuration <> JS Configuration (object)
+  template <>
+  struct JSIConverter<margelo::nitro::mmkv::Configuration> final {
+    static inline margelo::nitro::mmkv::Configuration fromJSI(jsi::Runtime& runtime, const jsi::Value& arg) {
+      jsi::Object obj = arg.asObject(runtime);
+      return margelo::nitro::mmkv::Configuration(
+        JSIConverter<std::string>::fromJSI(runtime, obj.getProperty(runtime, "id")),
+        JSIConverter<std::optional<std::string>>::fromJSI(runtime, obj.getProperty(runtime, "path")),
+        JSIConverter<std::optional<std::string>>::fromJSI(runtime, obj.getProperty(runtime, "encryptionKey")),
+        JSIConverter<std::optional<margelo::nitro::mmkv::Mode>>::fromJSI(runtime, obj.getProperty(runtime, "mode")),
+        JSIConverter<std::optional<bool>>::fromJSI(runtime, obj.getProperty(runtime, "readOnly"))
+      );
+    }
+    static inline jsi::Value toJSI(jsi::Runtime& runtime, const margelo::nitro::mmkv::Configuration& arg) {
+      jsi::Object obj(runtime);
+      obj.setProperty(runtime, "id", JSIConverter<std::string>::toJSI(runtime, arg.id));
+      obj.setProperty(runtime, "path", JSIConverter<std::optional<std::string>>::toJSI(runtime, arg.path));
+      obj.setProperty(runtime, "encryptionKey", JSIConverter<std::optional<std::string>>::toJSI(runtime, arg.encryptionKey));
+      obj.setProperty(runtime, "mode", JSIConverter<std::optional<margelo::nitro::mmkv::Mode>>::toJSI(runtime, arg.mode));
+      obj.setProperty(runtime, "readOnly", JSIConverter<std::optional<bool>>::toJSI(runtime, arg.readOnly));
+      return obj;
+    }
+    static inline bool canConvert(jsi::Runtime& runtime, const jsi::Value& value) {
+      if (!value.isObject()) {
+        return false;
+      }
+      jsi::Object obj = value.getObject(runtime);
+      if (!JSIConverter<std::string>::canConvert(runtime, obj.getProperty(runtime, "id"))) return false;
+      if (!JSIConverter<std::optional<std::string>>::canConvert(runtime, obj.getProperty(runtime, "path"))) return false;
+      if (!JSIConverter<std::optional<std::string>>::canConvert(runtime, obj.getProperty(runtime, "encryptionKey"))) return false;
+      if (!JSIConverter<std::optional<margelo::nitro::mmkv::Mode>>::canConvert(runtime, obj.getProperty(runtime, "mode"))) return false;
+      if (!JSIConverter<std::optional<bool>>::canConvert(runtime, obj.getProperty(runtime, "readOnly"))) return false;
+      return true;
+    }
+  };
+
+} // namespace margelo::nitro

package/nitrogen/generated/shared/c++/HybridMMKVFactorySpec.cpp

@@ -0,0 +1,23 @@
+///
+/// HybridMMKVFactorySpec.cpp
+/// This file was generated by nitrogen. DO NOT MODIFY THIS FILE.
+/// https://github.com/mrousavy/nitro
+/// Copyright © 2025 Marc Rousavy @ Margelo
+///
+
+#include "HybridMMKVFactorySpec.hpp"
+
+namespace margelo::nitro::mmkv {
+
+  void HybridMMKVFactorySpec::loadHybridMethods() {
+    // load base methods/properties
+    HybridObject::loadHybridMethods();
+    // load custom methods/properties
+    registerHybrids(this, [](Prototype& prototype) {
+      prototype.registerHybridGetter("defaultMMKVInstanceId", &HybridMMKVFactorySpec::getDefaultMMKVInstanceId);
+      prototype.registerHybridMethod("createMMKV", &HybridMMKVFactorySpec::createMMKV);
+      prototype.registerHybridMethod("initializeMMKV", &HybridMMKVFactorySpec::initializeMMKV);
+    });
+  }
+
+} // namespace margelo::nitro::mmkv

package/nitrogen/generated/shared/c++/HybridMMKVFactorySpec.hpp

@@ -0,0 +1,69 @@
+///
+/// HybridMMKVFactorySpec.hpp
+/// This file was generated by nitrogen. DO NOT MODIFY THIS FILE.
+/// https://github.com/mrousavy/nitro
+/// Copyright © 2025 Marc Rousavy @ Margelo
+///
+
+#pragma once
+
+#if __has_include(<NitroModules/HybridObject.hpp>)
+#include <NitroModules/HybridObject.hpp>
+#else
+#error NitroModules cannot be found! Are you sure you installed NitroModules properly?
+#endif
+
+// Forward declaration of `HybridMMKVSpec` to properly resolve imports.
+namespace margelo::nitro::mmkv { class HybridMMKVSpec; }
+// Forward declaration of `Configuration` to properly resolve imports.
+namespace margelo::nitro::mmkv { struct Configuration; }
+
+#include <string>
+#include <memory>
+#include "HybridMMKVSpec.hpp"
+#include "Configuration.hpp"
+
+namespace margelo::nitro::mmkv {
+
+  using namespace margelo::nitro;
+
+  /**
+   * An abstract base class for `MMKVFactory`
+   * Inherit this class to create instances of `HybridMMKVFactorySpec` in C++.
+   * You must explicitly call `HybridObject`'s constructor yourself, because it is virtual.
+   * @example
+   * ```cpp
+   * class HybridMMKVFactory: public HybridMMKVFactorySpec {
+   * public:
+   *   HybridMMKVFactory(...): HybridObject(TAG) { ... }
+   *   // ...
+   * };
+   * ```
+   */
+  class HybridMMKVFactorySpec: public virtual HybridObject {
+    public:
+      // Constructor
+      explicit HybridMMKVFactorySpec(): HybridObject(TAG) { }
+
+      // Destructor
+      ~HybridMMKVFactorySpec() override = default;
+
+    public:
+      // Properties
+      virtual std::string getDefaultMMKVInstanceId() = 0;
+
+    public:
+      // Methods
+      virtual std::shared_ptr<HybridMMKVSpec> createMMKV(const Configuration& configuration) = 0;
+      virtual void initializeMMKV(const std::string& rootPath) = 0;
+
+    protected:
+      // Hybrid Setup
+      void loadHybridMethods() override;
+
+    protected:
+      // Tag for logging
+      static constexpr auto TAG = "MMKVFactory";
+  };
+
+} // namespace margelo::nitro::mmkv

package/nitrogen/generated/shared/c++/HybridMMKVPlatformContextSpec.cpp

@@ -0,0 +1,22 @@
+///
+/// HybridMMKVPlatformContextSpec.cpp
+/// This file was generated by nitrogen. DO NOT MODIFY THIS FILE.
+/// https://github.com/mrousavy/nitro
+/// Copyright © 2025 Marc Rousavy @ Margelo
+///
+
+#include "HybridMMKVPlatformContextSpec.hpp"
+
+namespace margelo::nitro::mmkv {
+
+  void HybridMMKVPlatformContextSpec::loadHybridMethods() {
+    // load base methods/properties
+    HybridObject::loadHybridMethods();
+    // load custom methods/properties
+    registerHybrids(this, [](Prototype& prototype) {
+      prototype.registerHybridMethod("getBaseDirectory", &HybridMMKVPlatformContextSpec::getBaseDirectory);
+      prototype.registerHybridMethod("getAppGroupDirectory", &HybridMMKVPlatformContextSpec::getAppGroupDirectory);
+    });
+  }
+
+} // namespace margelo::nitro::mmkv

package/nitrogen/generated/shared/c++/HybridMMKVPlatformContextSpec.hpp

@@ -0,0 +1,64 @@
+///
+/// HybridMMKVPlatformContextSpec.hpp
+/// This file was generated by nitrogen. DO NOT MODIFY THIS FILE.
+/// https://github.com/mrousavy/nitro
+/// Copyright © 2025 Marc Rousavy @ Margelo
+///
+
+#pragma once
+
+#if __has_include(<NitroModules/HybridObject.hpp>)
+#include <NitroModules/HybridObject.hpp>
+#else
+#error NitroModules cannot be found! Are you sure you installed NitroModules properly?
+#endif
+
+
+
+#include <string>
+#include <optional>
+
+namespace margelo::nitro::mmkv {
+
+  using namespace margelo::nitro;
+
+  /**
+   * An abstract base class for `MMKVPlatformContext`
+   * Inherit this class to create instances of `HybridMMKVPlatformContextSpec` in C++.
+   * You must explicitly call `HybridObject`'s constructor yourself, because it is virtual.
+   * @example
+   * ```cpp
+   * class HybridMMKVPlatformContext: public HybridMMKVPlatformContextSpec {
+   * public:
+   *   HybridMMKVPlatformContext(...): HybridObject(TAG) { ... }
+   *   // ...
+   * };
+   * ```
+   */
+  class HybridMMKVPlatformContextSpec: public virtual HybridObject {
+    public:
+      // Constructor
+      explicit HybridMMKVPlatformContextSpec(): HybridObject(TAG) { }
+
+      // Destructor
+      ~HybridMMKVPlatformContextSpec() override = default;
+
+    public:
+      // Properties
+      
+
+    public:
+      // Methods
+      virtual std::string getBaseDirectory() = 0;
+      virtual std::optional<std::string> getAppGroupDirectory() = 0;
+
+    protected:
+      // Hybrid Setup
+      void loadHybridMethods() override;
+
+    protected:
+      // Tag for logging
+      static constexpr auto TAG = "MMKVPlatformContext";
+  };
+
+} // namespace margelo::nitro::mmkv

package/nitrogen/generated/shared/c++/HybridMMKVSpec.cpp

@@ -0,0 +1,34 @@
+///
+/// HybridMMKVSpec.cpp
+/// This file was generated by nitrogen. DO NOT MODIFY THIS FILE.
+/// https://github.com/mrousavy/nitro
+/// Copyright © 2025 Marc Rousavy @ Margelo
+///
+
+#include "HybridMMKVSpec.hpp"
+
+namespace margelo::nitro::mmkv {
+
+  void HybridMMKVSpec::loadHybridMethods() {
+    // load base methods/properties
+    HybridObject::loadHybridMethods();
+    // load custom methods/properties
+    registerHybrids(this, [](Prototype& prototype) {
+      prototype.registerHybridGetter("size", &HybridMMKVSpec::getSize);
+      prototype.registerHybridGetter("isReadOnly", &HybridMMKVSpec::getIsReadOnly);
+      prototype.registerHybridMethod("set", &HybridMMKVSpec::set);
+      prototype.registerHybridMethod("getBoolean", &HybridMMKVSpec::getBoolean);
+      prototype.registerHybridMethod("getString", &HybridMMKVSpec::getString);
+      prototype.registerHybridMethod("getNumber", &HybridMMKVSpec::getNumber);
+      prototype.registerHybridMethod("getBuffer", &HybridMMKVSpec::getBuffer);
+      prototype.registerHybridMethod("contains", &HybridMMKVSpec::contains);
+      prototype.registerHybridMethod("remove", &HybridMMKVSpec::remove);
+      prototype.registerHybridMethod("getAllKeys", &HybridMMKVSpec::getAllKeys);
+      prototype.registerHybridMethod("clearAll", &HybridMMKVSpec::clearAll);
+      prototype.registerHybridMethod("recrypt", &HybridMMKVSpec::recrypt);
+      prototype.registerHybridMethod("trim", &HybridMMKVSpec::trim);
+      prototype.registerHybridMethod("addOnValueChangedListener", &HybridMMKVSpec::addOnValueChangedListener);
+    });
+  }
+
+} // namespace margelo::nitro::mmkv