@react-native-ohos/react-native-mmkv 3.3.1-1

package/cpp/MmkvHostObject.cpp

@@ -0,0 +1,355 @@
+//
+//  MmkvHostObject.cpp
+//  Mmkv
+//
+//  Created by Marc Rousavy on 03.09.21.
+//  Copyright © 2021 Facebook. All rights reserved.
+//
+
+#include "MmkvHostObject.h"
+#include "MMKVManagedBuffer.h"
+#include "MmkvLogger.h"
+#include <MMKV.h>
+#include <string>
+#include <vector>
+
+using namespace mmkv;
+using namespace facebook;
+
+MmkvHostObject::MmkvHostObject(const facebook::react::MMKVConfig& config) {
+  std::string path = config.path.has_value() ? config.path.value() : "";
+  std::string encryptionKey = config.encryptionKey.has_value() ? config.encryptionKey.value() : "";
+  bool hasEncryptionKey = encryptionKey.size() > 0;
+  MmkvLogger::log("RNMMKV", "Creating MMKV instance \"%s\"... (Path: %s, Encrypted: %s)",
+                  config.id.c_str(), path.c_str(), hasEncryptionKey ? "true" : "false");
+
+  std::string* pathPtr = path.size() > 0 ? &path : nullptr;
+  std::string* encryptionKeyPtr = encryptionKey.size() > 0 ? &encryptionKey : nullptr;
+  MMKVMode mode = getMMKVMode(config);
+  if (config.readOnly.has_value() && config.readOnly.value()) {
+    MmkvLogger::log("RNMMKV", "Instance is read-only!");
+    mode = mode | MMKVMode::MMKV_READ_ONLY;
+  }
+
+#ifdef __APPLE__
+  instance = MMKV::mmkvWithID(config.id, mode, encryptionKeyPtr, pathPtr);
+#else
+  instance = MMKV::mmkvWithID(config.id, DEFAULT_MMAP_SIZE, mode, encryptionKeyPtr, pathPtr);
+#endif
+
+  if (instance == nullptr) [[unlikely]] {
+    // Check if instanceId is invalid
+    if (config.id.empty()) [[unlikely]] {
+      throw std::runtime_error("Failed to create MMKV instance! `id` cannot be empty!");
+    }
+
+    // Check if encryptionKey is invalid
+    if (encryptionKey.size() > 16) [[unlikely]] {
+      throw std::runtime_error(
+          "Failed to create MMKV instance! `encryptionKey` cannot be longer than 16 bytes!");
+    }
+
+    throw std::runtime_error("Failed to create MMKV instance!");
+  }
+}
+
+MmkvHostObject::~MmkvHostObject() {
+  if (instance != nullptr) {
+    std::string instanceId = instance->mmapID();
+    MmkvLogger::log("RNMMKV", "Destroying MMKV instance \"%s\"...", instanceId.c_str());
+    instance->sync();
+    instance->clearMemoryCache();
+  }
+  instance = nullptr;
+}
+
+std::vector<jsi::PropNameID> MmkvHostObject::getPropertyNames(jsi::Runtime& rt) {
+  return jsi::PropNameID::names(rt, "set", "getBoolean", "getBuffer", "getString", "getNumber",
+                                "contains", "delete", "getAllKeys", "deleteAll", "recrypt", "trim",
+                                "size", "isReadOnly");
+}
+
+MMKVMode MmkvHostObject::getMMKVMode(const facebook::react::MMKVConfig& config) {
+  if (!config.mode.has_value()) {
+    return MMKVMode::MMKV_SINGLE_PROCESS;
+  }
+  react::NativeMmkvMode mode = config.mode.value();
+  switch (mode) {
+    case react::NativeMmkvMode::SINGLE_PROCESS:
+      return MMKVMode::MMKV_SINGLE_PROCESS;
+    case react::NativeMmkvMode::MULTI_PROCESS:
+      return MMKVMode::MMKV_MULTI_PROCESS;
+    default:
+      [[unlikely]] throw std::runtime_error("Invalid MMKV Mode value!");
+  }
+}
+
+jsi::Value MmkvHostObject::get(jsi::Runtime& runtime, const jsi::PropNameID& propNameId) {
+  std::string propName = propNameId.utf8(runtime);
+
+  if (propName == "set") {
+    // MMKV.set(key: string, value: string | number | bool | ArrayBuffer)
+    return jsi::Function::createFromHostFunction(
+        runtime, jsi::PropNameID::forAscii(runtime, propName),
+        2, // key, value
+        [this](jsi::Runtime& runtime, const jsi::Value& thisValue, const jsi::Value* arguments,
+               size_t count) -> jsi::Value {
+          if (count != 2 || !arguments[0].isString()) [[unlikely]] {
+            throw jsi::JSError(runtime,
+                               "MMKV::set: First argument ('key') has to be of type string!");
+          }
+
+          std::string keyName = arguments[0].getString(runtime).utf8(runtime);
+
+          bool successful = false;
+          if (arguments[1].isBool()) {
+            // bool
+            successful = instance->set(arguments[1].getBool(), keyName);
+          } else if (arguments[1].isNumber()) {
+            // number
+            successful = instance->set(arguments[1].getNumber(), keyName);
+          } else if (arguments[1].isString()) {
+            // string
+            std::string stringValue = arguments[1].getString(runtime).utf8(runtime);
+            successful = instance->set(stringValue, keyName);
+          } else if (arguments[1].isObject()) {
+            // object
+            jsi::Object object = arguments[1].getObject(runtime);
+            if (object.isArrayBuffer(runtime)) {
+              // ArrayBuffer
+              jsi::ArrayBuffer arrayBuffer = object.getArrayBuffer(runtime);
+              MMBuffer data(arrayBuffer.data(runtime), arrayBuffer.size(runtime), MMBufferNoCopy);
+              successful = instance->set(data, keyName);
+            } else [[unlikely]] {
+              // unknown object
+              throw jsi::JSError(
+                  runtime,
+                  "MMKV::set: 'value' argument is an object, but not of type ArrayBuffer!");
+            }
+          } else [[unlikely]] {
+            // unknown type
+            throw jsi::JSError(
+                runtime,
+                "MMKV::set: 'value' argument is not of type bool, number, string or buffer!");
+          }
+
+          if (!successful) [[unlikely]] {
+            if (instance->isReadOnly()) {
+              throw jsi::JSError(runtime,
+                                 "Failed to set " + keyName + "! This instance is read-only!");
+            } else {
+              throw jsi::JSError(runtime, "Failed to set " + keyName + "!");
+            }
+          }
+
+          return jsi::Value::undefined();
+        });
+  }
+
+  if (propName == "getBoolean") {
+    // MMKV.getBoolean(key: string)
+    return jsi::Function::createFromHostFunction(
+        runtime, jsi::PropNameID::forAscii(runtime, propName),
+        1, // key
+        [this](jsi::Runtime& runtime, const jsi::Value& thisValue, const jsi::Value* arguments,
+               size_t count) -> jsi::Value {
+          if (count != 1 || !arguments[0].isString()) [[unlikely]] {
+            throw jsi::JSError(runtime, "First argument ('key') has to be of type string!");
+          }
+
+          std::string keyName = arguments[0].getString(runtime).utf8(runtime);
+          bool hasValue;
+          bool value = instance->getBool(keyName, false, &hasValue);
+          if (!hasValue) [[unlikely]] {
+            return jsi::Value::undefined();
+          }
+          return jsi::Value(value);
+        });
+  }
+
+  if (propName == "getNumber") {
+    // MMKV.getNumber(key: string)
+    return jsi::Function::createFromHostFunction(
+        runtime, jsi::PropNameID::forAscii(runtime, propName),
+        1, // key
+        [this](jsi::Runtime& runtime, const jsi::Value& thisValue, const jsi::Value* arguments,
+               size_t count) -> jsi::Value {
+          if (count != 1 || !arguments[0].isString()) [[unlikely]] {
+            throw jsi::JSError(runtime, "First argument ('key') has to be of type string!");
+          }
+
+          std::string keyName = arguments[0].getString(runtime).utf8(runtime);
+          bool hasValue;
+          double value = instance->getDouble(keyName, 0.0, &hasValue);
+          if (!hasValue) [[unlikely]] {
+            return jsi::Value::undefined();
+          }
+          return jsi::Value(value);
+        });
+  }
+
+  if (propName == "getString") {
+    // MMKV.getString(key: string)
+    return jsi::Function::createFromHostFunction(
+        runtime, jsi::PropNameID::forAscii(runtime, propName),
+        1, // key
+        [this](jsi::Runtime& runtime, const jsi::Value& thisValue, const jsi::Value* arguments,
+               size_t count) -> jsi::Value {
+          if (count != 1 || !arguments[0].isString()) [[unlikely]] {
+            throw jsi::JSError(runtime, "First argument ('key') has to be of type string!");
+          }
+
+          std::string keyName = arguments[0].getString(runtime).utf8(runtime);
+          std::string result;
+          bool hasValue = instance->getString(keyName, result);
+          if (!hasValue) [[unlikely]] {
+            return jsi::Value::undefined();
+          }
+          return jsi::Value(runtime, jsi::String::createFromUtf8(runtime, result));
+        });
+  }
+
+  if (propName == "getBuffer") {
+    // MMKV.getBuffer(key: string)
+    return jsi::Function::createFromHostFunction(
+        runtime, jsi::PropNameID::forAscii(runtime, propName),
+        1, // key
+        [this](jsi::Runtime& runtime, const jsi::Value& thisValue, const jsi::Value* arguments,
+               size_t count) -> jsi::Value {
+          if (count != 1 || !arguments[0].isString()) [[unlikely]] {
+            throw jsi::JSError(runtime, "First argument ('key') has to be of type string!");
+          }
+
+          std::string keyName = arguments[0].getString(runtime).utf8(runtime);
+          mmkv::MMBuffer buffer;
+          bool hasValue = instance->getBytes(keyName, buffer);
+          if (!hasValue) [[unlikely]] {
+            return jsi::Value::undefined();
+          }
+          auto mutableData = std::make_shared<MMKVManagedBuffer>(std::move(buffer));
+          return jsi::ArrayBuffer(runtime, mutableData);
+        });
+  }
+
+  if (propName == "contains") {
+    // MMKV.contains(key: string)
+    return jsi::Function::createFromHostFunction(
+        runtime, jsi::PropNameID::forAscii(runtime, propName),
+        1, // key
+        [this](jsi::Runtime& runtime, const jsi::Value& thisValue, const jsi::Value* arguments,
+               size_t count) -> jsi::Value {
+          if (count != 1 || !arguments[0].isString()) [[unlikely]] {
+            throw jsi::JSError(runtime, "First argument ('key') has to be of type string!");
+          }
+
+          std::string keyName = arguments[0].getString(runtime).utf8(runtime);
+          bool containsKey = instance->containsKey(keyName);
+          return jsi::Value(containsKey);
+        });
+  }
+
+  if (propName == "delete") {
+    // MMKV.delete(key: string)
+    return jsi::Function::createFromHostFunction(
+        runtime, jsi::PropNameID::forAscii(runtime, propName),
+        1, // key
+        [this](jsi::Runtime& runtime, const jsi::Value& thisValue, const jsi::Value* arguments,
+               size_t count) -> jsi::Value {
+          if (count != 1 || !arguments[0].isString()) [[unlikely]] {
+            throw jsi::JSError(runtime, "First argument ('key') has to be of type string!");
+          }
+
+          std::string keyName = arguments[0].getString(runtime).utf8(runtime);
+          instance->removeValueForKey(keyName);
+          return jsi::Value::undefined();
+        });
+  }
+
+  if (propName == "getAllKeys") {
+    // MMKV.getAllKeys()
+    return jsi::Function::createFromHostFunction(
+        runtime, jsi::PropNameID::forAscii(runtime, propName), 0,
+        [this](jsi::Runtime& runtime, const jsi::Value& thisValue, const jsi::Value* arguments,
+               size_t count) -> jsi::Value {
+          std::vector<std::string> keys = instance->allKeys();
+          jsi::Array array(runtime, keys.size());
+          for (int i = 0; i < keys.size(); i++) {
+            array.setValueAtIndex(runtime, i, keys[i]);
+          }
+          return array;
+        });
+  }
+
+  if (propName == "clearAll") {
+    // MMKV.clearAll()
+    return jsi::Function::createFromHostFunction(
+        runtime, jsi::PropNameID::forAscii(runtime, propName), 0,
+        [this](jsi::Runtime& runtime, const jsi::Value& thisValue, const jsi::Value* arguments,
+               size_t count) -> jsi::Value {
+          instance->clearAll();
+          return jsi::Value::undefined();
+        });
+  }
+
+  if (propName == "recrypt") {
+    // MMKV.recrypt(encryptionKey)
+    return jsi::Function::createFromHostFunction(
+        runtime, jsi::PropNameID::forAscii(runtime, propName),
+        1, // encryptionKey
+        [this](jsi::Runtime& runtime, const jsi::Value& thisValue, const jsi::Value* arguments,
+               size_t count) -> jsi::Value {
+          if (count != 1) [[unlikely]] {
+            throw jsi::JSError(runtime, "Expected 1 argument (encryptionKey), but received " +
+                                            std::to_string(count) + "!");
+          }
+
+          bool successful = false;
+          if (arguments[0].isUndefined()) {
+            // reset encryption key to "no encryption"
+            successful = instance->reKey(std::string());
+          } else if (arguments[0].isString()) {
+            // reKey(..) with new encryption-key
+            std::string encryptionKey = arguments[0].getString(runtime).utf8(runtime);
+            successful = instance->reKey(encryptionKey);
+          } else [[unlikely]] {
+            // Invalid argument (maybe object?)
+            throw jsi::JSError(
+                runtime,
+                "First argument ('encryptionKey') has to be of type string (or undefined)!");
+          }
+
+          if (!successful) [[unlikely]] {
+            throw jsi::JSError(runtime, "Failed to recrypt MMKV instance!");
+          }
+
+          return jsi::Value::undefined();
+        });
+  }
+
+  if (propName == "trim") {
+    // MMKV.trim()
+    return jsi::Function::createFromHostFunction(
+        runtime, jsi::PropNameID::forAscii(runtime, propName), 0,
+        [this](jsi::Runtime& runtime, const jsi::Value& thisValue, const jsi::Value* arguments,
+               size_t count) -> jsi::Value {
+          instance->clearMemoryCache();
+          instance->trim();
+
+          return jsi::Value::undefined();
+        });
+  }
+
+  if (propName == "size") {
+    // MMKV.size
+    size_t size = instance->actualSize();
+    return jsi::Value(static_cast<int>(size));
+  }
+
+  if (propName == "isReadOnly") {
+    // MMKV.isReadOnly
+    bool isReadOnly = instance->isReadOnly();
+    return jsi::Value(isReadOnly);
+  }
+
+  return jsi::Value::undefined();
+}

