react-native-unistyles 1.1.1 → 2.0.0-alpha.2

package/ios/UnistylesModule.h

@@ -0,0 +1,10 @@
+#import <React/RCTBridgeModule.h>
+#import <React/RCTEventEmitter.h>
+
+typedef void(^UnistylesEventHandler)(NSDictionary *);
+
+@interface UnistylesModule : RCTEventEmitter<RCTBridgeModule>
+
+@property (nonatomic, assign) void* unistylesRuntime;
+
+@end

package/ios/UnistylesModule.mm

@@ -0,0 +1,108 @@
+#import "UnistylesModule.h"
+#import "UnistylesRuntime.h"
+
+#import <React/RCTBridge+Private.h>
+#import <React/RCTUtils.h>
+#import <jsi/jsi.h>
+
+@implementation UnistylesModule
+
+BOOL hasListeners;
+
+using namespace facebook;
+
+RCT_EXPORT_MODULE(Unistyles)
+
+- (instancetype)init {
+    if ((self = [super init])) {
+        [[NSNotificationCenter defaultCenter] addObserver:self
+                                                 selector:@selector(handleOrientationChange:)
+                                                     name:UIDeviceOrientationDidChangeNotification
+                                                   object:nil];
+    }
+    return self;
+}
+
+- (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;
+
+        ((UnistylesRuntime*)self.unistylesRuntime)->handleScreenSizeChangeWithWidth(screenWidth, screenHeight);
+    });
+}
+
+- (void)dealloc {
+    delete (UnistylesRuntime*)self.unistylesRuntime;
+    [[NSNotificationCenter defaultCenter] removeObserver:self];
+}
+
++ (BOOL)requiresMainQueueSetup
+{
+  return YES;
+}
+
+RCT_EXPORT_BLOCKING_SYNCHRONOUS_METHOD(install)
+{
+    NSLog(@"Installing Unistyles 🦄...");
+
+    RCTBridge* bridge = [RCTBridge currentBridge];
+    RCTCxxBridge* cxxBridge = (RCTCxxBridge*)bridge;
+
+    if (cxxBridge == nil) {
+       return @false;
+    }
+
+    auto jsiRuntime = (jsi::Runtime*)cxxBridge.runtime;
+
+    if (jsiRuntime == nil) {
+       return @false;
+    }
+
+    auto& runtime = *jsiRuntime;
+    UnistylesModule *__weak weakSelf = self;
+
+    registerUnistylesHostObject(runtime, weakSelf);
+
+    NSLog(@"Installed Unistyles 🦄!");
+
+    return @true;
+}
+
+- (NSArray<NSString *> *)supportedEvents {
+    return @[@"onChange"];
+}
+
+- (void)startObserving
+{
+    hasListeners = YES;
+}
+
+- (void)stopObserving
+{
+    hasListeners = NO;
+}
+
+- (void)emitEvent:(NSString *)eventName withBody:(NSDictionary *)body {
+    if (hasListeners) {
+        [self sendEventWithName:@"onChange" body:body];
+    }
+}
+
+void registerUnistylesHostObject(jsi::Runtime &runtime, UnistylesModule* weakSelf) {
+    CGFloat initialScreenWidth = [UIScreen mainScreen].bounds.size.width;
+    CGFloat initialScreenHeight = [UIScreen mainScreen].bounds.size.height;
+    UnistylesEventHandler eventHandler = ^(NSDictionary *body) {
+        [weakSelf emitEvent:@"onChange" withBody:body];
+    };
+    
+    auto unistylesRuntime = std::make_shared<UnistylesRuntime>(eventHandler, initialScreenWidth, initialScreenHeight);
+    
+    weakSelf.unistylesRuntime = unistylesRuntime.get();
+
+    auto hostObject = jsi::Object::createFromHostObject(runtime, unistylesRuntime);
+ 
+    runtime.global().setProperty(runtime, "__UNISTYLES__", std::move(hostObject));
+}
+
+@end

package/ios/UnistylesRuntime.h

@@ -0,0 +1,30 @@
+#pragma once
+
+#import "UnistylesModule.h"
+#import <jsi/jsi.h>
+#import <vector>
+
+using namespace facebook;
+
+class JSI_EXPORT UnistylesRuntime : public jsi::HostObject {
+private:
+    UnistylesEventHandler eventHandler;
+    float screenWidth;
+    float screenHeight;
+
+public:
+    UnistylesRuntime(UnistylesEventHandler handler, CGFloat screenWidth, CGFloat screenHeight)
+    : eventHandler(handler), screenWidth(screenWidth), screenHeight(screenHeight) {}
+
+    std::string theme;
+    std::string breakpoint;
+    std::string colorScheme;
+    std::vector<std::string> featureFlags;
+    std::vector<std::pair<std::string, double>> sortedBreakpointEntries;
+
+    jsi::Value get(jsi::Runtime&, const jsi::PropNameID& name) override;
+    std::vector<jsi::PropNameID> getPropertyNames(jsi::Runtime& rt) override;
+
+    void handleScreenSizeChangeWithWidth(CGFloat width, CGFloat height);
+    std::string getBreakpointFromScreenWidth(double width, const std::vector<std::pair<std::string, double>>& sortedBreakpointEntries);
+};

