@react-native-ohos/react-native-blurhash 2.0.4-rc.1

package/harmony/blurhash/src/main/cpp/BlurhashViewComponentInstance.cpp

@@ -0,0 +1,137 @@
+/*
+ * Copyright (c) 2024 Huawei Device Co., Ltd. All rights reserved
+ * Use of this source code is governed by a MIT license that can be
+ * found in the LICENSE file.
+ */
+
+#include "BlurhashViewComponentInstance.h"
+#include "Blurhash.hpp"
+#include "Props.h"
+#include <filemanagement/file_uri/oh_file_uri.h>
+#include "RNBlurhashTurboModule.h"
+#include <filemanagement/environment/error_code.h>
+#include <iomanip>
+#include <react/renderer/core/ConcreteState.h>
+#include <sstream>
+#include <cstdio>
+
+namespace rnoh {
+
+BlurhashViewComponentInstance::BlurhashViewComponentInstance(Context context) : CppComponentInstance(std::move(context)) {
+    this->getLocalRootArkUINode().setNodeDelegate(this);
+}
+
+void BlurhashViewComponentInstance::onPropsChanged(SharedConcreteProps const &props) {
+
+    CppComponentInstance::onPropsChanged(props);
+
+    if (!m_props || m_props->resizeMode != props->resizeMode) {
+        this->getLocalRootArkUINode().setResizeMode(convertToImageResizeMode(props->resizeMode));
+    }
+    // Validate inputs and early-return to avoid passing null/invalid data into ArkUI
+    if (props->blurhash == "") {
+        if (m_eventEmitter) m_eventEmitter->onLoadError({.message = "The provided Blurhash string must not be empty!"});
+        return;
+    }
+    if (props->decodeWidth <= 0) {
+        if (m_eventEmitter) m_eventEmitter->onLoadError({.message = "decodeWidth must be greater than 0!"});
+        return;
+    }
+    if (props->decodeHeight <= 0) {
+        if (m_eventEmitter) m_eventEmitter->onLoadError({.message = "decodeHeight must be greater than 0!"});
+        return;
+    }
+    if (props->decodePunch <= 0) {
+        if (m_eventEmitter) m_eventEmitter->onLoadError({.message = "decodePunch must be greater than 0!"});
+        return;
+    }
+
+    std::string filePath = decodeImageByBlurhash(props->blurhash, props->decodeWidth, props->decodeHeight, props->decodePunch);
+    if (filePath.empty()) {
+        if (m_eventEmitter) m_eventEmitter->onLoadError({.message = "Failed to decode blurhash to image."});
+        return;
+    }
+    
+
+    // If filePath is already a URI, use it directly
+    if (filePath.find("://") != std::string::npos) {
+    this->getLocalRootArkUINode().setSource(filePath);
+        return;
+    }
+    // If filePath is an absolute path, use it as-is; otherwise prefix cache dir
+    std::string absPath = filePath;
+    if (!(absPath.rfind("/", 0) == 0)) {
+        absPath = "/data/storage/el2/base/haps/entry/cache/" + absPath;
+    }
+
+    const char *path = absPath.c_str();
+    unsigned int length = static_cast<unsigned int>(absPath.size());
+    char *result = nullptr;
+    FileManagement_ErrCode ret = OH_FileUri_GetUriFromPath(path, length, &result);
+    if (ret != FileManagement_ErrCode::ERR_OK || result == nullptr) {
+        if (m_eventEmitter) m_eventEmitter->onLoadError({.message = "Failed to convert path to file URI."});
+        return;
+    }
+    std::string uriStr(result);
+    this->getLocalRootArkUINode().setSource(uriStr);
+    free(result);
+}
+
+std::string BlurhashViewComponentInstance::decodeImageByBlurhash(const std::string &blurhash, const int &width, const int &height, const float &punch) {
+    std::string expectedName = blurhash + ".bmp";
+    blurhash::decode(blurhash, width, height, punch);
+    auto rnInstance = m_deps->rnInstance.lock();
+    auto turboModule = rnInstance->getTurboModule("ImageLoader");
+    auto arkTsTurboModule = std::dynamic_pointer_cast<rnoh::ArkTSTurboModule>(turboModule);
+    if (!arkTsTurboModule) {
+        return expectedName; // fallback filename
+    }
+    auto cache = arkTsTurboModule->callSync("getPrefetchResult", {expectedName});
+    std::string result;
+    if (cache.isString()) {
+        result = cache.asString();
+    }
+    if (result.empty()) {
+        // in case non-string/unsupported shape returned, fallback
+        result = expectedName;
+    }
+    return result;
+}
+
+BlurhashNode &BlurhashViewComponentInstance::getLocalRootArkUINode() { return m_imageNode; }
+
+void BlurhashViewComponentInstance::onComplete() {
+    if (m_eventEmitter) {
+        m_eventEmitter->onLoadStart({});
+        m_eventEmitter->onLoadEnd({});
+    }
+}
+
+void BlurhashViewComponentInstance::onError(int32_t errorCode) {
+    if (m_eventEmitter) {
+    m_eventEmitter->onLoadError({.message = ""});
+    }
+}
+
+void BlurhashViewComponentInstance::onLoadStart(SharedConcreteProps const &props) {
+    if (m_eventEmitter) {
+    // RN 0.77: DirectEventHandler<null>
+    m_eventEmitter->onLoadStart({});
+    }
+}
+
+facebook::react::ImageResizeMode BlurhashViewComponentInstance::convertToImageResizeMode(facebook::react::BlurhashViewResizeMode mode) {
+    switch (mode) {
+    case facebook::react::BlurhashViewResizeMode::Contain:
+        return facebook::react::ImageResizeMode::Contain;
+    case facebook::react::BlurhashViewResizeMode::Cover:
+        return facebook::react::ImageResizeMode::Cover;
+    case facebook::react::BlurhashViewResizeMode::Stretch:
+        return facebook::react::ImageResizeMode::Stretch;
+    case facebook::react::BlurhashViewResizeMode::Center:
+        return facebook::react::ImageResizeMode::Center;
+    }
+    // Fallback to avoid undefined behavior
+    return facebook::react::ImageResizeMode::Cover;
+}
+} // namespace rnoh

