react-native-unistyles 2.0.0-rc.2 → 2.0.0-rc.4

package/LICENSE

@@ -1,6 +1,6 @@
 MIT License
 
-Copyright (c) 2023 Jacek Pudysz
+Copyright (c) 2023-2024 Jacek Pudysz
 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

package/README.md

@@ -1,9 +1,15 @@
 [<img alt="react-native-unistyles" src="assets/banner.png">](https://reactnativeunistyles.vercel.app/)
 
 ![GitHub package.json version](https://img.shields.io/github/package-json/v/jpudysz/react-native-unistyles?style=for-the-badge)
-[![npm downloads](https://img.shields.io/npm/dm/react-native-unistyles.svg?style=for-the-badge)](https://www.npmjs.com/package/react-native-unistyles)
-![Platform - Android and iOS](https://img.shields.io/badge/platform-Android%20%7C%20IOS%20%7C%20SSR%20%7C%20Web-blue.svg?style=for-the-badge)
-[![License: MIT](https://img.shields.io/badge/License-MIT-green.svg?style=for-the-badge)](https://opensource.org/licenses/MIT)
+[![npm downloads](https://img.shields.io/npm/dt/react-native-unistyles?style=for-the-badge)](https://www.npmjs.com/package/react-native-unistyles)
+[![License: MIT](https://img.shields.io/badge/License-MIT-44CD11.svg?style=for-the-badge)](https://opensource.org/licenses/MIT)
+<br />
+[![platform - expo](https://img.shields.io/badge/Expo-fff?style=for-the-badge&logo=expo&logoColor=black)](https://docs.expo.dev/)
+[![platform - web](https://img.shields.io/badge/React_Native_Web-white?logo=react&logoColor=57BDDA&style=for-the-badge)](https://www.w3.org/)
+[![platform - ios](https://img.shields.io/badge/iOS-000?logo=apple&style=for-the-badge)](https://developer.apple.com/ios/)
+[![platform - macos](https://img.shields.io/badge/macOS-000?logo=apple&style=for-the-badge)](https://developer.apple.com/macos/)
+[![platform - ssr](https://img.shields.io/badge/SSR-black?style=for-the-badge&logo=next.js&logoColor=white)](https://nextjs.org/)
+[![platform - android](https://img.shields.io/badge/Android-44CD11?style=for-the-badge&logo=android&logoColor=white)](https://developer.android.com/)
 
 ## [Documentation](https://reactnativeunistyles.vercel.app/)
 - [Start here](https://reactnativeunistyles.vercel.app/start/introduction/)
@@ -20,7 +26,7 @@
 - ⚛️ No React Context
 - 🖥️ Supports custom breakpoints, css-like media queries and variants
 - 🎨 Register multiple themes and change them with single function call
-- 🥳 Compatible with Expo, Bare React Native, React Native Web and SSR
+- 🥳 Compatible with Expo, Bare React Native, React Native Web, React Native macOS and SSR
 - 🛡️ ~99% Test coverage
 - 🔌 Extend stylesheets with your own plugins
 - ⚔️ No 3rd party dependencies

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

@@ -27,7 +27,8 @@ Java_com_unistyles_UnistylesModule_nativeInstall(
         jlong jsi,
         jint screenWidth,
         jint screenHeight,
-        jstring colorScheme
+        jstring colorScheme,
+        jstring contentSizeCategory
 ) {
     auto runtime = reinterpret_cast<facebook::jsi::Runtime *>(jsi);
 
@@ -43,10 +44,15 @@ Java_com_unistyles_UnistylesModule_nativeInstall(
     std::string colorSchemeStr(colorSchemeChars);
     env->ReleaseStringUTFChars(colorScheme, colorSchemeChars);
 
+    const char *contentSizeCategoryChars = env->GetStringUTFChars(contentSizeCategory, nullptr);
+    std::string contentSizeCategoryStr(contentSizeCategoryChars);
+    env->ReleaseStringUTFChars(contentSizeCategory, contentSizeCategoryChars);
+
     unistylesRuntime = std::make_shared<UnistylesRuntime>(
         screenWidth,
         screenHeight,
-        colorSchemeStr
+        colorSchemeStr,
+        contentSizeCategoryStr
     );
 
     unistylesRuntime->onThemeChange([=](const std::string &theme) {
@@ -79,6 +85,16 @@ Java_com_unistyles_UnistylesModule_nativeInstall(
         env->DeleteLocalRef(cls);
     });
 
+    unistylesRuntime->onContentSizeCategoryChange([=](const std::string &contentSizeCategory) {
+        jstring contentSizeCategoryStr = env->NewStringUTF(contentSizeCategory.c_str());
+        jclass cls = env->GetObjectClass(unistylesModule);
+        jmethodID methodId = env->GetMethodID(cls, "onContentSizeCategoryChange", "(Ljava/lang/String;)V");
+
+        env->CallVoidMethod(unistylesModule, methodId, contentSizeCategoryStr);
+        env->DeleteLocalRef(contentSizeCategoryStr);
+        env->DeleteLocalRef(cls);
+    });
+
     jsi::Object hostObject = jsi::Object::createFromHostObject(*runtime, unistylesRuntime);
 
     runtime->global().setProperty(*runtime, "__UNISTYLES__", std::move(hostObject));
@@ -106,3 +122,11 @@ Java_com_unistyles_UnistylesModule_nativeOnAppearanceChange(JNIEnv *env, jobject
         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/UnistylesModule.kt

@@ -15,6 +15,7 @@ import com.facebook.react.bridge.ReactContextBaseJavaModule
 import com.facebook.react.bridge.ReactMethod
 import com.facebook.react.modules.core.DeviceEventManagerModule
 
+
 class UnistylesModule(reactContext: ReactApplicationContext) : ReactContextBaseJavaModule(reactContext), LifecycleEventListener {
     private val configurationChangeReceiver = object : BroadcastReceiver() {
         override fun onReceive(context: Context, intent: Intent) {
@@ -54,6 +55,7 @@ class UnistylesModule(reactContext: ReactApplicationContext) : ReactContextBaseJ
             this.nativeOnAppearanceChange(
                 config["colorScheme"] as String
             )
+            this.nativeOnContentSizeCategoryChange(config["contentSizeCategory"] as String)
         }
     }
 
@@ -64,11 +66,20 @@ class UnistylesModule(reactContext: ReactApplicationContext) : ReactContextBaseJ
             Configuration.UI_MODE_NIGHT_NO -> "light"
             else -> "unspecified"
         }
+        val fontScale = reactApplicationContext.resources.configuration.fontScale
+        val contentSizeCategory = when {
+            fontScale <= 0.85f -> "Small"
+            fontScale <= 1.0f -> "Default"
+            fontScale <= 1.15f -> "Large"
+            fontScale <= 1.3f -> "ExtraLarge"
+            else -> "Huge"
+        }
 
         return mapOf(
             "width" to (displayMetrics.widthPixels / displayMetrics.density).toInt(),
             "height" to (displayMetrics.heightPixels / displayMetrics.density).toInt(),
-            "colorScheme" to colorScheme
+            "colorScheme" to colorScheme,
+            "contentSizeCategory" to contentSizeCategory
         )
     }
 
@@ -85,7 +96,8 @@ class UnistylesModule(reactContext: ReactApplicationContext) : ReactContextBaseJ
                     it.get(),
                     config["width"] as Int,
                     config["height"] as Int,
-                    config["colorScheme"] as String
+                    config["colorScheme"] as String,
+                    config["contentSizeCategory"] as String
                 )
 
                 Log.i(NAME, "Installed Unistyles \uD83E\uDD84!")
@@ -99,10 +111,11 @@ class UnistylesModule(reactContext: ReactApplicationContext) : ReactContextBaseJ
         }
     }
 
-    private external fun nativeInstall(jsi: Long, width: Int, height: Int, colorScheme: String)
+    private external fun nativeInstall(jsi: Long, width: Int, height: Int, colorScheme: String, contentSizeCategory: String)
     private external fun nativeDestroy()
     private external fun nativeOnOrientationChange(width: Int, height: Int)
     private external fun nativeOnAppearanceChange(colorScheme: String)
+    private external fun nativeOnContentSizeCategoryChange(contentSizeCategory: String)
 
     //endregion
     //region Event emitter
@@ -147,6 +160,19 @@ class UnistylesModule(reactContext: ReactApplicationContext) : ReactContextBaseJ
             .emit("__unistylesOnChange", body)
     }
 
+    private fun onContentSizeCategoryChange(contentSizeCategory: String) {
+        val body = Arguments.createMap().apply {
+            putString("type", "dynamicTypeSize")
+            putMap("payload", Arguments.createMap().apply {
+                putString("contentSizeCategory", contentSizeCategory)
+            })
+        }
+
+        reactApplicationContext
+            .getJSModule(DeviceEventManagerModule.RCTDeviceEventEmitter::class.java)
+            .emit("__unistylesOnChange", body)
+    }
+
     @ReactMethod
     fun addListener(eventName: String?) = Unit
 

package/cxx/UnistylesRuntime.cpp

@@ -11,6 +11,7 @@ std::vector<jsi::PropNameID> UnistylesRuntime::getPropertyNames(jsi::Runtime& ru
     // getters
     properties.push_back(jsi::PropNameID::forUtf8(runtime, std::string("screenWidth")));
     properties.push_back(jsi::PropNameID::forUtf8(runtime, std::string("screenHeight")));
+    properties.push_back(jsi::PropNameID::forUtf8(runtime, std::string("contentSizeCategory")));
     properties.push_back(jsi::PropNameID::forUtf8(runtime, std::string("hasAdaptiveThemes")));
     properties.push_back(jsi::PropNameID::forUtf8(runtime, std::string("themeName")));
     properties.push_back(jsi::PropNameID::forUtf8(runtime, std::string("breakpoint")));
@@ -43,6 +44,10 @@ jsi::Value UnistylesRuntime::get(jsi::Runtime& runtime, const jsi::PropNameID& p
     if (propName == "hasAdaptiveThemes") {
         return jsi::Value(this->hasAdaptiveThemes);
     }
+    
+    if (propName == "contentSizeCategory") {
+        return jsi::Value(jsi::String::createFromUtf8(runtime, this->contentSizeCategory));
+    }
 
     if (propName == "themeName") {
         return !this->themeName.empty()
@@ -293,6 +298,11 @@ void UnistylesRuntime::handleAppearanceChange(std::string colorScheme) {
     }
 }
 
+void UnistylesRuntime::handleContentSizeCategoryChange(std::string contentSizeCategory) {
+    this->contentSizeCategory = contentSizeCategory;
+    this->onContentSizeCategoryChangeCallback(contentSizeCategory);
+}
+
 jsi::Value UnistylesRuntime::getThemeOrFail(jsi::Runtime& runtime) {
     if (this->themes.size() == 1) {
         std::string themeName = this->themes.at(0);

package/cxx/UnistylesRuntime.h

@@ -20,18 +20,21 @@ class JSI_EXPORT UnistylesRuntime : public jsi::HostObject {
 private:
     std::function<void(std::string)> onThemeChangeCallback;
     std::function<void(std::string breakpoint, std::string orientation, int screenWidth, int screenHeight)> onLayoutChangeCallback;
+    std::function<void(std::string)> onContentSizeCategoryChangeCallback;
     std::function<void()> onPluginChangeCallback;
 
     int screenWidth;
     int screenHeight;
     std::string colorScheme;
+    std::string contentSizeCategory;
 
 public:
     UnistylesRuntime(
         int screenWidth,
         int screenHeight,
-        std::string colorScheme
-    ): screenWidth(screenWidth), screenHeight(screenHeight), colorScheme(colorScheme) {}
+        std::string colorScheme,
+        std::string contentSizeCategory
+    ): screenWidth(screenWidth), screenHeight(screenHeight), colorScheme(colorScheme), contentSizeCategory(contentSizeCategory) {}
 
     bool hasAdaptiveThemes;
     bool supportsAutomaticColorScheme;
@@ -53,6 +56,10 @@ public:
     void onPluginChange(std::function<void()> callback) {
         this->onPluginChangeCallback = callback;
     }
+    
+    void onContentSizeCategoryChange(std::function<void(std::string)> callback) {
+        this->onContentSizeCategoryChangeCallback = callback;
+    }
 
     jsi::Value get(jsi::Runtime&, const jsi::PropNameID& name) override;
     void set(jsi::Runtime& runtime, const jsi::PropNameID& propNameId, const jsi::Value& value) override;
@@ -60,6 +67,7 @@ public:
 
     void handleScreenSizeChange(int width, int height);
     void handleAppearanceChange(std::string colorScheme);
+    void handleContentSizeCategoryChange(std::string contentSizeCategory);
 
     jsi::Value getThemeOrFail(jsi::Runtime&);
     std::string getBreakpointFromScreenWidth(int width, const std::vector<std::pair<std::string, double>>& sortedBreakpointEntries);

package/ios/UnistylesHelpers.h

@@ -1,4 +1,3 @@
 #include <string>
 
-std::string getColorScheme();
 NSString* cxxStringToNSString(std::string);

package/ios/UnistylesHelpers.mm

@@ -1,19 +1,4 @@
 #import "UnistylesHelpers.h"
-#import "UnistylesRuntime.h"
-
-std::string getColorScheme() {
-    UIUserInterfaceStyle colorScheme = [UIScreen mainScreen].traitCollection.userInterfaceStyle;
-
-    switch (colorScheme) {
-        case UIUserInterfaceStyleLight:
-            return UnistylesLightScheme;
-        case UIUserInterfaceStyleDark:
-            return UnistylesDarkScheme;
-        case UIUserInterfaceStyleUnspecified:
-        default:
-            return UnistylesUnspecifiedScheme;
-    }
-}
 
 NSString* cxxStringToNSString(std::string cxxString) {
     return [NSString stringWithUTF8String:cxxString.c_str()];

package/ios/UnistylesModule.h

@@ -2,9 +2,15 @@
 #import <React/RCTEventEmitter.h>
 #import <string>
 
+#if TARGET_OS_OSX
+    #import "Platform_macOS.h"
+#elif TARGET_OS_IOS
+    #import "Platform_iOS.h"
+#endif
+
 @interface UnistylesModule : RCTEventEmitter<RCTBridgeModule>
 
 @property (nonatomic, assign) BOOL hasListeners;
-@property (nonatomic, assign) void* unistylesRuntime;
+@property (nonatomic, strong) Platform *platform;
 
 @end

package/ios/UnistylesModule.mm

@@ -2,7 +2,6 @@
 #import "UnistylesHelpers.h"
 #import "UnistylesRuntime.h"
 
-#import <React/RCTAppearance.h>
 #import <React/RCTBridge+Private.h>
 #import <jsi/jsi.h>
 
@@ -16,53 +15,16 @@ RCT_EXPORT_MODULE(Unistyles)
 
 - (instancetype)init {
     if ((self = [super init])) {
-        [[NSNotificationCenter defaultCenter] addObserver:self
-                                                 selector:@selector(handleOrientationChange:)
-                                                     name:UIDeviceOrientationDidChangeNotification
-                                                   object:nil];
-        [[NSNotificationCenter defaultCenter] addObserver:self
-                                                 selector:@selector(appearanceChanged:)
-                                                     name:RCTUserInterfaceStyleDidChangeNotification
-                                                   object:nil];
+        self.platform = [[Platform alloc] init];
     }
 
     return self;
 }
 
-- (void)dealloc {
-    if (self.unistylesRuntime != nullptr) {
-        self.unistylesRuntime = nullptr;
-    }
-
-    [[NSNotificationCenter defaultCenter] removeObserver:self];
-}
-
-
 + (BOOL)requiresMainQueueSetup {
     return YES;
 }
 
-#pragma mark - Event handlers
-
-- (void)handleOrientationChange:(NSNotification *)notification {
-    dispatch_after(dispatch_time(DISPATCH_TIME_NOW, (int64_t)(0.1 * NSEC_PER_SEC)), dispatch_get_main_queue(), ^{
-        CGFloat screenWidth = [UIScreen mainScreen].bounds.size.width;
-        CGFloat screenHeight = [UIScreen mainScreen].bounds.size.height;
-
-        if (self.unistylesRuntime != nullptr) {
-            ((UnistylesRuntime*)self.unistylesRuntime)->handleScreenSizeChange((int)screenWidth, (int)screenHeight);
-        }
-    });
-}
-
-- (void)appearanceChanged:(NSNotification *)notification {
-    std::string colorScheme = getColorScheme();
-
-    if (self.unistylesRuntime != nullptr) {
-        ((UnistylesRuntime*)self.unistylesRuntime)->handleAppearanceChange(colorScheme);
-    }
-}
-
 #pragma mark - Event emitter
 - (NSArray<NSString *> *)supportedEvents {
     return @[@"__unistylesOnChange"];
@@ -109,14 +71,11 @@ RCT_EXPORT_BLOCKING_SYNCHRONOUS_METHOD(install) {
 }
 
 void registerUnistylesHostObject(jsi::Runtime &runtime, UnistylesModule* weakSelf) {
-    CGFloat initialScreenWidth = [UIScreen mainScreen].bounds.size.width;
-    CGFloat initialScreenHeight = [UIScreen mainScreen].bounds.size.height;
-    std::string initialColorScheme = getColorScheme();
-
     auto unistylesRuntime = std::make_shared<UnistylesRuntime>(
-        (int)initialScreenWidth,
-        (int)initialScreenHeight,
-        initialColorScheme
+        (int)weakSelf.platform.initialWidth,
+        (int)weakSelf.platform.initialWidth,
+        weakSelf.platform.initialColorScheme,
+        weakSelf.platform.initialContentSizeCategory
     );
 
     unistylesRuntime.get()->onThemeChange([=](std::string theme) {
@@ -155,8 +114,19 @@ void registerUnistylesHostObject(jsi::Runtime &runtime, UnistylesModule* weakSel
             [weakSelf emitEvent:@"__unistylesOnChange" withBody:body];
         });
     });
+    
+    unistylesRuntime.get()->onContentSizeCategoryChange([=](std::string contentSizeCategory) {
+        NSDictionary *body = @{
+            @"type": @"dynamicTypeSize",
+            @"payload": @{
+                @"contentSizeCategory": cxxStringToNSString(contentSizeCategory)
+            }
+        };
+
+        [weakSelf emitEvent:@"__unistylesOnChange" withBody:body];
+    });
 
-    weakSelf.unistylesRuntime = unistylesRuntime.get();
+    weakSelf.platform.unistylesRuntime = unistylesRuntime.get();
 
     auto hostObject = jsi::Object::createFromHostObject(runtime, unistylesRuntime);
 

package/ios/platform/Platform_iOS.h

@@ -0,0 +1,21 @@
+#include <string>
+
+@interface Platform : NSObject
+
+@property (nonatomic, assign) CGFloat initialWidth;
+@property (nonatomic, assign) CGFloat initialHeight;
+@property (nonatomic, assign) std::string initialColorScheme;
+@property (nonatomic, assign) std::string initialContentSizeCategory;
+@property (nonatomic, assign) void* unistylesRuntime;
+
+- (instancetype)init;
+
+- (void)setupListeners;
+- (void)onOrientationChange:(NSNotification *)notification;
+- (void)onAppearanceChange:(NSNotification *)notification;
+- (void)onContentSizeCategoryChange:(NSNotification *)notification;
+
+- (std::string)getColorScheme;
+- (std::string)getContentSizeCategory:(UIContentSizeCategory)contentSizeCategory;
+
+@end

package/ios/platform/Platform_iOS.mm

@@ -0,0 +1,132 @@
+#if TARGET_OS_IOS
+
+#import "Platform_iOS.h"
+#import "UnistylesRuntime.h"
+#import <React/RCTAppearance.h>
+
+@implementation Platform
+
+- (instancetype)init {
+    self = [super init];
+    if (self) {
+        UIScreen *screen = [UIScreen mainScreen];
+        UIContentSizeCategory contentSizeCategory = [[UIApplication sharedApplication] preferredContentSizeCategory];
+
+        self.initialWidth = screen.bounds.size.width;
+        self.initialHeight = screen.bounds.size.height;
+        self.initialColorScheme = [self getColorScheme];
+        self.initialContentSizeCategory = [self getContentSizeCategory:contentSizeCategory];
+        
+        [self setupListeners];
+    }
+    return self;
+}
+
+- (void)dealloc {
+    if (self.unistylesRuntime != nullptr) {
+        self.unistylesRuntime = nullptr;
+    }
+
+    [[NSNotificationCenter defaultCenter] removeObserver:self
+                                          name: UIContentSizeCategoryDidChangeNotification
+                                          object: nil];
+    [[NSNotificationCenter defaultCenter] removeObserver:self
+                                          name: RCTUserInterfaceStyleDidChangeNotification
+                                          object: nil];
+    [[NSNotificationCenter defaultCenter] removeObserver:self
+                                          name: UIDeviceOrientationDidChangeNotification
+                                          object: nil];
+}
+
+- (void)setupListeners {
+    [[NSNotificationCenter defaultCenter] addObserver:self
+                                             selector:@selector(onOrientationChange:)
+                                                 name:UIDeviceOrientationDidChangeNotification
+                                               object:nil];
+    [[NSNotificationCenter defaultCenter] addObserver:self
+                                             selector:@selector(onAppearanceChange:)
+                                                 name:RCTUserInterfaceStyleDidChangeNotification
+                                               object:nil];
+    [[NSNotificationCenter defaultCenter] addObserver:self
+                                             selector:@selector(onContentSizeCategoryChange:)
+                                                 name:UIContentSizeCategoryDidChangeNotification
+                                               object:nil];
+}
+
+- (void)onAppearanceChange:(NSNotification *)notification {
+    std::string colorScheme = [self getColorScheme];
+
+    if (self.unistylesRuntime != nullptr) {
+        ((UnistylesRuntime*)self.unistylesRuntime)->handleAppearanceChange(colorScheme);
+    }
+}
+
+- (void)onContentSizeCategoryChange:(NSNotification *)notification {
+    UIContentSizeCategory contentSizeCategory = [[UIApplication sharedApplication] preferredContentSizeCategory];
+
+    if (self.unistylesRuntime != nullptr) {
+        ((UnistylesRuntime*)self.unistylesRuntime)->handleContentSizeCategoryChange([self getContentSizeCategory:contentSizeCategory]);
+    }
+}
+
+- (void)onOrientationChange:(NSNotification *)notification {
+    dispatch_after(dispatch_time(DISPATCH_TIME_NOW, (int64_t)(0.1 * NSEC_PER_SEC)), dispatch_get_main_queue(), ^{
+        UIScreen *screen = [UIScreen mainScreen];
+        CGFloat screenWidth = screen.bounds.size.width;
+        CGFloat screenHeight = screen.bounds.size.height;
+
+        if (self.unistylesRuntime != nullptr) {
+            ((UnistylesRuntime*)self.unistylesRuntime)->handleScreenSizeChange((int)screenWidth, (int)screenHeight);
+        }
+    });
+}
+
+- (std::string)getColorScheme {
+    UIUserInterfaceStyle colorScheme = [UIScreen mainScreen].traitCollection.userInterfaceStyle;
+
+    switch (colorScheme) {
+        case UIUserInterfaceStyleLight:
+            return UnistylesLightScheme;
+        case UIUserInterfaceStyleDark:
+            return UnistylesDarkScheme;
+        case UIUserInterfaceStyleUnspecified:
+        default:
+            return UnistylesUnspecifiedScheme;
+    }
+}
+
+- (std::string)getContentSizeCategory:(UIContentSizeCategory)contentSizeCategory {
+    if ([contentSizeCategory isEqualToString:UIContentSizeCategoryExtraExtraExtraLarge]) {
+        return std::string([@"xxxLarge" UTF8String]);
+    }
+    
+    if ([contentSizeCategory isEqualToString:UIContentSizeCategoryExtraExtraLarge]) {
+        return std::string([@"xxLarge" UTF8String]);
+    }
+    
+    if ([contentSizeCategory isEqualToString:UIContentSizeCategoryExtraLarge]) {
+        return std::string([@"xLarge" UTF8String]);
+    }
+    
+    if ([contentSizeCategory isEqualToString:UIContentSizeCategoryLarge]) {
+        return std::string([@"Large" UTF8String]);
+    }
+    
+    if ([contentSizeCategory isEqualToString:UIContentSizeCategoryMedium]) {
+        return std::string([@"Medium" UTF8String]);
+    }
+    
+    if ([contentSizeCategory isEqualToString:UIContentSizeCategorySmall]) {
+        return std::string([@"Small" UTF8String]);
+    }
+    
+    if ([contentSizeCategory isEqualToString:UIContentSizeCategoryExtraSmall]) {
+        return std::string([@"xSmall" UTF8String]);
+    }
+    
+    return std::string([@"unspecified" UTF8String]);
+}
+
+@end
+
+#endif

package/ios/platform/Platform_macOS.h

@@ -0,0 +1,20 @@
+#include <string>
+
+@interface Platform : NSObject
+
+@property (nonatomic, assign) CGFloat initialWidth;
+@property (nonatomic, assign) CGFloat initialHeight;
+@property (nonatomic, assign) std::string initialColorScheme;
+@property (nonatomic, assign) std::string initialContentSizeCategory;
+@property (nonatomic, assign) void* unistylesRuntime;
+
+- (instancetype)init;
+
+- (void)setupListeners;
+- (void)onWindowResize;
+- (void)onAppearanceChange;
+
+- (std::string)getColorScheme;
+
+@end
+

package/ios/platform/Platform_macOS.mm

@@ -0,0 +1,83 @@
+#if TARGET_OS_OSX
+
+#import "Platform_macOS.h"
+#import "UnistylesRuntime.h"
+#import <React/RCTUtils.h>
+
+@implementation Platform
+
+- (instancetype)init {
+    self = [super init];
+    if (self) {
+        NSWindow *window = RCTSharedApplication().mainWindow;
+        
+        self.initialWidth = window.frame.size.width;
+        self.initialHeight = window.frame.size.height;
+        self.initialContentSizeCategory = std::string([@"unspecified" UTF8String]);
+        self.initialColorScheme = [self getColorScheme];
+        
+        [self setupListeners];
+    }
+    return self;
+}
+
+- (void)dealloc {
+    if (self.unistylesRuntime != nullptr) {
+        self.unistylesRuntime = nullptr;
+    }
+    
+    NSWindow *window = RCTSharedApplication().mainWindow;
+    
+    [window removeObserver:self forKeyPath:@"effectiveAppearance"];
+    [window removeObserver:self forKeyPath:@"frame"];
+}
+
+- (void)setupListeners {
+    NSWindow *window = RCTSharedApplication().mainWindow;
+    
+    [window addObserver:self forKeyPath:@"effectiveAppearance" options:NSKeyValueObservingOptionNew context:nil];
+    [window addObserver:self forKeyPath:@"frame" options:NSKeyValueObservingOptionNew context:nil];
+}
+
+- (void) observeValueForKeyPath:(NSString *)keyPath ofObject:(id)object change:(NSDictionary<NSKeyValueChangeKey,id> *)change context:(void *)context {
+    if ([keyPath isEqualToString:@"effectiveAppearance"]) {
+        return [self onAppearanceChange];
+    }
+    
+    if ([keyPath isEqualToString:@"frame"]) {
+        return [self onWindowResize];
+    }
+}
+
+- (void)onAppearanceChange {
+    std::string colorScheme = [self getColorScheme];
+
+    if (self.unistylesRuntime != nullptr) {
+        ((UnistylesRuntime*)self.unistylesRuntime)->handleAppearanceChange(colorScheme);
+    }
+}
+
+- (void)onWindowResize {
+    NSWindow *window = RCTSharedApplication().mainWindow;
+    
+    CGFloat screenWidth = window.frame.size.width;
+    CGFloat screenHeight  = window.frame.size.height;
+
+    if (self.unistylesRuntime != nullptr) {
+        ((UnistylesRuntime*)self.unistylesRuntime)->handleScreenSizeChange((int)screenWidth, (int)screenHeight);
+    }
+}
+
+- (std::string)getColorScheme {
+    NSAppearance *appearance = RCTSharedApplication().effectiveAppearance;
+
+    if (appearance.name == NSAppearanceNameDarkAqua) {
+        return UnistylesDarkScheme;
+    }
+    
+    return UnistylesLightScheme;
+}
+
+@end
+
+#endif