package/ios/UnistylesRuntime.mm

@@ -0,0 +1,191 @@
+#import "UnistylesRuntime.h"
+
+std::vector<jsi::PropNameID> UnistylesRuntime::getPropertyNames(jsi::Runtime& rt) {
+    std::vector<jsi::PropNameID> properties;
+
+    // getters
+    properties.push_back(jsi::PropNameID::forUtf8(rt, std::string("theme")));
+    properties.push_back(jsi::PropNameID::forUtf8(rt, std::string("breakpoint")));
+    properties.push_back(jsi::PropNameID::forUtf8(rt, std::string("colorScheme")));
+    properties.push_back(jsi::PropNameID::forUtf8(rt, std::string("sortedBreakpointPairs")));
+
+    // setters
+    properties.push_back(jsi::PropNameID::forUtf8(rt, std::string("useBreakpoints")));
+    properties.push_back(jsi::PropNameID::forUtf8(rt, std::string("useTheme")));
+    properties.push_back(jsi::PropNameID::forUtf8(rt, std::string("useColorScheme")));
+    properties.push_back(jsi::PropNameID::forUtf8(rt, std::string("useFeatureFlags")));
+
+    return properties;
+}
+
+
+jsi::Value UnistylesRuntime::get(jsi::Runtime& runtime, const jsi::PropNameID& propNameId) {
+    std::string propName = propNameId.utf8(runtime);
+    
+    if (propName == "theme") {
+        return !this->theme.empty()
+            ? jsi::Value(jsi::String::createFromUtf8(runtime, this->theme))
+            : jsi::Value::undefined();
+    }
+    
+    if (propName == "breakpoint") {
+        return !this->breakpoint.empty()
+            ? jsi::Value(jsi::String::createFromUtf8(runtime, this->breakpoint))
+            : jsi::Value::undefined();
+    }
+    
+    if (propName == "colorScheme") {
+        return !this->colorScheme.empty()
+            ? jsi::Value(jsi::String::createFromUtf8(runtime, this->colorScheme))
+            : jsi::Value::undefined();
+    }
+    
+    if (propName == "sortedBreakpointPairs") {
+        std::unique_ptr<jsi::Array> sortedBreakpointEntriesArray = std::make_unique<jsi::Array>(runtime, this->sortedBreakpointEntries.size());
+            
+        for (size_t i = 0; i < this->sortedBreakpointEntries.size(); ++i) {
+            std::unique_ptr<jsi::Array> pairArray = std::make_unique<jsi::Array>(runtime, 2);
+            jsi::String nameValue = jsi::String::createFromUtf8(runtime, this->sortedBreakpointEntries[i].first);
+            
+            pairArray->setValueAtIndex(runtime, 0, nameValue);
+            pairArray->setValueAtIndex(runtime, 1, jsi::Value(this->sortedBreakpointEntries[i].second));
+            sortedBreakpointEntriesArray->setValueAtIndex(runtime, i, *pairArray);
+        }
+        
+        return jsi::Value(runtime, *sortedBreakpointEntriesArray);
+    }
+    
+    if (propName == "useBreakpoints") {
+        return jsi::Function::createFromHostFunction(
+           runtime,
+           jsi::PropNameID::forAscii(runtime, "useBreakpoints"),
+           1,
+           [this](jsi::Runtime &runtime, const jsi::Value &thisVal, const jsi::Value *arguments, size_t count) -> jsi::Value {
+                jsi::Object breakpointsObj = arguments[0].asObject(runtime);
+                jsi::Array propertyNames = breakpointsObj.getPropertyNames(runtime);
+                std::vector<std::pair<std::string, double>> sortedBreakpointEntriesVec;
+
+                for (size_t i = 0; i < propertyNames.size(runtime); ++i) {
+                    jsi::Value propNameValue = propertyNames.getValueAtIndex(runtime, i);
+                    std::string name = propNameValue.asString(runtime).utf8(runtime);
+                    jsi::PropNameID propNameID = jsi::PropNameID::forUtf8(runtime, name);
+                    jsi::Value value = breakpointsObj.getProperty(runtime, propNameID);
+
+                    if (value.isNumber()) {
+                        double breakpointValue = value.asNumber();
+                        sortedBreakpointEntriesVec.push_back(std::make_pair(name, breakpointValue));
+                    }
+                }
+
+                std::sort(sortedBreakpointEntriesVec.begin(), sortedBreakpointEntriesVec.end(), [](const std::pair<std::string, double>& a, const std::pair<std::string, double>& b) {
+                        return a.second < b.second;
+                });
+
+                this->sortedBreakpointEntries = sortedBreakpointEntriesVec;
+                
+               std::string breakpoint = this->getBreakpointFromScreenWidth(this->screenWidth, sortedBreakpointEntriesVec);
+
+               this->breakpoint = breakpoint;
+
+               return jsi::Value::undefined();
+           }
+         );
+    }
+    
+    if (propName == "useTheme") {
+        return jsi::Function::createFromHostFunction(runtime,
+            jsi::PropNameID::forAscii(runtime, "useTheme"),
+            1,
+            [this](jsi::Runtime &runtime, const jsi::Value &thisVal, const jsi::Value *arguments, size_t count) -> jsi::Value {
+                std::string themeName = arguments[0].asString(runtime).utf8(runtime);
+                NSString *currentTheme = [NSString stringWithUTF8String:themeName.c_str()];
+            
+                this->theme = themeName;
+            
+                NSDictionary *body = @{
+                    @"type": @"theme",
+                    @"payload": @{
+                        @"currentTheme": currentTheme
+                    }
+                };
+                this->eventHandler(body);
+
+                return jsi::Value::undefined();
+            }
+        );
+    }
+    
+    if (propName == "useColorScheme") {
+        return jsi::Function::createFromHostFunction(runtime,
+            jsi::PropNameID::forAscii(runtime, "useColorScheme"),
+            1,
+            [this](jsi::Runtime &runtime, const jsi::Value &thisVal, const jsi::Value *arguments, size_t count) -> jsi::Value {
+                std::string colorScheme = arguments[0].asString(runtime).utf8(runtime);
+
+                this->colorScheme = colorScheme;
+
+                return jsi::Value::undefined();
+            }
+        );
+    }
+    
+    if (propName == "useFeatureFlags") {
+        return jsi::Function::createFromHostFunction(runtime,
+            jsi::PropNameID::forAscii(runtime, "useFeatureFlags"),
+            1,
+            [this](jsi::Runtime &runtime, const jsi::Value &thisVal, const jsi::Value *arguments, size_t count) -> jsi::Value {
+                jsi::Array featureFlagsArray = arguments[0].asObject(runtime).asArray(runtime);
+                size_t length = featureFlagsArray.size(runtime);
+                std::vector<std::string> featureFlags;
+                featureFlags.reserve(length);
+                    
+                for (size_t i = 0; i < length; ++i) {
+                    jsi::Value element = featureFlagsArray.getValueAtIndex(runtime, i);
+
+                    if (element.isString()) {
+                        std::string featureFlag = element.asString(runtime).utf8(runtime);
+                        featureFlags.push_back(featureFlag);
+                    }
+                }
+
+                this->featureFlags = featureFlags;
+            
+                return jsi::Value::undefined();
+            }
+        );
+    }
+   
+    return jsi::Value::undefined();
+}
+
+std::string UnistylesRuntime::getBreakpointFromScreenWidth(double width, const std::vector<std::pair<std::string, double>>& sortedBreakpointEntries) {
+    for (size_t i = 0; i < sortedBreakpointEntries.size(); ++i) {
+        const auto& [key, value] = sortedBreakpointEntries[i];
+        const double maxVal = (i + 1 < sortedBreakpointEntries.size()) ? sortedBreakpointEntries[i + 1].second : std::numeric_limits<double>::infinity();
+
+        if (width >= value && width < maxVal) {
+            return key;
+        }
+    }
+    
+    return sortedBreakpointEntries.empty() ? "" : sortedBreakpointEntries.back().first;
+}
+
+void UnistylesRuntime::handleScreenSizeChangeWithWidth(CGFloat width, CGFloat height) {
+    std::string currentBreakpoint = this->breakpoint;
+    std::string nextBreakpoint = this->getBreakpointFromScreenWidth(width, this->sortedBreakpointEntries);
+    
+    if (currentBreakpoint != nextBreakpoint) {
+        this->breakpoint = nextBreakpoint;
+
+        NSString *breakpoint = [NSString stringWithUTF8String:nextBreakpoint.c_str()];
+        NSDictionary *body = @{
+            @"type": @"breakpoint",
+            @"payload": @{
+                @"currentBreakpoint": breakpoint
+            }
+        };
+        
+        this->eventHandler(body);
+    }
+}