package/harmony/blurhash/src/main/cpp/BlurhashViewComponentInstance.h

@@ -0,0 +1,34 @@
+/*
+ * Copyright (c) 2024 Huawei Device Co., Ltd. All rights reserved
+ * Use of this source code is governed by a MIT license that can be
+ * found in the LICENSE file.
+ */
+
+#pragma once
+
+#include "EventEmitters.h"
+#include "BlurhashNode.h"
+#include "ShadowNodes.h"
+#include "RNOH/CppComponentInstance.h"
+#include "RNOH/arkui/ImageNode.h"
+
+namespace rnoh {
+class BlurhashViewComponentInstance : public CppComponentInstance<facebook::react::BlurhashViewShadowNode>, public BlurhashNodeDelegate {
+private:
+    BlurhashNode m_imageNode;
+    std::string m_uri;
+
+    std::string decodeImageByBlurhash(std::string const &blurhash, int const &width, int const &height, float const &punch);
+
+public:
+    BlurhashViewComponentInstance(Context context);
+    void onPropsChanged(SharedConcreteProps const &props) override;
+    void onComplete() override;
+    void onLoadStart(SharedConcreteProps const &props);
+    void onError(int32_t errorCode) override;
+
+    facebook::react::ImageResizeMode convertToImageResizeMode(facebook::react::BlurhashViewResizeMode mode);
+
+    BlurhashNode &getLocalRootArkUINode() override;
+};
+} // namespace rnoh

package/harmony/blurhash/src/main/cpp/BlurhashViewJSIBinder.h

