react-native-unistyles 2.10.0 → 3.0.0-alpha.10

package/README.md

@@ -22,7 +22,7 @@
 ## Installation
 
 ```shell
-yarn add react-native-unistyles
+bun install react-native-unistyles
 ```
 Install CocoaPods dependencies / generate native folders with Expo:
 

package/{react-native-unistyles.podspec → Unistyles.podspec}

@@ -3,23 +3,31 @@ require "json"
 package = JSON.parse(File.read(File.join(__dir__, "package.json")))
 
 Pod::Spec.new do |s|
-  s.name         = package["name"]
+  s.name         = "Unistyles"
   s.version      = package["version"]
   s.summary      = package["description"]
   s.homepage     = package["homepage"]
   s.license      = package["license"]
   s.authors      = package["author"]
 
-  s.platforms    = { :ios => min_ios_version_supported, :osx => "10.14", :tvos => "9.0", :visionos => "1.0" }
+  s.platforms    = { :ios => min_ios_version_supported }
   s.source       = { :git => package["repository"], :tag => "#{s.version}" }
 
   s.source_files = [
-    "ios/**/*.{h,mm}",
-    "cxx/*.{h,cpp}"
+    "ios/**/*.{swift,h,mm}",
+    "cxx/**/*.{h,cpp,hpp}"
   ]
   s.pod_target_xcconfig = {
-    "CLANG_CXX_LANGUAGE_STANDARD" => "c++20"
+    "CLANG_CXX_LANGUAGE_STANDARD" => "c++20",
+    "GCC_PREPROCESSOR_DEFINITIONS" => "$(inherited) FOLLY_NO_CONFIG FOLLY_CFG_NO_COROUTINES"
   }
 
+  s.public_header_files = [
+    "ios/Unistyles.h"
+  ]
+
+  load 'nitrogen/generated/ios/Unistyles+autolinking.rb'
+  add_nitrogen_files(s)
+
   install_modules_dependencies(s)
 end

package/android/CMakeLists.txt

@@ -4,17 +4,26 @@ project(unistyles)
 
 add_library(unistyles
     SHARED
-    ../cxx/UnistylesRuntime.cpp
-    ../cxx/UnistylesModel.cpp
+    ../cxx/HostStyle.cpp
+    ../cxx/HybridUnistylesRuntime.cpp
+    ../cxx/HybridStatusBar.cpp
+    ../cxx/HybridNavigationBar.cpp
+    ../cxx/ShadowTreeTraverser.cpp
+    ../cxx/StyleSheet.cpp
+    ../cxx/StyleSheetImpl.cpp
+    ../cxx/StyleSheetRegistry.cpp
     ../cxx/UnistylesImpl.cpp
+    ../cxx/UnistylesModel.cpp
+    ../cxx/UnistylesRuntime.cpp
     ./src/main/cxx/cpp-adapter.cpp
     ./src/main/cxx/helpers.cpp
     ./src/main/cxx/platform.cpp
 )
 