package/lib/commonjs/UnistyleRegistry.js

@@ -0,0 +1,37 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.UnistyleRegistry = void 0;
+class UnistyleRegistry {
+  isClosed = false;
+  themes = {};
+  breakpoints = {};
+  sortedBreakpointPairs = [];
+  config = {};
+  constructor(unistylesBridge) {
+    this.unistylesBridge = unistylesBridge;
+  }
+  addThemes = themes => {
+    this.themes = themes;
+    return this;
+  };
+  addBreakpoints = breakpoints => {
+    this.unistylesBridge.useBreakpoints(breakpoints);
+    this.sortedBreakpointPairs = this.unistylesBridge.sortedBreakpointPairs;
+    return this;
+  };
+  addConfig = config => {
+    this.config = config;
+    if (config.featureFlags && config.featureFlags.length > 0) {
+      this.unistylesBridge.useFeatureFlags(config.featureFlags);
+    }
+    if (config.colorScheme) {
+      this.unistylesBridge.useColorScheme(config.colorScheme);
+    }
+    return this;
+  };
+}
+exports.UnistyleRegistry = UnistyleRegistry;
+//# sourceMappingURL=UnistyleRegistry.js.map

package/lib/commonjs/UnistyleRegistry.js.map

@@ -0,0 +1 @@
+{"version":3,"names":["UnistyleRegistry","isClosed","themes","breakpoints","sortedBreakpointPairs","config","constructor","unistylesBridge","addThemes","addBreakpoints","useBreakpoints","addConfig","featureFlags","length","useFeatureFlags","colorScheme","useColorScheme","exports"],"sourceRoot":"../../src","sources":["UnistyleRegistry.ts"],"mappings":";;;;;;AAGO,MAAMA,gBAAgB,CAAC;EACnBC,QAAQ,GAAG,KAAK;EAChBC,MAAM,GAAoB,CAAC,CAAC;EAC5BC,WAAW,GAAyB,CAAC,CAAC;EACtCC,qBAAqB,GAA0F,EAAE;EACjHC,MAAM,GAAoB,CAAC,CAAC;EAEnCC,WAAWA,CAASC,eAAgC,EAAE;IAAA,KAAlCA,eAAgC,GAAhCA,eAAgC;EAAG;EAEhDC,SAAS,GAAIN,MAAuB,IAAK;IAC5C,IAAI,CAACA,MAAM,GAAGA,MAAM;IAEpB,OAAO,IAAI;EACf,CAAC;EAEMO,cAAc,GAAIN,WAAiC,IAAK;IAC3D,IAAI,CAACI,eAAe,CAACG,cAAc,CAACP,WAAW,CAAC;IAChD,IAAI,CAACC,qBAAqB,GAAG,IAAI,CAACG,eAAe,CAACH,qBAAqB;IAEvE,OAAO,IAAI;EACf,CAAC;EAEMO,SAAS,GAAIN,MAAuB,IAAK;IAC5C,IAAI,CAACA,MAAM,GAAGA,MAAM;IAEpB,IAAIA,MAAM,CAACO,YAAY,IAAIP,MAAM,CAACO,YAAY,CAACC,MAAM,GAAG,CAAC,EAAE;MACvD,IAAI,CAACN,eAAe,CAACO,eAAe,CAACT,MAAM,CAACO,YAAY,CAAC;IAC7D;IAEA,IAAIP,MAAM,CAACU,WAAW,EAAE;MACpB,IAAI,CAACR,eAAe,CAACS,cAAc,CAACX,MAAM,CAACU,WAAW,CAAC;IAC3D;IAEA,OAAO,IAAI;EACf,CAAC;AACL;AAACE,OAAA,CAAAjB,gBAAA,GAAAA,gBAAA"}