@@ -0,0 +1,34 @@
+/*
+ * Copyright (c) 2024 Huawei Device Co., Ltd. All rights reserved
+ * Use of this source code is governed by a MIT license that can be
+ * found in the LICENSE file.
+ */
+
+#pragma once
+
+#include "RNOHCorePackage/ComponentBinders/ViewComponentJSIBinder.h"
+
+namespace rnoh {
+class BlurhashViewJSIBinder : public ViewComponentJSIBinder {
+protected:
+    facebook::jsi::Object createNativeProps(facebook::jsi::Runtime &rt) override {
+        auto object = ViewComponentJSIBinder::createNativeProps(rt);
+        object.setProperty(rt, "imgUri", true);
+        object.setProperty(rt, "blurhash", true);
+        object.setProperty(rt, "decodeWidth", true);
+        object.setProperty(rt, "decodeHeight", true);
+        object.setProperty(rt, "decodePunch", true);
+        object.setProperty(rt, "decodeAsync", true);
+        object.setProperty(rt, "resizeMode", true);
+        return object;
+    }
+
+    facebook::jsi::Object createDirectEventTypes(facebook::jsi::Runtime &rt) override {
+        facebook::jsi::Object events(rt);
+        events.setProperty(rt, "topLoadStart", createDirectEvent(rt, "onLoadStart"));
+        events.setProperty(rt, "topLoadEnd", createDirectEvent(rt, "onLoadEnd"));
+        events.setProperty(rt, "topLoadError", createDirectEvent(rt, "onLoadError"));
+        return events;
+    }
+};
+} // namespace rnoh

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

@@ -0,0 +1,13 @@
+cmake_minimum_required(VERSION 3.13)
+set(CMAKE_VERBOSE_MAKEFILE on)
+
+file(GLOB rnoh_blurhash_SRC CONFIGURE_DEPENDS
+*.cpp
+)
+add_library(rnoh_blurhash SHARED ${rnoh_blurhash_SRC})
+target_include_directories(rnoh_blurhash PUBLIC ${CMAKE_CURRENT_SOURCE_DIR})
+#target_include_directories(rnoh_blurhash PRIVATE ${CMAKE_CURRENT_SOURCE_DIR}/openssl/include)
+
+target_link_libraries(rnoh_blurhash PUBLIC rnoh)
+target_link_libraries(rnoh_blurhash PUBLIC libohfileuri.so)
+#target_link_libraries(rnoh_blurhash PRIVATE ${CMAKE_CURRENT_SOURCE_DIR}/openssl/lib/libcrypto.a)

package/harmony/blurhash/src/main/cpp/ComponentDescriptors.h

@@ -0,0 +1,18 @@
+/*
+ * Copyright (c) 2024 Huawei Device Co., Ltd. All rights reserved
+ * Use of this source code is governed by a MIT license that can be
+ * found in the LICENSE file.
+ */
+
+#pragma once
+
+#include "ShadowNodes.h"
+#include <react/renderer/core/ConcreteComponentDescriptor.h>
+
+namespace facebook {
+namespace react {
+
+using BlurhashViewComponentDescriptor = ConcreteComponentDescriptor<BlurhashViewShadowNode>;
+
+} // namespace react
+} // namespace facebook

package/harmony/blurhash/src/main/cpp/EventEmitters.cpp

@@ -0,0 +1,36 @@
+/*
+ * Copyright (c) 2024 Huawei Device Co., Ltd. All rights reserved
+ * Use of this source code is governed by a MIT license that can be
+ * found in the LICENSE file.
+ */
+
+#include "EventEmitters.h"
+
+
+namespace facebook {
+namespace react {
+
+void BlurhashViewEventEmitter::onLoadError(OnLoadError event) const {
+    dispatchEvent("LoadError", [event = std::move(event)](jsi::Runtime &runtime) {
+        auto payload = jsi::Object(runtime);
+        payload.setProperty(runtime, "message", event.message);
+        return payload;
+    });
+}
+
+void BlurhashViewEventEmitter::onLoadEnd(OnLoadEnd event) const {
+    dispatchEvent("LoadEnd", [](jsi::Runtime &runtime) {
+        auto payload = jsi::Object(runtime);
+        return payload;
+    });
+}
+void BlurhashViewEventEmitter::onLoadStart(OnLoadStart event) const {
+    dispatchEvent("LoadStart", [](jsi::Runtime &runtime) {
+        auto payload = jsi::Object(runtime);
+        return payload;
+    });
+}
+
+
+} // namespace react
+} // namespace facebook

package/harmony/blurhash/src/main/cpp/EventEmitters.h