package/cpp/MmkvHostObject.h

@@ -0,0 +1,32 @@
+//
+//  MmkvHostObject.h
+//  Mmkv
+//
+//  Created by Marc Rousavy on 03.09.21.
+//  Copyright © 2021 Facebook. All rights reserved.
+//
+
+#pragma once
+
+#include "MMKV.h"
+#include "NativeMmkvModule.h"
+#include <jsi/jsi.h>
+
+using namespace facebook;
+using namespace mmkv;
+
+class MmkvHostObject : public jsi::HostObject {
+public:
+  MmkvHostObject(const facebook::react::MMKVConfig& config);
+  ~MmkvHostObject();
+
+public:
+  jsi::Value get(jsi::Runtime&, const jsi::PropNameID& name) override;
+  std::vector<jsi::PropNameID> getPropertyNames(jsi::Runtime& rt) override;
+
+private:
+  static MMKVMode getMMKVMode(const facebook::react::MMKVConfig& config);
+
+private:
+  MMKV* instance;
+};

package/cpp/MmkvLogger.h

@@ -0,0 +1,35 @@
+//
+//  MmkvLogger.h
+//  react-native-mmkv
+//
+//  Created by Marc Rousavy on 25.03.24.
+//
+
+#include <string>
+
+class MmkvLogger {
+private:
+  MmkvLogger() = delete;
+
+private:
+  template <typename... Args>
+  static std::string string_format(const std::string& format, Args... args) {
+    int size_s = std::snprintf(nullptr, 0, format.c_str(), args...) + 1; // Extra space for '\0'
+    if (size_s <= 0) {
+      throw std::runtime_error("Failed to format string!");
+    }
+    auto size = static_cast<size_t>(size_s);
+    std::unique_ptr<char[]> buf(new char[size]);
+    std::snprintf(buf.get(), size, format.c_str(), args...);
+    return std::string(buf.get(), buf.get() + size - 1); // We don't want the '\0' inside
+  }
+
+public:
+  static void log(const std::string& tag, const std::string& message);
+
+  template <typename... Args>
+  inline static void log(const std::string& tag, const std::string& formatString, Args&&... args) {
+    std::string formattedString = string_format(formatString, std::forward<Args>(args)...);
+    log(tag, formattedString);
+  }
+};