package/lib/commonjs/Unistyles.js

@@ -0,0 +1,36 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.unistyles = void 0;
+var _UnistylesModule = require("./UnistylesModule");
+var _UnistylesRuntime = require("./UnistylesRuntime");
+var _UnistylesEngine = require("./UnistylesEngine");
+var _UnistyleRegistry = require("./UnistyleRegistry");
+var _types = require("./types");
+class Unistyles {
+  constructor() {
+    const isInstalled = _UnistylesModule.UnistylesModule?.install() ?? false;
+    if (!isInstalled) {
+      throw new Error(_types.UnistylesError.RuntimeUnavailable);
+    }
+
+    // @ts-ignore
+    this._bridge = global.__UNISTYLES__;
+    this._registry = new _UnistyleRegistry.UnistyleRegistry(this._bridge);
+    this._runtime = new _UnistylesRuntime.UnistylesRuntime(this._bridge, this._registry);
+    this._engine = new _UnistylesEngine.UnistylesEngine(this._registry, this._runtime);
+  }
+  get registry() {
+    return this._registry;
+  }
+  get runtime() {
+    return this._runtime;
+  }
+  get engine() {
+    return this._engine;
+  }
+}
+const unistyles = exports.unistyles = new Unistyles();
+//# sourceMappingURL=Unistyles.js.map

package/lib/commonjs/Unistyles.js.map