@@ -0,0 +1,40 @@
+/*
+ * Copyright (c) 2024 Huawei Device Co., Ltd. All rights reserved
+ * Use of this source code is governed by a MIT license that can be
+ * found in the LICENSE file.
+ */
+
+#pragma once
+
+#include <react/renderer/components/view/ViewEventEmitter.h>
+#include <jsi/jsi.h>
+
+namespace facebook {
+namespace react {
+
+class JSI_EXPORT BlurhashViewEventEmitter : public ViewEventEmitter {
+public:
+    using ViewEventEmitter::ViewEventEmitter;
+
+    struct OnLoadStart {
+        std::string blurhash;
+        int decodeWidth;
+        int decodeHeight;
+        double  decodePunch;
+    };
+
+    struct OnLoadEnd {};
+
+    struct OnLoadError {
+        std::string message;
+    };
+
+    void onLoadError(OnLoadError value) const;
+
+    void onLoadEnd(OnLoadEnd value) const;
+
+    void onLoadStart(OnLoadStart value) const;
+};
+
+} // namespace react
+} // namespace facebook

package/harmony/blurhash/src/main/cpp/Props.cpp

@@ -0,0 +1,25 @@
+/*
+ * Copyright (c) 2024 Huawei Device Co., Ltd. All rights reserved
+ * Use of this source code is governed by a MIT license that can be
+ * found in the LICENSE file.
+ */
+
+#include "Props.h"
+#include <react/renderer/core/PropsParserContext.h>
+#include <react/renderer/core/propsConversions.h>
+
+namespace facebook {
+namespace react {
+
+BlurhashViewProps::BlurhashViewProps(const PropsParserContext &context, const BlurhashViewProps &sourceProps, const RawProps &rawProps)
+    : ViewProps(context, sourceProps, rawProps), 
+      imgUri(convertRawProp(context, rawProps, "imgUri", sourceProps.imgUri, {})),
+      blurhash(convertRawProp(context, rawProps, "blurhash", sourceProps.blurhash, {})),
+      decodeWidth(convertRawProp(context, rawProps, "decodeWidth", sourceProps.decodeWidth, {})),
+      decodeHeight(convertRawProp(context, rawProps, "decodeHeight", sourceProps.decodeHeight, {})),
+      decodePunch(convertRawProp(context, rawProps, "decodePunch", sourceProps.decodePunch, {})),
+      decodeAsync(convertRawProp(context, rawProps, "decodeAsync", sourceProps.decodeAsync, {})),
+      resizeMode(convertRawProp(context, rawProps, "resizeMode", sourceProps.resizeMode, {facebook::react::BlurhashViewResizeMode::Cover})) {}
+
+} // namespace react
+} // namespace facebook

package/harmony/blurhash/src/main/cpp/Props.h

@@ -0,0 +1,73 @@
+/*
+ * Copyright (c) 2024 Huawei Device Co., Ltd. All rights reserved
+ * Use of this source code is governed by a MIT license that can be
+ * found in the LICENSE file.
+ */
+
+#pragma once
+
+#include <jsi/jsi.h>
+#include <react/renderer/components/view/ViewProps.h>
+#include <react/renderer/core/PropsParserContext.h>
+#include <react/renderer/core/propsConversions.h>
+#include <vector>
+#include <react/renderer/imagemanager/primitives.h>
+
+namespace facebook {
+namespace react {
+
+enum class BlurhashViewResizeMode { Contain, Cover, Stretch, Center };
+
+static inline void fromRawValue(const PropsParserContext &context, const RawValue &value, BlurhashViewResizeMode &result) {
+    auto string = (std::string)value;
+    if (string == "contain") {
+        result = BlurhashViewResizeMode::Contain;
+        return;
+    }
+    if (string == "cover") {
+        result = BlurhashViewResizeMode::Cover;
+        return;
+    }
+    if (string == "stretch") {
+        result = BlurhashViewResizeMode::Stretch;
+        return;
+    }
+    if (string == "center") {
+        result = BlurhashViewResizeMode::Center;
+        return;
+    }
+    abort();
+}
+
+static inline std::string toString(const BlurhashViewResizeMode &value) {
+    switch (value) {
+    case BlurhashViewResizeMode::Contain:
+        return "contain";
+    case BlurhashViewResizeMode::Cover:
+        return "cover";
+    case BlurhashViewResizeMode::Stretch:
+        return "stretch";
+    case BlurhashViewResizeMode::Center:
+        return "center";
+    }
+}
+
+enum class decodeWeight { defaltWeight };
+
+class JSI_EXPORT BlurhashViewProps final : public ViewProps {
+public:
+    BlurhashViewProps() = default;
+    BlurhashViewProps(const PropsParserContext &context, const BlurhashViewProps &sourceProps, const RawProps &rawProps);
+
+#pragma mark - Props
+    std::string imgUri{};
+    std::string blurhash{};
+    int decodeWidth{};
+    int decodeHeight{};
+    double decodePunch{};
+    bool decodeAsync{};
+    BlurhashViewResizeMode resizeMode{BlurhashViewResizeMode::Cover};
+};
+
+} // namespace react
+} // namespace facebook

