react-native-unistyles 2.0.0-alpha.1 → 2.0.0-alpha.3

package/README.md

@@ -8,10 +8,9 @@
 
 ![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%20RNWeb-blue.svg?style=for-the-badge)
+![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)
 
-
 ## Features
 - ⚡ Blazing fast, adds around ~3ms on top of StyleSheet*
 - 🎳 Share up to 100% of your styles across platforms in monorepo
@@ -19,7 +18,8 @@
 - 🖥️ Supports custom breakpoints and css-like media queries
 - 🎨 Access theme in your StyleSheets and components
 - 🪄 Supports dynamic functions to access values from JSX
-- 🥳 Compatible with Expo, Expo Go, Bare React Native and React Native Web
+- 🥳 Compatible with Expo, Expo Go, Bare React Native, React Native Web and SSR
+- 🛡️ ~99% Test coverage
 - ⚔️ No 3rd party dependencies
 
 *-based on this [benchmark](https://github.com/efstathiosntonas/react-native-style-libraries-benchmark)
@@ -41,7 +41,7 @@ There is ongoing work on branch [2.0](https://github.com/jpudysz/react-native-un
 
 ---
 
-Join early testers and discussion [here](https://github.com/jpudysz/react-native-unistyles/discussions/41)
+Join early testers and discussion [here](https://github.com/jpudysz/react-native-unistyles/discussions/41).
 
 ```cmd
 yarn add react-native-unistyles@next

package/ios/UnistylesModule.h

@@ -0,0 +1,12 @@
+#import <React/RCTBridgeModule.h>
+#import <React/RCTEventEmitter.h>
+#import <string>
+
+typedef void(^UnistylesThemeChangeEvent)(std::string);
+typedef void(^UnistylesBreakpointChangeEvent)(std::string);
+
+@interface UnistylesModule : RCTEventEmitter<RCTBridgeModule>
+
+@property (nonatomic, assign) void* unistylesRuntime;
+
+@end

package/ios/UnistylesModule.mm

@@ -0,0 +1,163 @@
+#import "UnistylesModule.h"
+#import "UnistylesRuntime.h"
+#import "UnistylesModule.h"
+
+
+#import <React/RCTAppearance.h>
+#import <React/RCTBridge+Private.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];
+        // todo from iOS 13
+        [[NSNotificationCenter defaultCenter] addObserver:self
+                                                     selector:@selector(appearanceChanged:)
+                                                         name:RCTUserInterfaceStyleDidChangeNotification
+                                                       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)->handleScreenSizeChange((int)screenWidth, (int)screenHeight);
+    });
+}
+
+- (void)appearanceChanged:(NSNotification *)notification
+{
+  std::string colorScheme = [self getColorScheme];
+
+  ((UnistylesRuntime*)self.unistylesRuntime)->handleAppearanceChange(colorScheme);
+}
+
+- (std::string)getColorScheme {
+    UIUserInterfaceStyle colorScheme = [UIScreen mainScreen].traitCollection.userInterfaceStyle;
+    
+    // todo enums
+    switch (colorScheme) {
+        case UIUserInterfaceStyleLight:
+            return "light";
+        case UIUserInterfaceStyleDark:
+            return "dark";
+        case UIUserInterfaceStyleUnspecified:
+        default:
+            return "";
+    }
+}
+
+- (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;
+    std::string initalColorScheme = [weakSelf getColorScheme];
+    UnistylesThemeChangeEvent onThemeChange = ^(std::string theme) {
+        NSString *nextTheme = [NSString stringWithUTF8String:theme.c_str()];
+        NSDictionary *body = @{
+            @"type": @"theme",
+            @"payload": @{
+                @"themeName": nextTheme
+            }
+        };
+        
+        [weakSelf emitEvent:@"onChange" withBody:body];
+    };
+    UnistylesBreakpointChangeEvent onBreakpointChange = ^(std::string breakpoint) {
+        NSString *nextBreakpoint = [NSString stringWithUTF8String:breakpoint.c_str()];
+        NSDictionary *body = @{
+            @"type": @"breakpoint",
+            @"payload": @{
+                @"breakpoint": nextBreakpoint
+            }
+        };
+        
+        [weakSelf emitEvent:@"onChange" withBody:body];
+    };
+    
+    auto unistylesRuntime = std::make_shared<UnistylesRuntime>(
+        onThemeChange,
+        onBreakpointChange,
+        (int)initialScreenWidth,
+        (int)initialScreenHeight,
+        initalColorScheme
+    );
+    
+    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,48 @@
+#pragma once
+
+#import "UnistylesModule.h"
+#import <jsi/jsi.h>
+#import <vector>
+
+using namespace facebook;
+
+class JSI_EXPORT UnistylesRuntime : public jsi::HostObject {
+private:
+    UnistylesThemeChangeEvent onThemeChange;
+    UnistylesBreakpointChangeEvent onBreakpointChange;
+
+    int screenWidth;
+    int screenHeight;
+    std::string colorScheme;
+
+public:
+    UnistylesRuntime(
+        UnistylesThemeChangeEvent onThemeChange,
+        UnistylesBreakpointChangeEvent onBreakpointChange,
+        float screenWidth,
+        float screenHeight,
+        std::string colorScheme
+    ): onThemeChange(onThemeChange),
+       onBreakpointChange(onBreakpointChange),
+       screenWidth(screenWidth),
+       screenHeight(screenHeight),
+       colorScheme(colorScheme) {}
+
+    bool hasAdaptiveThemes;
+    bool supportsAutomaticColorScheme;
+
+    std::string theme;
+    std::string breakpoint;
+    std::vector<std::string> themes;
+    std::vector<std::pair<std::string, double>> sortedBreakpointEntries;
+
+    jsi::Value get(jsi::Runtime&, const jsi::PropNameID& name) override;
+    void set(jsi::Runtime& runtime, const jsi::PropNameID& propNameId, const jsi::Value& value) override;
+    std::vector<jsi::PropNameID> getPropertyNames(jsi::Runtime& runtime) override;
+
+    void handleScreenSizeChange(int width, int height);
+    void handleAppearanceChange(std::string colorScheme);
+
+    jsi::Value getThemeOrFail(jsi::Runtime&);
+    std::string getBreakpointFromScreenWidth(double width, const std::vector<std::pair<std::string, double>>& sortedBreakpointEntries);
+};

package/ios/UnistylesRuntime.mm

@@ -0,0 +1,228 @@
+#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("screenWidth")));
+    properties.push_back(jsi::PropNameID::forUtf8(rt, std::string("screenHeight")));
+    properties.push_back(jsi::PropNameID::forUtf8(rt, std::string("hasAdaptiveThemes")));
+    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("themes")));
+    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("useAdaptiveThemes")));
+    
+    return properties;
+}
+
+
+jsi::Value UnistylesRuntime::get(jsi::Runtime& runtime, const jsi::PropNameID& propNameId) {
+    std::string propName = propNameId.utf8(runtime);
+    
+    if (propName == "screenWidth") {
+        return jsi::Value(this->screenWidth);
+    }
+
+    if (propName == "screenHeight") {
+        return jsi::Value(this->screenHeight);
+    }
+    
+    if (propName == "hasAdaptiveThemes") {
+        return jsi::Value(this->hasAdaptiveThemes);
+    }
+    
+    if (propName == "theme") {
+        return !this->theme.empty()
+            ? jsi::Value(jsi::String::createFromUtf8(runtime, this->theme))
+            : this->getThemeOrFail(runtime);
+    }
+    
+    if (propName == "breakpoint") {
+        return !this->breakpoint.empty()
+            ? jsi::Value(jsi::String::createFromUtf8(runtime, this->breakpoint))
+            : jsi::Value::undefined();
+    }
+    
+    if (propName == "colorScheme") {
+        return jsi::Value(jsi::String::createFromUtf8(runtime, this->colorScheme));
+    }
+
+    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;
+                this->onThemeChange(themeName);
+
+                return jsi::Value::undefined();
+            }
+        );
+    }
+    
+    if (propName == "useAdaptiveThemes") {
+        return jsi::Function::createFromHostFunction(runtime,
+            jsi::PropNameID::forAscii(runtime, "useAdaptiveThemes"),
+            1,
+            [this](jsi::Runtime &runtime, const jsi::Value &thisVal, const jsi::Value *arguments, size_t count) -> jsi::Value {
+                bool enableAdaptiveThemes = arguments[0].asBool();
+
+                this->hasAdaptiveThemes = enableAdaptiveThemes;
+            
+                if (!enableAdaptiveThemes || !this->supportsAutomaticColorScheme) {
+                    return jsi::Value::undefined();
+                }
+
+                this->theme = this->colorScheme;
+//                this->onThemeChange(this->theme);
+
+                return jsi::Value::undefined();
+            }
+        );
+    }
+    
+    return jsi::Value::undefined();
+}
+
+void UnistylesRuntime::set(jsi::Runtime& runtime, const jsi::PropNameID& propNameId, const jsi::Value& value) {
+    std::string propName = propNameId.utf8(runtime);
+    
+    if (propName == "themes" && value.isObject()) {
+        jsi::Array themes = value.asObject(runtime).asArray(runtime);
+        std::vector<std::string> themesVector;
+        size_t length = themes.size(runtime);
+        
+        for (size_t i = 0; i < length; ++i) {
+            jsi::Value element = themes.getValueAtIndex(runtime, i);
+
+            if (element.isString()) {
+                std::string theme = element.asString(runtime).utf8(runtime);
+                themesVector.push_back(theme);
+            }
+        }
+        
+        this->themes = themesVector;
+        
+        bool hasLightTheme = std::find(themesVector.begin(), themesVector.end(), "light") != themesVector.end();
+        bool hasDarkTheme = std::find(themesVector.begin(), themesVector.end(), "dark") != themesVector.end();
+        
+        this->supportsAutomaticColorScheme = hasLightTheme && hasDarkTheme;
+        
+        return;
+    }
+}
+
+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::handleScreenSizeChange(int width, int height) {
+    if (width != this->screenWidth) {
+        this->screenWidth = width;
+    }
+    
+    if (height != this->screenHeight) {
+        this->screenHeight = height;
+    }
+    
+    std::string currentBreakpoint = this->breakpoint;
+    std::string nextBreakpoint = this->getBreakpointFromScreenWidth(width, this->sortedBreakpointEntries);
+    
+    if (currentBreakpoint != nextBreakpoint) {
+        this->breakpoint = nextBreakpoint;
+        this->onBreakpointChange(nextBreakpoint);
+    }
+}
+
+void UnistylesRuntime::handleAppearanceChange(std::string colorScheme) {
+    this->colorScheme = colorScheme;
+    
+    if (!this->supportsAutomaticColorScheme || !this->hasAdaptiveThemes) {
+        return;
+    }
+    
+    this->theme = this->colorScheme;
+    this->onThemeChange(this->theme);
+}
+
+jsi::Value UnistylesRuntime::getThemeOrFail(jsi::Runtime& runtime) {
+    if (this->themes.size() == 1) {
+        std::string themeName = this->themes.at(0);
+
+        this->theme = themeName;
+        
+        return jsi::String::createFromUtf8(runtime, themeName);
+    }
+    
+    return jsi::Value().undefined();
+}

package/lib/commonjs/UnistyleRegistry.js

@@ -0,0 +1,34 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.UnistyleRegistry = void 0;
+class UnistyleRegistry {
+  config = {};
+  themes = {};
+  breakpoints = {};
+  sortedBreakpointPairs = [];
+  constructor(unistylesBridge) {
+    this.unistylesBridge = unistylesBridge;
+  }
+  addThemes = themes => {
+    this.themes = themes;
+    this.unistylesBridge.themes = Object.keys(themes);
+    return this;
+  };
+  addBreakpoints = breakpoints => {
+    this.unistylesBridge.useBreakpoints(breakpoints);
+    this.sortedBreakpointPairs = this.unistylesBridge.sortedBreakpointPairs;
+    return this;
+  };
+  addConfig = config => {
+    this.config = config;
+    if (config.adaptiveThemes) {
+      this.unistylesBridge.useAdaptiveThemes(config.adaptiveThemes);
+    }
+    return this;
+  };
+}
+exports.UnistyleRegistry = UnistyleRegistry;
+//# sourceMappingURL=UnistyleRegistry.js.map

package/lib/commonjs/UnistyleRegistry.js.map

@@ -0,0 +1 @@
+{"version":3,"names":["UnistyleRegistry","config","themes","breakpoints","sortedBreakpointPairs","constructor","unistylesBridge","addThemes","Object","keys","addBreakpoints","useBreakpoints","addConfig","adaptiveThemes","useAdaptiveThemes","exports"],"sourceRoot":"../../src","sources":["UnistyleRegistry.ts"],"mappings":";;;;;;AAGO,MAAMA,gBAAgB,CAAC;EACnBC,MAAM,GAAoB,CAAC,CAAC;EAC5BC,MAAM,GAAoB,CAAC,CAAC;EAC5BC,WAAW,GAAyB,CAAC,CAAC;EACtCC,qBAAqB,GAA0F,EAAE;EAExHC,WAAWA,CAASC,eAAgC,EAAE;IAAA,KAAlCA,eAAgC,GAAhCA,eAAgC;EAAG;EAEhDC,SAAS,GAAIL,MAAuB,IAAK;IAC5C,IAAI,CAACA,MAAM,GAAGA,MAAM;IACpB,IAAI,CAACI,eAAe,CAACJ,MAAM,GAAGM,MAAM,CAACC,IAAI,CAACP,MAAM,CAAiC;IAEjF,OAAO,IAAI;EACf,CAAC;EAEMQ,cAAc,GAAIP,WAAiC,IAAK;IAC3D,IAAI,CAACG,eAAe,CAACK,cAAc,CAACR,WAAW,CAAC;IAChD,IAAI,CAACC,qBAAqB,GAAG,IAAI,CAACE,eAAe,CAACF,qBAAqB;IAEvE,OAAO,IAAI;EACf,CAAC;EAEMQ,SAAS,GAAIX,MAAuB,IAAK;IAC5C,IAAI,CAACA,MAAM,GAAGA,MAAM;IAEpB,IAAIA,MAAM,CAACY,cAAc,EAAE;MACvB,IAAI,CAACP,eAAe,CAACQ,iBAAiB,CAACb,MAAM,CAACY,cAAc,CAAC;IACjE;IAEA,OAAO,IAAI;EACf,CAAC;AACL;AAACE,OAAA,CAAAf,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,63 @@
+"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 hasAdaptiveThemes() {
+    return this.unistylesBridge.hasAdaptiveThemes;
+  }
+  get sortedBreakpoints() {
+    return this.registry.sortedBreakpointPairs;
+  }
+  get themeName() {
+    return this.unistylesBridge.theme;
+  }
+  get breakpoint() {
+    return this.unistylesBridge.breakpoint;
+  }
+  get screen() {
+    return {
+      width: this.unistylesBridge.screenWidth,
+      height: this.unistylesBridge.screenHeight
+    };
+  }
+  get orientation() {
+    const {
+      width,
+      height
+    } = this.screen;
+    if (width > height) {
+      return _types.ScreenOrientation.Landscape;
+    }
+    return _types.ScreenOrientation.Portrait;
+  }
+  setTheme = name => {
+    if (name !== this.themeName && this.hasTheme(name)) {
+      this.unistylesBridge.useTheme(name);
+      return true;
+    }
+    return false;
+  };
+  getTheme = forName => {
+    if (!this.hasTheme(forName)) {
+      throw new Error(_types.UnistylesError.ThemeNotFound);
+    }
+    return this.registry.themes[forName];
+  };
+  setAdaptiveThemes = enable => {
+    this.unistylesBridge.useAdaptiveThemes(enable);
+  };
+  hasTheme = name => name in this.registry.themes;
+}
+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","hasAdaptiveThemes","sortedBreakpoints","sortedBreakpointPairs","themeName","theme","breakpoint","screen","width","screenWidth","height","screenHeight","orientation","ScreenOrientation","Landscape","Portrait","setTheme","name","hasTheme","useTheme","getTheme","forName","Error","UnistylesError","ThemeNotFound","themes","setAdaptiveThemes","enable","useAdaptiveThemes","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,iBAAiBA,CAAA,EAAG;IAC3B,OAAO,IAAI,CAACH,eAAe,CAACG,iBAAiB;EACjD;EAEA,IAAWC,iBAAiBA,CAAA,EAAG;IAC3B,OAAO,IAAI,CAACH,QAAQ,CAACI,qBAAqB;EAC9C;EAEA,IAAWC,SAASA,CAAA,EAAG;IACnB,OAAO,IAAI,CAACN,eAAe,CAACO,KAAK;EACrC;EAEA,IAAWC,UAAUA,CAAA,EAAG;IACpB,OAAO,IAAI,CAACR,eAAe,CAACQ,UAAU;EAC1C;EAEA,IAAWC,MAAMA,CAAA,EAAG;IAChB,OAAO;MACHC,KAAK,EAAE,IAAI,CAACV,eAAe,CAACW,WAAW;MACvCC,MAAM,EAAE,IAAI,CAACZ,eAAe,CAACa;IACjC,CAAC;EACL;EAEA,IAAWC,WAAWA,CAAA,EAAG;IACrB,MAAM;MAAEJ,KAAK;MAAEE;IAAO,CAAC,GAAG,IAAI,CAACH,MAAM;IAErC,IAAIC,KAAK,GAAGE,MAAM,EAAE;MAChB,OAAOG,wBAAiB,CAACC,SAAS;IACtC;IAEA,OAAOD,wBAAiB,CAACE,QAAQ;EACrC;EAEOC,QAAQ,GAAIC,IAA2B,IAAK;IAC/C,IAAIA,IAAI,KAAK,IAAI,CAACb,SAAS,IAAI,IAAI,CAACc,QAAQ,CAACD,IAAI,CAAC,EAAE;MAChD,IAAI,CAACnB,eAAe,CAACqB,QAAQ,CAACF,IAAI,CAAC;MAEnC,OAAO,IAAI;IACf;IAEA,OAAO,KAAK;EAChB,CAAC;EAEMG,QAAQ,GAAIC,OAA8B,IAAK;IAClD,IAAI,CAAC,IAAI,CAACH,QAAQ,CAACG,OAAO,CAAC,EAAE;MACzB,MAAM,IAAIC,KAAK,CAACC,qBAAc,CAACC,aAAa,CAAC;IACjD;IAEA,OAAO,IAAI,CAACzB,QAAQ,CAAC0B,MAAM,CAACJ,OAAO,CAAC;EACxC,CAAC;EAEMK,iBAAiB,GAAIC,MAAe,IAAK;IAC5C,IAAI,CAAC7B,eAAe,CAAC8B,iBAAiB,CAACD,MAAM,CAAC;EAClD,CAAC;EAEOT,QAAQ,GAAID,IAA2B,IAAKA,IAAI,IAAI,IAAI,CAAClB,QAAQ,CAAC0B,MAAM;AACpF;AAACI,OAAA,CAAAjC,gBAAA,GAAAA,gBAAA"}