@@ -0,0 +1 @@
+{"version":3,"names":["_UnistylesModule","require","_UnistylesRuntime","_UnistylesEngine","_UnistyleRegistry","_types","Unistyles","constructor","isInstalled","UnistylesModule","install","Error","UnistylesError","RuntimeUnavailable","_bridge","global","__UNISTYLES__","_registry","UnistyleRegistry","_runtime","UnistylesRuntime","_engine","UnistylesEngine","registry","runtime","engine","unistyles","exports"],"sourceRoot":"../../src","sources":["Unistyles.ts"],"mappings":";;;;;;AAAA,IAAAA,gBAAA,GAAAC,OAAA;AACA,IAAAC,iBAAA,GAAAD,OAAA;AACA,IAAAE,gBAAA,GAAAF,OAAA;AACA,IAAAG,iBAAA,GAAAH,OAAA;AAEA,IAAAI,MAAA,GAAAJ,OAAA;AAEA,MAAMK,SAAS,CAAC;EAMZC,WAAWA,CAAA,EAAG;IACV,MAAMC,WAAW,GAAGC,gCAAe,EAAEC,OAAO,CAAC,CAAC,IAAI,KAAK;IAEvD,IAAI,CAACF,WAAW,EAAE;MACd,MAAM,IAAIG,KAAK,CAACC,qBAAc,CAACC,kBAAkB,CAAC;IACtD;;IAEA;IACA,IAAI,CAACC,OAAO,GAAGC,MAAM,CAACC,aAAgC;IACtD,IAAI,CAACC,SAAS,GAAG,IAAIC,kCAAgB,CAAC,IAAI,CAACJ,OAAO,CAAC;IACnD,IAAI,CAACK,QAAQ,GAAG,IAAIC,kCAAgB,CAAC,IAAI,CAACN,OAAO,EAAE,IAAI,CAACG,SAAS,CAAC;IAClE,IAAI,CAACI,OAAO,GAAG,IAAIC,gCAAe,CAAC,IAAI,CAACL,SAAS,EAAE,IAAI,CAACE,QAAQ,CAAC;EACrE;EAEA,IAAWI,QAAQA,CAAA,EAAG;IAClB,OAAO,IAAI,CAACN,SAAS;EACzB;EAEA,IAAWO,OAAOA,CAAA,EAAG;IACjB,OAAO,IAAI,CAACL,QAAQ;EACxB;EAEA,IAAWM,MAAMA,CAAA,EAAG;IAChB,OAAO,IAAI,CAACJ,OAAO;EACvB;AACJ;AAEO,MAAMK,SAAS,GAAAC,OAAA,CAAAD,SAAA,GAAG,IAAIpB,SAAS,CAAC,CAAC"}

package/lib/commonjs/UnistylesEngine.js

@@ -0,0 +1,22 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.UnistylesEngine = void 0;
+// todo implement engine
+class UnistylesEngine {
+  // @ts-ignore
+  constructor(registry, runtime) {
+    this.registry = registry;
+    this.runtime = runtime;
+    this.registry = registry;
+    this.runtime = runtime;
+  }
+
+  // UnistylesEngine.parseStyleSheet
+  // UnistylesEngine.parseStyle
+  // UnistylesEngine.proxify
+}
+exports.UnistylesEngine = UnistylesEngine;
+//# sourceMappingURL=UnistylesEngine.js.map

package/lib/commonjs/UnistylesEngine.js.map

@@ -0,0 +1 @@
+{"version":3,"names":["UnistylesEngine","constructor","registry","runtime","exports"],"sourceRoot":"../../src","sources":["UnistylesEngine.ts"],"mappings":";;;;;;AAGA;AACO,MAAMA,eAAe,CAAC;EACzB;EACAC,WAAWA,CAASC,QAA0B,EAAUC,OAAyB,EAAE;IAAA,KAA/DD,QAA0B,GAA1BA,QAA0B;IAAA,KAAUC,OAAyB,GAAzBA,OAAyB;IAC7E,IAAI,CAACD,QAAQ,GAAGA,QAAQ;IACxB,IAAI,CAACC,OAAO,GAAGA,OAAO;EAC1B;;EAEA;EACA;EACA;AACJ;AAACC,OAAA,CAAAJ,eAAA,GAAAA,eAAA"}

package/lib/commonjs/UnistylesModule.js

@@ -0,0 +1,9 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.UnistylesModule = void 0;
+var _reactNative = require("react-native");
+const UnistylesModule = exports.UnistylesModule = _reactNative.NativeModules?.Unistyles;
+//# sourceMappingURL=UnistylesModule.js.map

package/lib/commonjs/UnistylesModule.js.map

@@ -0,0 +1 @@
+{"version":3,"names":["_reactNative","require","UnistylesModule","exports","NativeModules","Unistyles"],"sourceRoot":"../../src","sources":["UnistylesModule.ts"],"mappings":";;;;;;AAAA,IAAAA,YAAA,GAAAC,OAAA;AAMO,MAAMC,eAAe,GAAAC,OAAA,CAAAD,eAAA,GAAGE,0BAAa,EAAEC,SAAkC"}

package/lib/commonjs/UnistylesRuntime.js