-include_directories(
-    ../cxx
-)
+include_directories(../cxx)
+include("${CMAKE_SOURCE_DIR}/../nitrogen/generated/android/Unistyles+autolinking.cmake")
+
+string(APPEND CMAKE_CXX_FLAGS " -DFOLLY_NO_CONFIG")
 
 set_target_properties(unistyles PROPERTIES
     CXX_STANDARD 20
@@ -26,19 +35,28 @@ set_target_properties(unistyles PROPERTIES
 find_package(ReactAndroid REQUIRED CONFIG)
 find_package(fbjni REQUIRED CONFIG)
 
-# REACTNATIVE_MERGED_SO doesnt work as of RN 0.76.0-rc.3
-if (ReactAndroid_VERSION_MINOR GREATER_EQUAL 76)
-    target_link_libraries(unistyles ReactAndroid::reactnative)
-else()
-    target_link_libraries(unistyles
-        ReactAndroid::turbomodulejsijni
-        ReactAndroid::react_nativemodule_core
-        android
-        fbjni::fbjni
-    )
-endif()
+target_include_directories(
+    unistyles
+    PRIVATE
+    "../node_modules/react-native/ReactCommon"
+    "../node_modules/react-native/ReactAndroid/src/main/jni/react/turbomodule"
+    "../node_modules/react-native/ReactCommon/callinvoker"
+    "../node_modules/react-native/ReactCommon/runtimeexecutor"
+    "../node_modules/react-native/ReactCommon/yoga"
+    "../node_modules/react-native/ReactCommon/react/renderer/graphics/platform/cxx"
+)
 
 target_link_libraries(unistyles
     ReactAndroid::jsi
-    fbjni::fbjni
+    ReactAndroid::turbomodulejsijni
+    ReactAndroid::react_nativemodule_core
+    android
+    ReactAndroid::react_render_core
+    ReactAndroid::runtimeexecutor
+    ReactAndroid::fabricjni
+    ReactAndroid::react_debug
+    ReactAndroid::react_render_core
+    ReactAndroid::react_render_componentregistry
+    ReactAndroid::rrc_view
+    ReactAndroid::folly_runtime
 )

package/android/build.gradle

@@ -14,6 +14,7 @@ buildscript {
 
 apply plugin: 'com.android.library'
 apply plugin: 'org.jetbrains.kotlin.android'
+apply from: '../nitrogen/generated/android/Unistyles+autolinking.gradle'
 
 def resolveBuildType() {
     Gradle gradle = getGradle()
@@ -31,12 +32,12 @@ if (isNewArchitectureEnabled()) {
 }
 
 android {
-    compileSdkVersion safeExtGet('compileSdkVersion', 33)
+    compileSdkVersion safeExtGet('compileSdkVersion', 34)
     namespace "com.unistyles"
 
     defaultConfig {
         buildConfigField "boolean", "IS_NEW_ARCHITECTURE_ENABLED", isNewArchitectureEnabled().toString()
-        minSdkVersion safeExtGet('minSdkVersion', 21)
+        minSdkVersion safeExtGet('minSdkVersion', 23)
         externalNativeBuild {
             cmake {
                 arguments "-DANDROID_STL=c++_shared"
@@ -75,4 +76,5 @@ repositories {
 
 dependencies {
     implementation 'com.facebook.react:react-native'
+    implementation project(":react-native-nitro-modules")
 }

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

@@ -1,71 +1,88 @@
 #include <jni.h>
-#include <jsi/jsi.h>
-#include <map>
-#include <ReactCommon/CallInvokerHolder.h>
-#include "UnistylesRuntime.h"
-#include "helpers.h"
-#include "platform.h"
 
-using namespace facebook;
+#include <NitroModules/HybridObjectRegistry.hpp>
+#include <HybridUnistylesRuntime.h>
+#include <HybridStatusBar.h>
+#include <HybridNavigationBar.h>
 
-static jobject unistylesModule = nullptr;
-std::shared_ptr<UnistylesRuntime> unistylesRuntime = nullptr;
+JNIEXPORT jint JNICALL JNI_OnLoad(JavaVM* vm, void*) {
+    HybridObjectRegistry::registerHybridObjectConstructor("UnistylesRuntime", []() -> std::shared_ptr<HybridObject>{
+        return std::make_shared<HybridUnistylesRuntime>();
+    });
+    HybridObjectRegistry::registerHybridObjectConstructor("StatusBar", []() -> std::shared_ptr<HybridObject>{
+        return std::make_shared<HybridStatusBar>();
+    });
+    HybridObjectRegistry::registerHybridObjectConstructor("NavigationBar", []() -> std::shared_ptr<HybridObject>{
+        return std::make_shared<HybridNavigationBar>();
+    });
 
-extern "C"
-JNIEXPORT void JNICALL
-Java_com_unistyles_UnistylesModule_nativeInstall(JNIEnv *env, jobject thiz, jlong jsi, jobject callInvokerHolder) {
-    auto runtime = reinterpret_cast<jsi::Runtime *>(jsi);
-    auto callInvoker{
-        jni::alias_ref<react::CallInvokerHolder::javaobject>{ reinterpret_cast<react::CallInvokerHolder::javaobject>(callInvokerHolder)} -> cthis() ->getCallInvoker()
-    };
-
-    if (unistylesModule == nullptr) {
-        unistylesModule = env->NewGlobalRef(thiz);
-    }
-
-    if (unistylesModule == nullptr) {
-        return throwKotlinException(env, "Something went wrong while initializing UnistylesModule");
-    }
-
-    unistylesRuntime = std::make_shared<UnistylesRuntime>(*runtime, callInvoker);
-    makeShared(env, unistylesModule, unistylesRuntime);
-
-    jsi::Object hostObject = jsi::Object::createFromHostObject(*runtime, unistylesRuntime);
-    runtime->global().setProperty(*runtime, "__UNISTYLES__", std::move(hostObject));
-}
-
-extern "C"
-JNIEXPORT void JNICALL
-Java_com_unistyles_UnistylesModule_nativeDestroy(JNIEnv *env, jobject thiz) {
-    unistylesRuntime.reset();
-    unistylesModule = nullptr;
+    return JNI_VERSION_1_2;
 }
 
-extern "C"
-JNIEXPORT void JNICALL
-Java_com_unistyles_UnistylesModule_nativeOnOrientationChange(JNIEnv *env, jobject thiz, jobject screen, jobject insets, jobject statusBar, jobject navigationBar) {
-    if (unistylesRuntime != nullptr) {
-        Screen screenDimensions = jobjectToScreen(env, screen);
-        Dimensions statusBarDimensions = jobjectToDimensions(env, statusBar);
-        Insets screenInsets = jobjectToInsets(env, insets);
-        Dimensions navigationBarDimensions = jobjectToDimensions(env, navigationBar);
-
-        unistylesRuntime->handleScreenSizeChange(screenDimensions, screenInsets, statusBarDimensions, navigationBarDimensions);
-    }
-}
-
-extern "C"
-JNIEXPORT void JNICALL
-Java_com_unistyles_UnistylesModule_nativeOnAppearanceChange(JNIEnv *env, jobject thiz, jstring colorScheme) {
-    if (unistylesRuntime != nullptr) {
-        unistylesRuntime->handleAppearanceChange(env->GetStringUTFChars(colorScheme, nullptr));
-    }
-}
-
-extern "C"
-JNIEXPORT void JNICALL
-Java_com_unistyles_UnistylesModule_nativeOnContentSizeCategoryChange(JNIEnv *env, jobject thiz, jstring contentSizeCategory) {
-    if (unistylesRuntime != nullptr) {
-        unistylesRuntime->handleContentSizeCategoryChange(env->GetStringUTFChars(contentSizeCategory, nullptr));
-    }
-}
+//using namespace facebook;
+//
+//static jobject unistylesModule = nullptr;
+//std::shared_ptr<UnistylesRuntime> unistylesRuntime = nullptr;
+//
+//extern "C"
+//JNIEXPORT void JNICALL
+//Java_com_unistyles_UnistylesModule_nativeInstall(JNIEnv *env, jobject thiz, jlong jsi, jobject callInvokerHolder) {
+//    auto runtime = reinterpret_cast<jsi::Runtime *>(jsi);
+//    auto callInvoker{
+//        jni::alias_ref<react::CallInvokerHolder::javaobject>{ reinterpret_cast<react::CallInvokerHolder::javaobject>(callInvokerHolder)} -> cthis() ->getCallInvoker()
+//    };
+//
+//    if (unistylesModule == nullptr) {
+//        unistylesModule = env->NewGlobalRef(thiz);
+//    }
+//
+//    if (unistylesModule == nullptr) {
+//        return throwKotlinException(env, "Something went wrong while initializing UnistylesModule");
+//    }
+//
+//    unistylesRuntime = std::make_shared<UnistylesRuntime>(*runtime, callInvoker);
+//    auto styleSheet = std::make_shared<StyleSheet>(*runtime, unistylesRuntime);
+//
+//    makeShared(env, unistylesModule, unistylesRuntime);
+//
+//    jsi::Object hostObject = jsi::Object::createFromHostObject(*runtime, unistylesRuntime);
+//    jsi::Object styleSheetHostObject = jsi::Object::createFromHostObject(*runtime, styleSheet);
+//    runtime->global().setProperty(*runtime, "__UNISTYLES__", std::move(hostObject));
+//    runtime->global().setProperty(*runtime, "__UNISTYLES__STYLESHEET__", std::move(styleSheetHostObject));
+//}
+//
+//extern "C"
+//JNIEXPORT void JNICALL
+//Java_com_unistyles_UnistylesModule_nativeDestroy(JNIEnv *env, jobject thiz) {
+//    unistylesRuntime.reset();
+//    unistylesModule = nullptr;
+//}
+//
+//extern "C"
+//JNIEXPORT void JNICALL
+//Java_com_unistyles_UnistylesModule_nativeOnOrientationChange(JNIEnv *env, jobject thiz, jobject screen, jobject insets, jobject statusBar, jobject navigationBar) {
+//    if (unistylesRuntime != nullptr) {
+//        Screen screenDimensions = jobjectToScreen(env, screen);
+//        Dimensions statusBarDimensions = jobjectToDimensions(env, statusBar);
+//        Insets screenInsets = jobjectToInsets(env, insets);
+//        Dimensions navigationBarDimensions = jobjectToDimensions(env, navigationBar);
+//
+//        unistylesRuntime->handleScreenSizeChange(screenDimensions, screenInsets, statusBarDimensions, navigationBarDimensions);
+//    }
+//}
+//
+//extern "C"
+//JNIEXPORT void JNICALL
+//Java_com_unistyles_UnistylesModule_nativeOnAppearanceChange(JNIEnv *env, jobject thiz, jstring colorScheme) {
+//    if (unistylesRuntime != nullptr) {
+//        unistylesRuntime->handleAppearanceChange(env->GetStringUTFChars(colorScheme, nullptr));
+//    }
+//}
+//
+//extern "C"
+//JNIEXPORT void JNICALL
+//Java_com_unistyles_UnistylesModule_nativeOnContentSizeCategoryChange(JNIEnv *env, jobject thiz, jstring contentSizeCategory) {
+//    if (unistylesRuntime != nullptr) {
+//        unistylesRuntime->handleContentSizeCategoryChange(env->GetStringUTFChars(contentSizeCategory, nullptr));
+//    }
+//}

package/android/src/main/java/com/unistyles/UnistylesPackage.kt

@@ -1,18 +1,28 @@
 package com.unistyles
 
-import android.view.View
-import com.facebook.react.ReactPackage
+import android.util.Log
+import com.facebook.react.TurboReactPackage
 import com.facebook.react.bridge.NativeModule
 import com.facebook.react.bridge.ReactApplicationContext
-import com.facebook.react.uimanager.ReactShadowNode
-import com.facebook.react.uimanager.ViewManager
+import com.facebook.react.module.model.ReactModuleInfoProvider
 
-class UnistylesPackage: ReactPackage {
-    override fun createNativeModules(reactContext: ReactApplicationContext): MutableList<NativeModule> {
-        return mutableListOf(UnistylesModule(reactContext))
+class UnistylesPackage: TurboReactPackage() {
+    companion object {
+        private const val TAG: String = "Unistyles"
+
+        init {
+            try {
+                System.loadLibrary("unistyles")
+                Log.i(TAG, "Installed Unistyles \uD83E\uDD84!")
+            } catch (e: Throwable) {
+                Log.e(TAG, "Failed to load Unistyles C++ library! Is it properly linked?", e)
+                throw e
+            }
+        }
     }
 
-    override fun createViewManagers(reactContext: ReactApplicationContext): MutableList<ViewManager<View, ReactShadowNode<*>>> {
-        return mutableListOf()
+    override fun getModule(name: String, reactContext: ReactApplicationContext): NativeModule? = null
+    override fun getReactModuleInfoProvider(): ReactModuleInfoProvider {
+        return ReactModuleInfoProvider { emptyMap() }
     }
 }

package/cxx/common/Breakpoints.h

@@ -0,0 +1,43 @@
+#pragma once
+
+#include <jsi/jsi.h>
+#include "Helpers.h"
+
+using namespace facebook;
+
+namespace margelo::nitro::unistyles::helpers {
+
+using Breakpoints = std::vector<std::pair<std::string, double>>;
+
+// convert user's breakpoints to sorted C++ representation
+inline Breakpoints jsiBreakpointsToVecPairs(jsi::Runtime& rt, jsi::Value&& breakpoints) {
+    Breakpoints sortedVecPairs;
+    
+    enumerateJSIObject(rt, breakpoints.asObject(rt), [&](const std::string& propertyName, jsi::Value& propertyValue){
+        assertThat(rt, propertyValue.isNumber(), "value for breakpoint " + std::string(propertyName) + " is not a number.");
+        
+        sortedVecPairs.emplace_back(propertyName, propertyValue.asNumber());
+    });
+    
+    std::sort(sortedVecPairs.begin(), sortedVecPairs.end(), [](auto& a, auto& b){
+        return a.second < b.second;
+    });
+    
+    return sortedVecPairs;
+}
+
+// C++ function to select current breakpoint based on screen width
+inline std::string getBreakpointFromScreenWidth(int screenWidth, const Breakpoints& sortedVecPairs) {
+    auto it = std::upper_bound(sortedVecPairs.cbegin(), sortedVecPairs.cend(), screenWidth, [](int width, const auto& pair) {
+        return width < pair.second;
+    });
+    
+    // return breakpoint with 0 as lowest
+    if (it == sortedVecPairs.begin()) {
+        return sortedVecPairs.front().first;
+    }
+    
+    return (--it)->first;
+}
+
+}

package/cxx/common/Constants.h

@@ -0,0 +1,11 @@
+#pragma once
+
+namespace margelo::nitro::unistyles::helpers {
+
+static const std::string UNISTYLES_ID = "__unid";
+static const std::string ADD_VARIANTS_FN = "useVariants";
+static const std::string STYLE_DEPENDENCIES = "uni__dependencies";
+static const std::string STYLE_VARIANTS = "uni__variants";
+static const std::string WEB_STYLE_KEY = "_web";
+
+}

package/cxx/common/Helpers.h

@@ -0,0 +1,185 @@
+#pragma once
+
+#include <jsi/jsi.h>
+#include <jsi/JSIDynamic.h>
+#include <folly/dynamic.h>
+#include <unordered_set>
+
+using namespace facebook;
+
+namespace margelo::nitro::unistyles::helpers {
+
+using Variants = std::vector<std::pair<std::string, std::string>>;
+
+inline void assertThat(jsi::Runtime& rt, bool condition, const std::string& message) {
+    if (!condition) {
+        throw jsi::JSError(rt, message);
+    }
+}
+
+inline void enumerateJSIObject(jsi::Runtime& rt, const jsi::Object& obj, std::function<void(const std::string& propertyName, jsi::Value& propertyValue)> callback) {
+    jsi::Array propertyNames = obj.getPropertyNames(rt);
+    size_t length = propertyNames.size(rt);
+    
+    for (size_t i = 0; i < length; i++) {
+        auto propertyName = propertyNames.getValueAtIndex(rt, i).asString(rt).utf8(rt);
+        auto propertyValue = obj.getProperty(rt, propertyName.c_str());
+        
+        callback(propertyName, propertyValue);
+    }
+}
+
+template<typename PropertyType>
+inline bool vecContainsKeys(std::vector<PropertyType>& vec, std::vector<PropertyType>&& keys) {
+    std::unordered_set<PropertyType> availableKeys(keys.begin(), keys.end());
+    
+    for (const auto& key : vec) {
+        availableKeys.erase(key);
+        
+        if (availableKeys.empty()) {
+            return true;
+        }
+    }
+    
+    return false;
+}
+
+template<typename PropertyType>
+inline void defineHiddenProperty(jsi::Runtime& rt, jsi::Object& object, const std::string& propName, PropertyType&& property) {
+    auto global = rt.global();
+    auto objectConstructor = global.getPropertyAsObject(rt, "Object");
+    auto defineProperty = objectConstructor.getPropertyAsFunction(rt, "defineProperty");
+
+    facebook::jsi::Object descriptor(rt);
+
+    if constexpr (std::is_same_v<std::decay_t<PropertyType>, jsi::Function>) {
+        descriptor.setProperty(rt, facebook::jsi::PropNameID::forUtf8(rt, "value"), std::forward<PropertyType>(property));
+    } else {
+        descriptor.setProperty(rt, facebook::jsi::PropNameID::forUtf8(rt, "value"), property);
+    }
+
+    descriptor.setProperty(rt, facebook::jsi::PropNameID::forUtf8(rt, "enumerable"), facebook::jsi::Value(false));
+    descriptor.setProperty(rt, facebook::jsi::PropNameID::forUtf8(rt, "writable"), facebook::jsi::Value(true));
+    descriptor.setProperty(rt, facebook::jsi::PropNameID::forUtf8(rt, "configurable"), facebook::jsi::Value(true));
+
+    defineProperty.call(rt, object, facebook::jsi::String::createFromAscii(rt, propName.c_str()), descriptor);
+}
+
+inline jsi::Object& mergeJSIObjects(jsi::Runtime&rt, jsi::Object& obj1, jsi::Object& obj2) {
+    helpers::enumerateJSIObject(rt, obj2, [&](const std::string& propertyName, jsi::Value& propertyValue){
+        obj1.setProperty(rt, propertyName.c_str(), propertyValue);
+    });
+
+    return obj1;
+}
+
+inline void iterateJSIArray(jsi::Runtime& rt, const jsi::Array& array, std::function<void(size_t, jsi::Value&)> callback) {
+    size_t length = array.size(rt);
+
+    for (size_t i = 0; i < length; i++) {
+        auto value = array.getValueAtIndex(rt, i);
+
+        callback(i, value);
+    }
+}
+
+inline bool isPlatformColor(jsi::Runtime& rt, jsi::Object& maybePlatformColor) {
+    auto isIOSPlatformColor = maybePlatformColor.hasProperty(rt, "semantic") && maybePlatformColor.getProperty(rt, "semantic").isObject();
+
+    if (isIOSPlatformColor) {
+        return true;
+    }
+
+    // Android
+    return maybePlatformColor.hasProperty(rt, "resource_paths") && maybePlatformColor.getProperty(rt, "resource_paths").isObject();
+}
+
+inline Variants variantsToPairs(jsi::Runtime& rt, jsi::Object&& variants) {
+    Variants pairs{};
+
+    helpers::enumerateJSIObject(rt, variants, [&](const std::string& variantName, jsi::Value& variantValue){
+        if (variantValue.isUndefined() || variantValue.isNull()) {
+            return;
+        }
+
+        if (variantValue.isBool()) {
+            pairs.emplace_back(std::make_pair(variantName, variantValue.asBool() ? "true" : "false"));
+
+            return;
+        }
+
+        if (variantValue.isString()) {
+            pairs.emplace_back(std::make_pair(variantName, variantValue.asString(rt).utf8(rt)));
+        }
+    });
+
+    return pairs;
+}
+
+inline jsi::Object variantsToValue(jsi::Runtime& rt, Variants& variants) {
+    jsi::Object rawVariants = jsi::Object(rt);
+    
+    std::for_each(variants.begin(), variants.end(), [&](std::pair<std::string, std::string>& pair){
+        rawVariants.setProperty(rt, pair.first.c_str(), jsi::String::createFromUtf8(rt, pair.second));
+    });
+    
+    return rawVariants;
+}
+
+inline std::vector<folly::dynamic> parseDynamicFunctionArguments(jsi::Runtime& rt, jsi::Array& arguments) {
+    std::vector<folly::dynamic> parsedArgument{};
+    size_t count = arguments.size(rt);
+
+    parsedArgument.reserve(count);
+
+    for (size_t i = 0; i < count; i++) {
+        jsi::Value arg = arguments.getValueAtIndex(rt, i);
+
+        if (arg.isBool()) {
+            parsedArgument.push_back(folly::dynamic(arg.asBool()));
+
+            continue;
+        }
+
+        if (arg.isNumber()) {
+            parsedArgument.push_back(folly::dynamic(arg.asNumber()));
+
+            continue;
+        }
+
+        if (arg.isString()) {
+            parsedArgument.push_back(folly::dynamic(arg.asString(rt).utf8(rt)));
+
+            continue;
+        }
+
+        if (arg.isUndefined()) {
+            parsedArgument.push_back(folly::dynamic());
+
+            continue;
+        }
+
+        if (arg.isNull()) {
+            parsedArgument.push_back(folly::dynamic(nullptr));
+
+            continue;
+        }
+
+        if (!arg.isObject()) {
+            continue;;
+        }
+
+        auto argObj = arg.asObject(rt);
+
+        // allow arrays and objects too
+        if (!argObj.isFunction(rt) && !argObj.isArrayBuffer(rt)) {
+            parsedArgument.push_back(jsi::dynamicFromValue(rt, arg));
+
+            continue;
+        }
+    }
+
+    return parsedArgument;
+}
+
+}

package/cxx/core/HostStyle.cpp

@@ -0,0 +1,63 @@
+#include "HostStyle.h"
+
+using namespace margelo::nitro::unistyles::core;
+using namespace margelo::nitro::unistyles::parser;
+using namespace facebook;
+
+std::vector<jsi::PropNameID> HostStyle::getPropertyNames(jsi::Runtime& rt) {
+    auto propertyNames = std::vector<jsi::PropNameID> {};
+
+    propertyNames.reserve(8);
+
+    for (const auto& pair : this->_styleSheet->unistyles) {
+        propertyNames.emplace_back(jsi::PropNameID::forUtf8(rt, pair.first));
+    }
+
+    return propertyNames;
+}
+
+jsi::Value HostStyle::get(jsi::Runtime& rt, const jsi::PropNameID& propNameId) {
+    auto propertyName = propNameId.utf8(rt);
+
+    if (propertyName == helpers::UNISTYLES_ID) {
+        return jsi::Value(this->_styleSheet->tag);
+    }
+
+    if (propertyName == helpers::ADD_VARIANTS_FN) {
+        return this->createAddVariantsProxyFunction(rt);
+    }
+
+    if (this->_styleSheet->unistyles.contains(propertyName)) {
+        return valueFromUnistyle(rt, this->_styleSheet->unistyles[propertyName]);
+    }
+    
+    if (propertyName == helpers::STYLE_VARIANTS) {
+        return helpers::variantsToValue(rt, this->_variants);
+    }
+
+    return jsi::Value::undefined();
+}
+
+jsi::Function HostStyle::createAddVariantsProxyFunction(jsi::Runtime& rt) {
+    auto useVariantsFnName = jsi::PropNameID::forUtf8(rt, helpers::ADD_VARIANTS_FN);
+
+    return jsi::Function::createFromHostFunction(rt, useVariantsFnName, 1, [&](jsi::Runtime &rt, const jsi::Value &thisVal, const jsi::Value *arguments, size_t count){
+        helpers::assertThat(rt, count == 1, "Unistyles: useVariants expected to be called with one argument.");
+        helpers::assertThat(rt, arguments[0].isObject(), "Unistyles: useVariants expected to be called with object.");
+
+        auto parser = parser::Parser(this->_unistylesRuntime);
+        auto pairs = helpers::variantsToPairs(rt, arguments[0].asObject(rt));
+
+        if (pairs == this->_variants) {
+            return jsi::Value::undefined();
+        }
+
+        this->_variants = pairs;
+
+        parser.rebuildUnistylesWithVariants(rt, this->_styleSheet, this->_variants);
+
+        return jsi::Value::undefined();
+    });
+}
+
+void HostStyle::set(jsi::Runtime& rt, const jsi::PropNameID& propNameId, const jsi::Value& value) {}

package/cxx/core/HostStyle.h

@@ -0,0 +1,28 @@
+#pragma once
+
+#include <jsi/jsi.h>
+#include "StyleSheet.h"
+#include "Constants.h"
+#include "Parser.h"
+#include "HybridUnistylesRuntime.h"
+
+namespace margelo::nitro::unistyles::core {
+
+using Variants = std::vector<std::pair<std::string, std::string>>;
+
+struct JSI_EXPORT HostStyle : public jsi::HostObject {
+    HostStyle(std::shared_ptr<StyleSheet> styleSheet, std::shared_ptr<HybridUnistylesRuntime> unistylesRuntime)
+        : _styleSheet{styleSheet}, _unistylesRuntime{unistylesRuntime} {};
+
+    std::vector<jsi::PropNameID> getPropertyNames(jsi::Runtime& rt);
+    jsi::Value get(jsi::Runtime& rt, const jsi::PropNameID& propNameId);
+    void set(jsi::Runtime& rt, const jsi::PropNameID& propNameId, const jsi::Value& value);
+    jsi::Function createAddVariantsProxyFunction(jsi::Runtime& rt);
+
+private:
+    std::shared_ptr<StyleSheet> _styleSheet;
+    std::shared_ptr<HybridUnistylesRuntime> _unistylesRuntime;
+    std::vector<std::pair<std::string, std::string>> _variants{};    
+};
+
+}