react-native-unistyles 3.0.0-alpha.9 → 3.0.0-beta.2

package/cxx/parser/Parser.cpp

@@ -1,4 +1,5 @@
 #include "Parser.h"
+#include "UnistyleWrapper.h"
 
 using namespace margelo::nitro::unistyles;
 using namespace facebook;
@@ -8,19 +9,19 @@ using Variants = std::vector<std::pair<std::string, std::string>>;
 
 // called only once while processing StyleSheet.create
 void parser::Parser::buildUnistyles(jsi::Runtime& rt, std::shared_ptr<StyleSheet> styleSheet) {
-    jsi::Object unwrappedStyleSheet = this->unwrapStyleSheet(rt, styleSheet);
+    jsi::Object unwrappedStyleSheet = this->unwrapStyleSheet(rt, styleSheet, std::nullopt);
 
     helpers::enumerateJSIObject(rt, unwrappedStyleSheet, [&](const std::string& styleKey, jsi::Value& propertyValue){
         helpers::assertThat(rt, propertyValue.isObject(), "Unistyles: Style with name '" + styleKey + "' is not a function or object.");
 
         jsi::Object styleValue = propertyValue.asObject(rt);
 
-
         if (styleValue.isFunction(rt)) {
             styleSheet->unistyles[styleKey] = std::make_shared<UnistyleDynamicFunction>(
                 UnistyleType::DynamicFunction,
                 styleKey,
-                styleValue
+                styleValue,
+                styleSheet
             );
 
             return;
@@ -29,12 +30,92 @@ void parser::Parser::buildUnistyles(jsi::Runtime& rt, std::shared_ptr<StyleSheet
         styleSheet->unistyles[styleKey] = std::make_shared<Unistyle>(
             UnistyleType::Object,
             styleKey,
-            styleValue
+            styleValue,
+            styleSheet
         );
     });
 }
 
-jsi::Object parser::Parser::unwrapStyleSheet(jsi::Runtime& rt, std::shared_ptr<StyleSheet> styleSheet) {
+jsi::Value parser::Parser::getParsedStyleSheetForScopedTheme(jsi::Runtime& rt, core::Unistyle::Shared unistyle, std::string& scopedTheme) {
+    // for static stylesheets and exotic styles we don't need to do anything
+    if (unistyle->parent == nullptr || unistyle->parent->type == StyleSheetType::Static) {
+        return jsi::Value::undefined();
+    }
+
+    auto& state = core::UnistylesRegistry::get().getState(rt);
+    auto jsTheme = state.getJSThemeByName(scopedTheme);
+
+    if (unistyle->parent->type == StyleSheetType::Themable) {
+        return unistyle->parent->rawValue
+            .asFunction(rt)
+            .call(rt, std::move(jsTheme))
+            .asObject(rt);
+    }
+
+    auto miniRuntime = this->_unistylesRuntime->getMiniRuntimeAsValue(rt, std::nullopt);
+
+    return unistyle->parent->rawValue
+        .asFunction(rt)
+        .call(rt, std::move(jsTheme), std::move(miniRuntime))
+        .asObject(rt);
+}
+
+void parser::Parser::rebuildUnistyleWithScopedTheme(jsi::Runtime& rt, jsi::Value& jsScopedTheme, std::shared_ptr<core::UnistyleData> unistyleData) {
+    auto parsedStyleSheet = jsScopedTheme.isUndefined()
+        ? this->getParsedStyleSheetForScopedTheme(rt, unistyleData->unistyle, unistyleData->scopedTheme.value())
+        : jsScopedTheme.asObject(rt);
+
+    if (parsedStyleSheet.isUndefined()) {
+        return;
+    }
+
+    // get target style
+    auto targetStyle = parsedStyleSheet.asObject(rt).getProperty(rt, unistyleData->unistyle->styleKey.c_str()).asObject(rt);
+
+    // for object we just need to parse it
+    if (unistyleData->unistyle->type == UnistyleType::Object) {
+        // we need to temporarly swap rawValue to enforce correct parings
+        auto sharedRawValue = std::move(unistyleData->unistyle->rawValue);
+
+        unistyleData->unistyle->rawValue = std::move(targetStyle);
+        unistyleData->parsedStyle = this->parseFirstLevel(rt, unistyleData->unistyle, unistyleData->variants);
+        unistyleData->unistyle->rawValue = std::move(sharedRawValue);
+
+        return;
+    }
+
+    // for functions we need to call them with memoized arguments
+    auto unistyleFn = std::dynamic_pointer_cast<UnistyleDynamicFunction>(unistyleData->unistyle);
+
+    // convert arguments to jsi::Value
+    std::vector<jsi::Value> args{};
+    auto arguments = unistyleData->dynamicFunctionMetadata.value();
+
+    args.reserve(arguments.size());
+
+    for (int i = 0; i < arguments.size(); i++) {
+        folly::dynamic& arg = arguments.at(i);
+
+        args.emplace_back(jsi::valueFromDynamic(rt, arg));
+    }
+
+    const jsi::Value *argStart = args.data();
+
+    // we need to temporarly swap unprocessed value to enforce correct parings
+    auto sharedUnprocessedValue = std::move(unistyleFn->unprocessedValue);
+
+    // call cached function with memoized arguments
+    auto functionResult = targetStyle
+        .asFunction(rt)
+        .call(rt, argStart, arguments.size())
+        .asObject(rt);
+
+    unistyleFn->unprocessedValue = std::move(functionResult);
+    unistyleData->parsedStyle = this->parseFirstLevel(rt, unistyleFn, unistyleData->variants);
+    unistyleFn->unprocessedValue = std::move(sharedUnprocessedValue);
+}
+
+jsi::Object parser::Parser::unwrapStyleSheet(jsi::Runtime& rt, std::shared_ptr<StyleSheet> styleSheet, std::optional<UnistylesNativeMiniRuntime> maybeMiniRuntime) {
     // firstly we need to get object representation of user's StyleSheet
     // StyleSheet can be a function or an object
 
@@ -45,7 +126,7 @@ jsi::Object parser::Parser::unwrapStyleSheet(jsi::Runtime& rt, std::shared_ptr<S
 
     // StyleSheet is a function
     auto& state = core::UnistylesRegistry::get().getState(rt);
-    auto theme = state.getJSTheme();
+    auto theme = state.getCurrentJSTheme();
 
     if (styleSheet->type == StyleSheetType::Themable) {
         return styleSheet->rawValue
@@ -56,7 +137,7 @@ jsi::Object parser::Parser::unwrapStyleSheet(jsi::Runtime& rt, std::shared_ptr<S
 
     // stylesheet also has a mini runtime dependency
     // StyleSheetType::ThemableWithMiniRuntime
-    auto miniRuntime = this->_unistylesRuntime->getMiniRuntimeAsValue(rt);
+    auto miniRuntime = this->_unistylesRuntime->getMiniRuntimeAsValue(rt, maybeMiniRuntime);
 
     return styleSheet->rawValue
         .asFunction(rt)
@@ -85,35 +166,156 @@ void parser::Parser::parseUnistyles(jsi::Runtime& rt, std::shared_ptr<StyleSheet
 }
 
 // rebuild all unistyles in StyleSheet that depends on variants
-void parser::Parser::rebuildUnistylesWithVariants(jsi::Runtime& rt, std::shared_ptr<StyleSheet> styleSheet, Variants& variants) {
-    for (const auto& [_, unistyle] : styleSheet->unistyles) {
-        if (!unistyle->dependsOn(UnistyleDependency::VARIANTS)) {
-            continue;
-        }
+void parser::Parser::rebuildUnistyleWithVariants(jsi::Runtime& rt, std::shared_ptr<core::UnistyleData> unistyleData) {
+    if (unistyleData->unistyle->styleKey == helpers::EXOTIC_STYLE_KEY) {
+        return;
+    }
+    
+    if (unistyleData->unistyle->type == UnistyleType::Object) {
+        unistyleData->parsedStyle = this->parseFirstLevel(rt, unistyleData->unistyle, unistyleData->variants);
+        
+        return;
+    }
+    
+    // for functions we need to call them with memoized arguments
+    auto unistyleFn = std::dynamic_pointer_cast<UnistyleDynamicFunction>(unistyleData->unistyle);
+
+    // convert arguments to jsi::Value
+    std::vector<jsi::Value> args{};
+    auto arguments = unistyleData->dynamicFunctionMetadata.value();
+
+    args.reserve(arguments.size());
 
-        // todo skip dynamic functions
-        this->rebuildUnistyle(rt, styleSheet, unistyle, variants, std::nullopt);
+    for (int i = 0; i < arguments.size(); i++) {
+        folly::dynamic& arg = arguments.at(i);
+
+        args.emplace_back(jsi::valueFromDynamic(rt, arg));
     }
+
+    const jsi::Value *argStart = args.data();
+
+    // we need to temporarly swap unprocessed value to enforce correct parings
+    auto sharedUnprocessedValue = std::move(unistyleFn->unprocessedValue);
+
+    // call cached function with memoized arguments
+    auto functionResult = unistyleFn->rawValue
+        .asFunction(rt)
+        .call(rt, argStart, arguments.size())
+        .asObject(rt);
+
+    unistyleFn->unprocessedValue = std::move(functionResult);
+    unistyleData->parsedStyle = this->parseFirstLevel(rt, unistyleFn, unistyleData->variants);
+    unistyleFn->unprocessedValue = std::move(sharedUnprocessedValue);
 }
 
 // rebuild all unistyles that are affected by platform event
-void parser::Parser::rebuildUnistylesInDependencyMap(jsi::Runtime& rt, DependencyMap& dependencyMap) {
-    for (auto& [styleSheet, map] : dependencyMap) {
-        jsi::Object unwrappedStyleSheet = this->unwrapStyleSheet(rt, styleSheet);
+void parser::Parser::rebuildUnistylesInDependencyMap(jsi::Runtime& rt, DependencyMap& dependencyMap, std::vector<std::shared_ptr<core::StyleSheet>>& styleSheets, std::optional<UnistylesNativeMiniRuntime> maybeMiniRuntime) {
+    std::unordered_map<std::shared_ptr<StyleSheet>, jsi::Value> parsedStyleSheetsWithDefaultTheme{};
+    std::unordered_map<std::string, std::unordered_map<std::shared_ptr<StyleSheet>, jsi::Value>> parsedStyleSheetsWithScopedTheme{};
+    std::unordered_map<std::shared_ptr<core::Unistyle>, bool> parsedUnistyles{};
+
+    // parse all stylesheets that depends on changes
+    for (auto styleSheet : styleSheets) {
+        parsedStyleSheetsWithDefaultTheme.emplace(styleSheet, this->unwrapStyleSheet(rt, styleSheet, maybeMiniRuntime));
+    }
 
-        for (auto& [shadowNode, unistyles] : map) {
-            for (auto& unistyleData : unistyles) {
-                auto& unistyle = unistyleData->unistyle;
+    // then parse all visible Unistyles managed by Unistyle
+    for (auto& [shadowNode, unistyles] : dependencyMap) {
+        auto styleSheet = unistyles.begin()->get()->unistyle->parent;
+
+        // stylesheet may be optional for exotic unistyles
+        if (styleSheet != nullptr && !parsedStyleSheetsWithDefaultTheme.contains(styleSheet)) {
+            parsedStyleSheetsWithDefaultTheme.emplace(styleSheet, this->unwrapStyleSheet(rt, styleSheet, maybeMiniRuntime));
+        }
 
-                // StyleSheet might have styles that are not affected
-                if (!unwrappedStyleSheet.hasProperty(rt, unistyle->styleKey.c_str())) {
-                    continue;
+        for (auto& unistyleData : unistyles) {
+            auto& unistyle = unistyleData->unistyle;
+
+            // for RN styles or inline styles, compute styles only once
+            if (unistyle->styleKey == helpers::EXOTIC_STYLE_KEY) {
+                if (!unistyleData->parsedStyle.has_value()) {
+                    unistyleData->parsedStyle = jsi::Value(rt, unistyle->rawValue).asObject(rt);
+
+                    if (!parsedUnistyles.contains(unistyle)) {
+                        parsedUnistyles.emplace(unistyle, true);
+                    }
                 }
 
-                unistyle->rawValue = unwrappedStyleSheet.getProperty(rt, unistyle->styleKey.c_str()).asObject(rt);
-                this->rebuildUnistyle(rt, styleSheet, unistyle, unistyleData->variants, unistyleData->dynamicFunctionMetadata);
+                continue;
+            }
+
+            // reference Unistyles StyleSheet as we may mix them for one style
+            auto unistyleStyleSheet = unistyle->parent;
+
+            // we may hit now other StyleSheets that are referenced from affected nodes
+            if (unistyleStyleSheet != nullptr && !parsedStyleSheetsWithDefaultTheme.contains(unistyleStyleSheet)) {
+                parsedStyleSheetsWithDefaultTheme.emplace(unistyleStyleSheet, this->unwrapStyleSheet(rt, unistyleStyleSheet, maybeMiniRuntime));
+            }
+
+            // StyleSheet might have styles that are not affected
+            if (!parsedStyleSheetsWithDefaultTheme[unistyleStyleSheet].asObject(rt).hasProperty(rt, unistyle->styleKey.c_str())) {
+                continue;
+            }
+
+            // for scoped themes we need to parse unistyle exclusively
+            if (unistyleData->scopedTheme.has_value()) {
+                std::vector<folly::dynamic> arguments = {};
+
+                if (unistyleData->dynamicFunctionMetadata.has_value()) {
+                    arguments = unistyleData->dynamicFunctionMetadata.value();
+                }
+
+                auto parsedStyleSheet = jsi::Value::undefined();
+                auto scopedThemeName = unistyleData->scopedTheme.value();
+
+                // check if we have theme in cache
+                if (parsedStyleSheetsWithScopedTheme.contains(scopedThemeName)) {
+                    if (parsedStyleSheetsWithScopedTheme[scopedThemeName].contains(unistyle->parent)) {
+                        parsedStyleSheet = jsi::Value(rt, parsedStyleSheetsWithScopedTheme[scopedThemeName][unistyle->parent]);
+                    }
+                }
+
+                // if not, let's build it
+                if (parsedStyleSheet.isUndefined()) {
+                    parsedStyleSheet = this->getParsedStyleSheetForScopedTheme(rt, unistyle, unistyleData->scopedTheme.value());
+
+                    if (!parsedStyleSheetsWithScopedTheme.contains(scopedThemeName)) {
+                        parsedStyleSheetsWithScopedTheme.emplace(
+                            scopedThemeName,
+                            std::unordered_map<std::shared_ptr<StyleSheet>, jsi::Value>{}
+                        );
+                    }
+
+                    parsedStyleSheetsWithScopedTheme[scopedThemeName].emplace(
+                        unistyle->parent,
+                        jsi::Value(rt, parsedStyleSheet)
+                    );
+                }
+
+                this->rebuildUnistyleWithScopedTheme(
+                    rt,
+                    parsedStyleSheet,
+                    unistyleData
+                );
+            } else {
+                unistyle->rawValue = parsedStyleSheetsWithDefaultTheme[unistyleStyleSheet].asObject(rt).getProperty(rt, unistyle->styleKey.c_str()).asObject(rt);
+                this->rebuildUnistyle(rt, unistyleStyleSheet, unistyle, unistyleData->variants, unistyleData->dynamicFunctionMetadata);
                 unistyleData->parsedStyle = jsi::Value(rt, unistyle->parsedStyle.value()).asObject(rt);
             }
+
+            if (!parsedUnistyles.contains(unistyle)) {
+                parsedUnistyles.emplace(unistyle, true);
+            }
+        }
+    }
+
+    // parse whatever left in StyleSheets to be later accessible
+    // for createUnistylesComponent
+    for (auto styleSheet : styleSheets) {
+        for (auto& [_, unistyle] : styleSheet->unistyles) {
+            if (!parsedUnistyles.contains(unistyle)) {
+                unistyle->rawValue = parsedStyleSheetsWithDefaultTheme[styleSheet].asObject(rt).getProperty(rt, unistyle->styleKey.c_str()).asObject(rt);
+            }
         }
     }
 }
@@ -146,7 +348,10 @@ void parser::Parser::rebuildUnistyle(jsi::Runtime& rt, std::shared_ptr<StyleShee
         const jsi::Value *argStart = args.data();
 
         // call cached function with memoized arguments
-        auto functionResult = unistyleFn->proxiedFunction.value().callAsConstructor(rt, argStart, dynamicFunctionMetadata.size()).asObject(rt);
+        auto functionResult = unistyleFn->rawValue
+            .asFunction(rt)
+            .call(rt, argStart, dynamicFunctionMetadata.size())
+            .asObject(rt);
 
         unistyleFn->unprocessedValue = std::move(functionResult);
         unistyleFn->parsedStyle = this->parseFirstLevel(rt, unistyleFn, variants);
@@ -154,27 +359,19 @@ void parser::Parser::rebuildUnistyle(jsi::Runtime& rt, std::shared_ptr<StyleShee
 }
 
 // convert dependency map to shadow tree updates
-shadow::ShadowLeafUpdates parser::Parser::dependencyMapToShadowLeafUpdates(core::DependencyMap& dependencyMap) {
+void parser::Parser::rebuildShadowLeafUpdates(jsi::Runtime& rt, core::DependencyMap& dependencyMap) {
     shadow::ShadowLeafUpdates updates;
-    auto& rt = this->_unistylesRuntime->getRuntime();
-
-    for (const auto& [styleSheet, map] : dependencyMap) {
-        for (const auto& [shadowNode, unistyles] : map) {
-            for (const auto& unistyleData : unistyles) {
-                auto rawProps = this->parseStylesToShadowTreeStyles(rt, unistyleData->parsedStyle.value());
-
-                if (updates.contains(shadowNode)) {
-                    updates[shadowNode].emplace_back(std::move(rawProps));
+    auto& registry = core::UnistylesRegistry::get();
 
-                    continue;
-                }
+    for (const auto& [shadowNode, unistyles] : dependencyMap) {
+        // this step is required to parse string colors eg. #000000 to int representation
+        auto rawProps = this->parseStylesToShadowTreeStyles(rt, unistyles);
 
-                updates.emplace(shadowNode, std::vector<RawProps>{std::move(rawProps)});
-            }
-        }
+        updates.emplace(shadowNode, std::move(rawProps));
     }
 
-    return updates;
+    registry.trafficController.setUpdates(updates);
+    registry.trafficController.resumeUnistylesTraffic();
 }
 
 // first level of StyleSheet, we can expect here different properties than on second level
@@ -238,6 +435,18 @@ jsi::Object parser::Parser::parseFirstLevel(jsi::Runtime& rt, Unistyle::Shared u
             return;
         }
 
+        if (propertyName == "boxShadow" && propertyValueObject.isArray(rt)) {
+            parsedStyle.setProperty(rt, jsi::PropNameID::forUtf8(rt, propertyName), parseBoxShadow(rt, unistyle, propertyValueObject));
+
+            return;
+        }
+
+        if (propertyName == "filter" && propertyValueObject.isArray(rt)) {
+            parsedStyle.setProperty(rt, jsi::PropNameID::forUtf8(rt, propertyName), parseFilters(rt, unistyle, propertyValueObject));
+
+            return;
+        }
+
         if (propertyName == "fontVariant" && propertyValueObject.isArray(rt)) {
             parsedStyle.setProperty(rt, jsi::PropNameID::forUtf8(rt, propertyName), propertyValue);
 
@@ -262,7 +471,7 @@ jsi::Object parser::Parser::parseFirstLevel(jsi::Runtime& rt, Unistyle::Shared u
         parsedStyle.setProperty(rt, jsi::PropNameID::forUtf8(rt, propertyName), this->parseSecondLevel(rt, unistyle, valueFromBreakpoint));
     });
 
-    if (shouldParseVariants && variants.has_value() && !variants.value().empty()) {
+    if (shouldParseVariants && variants.has_value()) {
         auto propertyValueObject = style.getProperty(rt, "variants").asObject(rt);
         auto parsedVariant = this->parseVariants(rt, unistyle, propertyValueObject, variants.value());
 
@@ -288,31 +497,49 @@ jsi::Function parser::Parser::createDynamicFunctionProxy(jsi::Runtime& rt, Unist
         jsi::PropNameID::forUtf8(rt, unistyle->styleKey),
         1,
         [this, unistylesRuntime, unistyle](jsi::Runtime& rt, const jsi::Value& thisVal, const jsi::Value* args, size_t count) {
-            auto thisObject = thisVal.asObject(rt);
+            auto thisObject = thisVal.isObject()
+                ? thisVal.asObject(rt)
+                : jsi::Object(rt);
             auto parser = parser::Parser(unistylesRuntime);
-
             // call user function
             auto result = unistyle->rawValue.asFunction(rt).call(rt, args, count);
 
             // memoize metadata to call it later
             auto unistyleFn = std::dynamic_pointer_cast<UnistyleDynamicFunction>(unistyle);
-            jsi::Array arguments = jsi::Array(rt, count);
-
-            for (size_t i = 0; i < count; i++) {
-                arguments.setValueAtIndex(rt, i, args[i]);
-            }
+            auto& registry = core::UnistylesRegistry::get();
 
             unistyleFn->unprocessedValue = jsi::Value(rt, result).asObject(rt);
 
-            // todo pass here variants
-            unistyleFn->parsedStyle = this->parseFirstLevel(rt, unistyleFn, std::nullopt);
+            jsi::Value rawVariants = thisObject.hasProperty(rt, helpers::STYLE_VARIANTS.c_str())
+                ? thisObject.getProperty(rt, helpers::STYLE_VARIANTS.c_str())
+                : jsi::Value::undefined();
+            std::optional<Variants> variants = rawVariants.isUndefined()
+                ? registry.getScopedVariants()
+                : std::optional<Variants>(helpers::variantsToPairs(rt, rawVariants.asObject(rt)));
+
+            unistyleFn->parsedStyle = this->parseFirstLevel(rt, unistyleFn, variants);
             unistyleFn->seal();
 
-            return jsi::Value(rt, unistyleFn->parsedStyle.value());
+            jsi::Object style = jsi::Value(rt, unistyleFn->parsedStyle.value()).asObject(rt);
+
+            // include dependencies for createUnistylesComponent
+            style.setProperty(rt, "__proto__", generateUnistylesPrototype(rt, unistylesRuntime, unistyle, variants, helpers::functionArgumentsToArray(rt, args, count)));
+
+            jsi::Object secrets = jsi::Object(rt);
+
+            secrets.setProperty(rt, helpers::ARGUMENTS.c_str(), helpers::functionArgumentsToArray(rt, args, count));
+
+            helpers::defineHiddenProperty(rt, style, helpers::SECRETS.c_str(), secrets);
+
+            auto wrappedUnistyle = std::make_shared<UnistyleWrapper>(unistyle);
+
+            style.setNativeState(rt, std::move(wrappedUnistyle));
+
+            return style;
     });
 }
 
-// function convert babel generated dependencies to C++ dependencies
+// function converts babel generated dependencies to C++ dependencies
 std::vector<UnistyleDependency> parser::Parser::parseDependencies(jsi::Runtime &rt, jsi::Object&& dependencies) {
     helpers::assertThat(rt, dependencies.isArray(rt), "Unistyles: Babel transform is invalid - unexpected type for dependencies.");
 
@@ -331,10 +558,6 @@ std::vector<UnistyleDependency> parser::Parser::parseDependencies(jsi::Runtime &
 
 // eg. [{ scale: 2 }, { translateX: 100 }]
 jsi::Value parser::Parser::parseTransforms(jsi::Runtime& rt, Unistyle::Shared unistyle, jsi::Object& obj) {
-    if (!obj.isArray(rt)) {
-        return jsi::Value::undefined();
-    }
-
     std::vector<jsi::Value> parsedTransforms{};
 
     parsedTransforms.reserve(2);
@@ -364,6 +587,67 @@ jsi::Value parser::Parser::parseTransforms(jsi::Runtime& rt, Unistyle::Shared un
     return result;
 }
 
+// eg [{offsetX: 5, offsetY: 5, blurRadius: 5, spreadDistance: 0, color: ‘rgba(255, 0, 0, 0.5)’}]
+jsi::Value parser::Parser::parseBoxShadow(jsi::Runtime &rt, Unistyle::Shared unistyle, jsi::Object &obj) {
+    std::vector<jsi::Value> parsedBoxShadows{};
+
+    parsedBoxShadows.reserve(2);
+
+    helpers::iterateJSIArray(rt, obj.asArray(rt), [&](size_t i, jsi::Value& value){
+        if (!value.isObject()) {
+            return;
+        }
+
+        auto parsedResult = this->parseSecondLevel(rt, unistyle, value);
+
+        parsedBoxShadows.emplace_back(std::move(parsedResult));
+    });
+
+    // create jsi::Array result with correct box shadows
+    jsi::Array result = jsi::Array(rt, parsedBoxShadows.size());
+
+    for (size_t i = 0; i < parsedBoxShadows.size(); i++) {
+        result.setValueAtIndex(rt, i, parsedBoxShadows[i]);
+    }
+
+    return result;
+}
+
+// eg. [{ brightness: 0.5 }, { opacity: 0.25 }]
+jsi::Value parser::Parser::parseFilters(jsi::Runtime &rt, Unistyle::Shared unistyle, jsi::Object &obj) {
+    std::vector<jsi::Value> parsedFilters{};
+
+    parsedFilters.reserve(2);
+
+    helpers::iterateJSIArray(rt, obj.asArray(rt), [&](size_t i, jsi::Value& value){
+        if (!value.isObject()) {
+            return;
+        }
+
+        auto parsedResult = this->parseSecondLevel(rt, unistyle, value);
+
+        // take only one filter per object
+        jsi::Array propertyNames = parsedResult.asObject(rt).getPropertyNames(rt);
+        size_t length = propertyNames.size(rt);
+
+        // ignore no filters
+        if (length == 0) {
+            return;
+        }
+
+        parsedFilters.emplace_back(std::move(parsedResult));
+    });
+
+    // create jsi::Array result with correct filters
+    jsi::Array result = jsi::Array(rt, parsedFilters.size());
+
+    for (size_t i = 0; i < parsedFilters.size(); i++) {
+        result.setValueAtIndex(rt, i, parsedFilters[i]);
+    }
+
+    return result;
+}
+
 // find value based on breakpoints and mq
 jsi::Value parser::Parser::getValueFromBreakpoints(jsi::Runtime& rt, Unistyle::Shared unistyle, jsi::Object& obj) {
     auto& registry = core::UnistylesRegistry::get();
@@ -479,8 +763,8 @@ jsi::Value parser::Parser::getStylesForVariant(jsi::Runtime& rt, const std::stri
         : "default";
     auto hasKey = groupValue.hasProperty(rt, selectedVariantKey);
 
-    if (hasKey && !selectedVariant.has_value()) {
-        // add 'default' selection to variants map
+    if (!hasKey || !selectedVariant.has_value()) {
+        // for no key, add 'default' selection to variants map
         variants.emplace_back(groupName, selectedVariantKey);
     }
 
@@ -518,7 +802,7 @@ jsi::Object parser::Parser::parseCompoundVariants(jsi::Runtime& rt, Unistyle::Sh
     return parsedCompoundVariants;
 }
 
-// check every condition in compound variants, support boolean variants
+// check every condition in compound variants, supports boolean variants
 bool parser::Parser::shouldApplyCompoundVariants(jsi::Runtime& rt, const Variants& variants, jsi::Object& compoundVariant) {
     if (variants.empty()) {
         return false;
@@ -535,7 +819,9 @@ bool parser::Parser::shouldApplyCompoundVariants(jsi::Runtime& rt, const Variant
         auto property = compoundVariant.getProperty(rt, variantKey.c_str());
         auto propertyName = property.isBool()
             ? (property.asBool() ? "true" : "false")
-            : property.asString(rt).utf8(rt);
+            : property.isString()
+                ? property.asString(rt).utf8(rt)
+                : "";
 
         if (propertyName != variantValue) {
             return false;
@@ -613,20 +899,27 @@ jsi::Value parser::Parser::parseSecondLevel(jsi::Runtime &rt, Unistyle::Shared u
     return parsedStyle;
 }
 
-// convert jsi::Object to RawValue with int colors
-RawProps parser::Parser::parseStylesToShadowTreeStyles(jsi::Runtime& rt, const jsi::Object& styles) {
+// convert unistyles to folly with int colors
+folly::dynamic parser::Parser::parseStylesToShadowTreeStyles(jsi::Runtime& rt, const std::vector<std::shared_ptr<UnistyleData>>& unistyles) {
     jsi::Object convertedStyles = jsi::Object(rt);
     auto& state = core::UnistylesRegistry::get().getState(rt);
 
-    helpers::enumerateJSIObject(rt, styles, [&](const std::string& propertyName, jsi::Value& propertyValue){
-        if (this->isColor(propertyName)) {
-            return convertedStyles.setProperty(rt, propertyName.c_str(), jsi::Value(state.parseColor(propertyValue)));
+    for (const auto& unistyleData : unistyles) {
+        // this can happen for exotic stylesheets
+        if (!unistyleData->parsedStyle.has_value()) {
+            return nullptr;
         }
 
-        convertedStyles.setProperty(rt, propertyName.c_str(), propertyValue);
-    });
+        helpers::enumerateJSIObject(rt, unistyleData->parsedStyle.value(), [&](const std::string& propertyName, jsi::Value& propertyValue){
+            if (this->isColor(propertyName)) {
+                return convertedStyles.setProperty(rt, propertyName.c_str(), jsi::Value(state.parseColor(propertyValue)));
+            }
+
+            convertedStyles.setProperty(rt, propertyName.c_str(), propertyValue);
+        });
+    }
 
-    return RawProps(rt, std::move(convertedStyles));
+    return jsi::dynamicFromValue(rt, std::move(convertedStyles));
 }
 
 // check is styleKey contains color

package/cxx/parser/Parser.h

@@ -23,24 +23,28 @@ struct Parser {
 
     void buildUnistyles(jsi::Runtime& rt, std::shared_ptr<StyleSheet> styleSheet);
     void parseUnistyles(jsi::Runtime& rt, std::shared_ptr<StyleSheet> styleSheet);
-    void rebuildUnistylesWithVariants(jsi::Runtime& rt, std::shared_ptr<StyleSheet> styleSheet, Variants& variants);
-    void rebuildUnistylesInDependencyMap(jsi::Runtime& rt, core::DependencyMap& dependencyMap);
-    shadow::ShadowLeafUpdates dependencyMapToShadowLeafUpdates(core::DependencyMap& dependencyMap);
+    void rebuildUnistyleWithVariants(jsi::Runtime& rt, std::shared_ptr<core::UnistyleData> unistyleData);
+    void rebuildUnistylesInDependencyMap(jsi::Runtime& rt, core::DependencyMap& dependencyMap, std::vector<std::shared_ptr<core::StyleSheet>>& styleSheets, std::optional<UnistylesNativeMiniRuntime> maybeMiniRuntime);
+    void rebuildShadowLeafUpdates(jsi::Runtime& rt, core::DependencyMap& dependencyMap);
+    folly::dynamic parseStylesToShadowTreeStyles(jsi::Runtime& rt, const std::vector<std::shared_ptr<UnistyleData>>& unistyles);
+    void rebuildUnistyle(jsi::Runtime& rt, std::shared_ptr<StyleSheet> styleSheet, Unistyle::Shared unistyle, const Variants& variants, std::optional<std::vector<folly::dynamic>>);
+    void rebuildUnistyleWithScopedTheme(jsi::Runtime& rt, jsi::Value& jsScopedTheme, std::shared_ptr<core::UnistyleData> unistyleData);
+    jsi::Value getParsedStyleSheetForScopedTheme(jsi::Runtime& rt, core::Unistyle::Shared unistyle, std::string& scopedTheme);
 
 private:
-    void rebuildUnistyle(jsi::Runtime& rt, std::shared_ptr<StyleSheet> styleSheet, Unistyle::Shared unistyle, const Variants& variants, std::optional<std::vector<folly::dynamic>>);
-    jsi::Object unwrapStyleSheet(jsi::Runtime& rt, std::shared_ptr<StyleSheet> styleSheet);
+    jsi::Object unwrapStyleSheet(jsi::Runtime& rt, std::shared_ptr<StyleSheet> styleSheet, std::optional<UnistylesNativeMiniRuntime>);
     jsi::Object parseFirstLevel(jsi::Runtime& rt, Unistyle::Shared unistyle, std::optional<Variants> variants);
     jsi::Value parseSecondLevel(jsi::Runtime& rt, Unistyle::Shared unistyle, jsi::Value& nestedObject);
     jsi::Function createDynamicFunctionProxy(jsi::Runtime& rt, Unistyle::Shared unistyle);
     std::vector<UnistyleDependency> parseDependencies(jsi::Runtime &rt, jsi::Object&& dependencies);
     jsi::Value parseTransforms(jsi::Runtime& rt, Unistyle::Shared unistyle, jsi::Object& obj);
+    jsi::Value parseBoxShadow(jsi::Runtime& rt, Unistyle::Shared unistyle, jsi::Object& obj);
+    jsi::Value parseFilters(jsi::Runtime& rt, Unistyle::Shared unistyle, jsi::Object& obj);
     jsi::Value getValueFromBreakpoints(jsi::Runtime& rt, Unistyle::Shared unistyle, jsi::Object& obj);
     jsi::Object parseVariants(jsi::Runtime& rt, Unistyle::Shared unistyle, jsi::Object& obj, Variants& variants);
     jsi::Value getStylesForVariant(jsi::Runtime& rt, const std::string groupName, jsi::Object&& groupValue, std::optional<std::string> selectedVariant, Variants& variants);
     jsi::Object parseCompoundVariants(jsi::Runtime& rt, Unistyle::Shared unistyle, jsi::Object& obj, Variants& variants);
     bool shouldApplyCompoundVariants(jsi::Runtime& rt, const Variants& variants, jsi::Object& compoundVariant);
-    RawProps parseStylesToShadowTreeStyles(jsi::Runtime& rt, const jsi::Object& parsedStyles);
     bool isColor(const std::string& propertyName);
 
     std::shared_ptr<HybridUnistylesRuntime> _unistylesRuntime;

package/cxx/shadowTree/ShadowLeafUpdate.h

@@ -1,6 +1,7 @@
 #pragma once
 
 #include <jsi/jsi.h>
+#include <folly/dynamic.h>
 #include <react/renderer/uimanager/UIManager.h>
 
 namespace margelo::nitro::unistyles::shadow {
@@ -8,6 +9,7 @@ namespace margelo::nitro::unistyles::shadow {
 using namespace facebook;
 using namespace facebook::react;
 
-using ShadowLeafUpdates = std::unordered_map<const ShadowNodeFamily*, std::vector<RawProps>>;
+// translates Unistyles changes to unified shadow tree changes
+using ShadowLeafUpdates = std::unordered_map<const ShadowNodeFamily*, folly::dynamic>;
 
 }