@@ -0,0 +1,52 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.UnistylesRuntime = void 0;
+var _types = require("./types");
+class UnistylesRuntime {
+  constructor(unistylesBridge, registry) {
+    this.unistylesBridge = unistylesBridge;
+    this.registry = registry;
+  }
+  get colorScheme() {
+    return this.unistylesBridge.colorScheme;
+  }
+  get breakpoints() {
+    return this.registry.breakpoints;
+  }
+  get sortedBreakpoints() {
+    return this.registry.sortedBreakpointPairs;
+  }
+  get config() {
+    return this.registry.config;
+  }
+  get theme() {
+    return this.unistylesBridge.theme;
+  }
+  get currentBreakpoint() {
+    return this.unistylesBridge.breakpoint;
+  }
+  setColorScheme = scheme => {
+    if (scheme !== this.colorScheme) {
+      this.unistylesBridge.useColorScheme(scheme);
+    }
+  };
+  setTheme = name => {
+    if (name !== this.theme && this.hasTheme(name)) {
+      this.unistylesBridge.useTheme(name);
+      return true;
+    }
+    return false;
+  };
+  hasTheme = name => name in this.registry.themes;
+  getTheme = forName => {
+    if (!this.hasTheme(forName)) {
+      throw new Error(_types.UnistylesError.ThemeNotFound);
+    }
+    return this.registry.themes[forName];
+  };
+}
+exports.UnistylesRuntime = UnistylesRuntime;
+//# sourceMappingURL=UnistylesRuntime.js.map

package/lib/commonjs/UnistylesRuntime.js.map

@@ -0,0 +1 @@
+{"version":3,"names":["_types","require","UnistylesRuntime","constructor","unistylesBridge","registry","colorScheme","breakpoints","sortedBreakpoints","sortedBreakpointPairs","config","theme","currentBreakpoint","breakpoint","setColorScheme","scheme","useColorScheme","setTheme","name","hasTheme","useTheme","themes","getTheme","forName","Error","UnistylesError","ThemeNotFound","exports"],"sourceRoot":"../../src","sources":["UnistylesRuntime.ts"],"mappings":";;;;;;AAEA,IAAAA,MAAA,GAAAC,OAAA;AAGO,MAAMC,gBAAgB,CAAC;EAC1BC,WAAWA,CAASC,eAAgC,EAAUC,QAA0B,EAAE;IAAA,KAAtED,eAAgC,GAAhCA,eAAgC;IAAA,KAAUC,QAA0B,GAA1BA,QAA0B;EAAG;EAE3F,IAAWC,WAAWA,CAAA,EAAG;IACrB,OAAO,IAAI,CAACF,eAAe,CAACE,WAAW;EAC3C;EAEA,IAAWC,WAAWA,CAAA,EAAG;IACrB,OAAO,IAAI,CAACF,QAAQ,CAACE,WAAW;EACpC;EAEA,IAAWC,iBAAiBA,CAAA,EAAG;IAC3B,OAAO,IAAI,CAACH,QAAQ,CAACI,qBAAqB;EAC9C;EAEA,IAAWC,MAAMA,CAAA,EAAG;IAChB,OAAO,IAAI,CAACL,QAAQ,CAACK,MAAM;EAC/B;EAEA,IAAWC,KAAKA,CAAA,EAAG;IACf,OAAO,IAAI,CAACP,eAAe,CAACO,KAAK;EACrC;EAEA,IAAWC,iBAAiBA,CAAA,EAAG;IAC3B,OAAO,IAAI,CAACR,eAAe,CAACS,UAAU;EAC1C;EAEOC,cAAc,GAAIC,MAA4B,IAAK;IACtD,IAAIA,MAAM,KAAK,IAAI,CAACT,WAAW,EAAE;MAC7B,IAAI,CAACF,eAAe,CAACY,cAAc,CAACD,MAAM,CAAC;IAC/C;EACJ,CAAC;EAEME,QAAQ,GAAIC,IAA2B,IAAK;IAC/C,IAAIA,IAAI,KAAK,IAAI,CAACP,KAAK,IAAI,IAAI,CAACQ,QAAQ,CAACD,IAAI,CAAC,EAAE;MAC5C,IAAI,CAACd,eAAe,CAACgB,QAAQ,CAACF,IAAI,CAAC;MAEnC,OAAO,IAAI;IACf;IAEA,OAAO,KAAK;EAChB,CAAC;EAEMC,QAAQ,GAAID,IAA2B,IAAKA,IAAI,IAAI,IAAI,CAACb,QAAQ,CAACgB,MAAM;EAExEC,QAAQ,GAAIC,OAA8B,IAAK;IAClD,IAAI,CAAC,IAAI,CAACJ,QAAQ,CAACI,OAAO,CAAC,EAAE;MACzB,MAAM,IAAIC,KAAK,CAACC,qBAAc,CAACC,aAAa,CAAC;IACjD;IAEA,OAAO,IAAI,CAACrB,QAAQ,CAACgB,MAAM,CAACE,OAAO,CAAC;EACxC,CAAC;AACL;AAACI,OAAA,CAAAzB,gBAAA,GAAAA,gBAAA"}

package/lib/commonjs/createStyleSheet.js

@@ -0,0 +1,14 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.createStyleSheet = void 0;
+const createStyleSheet = styles => {
+  if (typeof styles === 'function') {
+    return styles;
+  }
+  return styles;
+};
+exports.createStyleSheet = createStyleSheet;
+//# sourceMappingURL=createStyleSheet.js.map

package/lib/commonjs/createStyleSheet.js.map

