react-native-yoga-jsi 0.0.2

package/LICENSE

@@ -0,0 +1,27 @@
+**react-native-yoga-jsi**
+
+MIT License
+
+Copyright (c) 2021 Margelo GmbH
+
+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.
+
+**NodeJS Crypto**
+
+See https://github.com/nodejs/node/blob/main/LICENSE

package/README.md

@@ -0,0 +1,166 @@
+<a href="https://margelo.io">
+  <img src="./docs/img/banner.svg" width="100%" />
+</a>
+
+# ⚡️ react-native-yoga-jsi
+
+A fast implementation of Node's `crypto` module.
+
+> Note: This version `0.x` is the Old Architecture, Bridged version for React Native. The `1.x` and higher branches are refactored to work with the New Architecture, Bridgeless, and [`Nitro Modules`](https://github.com/mrousavy/react-native-nitro). Status, as always, will be represented in [implementation-coverage.md](../0.x/docs/implementation-coverage.md).
+
+## Features
+
+Unlike any other current JS-based polyfills, react-native-yoga-jsi is written in C/C++ JSI and provides much greater performance - especially on mobile devices.
+QuickCrypto can be used as a drop-in replacement for your Web3/Crypto apps to speed up common cryptography functions.
+
+- 🏎️ Up to 58x faster than all other solutions
+- ⚡️ Lightning fast implementation with pure C++ and JSI, instead of JS
+- 🧪 Well tested in JS and C++ (OpenSSL)
+- 💰 Made for crypto apps and Wallets
+- 🔢 Secure native compiled cryptography
+- 🔁 Easy drop-in replacement for [crypto-browserify](https://github.com/browserify/crypto-browserify) or [react-native-crypto](https://github.com/tradle/react-native-crypto)
+
+## Versions
+
+| Version              | RN Architecture                                                                                  | Modules                                                           |
+| -------------------- | ------------------------------------------------------------------------------------------------ | ----------------------------------------------------------------- |
+| `0.x` (you are here) | old                                                                                              | Bridge & JSI                                                      |
+| `1.x`+               | new [->](https://github.com/reactwg/react-native-new-architecture/blob/main/docs/enable-apps.md) | Nitro Modules [->](https://github.com/margelo/react-native-nitro) |
+
+## Benchmarks
+
+For example, creating a Wallet using ethers.js uses complex algorithms to generate a private-key/mnemonic-phrase pair:
+
+```ts
+const start = performance.now();
+const wallet = ethers.Wallet.createRandom();
+const end = performance.now();
+console.log(`Creating a Wallet took ${end - start} ms.`);
+```
+
+**Without** react-native-yoga-jsi 🐢:
+
+```
+Creating a Wallet took 16862 ms
+```
+
+**With** react-native-yoga-jsi ⚡️:
+
+```
+Creating a Wallet took 289 ms
+```
+
+---
+
+## Installation
+
+<h3>
+  React Native  <a href="#"><img src="./docs/img/react-native.png" height="15" /></a>
+</h3>
+
+```sh
+yarn add react-native-yoga-jsi
+cd ios && pod install
+```
+
+<h3>
+  Expo  <a href="#"><img src="./docs/img/expo.png" height="12" /></a>
+</h3>
+
+```sh
+expo install react-native-yoga-jsi
+expo prebuild
+```
+
+Optional: override `global.Buffer` and `global.crypto` in your application as early as possible for example in index.js.
+
+```ts
+import { install } from 'react-native-yoga-jsi';
+
+install();
+```
+
+## Replace `crypto-browserify`
+
+If you are using a library that depends on `crypto`, instead of polyfilling it with `crypto-browserify` (or `react-native-crypto`) you can use `react-native-yoga-jsi` for a fully native implementation. This way you can get much faster crypto operations with just a single-line change!
+
+### Using metro config
+
+Use the [`resolveRequest`](https://facebook.github.io/metro/docs/resolution#resolverequest-customresolver) configuration option in your `metro.config.js`
+
+```js
+config.resolver.resolveRequest = (context, moduleName, platform) => {
+  if (moduleName === 'crypto') {
+    // when importing crypto, resolve to react-native-yoga-jsi
+    return context.resolveRequest(context, 'react-native-yoga-jsi', platform);
+  }
+  // otherwise chain to the standard Metro resolver.
+  return context.resolveRequest(context, moduleName, platform);
+};
+```
+
+### Using babel-plugin-module-resolver
+
+You need to install `babel-plugin-module-resolver`, it's a babel plugin that will alias any imports in the code with the values you pass to it. It tricks any module that will try to import certain dependencies with the native versions we require for React Native.
+
+```sh
+yarn add --dev babel-plugin-module-resolver
+```
+
+Then, in your `babel.config.js`, add the plugin to swap the `crypto`, `stream` and `buffer` dependencies:
+
+```diff
+module.exports = {
+  presets: ['module:metro-react-native-babel-preset'],
+  plugins: [
++   [
++     'module-resolver',
++     {
++       alias: {
++         'crypto': 'react-native-yoga-jsi',
++         'stream': 'readable-stream',
++         'buffer': '@craftzdog/react-native-buffer',
++       },
++     },
++   ],
+    ...
+  ],
+};
+```
+
+Then restart your bundler using `yarn start --reset-cache`.
+
+## Usage
+
+For example, to hash a string with SHA256 you can do the following:
+
+```ts
+import QuickCrypto from 'react-native-yoga-jsi';
+
+const hashed = QuickCrypto.createHash('sha256')
+  .update('Damn, Margelo writes hella good software!')
+  .digest('hex');
+```
+
+## Limitations
+
+As the library uses JSI for synchronous native methods access, remote debugging (e.g. with Chrome) is no longer possible. Instead, you should use [Flipper](https://fbflipper.com).
+
+Not all cryptographic algorithms are supported yet. See the [implementation coverage](./docs/implementation-coverage.md) document for more details. If you need a specific algorithm, please open a `feature request` issue and we'll see what we can do.
+
+## Community Discord
+
+[Join the Margelo Community Discord](https://discord.gg/6CSHz2qAvA) to chat about react-native-yoga-jsi or other Margelo libraries.
+
+## Adopting at scale
+
+react-native-yoga-jsi was built at Margelo, an elite app development agency. For enterprise support or other business inquiries, contact us at <a href="mailto:hello@margelo.io?subject=Adopting react-native-yoga-jsi at scale">hello@margelo.io</a>!
+
+## Contributing
+
+See the [contributing guide](CONTRIBUTING.md) to learn how to contribute to the repository and the development workflow.
+
+## License
+
+- react-native-yoga-jsi is licensed under MIT.
+- react-native-yoga-jsi is heavily inspired by NodeJS Crypto, which is licensed under [nodejs/LICENSE](https://github.com/nodejs/node/blob/main/LICENSE).

package/android/CMakeLists.txt

@@ -0,0 +1,72 @@
+project(ReactNativeYogaJSI)
+cmake_minimum_required(VERSION 3.10.2)
+
+set(PACKAGE_NAME "reactnativeyogajsi")
+set(BUILD_DIR ${CMAKE_SOURCE_DIR}/build)
+set(CMAKE_VERBOSE_MAKEFILE ON)
+set(CMAKE_CXX_STANDARD 17)
+
+# set (CMAKE_C_FLAGS_DEBUG "${CMAKE_C_FLAGS_DEBUG} -g")
+# set (CMAKE_CXX_FLAGS_DEBUG "${CMAKE_CXX_FLAGS_DEBUG} -g")
+
+# Third party libraries (Prefabs)
+find_package(fbjni REQUIRED CONFIG)
+find_package(ReactAndroid REQUIRED CONFIG)
+find_package(openssl REQUIRED CONFIG)
+find_library(LOG_LIB log)
+
+# Set the Yoga path and include all files recursively
+set(YOGA_PATH "${NODE_MODULES_DIR}/react-native/ReactCommon/yoga")
+file(GLOB_RECURSE YOGA_SOURCES "${YOGA_PATH}/*.cpp" "${YOGA_PATH}/*.h")
+
+# Add main library sources
+add_library(
+  ${PACKAGE_NAME}
+  SHARED
+  "../cpp/yogaJSI.h"
+  "../cpp/nodeCreation.h"
+  "../cpp/configCreation.h"
+  "../cpp/macros.h"
+  "src/main/cpp/cpp-adapter.cpp"
+  ${YOGA_SOURCES} # Add Yoga sources
+)
+
+# Include directories for Yoga and other dependencies
+target_include_directories(
+  ${PACKAGE_NAME}
+  PRIVATE
+  "../cpp"
+  "src/main/cpp"
+  "${NODE_MODULES_DIR}/react-native/ReactCommon"
+  "${NODE_MODULES_DIR}/react-native/ReactCommon/callinvoker"
+  "${NODE_MODULES_DIR}/react-native/ReactAndroid/src/main/jni/react/turbomodule"
+  "${NODE_MODULES_DIR}/react-native/ReactCommon/jsi"
+  "${NODE_MODULES_DIR}/react-native/ReactCommon/turbomodule/core"
+  "${NODE_MODULES_DIR}/react-native/ReactCommon/react/nativemodule/core"
+  ${YOGA_PATH} # Add Yoga path to include directories
+)
+
+# Linking libraries
+target_link_libraries(
+  ${PACKAGE_NAME}
+  fbjni::fbjni                           # <-- fbjni
+  ${LOG_LIB}                             # <-- Logcat logger
+  ReactAndroid::jsi                      # <-- RN: JSI
+  android                                # <-- Android JNI core
+  openssl::crypto                        # <-- OpenSSL (Crypto)
+)
+
+# Conditionally link libraries based on ReactAndroid version
+if(ReactAndroid_VERSION_MINOR GREATER_EQUAL 76)
+  target_link_libraries(
+    ${PACKAGE_NAME}
+    ReactAndroid::reactnative             # <-- RN: Native Modules umbrella prefab
+  )
+else()
+  target_link_libraries(
+    ${PACKAGE_NAME}
+    ReactAndroid::turbomodulejsijni
+    ReactAndroid::reactnativejni           # <-- RN: React Native JNI bindings
+    ReactAndroid::react_nativemodule_core  # <-- RN: React Native native module core
+  )
+endif()

package/android/build.gradle

@@ -0,0 +1,190 @@
+import java.nio.file.Paths
+import com.android.Version
+
+def agpVersion = com.android.Version.ANDROID_GRADLE_PLUGIN_VERSION
+def agpVersionMajor = agpVersion.tokenize('.')[0].toInteger()
+def agpVersionMinor = agpVersion.tokenize('.')[1].toInteger()
+
+buildscript {
+  repositories {
+    maven {
+      url "https://plugins.gradle.org/m2/"
+    }
+    mavenCentral()
+    google()
+  }
+
+  dependencies {
+    classpath("com.android.tools.build:gradle:8.3.1")
+  }
+}
+
+def isNewArchitectureEnabled() {
+  // To opt-in for the New Architecture, you can either:
+  // - Set `newArchEnabled` to true inside the `gradle.properties` file
+  // - Invoke gradle with `-newArchEnabled=true`
+  // - Set an environment variable `ORG_GRADLE_PROJECT_newArchEnabled=true`
+  return project.hasProperty("newArchEnabled") && project.newArchEnabled == "true"
+}
+
+def resolveBuildType() {
+    Gradle gradle = getGradle()
+    String tskReqStr = gradle.getStartParameter().getTaskRequests()['args'].toString()
+
+    return tskReqStr.contains('Release') ? 'release' : 'debug'
+}
+
+if (isNewArchitectureEnabled()) {
+  apply plugin: "com.facebook.react"
+}
+apply plugin: 'com.android.library'
+
+def safeExtGet(prop, fallback) {
+  rootProject.ext.has(prop) ? rootProject.ext.get(prop) : fallback
+}
+
+def reactNativeArchitectures() {
+  def value = project.getProperties().get("reactNativeArchitectures")
+  return value ? value.split(",") : ["armeabi-v7a", "x86", "x86_64", "arm64-v8a"]
+}
+
+static def findNodeModules(baseDir) {
+  def basePath = baseDir.toPath().normalize()
+  // Node's module resolution algorithm searches up to the root directory,
+  // after which the base path will be null
+  while (basePath) {
+    def nodeModulesPath = Paths.get(basePath.toString(), "node_modules")
+    def reactNativePath = Paths.get(nodeModulesPath.toString(), "react-native")
+    if (nodeModulesPath.toFile().exists() && reactNativePath.toFile().exists()) {
+      return nodeModulesPath.toString()
+    }
+    basePath = basePath.getParent()
+  }
+  throw new GradleException("react-native-yoga-jsi: Failed to find node_modules/ path!")
+}
+
+def nodeModules = findNodeModules(projectDir)
+
+repositories {
+  google()
+  mavenCentral()
+}
+
+android {
+  compileSdkVersion safeExtGet("compileSdkVersion", 31)
+
+  if ((agpVersionMajor == 7 && agpVersionMinor >= 3) || agpVersionMajor >= 8) {
+    // Namespace support was added in 7.3.0
+    namespace "com.yogajsi"
+
+    sourceSets {
+      main {
+        manifest.srcFile "src/main/AndroidManifestNew.xml"
+      }
+    }
+  }
+
+  if (agpVersionMajor >= 8) {
+      buildFeatures {
+          buildConfig = true
+      }
+  }
+
+  // Used to override the NDK path/version on internal CI or by allowing
+  // users to customize the NDK path/version from their root project (e.g. for M1 support)
+  if (rootProject.hasProperty("ndkPath")) {
+    ndkPath rootProject.ext.ndkPath
+  }
+  if (rootProject.hasProperty("ndkVersion")) {
+    ndkVersion rootProject.ext.ndkVersion
+  }
+
+  buildFeatures {
+    prefab true
+  }
+
+  defaultConfig {
+    minSdkVersion safeExtGet('minSdkVersion', 23)
+    targetSdkVersion safeExtGet('targetSdkVersion', 31)
+    versionCode 1
+    versionName "1.0"
+    buildConfigField "boolean", "IS_NEW_ARCHITECTURE_ENABLED", isNewArchitectureEnabled().toString()
+    externalNativeBuild {
+      cmake {
+        cppFlags "-O2 -frtti -fexceptions -Wall -Wno-unused-variable -fstack-protector-all -DANDROID"
+        arguments "-DANDROID_STL=c++_shared", "-DNODE_MODULES_DIR=${nodeModules}"
+        abiFilters (*reactNativeArchitectures())
+      }
+    }
+  }
+
+  externalNativeBuild {
+    cmake {
+      path "CMakeLists.txt"
+    }
+  }
+
+  packagingOptions {
+    doNotStrip resolveBuildType() == 'debug' ? "**/**/*.so" : ''
+    excludes = [
+            "**/libc++_shared.so",
+            "**/libfbjni.so",
+            "**/libreactnativejni.so",
+            "**/libjsi.so",
+            "**/libreact_nativemodule_core.so",
+            "**/libturbomodulejsijni.so",
+            "**/MANIFEST.MF",
+    ]
+  }
+
+  buildTypes {
+    release {
+      minifyEnabled false
+    }
+    debug {
+      packagingOptions {
+        doNotStrip '**/*.so'
+      }
+      minifyEnabled false
+      debuggable true
+      jniDebuggable true
+      renderscriptDebuggable true
+    }
+  }
+
+  lintOptions {
+    disable 'GradleCompatible'
+  }
+  compileOptions {
+    sourceCompatibility JavaVersion.VERSION_1_8
+    targetCompatibility JavaVersion.VERSION_1_8
+  }
+
+}
+
+repositories {
+  mavenCentral()
+  google()
+}
+
+dependencies {
+  //noinspection GradleDynamicVersion
+  implementation "com.facebook.react:react-android:+"
+  // https://mvnrepository.com/artifact/com.android.ndk.thirdparty/openssl
+  implementation 'com.android.ndk.thirdparty:openssl:1.1.1q-beta-1'
+}
+
+// Resolves "LOCAL_SRC_FILES points to a missing file, Check that libfb.so exists or that its path is correct".
+tasks.whenTaskAdded { task ->
+  if (task.name.contains("configureCMakeDebug")) {
+    rootProject.getTasksByName("packageReactNdkDebugLibs", true).forEach {
+      task.dependsOn(it)
+    }
+  }
+  // We want to add a dependency for both configureCMakeRelease and configureCMakeRelWithDebInfo
+  if (task.name.contains("configureCMakeRel")) {
+    rootProject.getTasksByName("packageReactNdkReleaseLibs", true).forEach {
+      task.dependsOn(it)
+    }
+  }
+}

package/android/gradle.properties

@@ -0,0 +1,6 @@
+YogaJSI_compileSdkVersion=31
+YogaJSI_targetSdkVersion=31
+YogaJSI_ndkversion=21.4.7075529
+YogaJSI_minSdkVersion=23
+
+android.useAndroidX=true

package/android/src/main/AndroidManifestNew.xml

@@ -0,0 +1,3 @@
+<manifest xmlns:android="http://schemas.android.com/apk/res/android">
+
+</manifest>

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

@@ -0,0 +1,17 @@
+#include <fbjni/fbjni.h>
+#include <jni.h>
+#include <jsi/jsi.h>
+#include "yogaJSI.h"
+#include <ReactCommon/CallInvokerHolder.h>
+
+using namespace facebook;
+
+extern "C" JNIEXPORT void JNICALL
+Java_com_yogajsi_YogaJSIModule_nativeInstall(JNIEnv *env, jobject thiz, jlong jsiPtr)
+{
+  auto runtime = reinterpret_cast<jsi::Runtime *>(jsiPtr);
+  if (runtime)
+  {
+    yogaJSI::install(*runtime);
+  }
+}

package/android/src/main/java/com/yogajsi/YogaJSIModule.java

@@ -0,0 +1,51 @@
+package com.yogajsi;
+
+import android.util.Log;
+
+import androidx.annotation.NonNull;
+
+import com.facebook.react.bridge.JavaScriptContextHolder;
+import com.facebook.react.bridge.ReactContextBaseJavaModule;
+import com.facebook.react.bridge.ReactApplicationContext;
+import com.facebook.react.bridge.ReactMethod;
+import com.facebook.react.module.annotations.ReactModule;
+
+@ReactModule(name = YogaJSIModule.NAME)
+public class YogaJSIModule extends ReactContextBaseJavaModule {
+  public static final String NAME = "YogaJSI";
+
+  public YogaJSIModule(ReactApplicationContext reactContext) {
+    super(reactContext);
+  }
+
+  @NonNull
+  @Override
+  public String getName() {
+    return NAME;
+  }
+
+  @ReactMethod(isBlockingSynchronousMethod = true)
+  public boolean install() {
+    try {
+      Log.i(NAME, "Loading C++ library...");
+      System.loadLibrary("reactnativeyogajsi");
+
+      JavaScriptContextHolder jsContext = getReactApplicationContext().getJavaScriptContextHolder();
+      if (jsContext.get() == 0) {
+        Log.e(NAME, "JSI Runtime is not available in JavaScriptContextHolder.");
+        return false;
+      }
+
+      Log.i(NAME, "Installing JSI Bindings for react-native-yoga-jsi...");
+      nativeInstall(jsContext.get());
+      Log.i(NAME, "Successfully installed JSI Bindings for react-native-yoga-jsi!");
+
+      return true;
+    } catch (Exception exception) {
+      Log.e(NAME, "Failed to install JSI Bindings for react-native-yoga-jsi!", exception);
+      return false;
+    }
+  }
+
+  private native void nativeInstall(long jsiPtr);
+}

package/android/src/main/java/com/yogajsi/YogaJSIPackage.java

@@ -0,0 +1,25 @@
+package com.yogajsi;
+
+import androidx.annotation.NonNull;
+
+import com.facebook.react.ReactPackage;
+import com.facebook.react.bridge.NativeModule;
+import com.facebook.react.bridge.ReactApplicationContext;
+import com.facebook.react.uimanager.ViewManager;
+
+import java.util.Collections;
+import java.util.List;
+
+public class YogaJSIPackage implements ReactPackage {
+  @NonNull
+  @Override
+  public List<NativeModule> createNativeModules(@NonNull ReactApplicationContext reactContext) {
+    return Collections.singletonList(new YogaJSIModule(reactContext));
+  }
+
+  @NonNull
+  @Override
+  public List<ViewManager> createViewManagers(@NonNull ReactApplicationContext reactContext) {
+    return Collections.emptyList();
+  }
+}

package/cpp/configCreation.h

@@ -0,0 +1,91 @@
+#ifndef CONFIG_CREATION_H
+#define CONFIG_CREATION_H
+
+#include <jsi/jsi.h>
+#include <yoga/Yoga.h>
+#include "macros.h"
+
+#define INSTALL_HOST_FUN_TO_CONFIG_CREATION(funcName, argCount, body)                                                                                    \
+    auto funcName = Function::createFromHostFunction(rt,                                                                                                 \
+                                                     PropNameID::forAscii(rt, #funcName),                                                                \
+                                                     argCount,                                                                                           \
+                                                     [](Runtime & runtime, const Value &thisValue, const Value *arguments, size_t count) -> Value body); \
+    configCreationObject.setProperty(rt, #funcName, std::move(funcName));
+
+#define INSTALL_HOST_FUN_TO_CONFIG(funcName, argCount, body)                                                                                                   \
+    auto funcName = Function::createFromHostFunction(runtime,                                                                                                  \
+                                                     PropNameID::forAscii(runtime, #funcName),                                                                 \
+                                                     argCount,                                                                                                 \
+                                                     [config](Runtime & runtime, const Value &thisValue, const Value *arguments, size_t count) -> Value body); \
+    configObject.setProperty(runtime, #funcName, std::move(funcName));
+
+using namespace facebook::jsi;
+
+namespace configCreation
+{
+
+    void setUpConfigObject()
+    {
+    }
+
+    void setConfigCreationObj(Object &yogaJsi, Runtime &rt)
+    {
+        auto configCreationObject = Object(rt);
+
+        INSTALL_HOST_FUN_TO_CONFIG_CREATION(create, 0, {
+            YGConfigRef config = YGConfigNew();
+
+            auto configObject = Object(runtime);
+
+            std::uintptr_t configPtr = reinterpret_cast<std::uintptr_t>(config);
+
+            char buffer[20];
+            std::snprintf(buffer, sizeof(buffer), "%lx", configPtr);
+            std::string configStr(buffer);
+
+            configObject.setProperty(runtime, "__config__", configStr);
+
+            INSTALL_HOST_FUN_TO_CONFIG(setPointScaleFactor, 1, {
+                YGConfigSetPointScaleFactor(config, arguments[0].getNumber());
+                return Value::undefined();
+            })
+
+            INSTALL_HOST_FUN_TO_CONFIG(setUseWebDefaults, 1, {
+                YGConfigSetUseWebDefaults(config, arguments[0].getBool());
+                return Value::undefined();
+            });
+
+            INSTALL_HOST_FUN_TO_CONFIG(useWebDefaults, 0, {
+                return Value(YGConfigGetUseWebDefaults(config));
+            });
+
+            INSTALL_HOST_FUN_TO_CONFIG(free, 0, {
+                YGConfigFree(config);
+                return Value::undefined();
+            });
+
+            INSTALL_HOST_FUN_TO_CONFIG(setExperimentalFeatureEnabled, 2, {
+                YGConfigSetExperimentalFeatureEnabled(
+                    config, static_cast<YGExperimentalFeature>(arguments[0].getNumber()), arguments[1].getBool());
+                return Value::undefined();
+            });
+
+            INSTALL_HOST_FUN_TO_CONFIG(isExperimentalFeatureEnabled, 1, {
+                return Value(YGConfigIsExperimentalFeatureEnabled(
+                    config, static_cast<YGExperimentalFeature>(arguments[0].getNumber())));
+            });
+
+            return configObject;
+        })
+
+        INSTALL_HOST_FUN_TO_CONFIG_CREATION(destroy, 1, {
+            READ_CONFIG(arguments[0])
+            YGConfigFree(config);
+            return Value::undefined();
+        })
+
+        yogaJsi.setProperty(rt, "Config", std::move(configCreationObject));
+    }
+}
+
+#endif // CONFIG_CREATION_H