package/harmony/blurhash/src/main/cpp/RNBlurhashTurboModule.cpp

@@ -0,0 +1,42 @@
+/*
+ * Copyright (c) 2024 Huawei Device Co., Ltd. All rights reserved
+ * Use of this source code is governed by a MIT license that can be
+ * found in the LICENSE file.
+ */
+
+#include "RNBlurhashTurboModule.h"
+#include "Blurhash.hpp"
+#include <sstream>
+#include <jsi/jsi.h>
+#include <react/renderer/components/view/ViewProps.h>
+#include <react/renderer/core/propsConversions.h>
+#include <react/renderer/imagemanager/primitives.h>
+#include <string>
+
+using namespace rnoh;
+using namespace facebook;
+
+using Object = std::optional<jsi::Object>;
+
+static jsi::Value __hostFunction_RNBlurhashInstallModule_createBlurhashFromImage(jsi::Runtime &rt, react::TurboModule &turboModule, const jsi::Value *args,
+                                                                                 size_t count) {
+    
+    return static_cast<ArkTSTurboModule &>(turboModule).callAsync(rt, "createBlurhashFromImage", args, count);
+}
+
+
+void RNBlurhashTurboModule::clearCosineCache() {
+    ::blurhash::clearCache();
+    return;
+}
+
+static jsi::Value __hostFunction_RNBlurhashInstallModule_clearCosineCache(jsi::Runtime &rt, react::TurboModule &turboModule, const jsi::Value *args, size_t count) {
+    static_cast<RNBlurhashTurboModule *>(&turboModule)->clearCosineCache();
+    return jsi::Value::undefined();
+};
+
+
+RNBlurhashTurboModule::RNBlurhashTurboModule(const ArkTSTurboModule::Context ctx, const std::string name) : ArkTSTurboModule(ctx, name) {
+    methodMap_["clearCosineCache"] = MethodMetadata{0, __hostFunction_RNBlurhashInstallModule_clearCosineCache};
+    methodMap_["createBlurhashFromImage"] = MethodMetadata{4, __hostFunction_RNBlurhashInstallModule_createBlurhashFromImage};
+}

package/harmony/blurhash/src/main/cpp/RNBlurhashTurboModule.h

@@ -0,0 +1,19 @@
+/*
+ * Copyright (c) 2024 Huawei Device Co., Ltd. All rights reserved
+ * Use of this source code is governed by a MIT license that can be
+ * found in the LICENSE file.
+ */
+#pragma once
+
+#include <ReactCommon/TurboModule.h>
+#include "RNOH/ArkTSTurboModule.h"
+namespace rnoh {
+
+class JSI_EXPORT RNBlurhashTurboModule : public ArkTSTurboModule {
+public:
+    RNBlurhashTurboModule(const ArkTSTurboModule::Context ctx, const std::string name);
+
+    void clearCosineCache();
+
+};
+} // namespace rnoh

package/harmony/blurhash/src/main/cpp/ShadowNodes.cpp

@@ -0,0 +1,15 @@
+/*
+ * Copyright (c) 2024 Huawei Device Co., Ltd. All rights reserved
+ * Use of this source code is governed by a MIT license that can be
+ * found in the LICENSE file.
+ */
+
+#include "ShadowNodes.h"
+
+namespace facebook {
+namespace react {
+
+extern const char BlurhashViewComponentName[] = "BlurhashView";
+
+} // namespace react
+} // namespace facebook

package/harmony/blurhash/src/main/cpp/ShadowNodes.h