@@ -0,0 +1 @@
+{"version":3,"names":["createStyleSheet","styles","exports"],"sourceRoot":"../../src","sources":["createStyleSheet.ts"],"mappings":";;;;;;AAKO,MAAMA,gBAAgB,GAAuCC,MAA+E,IAAY;EAC3J,IAAI,OAAOA,MAAM,KAAK,UAAU,EAAE;IAC9B,OAAOA,MAAM;EACjB;EAEA,OAAOA,MAAM;AACjB,CAAC;AAAAC,OAAA,CAAAF,gBAAA,GAAAA,gBAAA"}

package/lib/commonjs/global.js

@@ -0,0 +1,2 @@
+"use strict";
+//# sourceMappingURL=global.js.map

package/lib/commonjs/global.js.map

@@ -0,0 +1 @@
+{"version":3,"names":[],"sourceRoot":"../../src","sources":["global.ts"],"mappings":""}

package/lib/commonjs/index.js

@@ -3,18 +3,45 @@
 Object.defineProperty(exports, "__esModule", {
   value: true
 });
-Object.defineProperty(exports, "UnistylesTheme", {
+Object.defineProperty(exports, "UnistylesColorScheme", {
   enumerable: true,
   get: function () {
-    return _UnistylesTheme.UnistylesTheme;
+    return _types.UnistylesColorScheme;
   }
 });
-Object.defineProperty(exports, "createUnistyles", {
+exports.UnistylesRuntime = exports.UnistylesRegistry = void 0;
+Object.defineProperty(exports, "createStyleSheet", {
   enumerable: true,
   get: function () {
-    return _createUnistyles.createUnistyles;
+    return _createStyleSheet.createStyleSheet;
   }
 });
-var _UnistylesTheme = require("./UnistylesTheme");
-var _createUnistyles = require("./createUnistyles");
+Object.defineProperty(exports, "useInitialTheme", {
+  enumerable: true,
+  get: function () {
+    return _useInitialTheme.useInitialTheme;
+  }
+});
+Object.defineProperty(exports, "useStyles", {
+  enumerable: true,
+  get: function () {
+    return _useStyles.useStyles;
+  }
+});
+var _Unistyles = require("./Unistyles");
+var _types = require("./types");
+var _useInitialTheme = require("./useInitialTheme");
+var _useStyles = require("./useStyles");
+var _createStyleSheet = require("./createStyleSheet");
+const {
+  addThemes,
+  addBreakpoints,
+  addConfig
+} = _Unistyles.unistyles.registry;
+const UnistylesRuntime = exports.UnistylesRuntime = _Unistyles.unistyles.runtime;
+const UnistylesRegistry = exports.UnistylesRegistry = {
+  addThemes,
+  addBreakpoints,
+  addConfig
+};
 //# sourceMappingURL=index.js.map

package/lib/commonjs/index.js.map

@@ -1 +1 @@
-{"version":3,"names":["_UnistylesTheme","require","_createUnistyles"],"sourceRoot":"../../src","sources":["index.ts"],"mappings":";;;;;;;;;;;;;;;;;AAAA,IAAAA,eAAA,GAAAC,OAAA;AACA,IAAAC,gBAAA,GAAAD,OAAA"}
+{"version":3,"names":["_Unistyles","require","_types","_useInitialTheme","_useStyles","_createStyleSheet","addThemes","addBreakpoints","addConfig","unistyles","registry","UnistylesRuntime","exports","runtime","UnistylesRegistry"],"sourceRoot":"../../src","sources":["index.ts"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAAA,IAAAA,UAAA,GAAAC,OAAA;AAEA,IAAAC,MAAA,GAAAD,OAAA;AAEA,IAAAE,gBAAA,GAAAF,OAAA;AAEA,IAAAG,UAAA,GAAAH,OAAA;AACA,IAAAI,iBAAA,GAAAJ,OAAA;AAEA,MAAM;EAAEK,SAAS;EAAEC,cAAc;EAAEC;AAAW,CAAC,GAAGC,oBAAS,CAACC,QAAQ;AACpE,MAAMC,gBAAgB,GAAAC,OAAA,CAAAD,gBAAA,GAAGF,oBAAS,CAACI,OAAO;AAC1C,MAAMC,iBAAiB,GAAAF,OAAA,CAAAE,iBAAA,GAAG;EACtBR,SAAS;EACTC,cAAc;EACdC;AACJ,CAAC"}

package/lib/commonjs/types/cxx.js

@@ -0,0 +1,23 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.UnistylesError = exports.UnistylesColorScheme = exports.CxxUnistylesEventTypes = void 0;
+let UnistylesColorScheme = exports.UnistylesColorScheme = /*#__PURE__*/function (UnistylesColorScheme) {
+  UnistylesColorScheme["System"] = "system";
+  UnistylesColorScheme["Manual"] = "manual";
+  return UnistylesColorScheme;
+}({});
+let CxxUnistylesEventTypes = exports.CxxUnistylesEventTypes = /*#__PURE__*/function (CxxUnistylesEventTypes) {
+  CxxUnistylesEventTypes["Theme"] = "theme";
+  CxxUnistylesEventTypes["Size"] = "size";
+  CxxUnistylesEventTypes["Breakpoint"] = "breakpoint";
+  return CxxUnistylesEventTypes;
+}({});
+let UnistylesError = exports.UnistylesError = /*#__PURE__*/function (UnistylesError) {
+  UnistylesError["RuntimeUnavailable"] = "UNISTYLES_ERROR_RUNTIME_UNAVAILABLE";
+  UnistylesError["ThemeNotFound"] = "UNISTYLES_ERROR_THEME_NOT_FOUND";
+  return UnistylesError;
+}({});
+//# sourceMappingURL=cxx.js.map

package/lib/commonjs/types/cxx.js.map

@@ -0,0 +1 @@
+{"version":3,"names":["UnistylesColorScheme","exports","CxxUnistylesEventTypes","UnistylesError"],"sourceRoot":"../../../src","sources":["types/cxx.ts"],"mappings":";;;;;;IAGYA,oBAAoB,GAAAC,OAAA,CAAAD,oBAAA,0BAApBA,oBAAoB;EAApBA,oBAAoB;EAApBA,oBAAoB;EAAA,OAApBA,oBAAoB;AAAA;AAAA,IAwBpBE,sBAAsB,GAAAD,OAAA,CAAAC,sBAAA,0BAAtBA,sBAAsB;EAAtBA,sBAAsB;EAAtBA,sBAAsB;EAAtBA,sBAAsB;EAAA,OAAtBA,sBAAsB;AAAA;AAAA,IA8BtBC,cAAc,GAAAF,OAAA,CAAAE,cAAA,0BAAdA,cAAc;EAAdA,cAAc;EAAdA,cAAc;EAAA,OAAdA,cAAc;AAAA"}

package/lib/commonjs/types/index.js

@@ -14,4 +14,15 @@ Object.keys(_normalizer).forEach(function (key) {
     }
   });
 });
+var _cxx = require("./cxx");
+Object.keys(_cxx).forEach(function (key) {
+  if (key === "default" || key === "__esModule") return;
+  if (key in exports && exports[key] === _cxx[key]) return;
+  Object.defineProperty(exports, key, {
+    enumerable: true,
+    get: function () {
+      return _cxx[key];
+    }
+  });
+});
 //# sourceMappingURL=index.js.map

package/lib/commonjs/types/index.js.map

@@ -1 +1 @@
-{"version":3,"names":["_normalizer","require","Object","keys","forEach","key","exports","defineProperty","enumerable","get"],"sourceRoot":"../../../src","sources":["types/index.ts"],"mappings":";;;;;AAAA,IAAAA,WAAA,GAAAC,OAAA;AAAAC,MAAA,CAAAC,IAAA,CAAAH,WAAA,EAAAI,OAAA,WAAAC,GAAA;EAAA,IAAAA,GAAA,kBAAAA,GAAA;EAAA,IAAAA,GAAA,IAAAC,OAAA,IAAAA,OAAA,CAAAD,GAAA,MAAAL,WAAA,CAAAK,GAAA;EAAAH,MAAA,CAAAK,cAAA,CAAAD,OAAA,EAAAD,GAAA;IAAAG,UAAA;IAAAC,GAAA,WAAAA,CAAA;MAAA,OAAAT,WAAA,CAAAK,GAAA;IAAA;EAAA;AAAA"}
+{"version":3,"names":["_normalizer","require","Object","keys","forEach","key","exports","defineProperty","enumerable","get","_cxx"],"sourceRoot":"../../../src","sources":["types/index.ts"],"mappings":";;;;;AAAA,IAAAA,WAAA,GAAAC,OAAA;AAAAC,MAAA,CAAAC,IAAA,CAAAH,WAAA,EAAAI,OAAA,WAAAC,GAAA;EAAA,IAAAA,GAAA,kBAAAA,GAAA;EAAA,IAAAA,GAAA,IAAAC,OAAA,IAAAA,OAAA,CAAAD,GAAA,MAAAL,WAAA,CAAAK,GAAA;EAAAH,MAAA,CAAAK,cAAA,CAAAD,OAAA,EAAAD,GAAA;IAAAG,UAAA;IAAAC,GAAA,WAAAA,CAAA;MAAA,OAAAT,WAAA,CAAAK,GAAA;IAAA;EAAA;AAAA;AACA,IAAAK,IAAA,GAAAT,OAAA;AAAAC,MAAA,CAAAC,IAAA,CAAAO,IAAA,EAAAN,OAAA,WAAAC,GAAA;EAAA,IAAAA,GAAA,kBAAAA,GAAA;EAAA,IAAAA,GAAA,IAAAC,OAAA,IAAAA,OAAA,CAAAD,GAAA,MAAAK,IAAA,CAAAL,GAAA;EAAAH,MAAA,CAAAK,cAAA,CAAAD,OAAA,EAAAD,GAAA;IAAAG,UAAA;IAAAC,GAAA,WAAAA,CAAA;MAAA,OAAAC,IAAA,CAAAL,GAAA;IAAA;EAAA;AAAA"}