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

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/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,10 @@
+#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 WEB_STYLE_KEY = "_web";
+
+}

package/cxx/common/Helpers.h

@@ -0,0 +1,93 @@
+#pragma once
+
+#include <jsi/jsi.h>
+#include <unordered_set>
+
+using namespace facebook;
+
+namespace margelo::nitro::unistyles::helpers {
+
+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();
+}
+
+}

package/cxx/core/HostStyle.cpp

@@ -0,0 +1,57 @@
+#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> {};
+
+    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]);
+    }
+    
+    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, "useVariants expected to be called with one argument.");
+        helpers::assertThat(rt, arguments[0].isObject(), "useVariants expected to be called with object.");
+
+        auto parser = parser::Parser(this->_unistylesRuntime);
+        auto pairs = parser.variantsToPairs(rt, arguments[0].asObject(rt));
+        
+        if (pairs == this->_styleSheet->variants) {
+            return jsi::Value::undefined();
+        }
+        
+        this->_styleSheet->variants = pairs;
+        
+        parser.rebuildUnistylesWithVariants(rt, this->_styleSheet);
+        
+        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,25 @@
+#pragma once
+
+#include <jsi/jsi.h>
+#include "StyleSheet.h"
+#include "Constants.h"
+#include "Parser.h"
+#include "HybridUnistylesRuntime.h"
+
+namespace margelo::nitro::unistyles::core {
+
+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;
+};
+
+}

package/cxx/core/MediaQueries.cpp

@@ -0,0 +1,87 @@
+#include "MediaQueries.h"
+
+using namespace margelo::nitro::unistyles;
+
+bool core::UnistylesMQ::isMQ() {
+    return this->isValid;
+}
+
+bool core::UnistylesMQ::checkIsMQ(const std::string& maybeMQ) {
+    std::regex pattern(R"(:([hw])\[(\d+)(?:,\s*(\d+|Infinity))?\])");
+
+    return std::regex_search(maybeMQ, pattern);
+}
+
+bool core::UnistylesMQ::checkIsValidMQ() {
+    if (parsedMQ->width && parsedMQ->height) {
+        return parsedMQ->width->from <= parsedMQ->width->to && parsedMQ->height->from <= parsedMQ->height->to;
+    }
+
+    if (parsedMQ->width) {
+        return parsedMQ->width->from <= parsedMQ->width->to;
+    }
+
+    if (parsedMQ->height) {
+        return parsedMQ->height->from <= parsedMQ->height->to;
+    }
+    
+    return false;
+}
+
+void core::UnistylesMQ::parseMQ(const std::string& maybeMQ) {
+    const std::regex UNISTYLES_WIDTH_REGEX(R"(:(w)\[(\d+)(?:,\s*(\d+|Infinity))?\])");
+    const std::regex UNISTYLES_HEIGHT_REGEX(R"(:(h)\[(\d+)(?:,\s*(\d+|Infinity))?\])");
+
+    ParsedMQ result;
+    std::smatch match;
+
+    if (std::regex_search(maybeMQ, match, UNISTYLES_WIDTH_REGEX)) {
+        double from = std::stod(match[2]);
+        double to = match[3].matched
+        ? (match[3] == "Infinity" ? std::numeric_limits<double>::infinity(): std::stod(match[3]))
+        : from;
+        
+        result.width = ParsedMQDimension{from, to};
+    }
+
+    if (std::regex_search(maybeMQ, match, UNISTYLES_HEIGHT_REGEX)) {
+        double from = std::stod(match[2]);
+        double to = match[3].matched
+        ? (match[3] == "Infinity" ? std::numeric_limits<double>::infinity() : std::stod(match[3]))
+        : from;
+
+        result.height = ParsedMQDimension{from, to};
+    }
+    
+    this->parsedMQ = result;
+}
+
+bool core::UnistylesMQ::isWithinScreenWidth(const ParsedMQDimension& width, double screenWidth) {
+    return screenWidth >= width.from && screenWidth <= width.to;
+}
+
+bool core::UnistylesMQ::isWithinScreenHeight(const ParsedMQDimension& height, double screenHeight) {
+    return screenHeight >= height.from && screenHeight <= height.to;
+}
+
+bool core::UnistylesMQ::isWithinTheWidthAndHeight(const Dimensions& screenSize) {
+    if (!isValid) {
+        return false;
+    }
+    
+    auto parsedMq = parsedMQ.value();
+    
+    if (parsedMq.width && parsedMq.height) {
+        return isWithinScreenWidth(*parsedMq.width, screenSize.width) && isWithinScreenHeight(*parsedMq.height, screenSize.height);
+    }
+
+    if (parsedMq.width) {
+        return isWithinScreenWidth(*parsedMq.width, screenSize.width);
+    }
+
+    if (parsedMq.height) {
+        return isWithinScreenHeight(*parsedMq.height, screenSize.height);
+    }
+
+    return false;
+}

package/cxx/core/MediaQueries.h

@@ -0,0 +1,47 @@
+#pragma once
+
+#include <optional>
+#include <regex>
+#include "Dimensions.hpp"
+
+namespace margelo::nitro::unistyles::core {
+
+struct ParsedMQDimension {
+    double from;
+    double to;
+};
+
+struct ParsedMQ {
+    std::optional<ParsedMQDimension> width;
+    std::optional<ParsedMQDimension> height;
+};
+
+struct UnistylesMQ {
+    UnistylesMQ(const std::string& maybeMQ) {
+        if (!this->checkIsMQ(maybeMQ)) {
+            return;
+        }
+        
+        this->parseMQ(maybeMQ);
+        
+        if (!this->checkIsValidMQ()) {
+            return;
+        }
+        
+        this->isValid = true;
+    }
+
+    bool isMQ();
+    bool isWithinTheWidthAndHeight(const Dimensions& screenSize);
+    
+private:
+    bool isValid = false;
+    std::optional<ParsedMQ> parsedMQ;
+    bool checkIsValidMQ();
+    bool checkIsMQ(const std::string& maybeMQ);
+    void parseMQ(const std::string& maybeMQ);
+    bool isWithinScreenWidth(const ParsedMQDimension& width, double screenWidth);
+    bool isWithinScreenHeight(const ParsedMQDimension& height, double screenHeight);
+};
+
+}