package/cpp/NativeMmkvModule.cpp

@@ -0,0 +1,43 @@
+//
+//  NativeMmkvModule.cpp
+//  react-native-mmkv
+//
+//  Created by Marc Rousavy on 25.03.2024.
+//
+
+#include "NativeMmkvModule.h"
+#include "MMKV.h"
+#include "MmkvHostObject.h"
+#include "MmkvLogger.h"
+
+namespace facebook::react {
+
+NativeMmkvModule::NativeMmkvModule(std::shared_ptr<CallInvoker> jsInvoker)
+    : NativeMmkvCxxSpec(jsInvoker) {}
+
+bool NativeMmkvModule::initialize(jsi::Runtime& runtime, std::string basePath) {
+  if (basePath.empty()) {
+    throw jsi::JSError(runtime, "Path cannot be empty!");
+  }
+
+  MmkvLogger::log("RNMMKV", "Initializing MMKV at %s...", basePath.c_str());
+
+#ifdef DEBUG
+  MMKVLogLevel logLevel = MMKVLogDebug;
+#else
+  MMKVLogLevel logLevel = MMKVLogWarning;
+#endif
+
+  MMKV::initializeMMKV(basePath, logLevel);
+
+  return true;
+}
+
+NativeMmkvModule::~NativeMmkvModule() {}
+
+jsi::Object NativeMmkvModule::createMMKV(jsi::Runtime& runtime, MMKVConfig config) {
+  auto instance = std::make_shared<MmkvHostObject>(config);
+  return jsi::Object::createFromHostObject(runtime, instance);
+}
+
+} // namespace facebook::react