@@ -0,0 +1,27 @@
+/*
+ * Copyright (c) 2024 Huawei Device Co., Ltd. All rights reserved
+ * Use of this source code is governed by a MIT license that can be
+ * found in the LICENSE file.
+ */
+
+#pragma once
+#include "Props.h"
+#include "EventEmitters.h"
+#include <react/renderer/components/view/ConcreteViewShadowNode.h>
+#include <jsi/jsi.h>
+
+namespace facebook {
+namespace react {
+
+JSI_EXPORT extern const char BlurhashViewComponentName[];
+
+/*
+ * `ShadowNode` for <BlurhashView> component.
+ */
+using BlurhashViewShadowNode = ConcreteViewShadowNode<
+    BlurhashViewComponentName,
+    BlurhashViewProps,
+    BlurhashViewEventEmitter>;
+
+} // namespace react
+} // namespace facebook

package/harmony/blurhash/src/main/cpp/SparseArray.cpp

@@ -0,0 +1,28 @@
+/*
+ * Copyright (c) 2024 Huawei Device Co., Ltd. All rights reserved
+ * Use of this source code is governed by a MIT license that can be
+ * found in the LICENSE file.
+ */
+
+#include "SparseArray.h"
+#include <stdexcept>
+
+template <typename T> void SparseArray<T>::set(int key, const T &value) { data[key] = value; }
+
+template <typename T> T SparseArray<T>::get(int key) const {
+    auto it = data.find(key);
+    if (it != data.end()) {
+        return it->second;
+    }
+    throw std::runtime_error("Key not found");
+}
+
+template <typename T> void SparseArray<T>::remove(int key) { data.erase(key); }
+
+template <typename T> void SparseArray<T>::clear() { data.clear(); }
+
+template <typename T> bool SparseArray<T>::containsKey(int key) const { return data.find(key) != data.end(); }
+
+// 显式实例化模板类
+template class SparseArray<std::vector<double>>;
+template class SparseArray<std::vector<int>>;

package/harmony/blurhash/src/main/cpp/SparseArray.h

@@ -0,0 +1,26 @@
+/*
+ * Copyright (c) 2024 Huawei Device Co., Ltd. All rights reserved
+ * Use of this source code is governed by a MIT license that can be
+ * found in the LICENSE file.
+ */
+
+#ifndef SPARSEARRAY_H
+#define SPARSEARRAY_H
+
+#include <unordered_map>
+#include <vector>
+
+template <typename T>
+class SparseArray {
+private:
+    std::unordered_map<int, T> data;
+
+public:
+    void set(int key, const T &value);
+    T get(int key) const;
+    void remove(int key);
+    void clear();
+    bool containsKey(int key) const;
+};
+
+#endif // SPARSEARRAY_H

package/harmony/blurhash/src/main/cpp/napi_init.cpp

@@ -0,0 +1,68 @@
+/**
+ * MIT License
+ *
+ * Copyright (C) 2024 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.
+ */
+
+#include "RNOH/ArkJS.h"
+#include "Blurhash.hpp"
+#include "napi/native_api.h"
+
+
+static napi_value getEncode(napi_env env, napi_callback_info info){
+    ArkJS arkJs(env);
+    auto args = arkJs.getCallbackArgs(info, 3);
+    std::string filename = arkJs.getString(args[0]);
+    int components_x = arkJs.getInteger(args[1]);
+    int components_y = arkJs.getInteger(args[2]);
+    
+    std::string blurhashcode = blurhash::encode(filename.c_str(),components_x,components_y);
+    
+    napi_value val;
+    napi_create_string_utf8(env, blurhashcode.c_str(), blurhashcode.size(), &val);
+    return val;
+}
+
+EXTERN_C_START
+static napi_value Init(napi_env env, napi_value exports)
+{
+    napi_property_descriptor desc[] = {
+        { "getEncode", nullptr, getEncode, nullptr, nullptr, nullptr, napi_default, nullptr }
+    };
+    napi_define_properties(env, exports, sizeof(desc) / sizeof(desc[0]), desc);
+    return exports;
+}
+EXTERN_C_END
+
+static napi_module blurhashModule = {
+    .nm_version = 1,
+    .nm_flags = 0,
+    .nm_filename = nullptr,
+    .nm_register_func = Init,
+    .nm_modname = "rnoh_blurhash",
+    .nm_priv = ((void*)0),
+    .reserved = { 0 },
+};
+
+extern "C" __attribute__((constructor)) void RegisterNdktesterModule(void)
+{
+    napi_module_register(&blurhashModule);
+}