package/cpp/NativeMmkvModule.h

@@ -0,0 +1,38 @@
+//
+//  NativeMmkvModule.h
+//  react-native-mmkv
+//
+//  Created by Marc Rousavy on 25.03.2024.
+//
+
+#pragma once
+
+#if __has_include(<React-Codegen/RNMmkvSpecJSI.h>)
+// CocoaPods include (iOS)
+#include <React-Codegen/RNMmkvSpecJSI.h>
+#elif __has_include(<RNMmkvSpecJSI.h>)
+// CMake include on Android
+#include <RNMmkvSpecJSI.h>
+#else
+#error Cannot find react-native-mmkv spec! Try cleaning your cache and re-running CodeGen!
+#endif
+
+namespace facebook::react {
+
+// The MMKVConfiguration type from JS
+using MMKVConfig =
+    NativeMmkvConfiguration<std::string, std::optional<std::string>, std::optional<std::string>,
+                            std::optional<NativeMmkvMode>, std::optional<bool>>;
+template <> struct Bridging<MMKVConfig> : NativeMmkvConfigurationBridging<MMKVConfig> {};
+
+// The TurboModule itself
+class NativeMmkvModule : public NativeMmkvCxxSpec<NativeMmkvModule> {
+public:
+  NativeMmkvModule(std::shared_ptr<CallInvoker> jsInvoker);
+  ~NativeMmkvModule();
+
+  bool initialize(jsi::Runtime& runtime, std::string basePath);
+  jsi::Object createMMKV(jsi::Runtime& runtime, MMKVConfig config);
+};
+
+} // namespace facebook::react

package/harmony/reactNativeMMKV/BuildProfile.ets

@@ -0,0 +1,17 @@
+/**
+ * Use these variables when you tailor your ArkTS code. They must be of the const type.
+ */
+export const HAR_VERSION = '3.3.3';
+export const BUILD_MODE_NAME = 'debug';
+export const DEBUG = true;
+export const TARGET_NAME = 'default';
+
+/**
+ * BuildProfile Class is used only for compatibility purposes.
+ */
+export default class BuildProfile { 
+	static readonly HAR_VERSION = HAR_VERSION;
+	static readonly BUILD_MODE_NAME = BUILD_MODE_NAME;
+	static readonly DEBUG = DEBUG;
+	static readonly TARGET_NAME = TARGET_NAME;
+}

package/harmony/reactNativeMMKV/LICENSE

@@ -0,0 +1,20 @@
+MIT License
+
+Copyright (c) 2024 Marc Rousavy
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/harmony/reactNativeMMKV/NOTICE

@@ -0,0 +1,34 @@
+OPEN SOURCE SOFTWARE NOTICE
+
+Please note we provide an open source software notice for the third party open source software along with this software and/or this software component (in the following just “this SOFTWARE”). The open source software licenses are granted by the respective right holders.
+
+Warranty Disclaimer
+THE OPEN SOURCE SOFTWARE IN THIS PRODUCT IS DISTRIBUTED IN THE HOPE THAT IT WILL BE USEFUL, BUT WITHOUT ANY WARRANTY, WITHOUT EVEN THE IMPLIED WARRANTY OF MERCHANTABILITY OR FITNESS FOR A PARTICULAR PURPOSE. SEE THE APPLICABLE LICENSES FOR MORE DETAILS.
+
+Copyright Notice and License Texts
+
+----------------------------------------------------------------------
+Software: react-native-mmkv V3.3.0
+
+MIT License
+
+Copyright (c) 2024 Marc Rousavy
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.
+
+

package/harmony/reactNativeMMKV/README.OpenSource

@@ -0,0 +1,11 @@
+[
+    {
+        "Name": "react-native-mmkv",
+        "License": "MIT License",
+        "License File": "https://github.com/mrousavy/react-native-mmkv/blob/v3.3.0/LICENSE",
+        "Version Number": "v3.3.0",
+        "Owner" : "react-native-mmkv"
+        "Upstream URL": "https://github.com/mrousavy/react-native-mmkv",
+        "Description": " The fastest key/value storage for React Native. ~30x faster than AsyncStorage!"
+    }
+]

package/harmony/reactNativeMMKV/build-profile.json5

@@ -0,0 +1,9 @@
+{
+  "apiType": "stageMode",
+  "targets": [
+    {
+      "name": "default",
+      "runtimeOS": "HarmonyOS"
+    }
+  ]
+}

package/harmony/reactNativeMMKV/hvigorfile.ts

@@ -0,0 +1,6 @@
+import { harTasks } from '@ohos/hvigor-ohos-plugin';
+
+export default {
+    system: harTasks,  /* Built-in plugin of Hvigor. It cannot be modified. */
+    plugins:[]         /* Custom plugin to extend the functionality of Hvigor. */
+}

package/harmony/reactNativeMMKV/index.ets

@@ -0,0 +1,24 @@
+/**
+ * MIT License
+ *
+ * Copyright (C) 2025 Huawei Device Co., Ltd.
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a copy
+ * of this software and associated documentation files (the "Software"), to deal
+ * in the Software without restriction, including without limitation the rights
+ * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+ * copies of the Software, and to permit persons to whom the Software is
+ * furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included in all
+ * copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+ * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+ * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+ * SOFTWARE.
+ */
+export * from "./ts"

package/harmony/reactNativeMMKV/oh-package.json5

@@ -0,0 +1,15 @@
+{
+  "license": "MIT License",
+  "types": "",
+  "devDependencies": {
+
+  },
+  "author": "",
+  "name": "@react-native-ohos/react-native-mmkv",
+  "description": "The fastest key/value storage for React Native. ~30x faster than AsyncStorage! Works on Android, iOS and Web.",
+  "main": "index.ets",
+  "version": "3.3.1-1",
+  "dependencies": {
+    "@rnoh/react-native-openharmony": "0.72.90"
+  }
+}

package/harmony/reactNativeMMKV/src/main/cpp/CMakeLists.txt

@@ -0,0 +1,15 @@
+cmake_minimum_required(VERSION 3.13)
+set(CMAKE_VERBOSE_MAKEFILE on)
+set(rnoh_native_mmkv_generated_dir "${RNOH_GENERATED_DIR}/react_native_harmony_native_camera")
+file(GLOB rnoh_native_mmkv_SRC CONFIGURE_DEPENDS *.cpp)
+add_library(rnoh_native_mmkv SHARED ${rnoh_native_mmkv_SRC}
+                                     HarmonyLogger.cpp
+                                     )
+
+target_include_directories(rnoh_native_mmkv PUBLIC ${CMAKE_CURRENT_SOURCE_DIR})
+
+target_include_directories(rnoh_native_mmkv PUBLIC MMKV/Core)
+
+add_subdirectory(MMKV/Core core)
+
+target_link_libraries(rnoh_native_mmkv PUBLIC rnoh core libace_napi.z.so libhilog_ndk.z.so)