react-native-unistyles 1.2.0 → 2.0.0-alpha.10

package/cxx/UnistylesRuntime.cpp

@@ -0,0 +1,255 @@
+#include "UnistylesRuntime.h"
+
+#include <string>
+#include <vector>
+
+#pragma region HostObject
+
+std::vector<jsi::PropNameID> UnistylesRuntime::getPropertyNames(jsi::Runtime& runtime) {
+    std::vector<jsi::PropNameID> properties;
+
+    // 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("hasAdaptiveThemes")));
+    properties.push_back(jsi::PropNameID::forUtf8(runtime, std::string("themeName")));
+    properties.push_back(jsi::PropNameID::forUtf8(runtime, std::string("breakpoint")));
+    properties.push_back(jsi::PropNameID::forUtf8(runtime, std::string("colorScheme")));
+    properties.push_back(jsi::PropNameID::forUtf8(runtime, std::string("sortedBreakpointPairs")));
+    properties.push_back(jsi::PropNameID::forUtf8(runtime, std::string("useBreakpoints")));
+    properties.push_back(jsi::PropNameID::forUtf8(runtime, std::string("useTheme")));
+    properties.push_back(jsi::PropNameID::forUtf8(runtime, std::string("useAdaptiveThemes")));
+
+    // setters
+    properties.push_back(jsi::PropNameID::forUtf8(runtime, std::string("themes")));
+
+    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 == "themeName") {
+        return !this->themeName.empty()
+            ? jsi::Value(jsi::String::createFromUtf8(runtime, this->themeName))
+            : 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->sortedBreakpointPairs.size());
+
+        for (size_t i = 0; i < this->sortedBreakpointPairs.size(); ++i) {
+            std::unique_ptr<jsi::Array> pairArray = std::make_unique<jsi::Array>(runtime, 2);
+            jsi::String nameValue = jsi::String::createFromUtf8(runtime, this->sortedBreakpointPairs[i].first);
+
+            pairArray->setValueAtIndex(runtime, 0, nameValue);
+            pairArray->setValueAtIndex(runtime, 1, jsi::Value(this->sortedBreakpointPairs[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;
+                });
+
+                if (sortedBreakpointEntriesVec.size() == 0) {
+                    throw jsi::JSError(runtime, UnistylesErrorBreakpointsCannotBeEmpty);
+                }
+
+                if (sortedBreakpointEntriesVec.at(0).second != 0) {
+                    throw jsi::JSError(runtime, UnistylesErrorBreakpointsMustStartFromZero);
+                }
+
+                this->sortedBreakpointPairs = 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);
+
+                if (this->themeName != themeName) {
+                    this->themeName = themeName;
+                    this->onThemeChangeCallback(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();
+                }
+            
+                if (this->themeName != this->colorScheme) {
+                    this->themeName = this->colorScheme;
+                    this->onThemeChangeCallback(this->themeName);
+                }
+
+                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);
+            }
+        }
+
+        if (themesVector.size() == 0) {
+            throw jsi::JSError(runtime, UnistylesErrorThemesCannotBeEmpty);
+        }
+
+        this->themes = themesVector;
+        this->themeName = "";
+
+        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;
+    }
+}
+
+#pragma endregion
+#pragma region Helpers
+
+std::string UnistylesRuntime::getBreakpointFromScreenWidth(int width, const std::vector<std::pair<std::string, double>>& sortedBreakpointPairs) {
+    for (size_t i = 0; i < sortedBreakpointPairs.size(); ++i) {
+        const auto& [key, value] = sortedBreakpointPairs[i];
+        const double maxVal = (i + 1 < sortedBreakpointPairs.size()) ? sortedBreakpointPairs[i + 1].second : std::numeric_limits<double>::infinity();
+
+        if (width >= value && width < maxVal) {
+            return key;
+        }
+    }
+
+    return sortedBreakpointPairs.empty() ? "" : sortedBreakpointPairs.back().first;
+}
+
+void UnistylesRuntime::handleScreenSizeChange(int width, int height) {
+    std::string breakpoint = this->getBreakpointFromScreenWidth(width, this->sortedBreakpointPairs);
+    bool shouldNotify = this->breakpoint != breakpoint || this->screenWidth != width || this->screenHeight != height;
+    
+    this->breakpoint = breakpoint;
+    this->screenWidth = width;
+    this->screenHeight = height;
+
+    int orientation = width > height
+        ? UnistylesOrientationLandscape
+        : UnistylesOrientationPortrait;
+
+    if (shouldNotify) {
+        this->onLayoutChangeCallback(breakpoint, orientation, width, height);
+    }
+}
+
+void UnistylesRuntime::handleAppearanceChange(std::string colorScheme) {
+    this->colorScheme = colorScheme;
+
+    if (!this->supportsAutomaticColorScheme || !this->hasAdaptiveThemes) {
+        return;
+    }
+    
+    if (this->themeName != this->colorScheme) {
+        this->onThemeChangeCallback(this->colorScheme);
+        this->themeName = this->colorScheme;
+    }
+}
+
+jsi::Value UnistylesRuntime::getThemeOrFail(jsi::Runtime& runtime) {
+    if (this->themes.size() == 1) {
+        std::string themeName = this->themes.at(0);
+
+        this->themeName = themeName;
+
+        return jsi::String::createFromUtf8(runtime, themeName);
+    }
+
+    return jsi::Value().undefined();
+}
+
+#pragma endregion

package/cxx/UnistylesRuntime.h

@@ -0,0 +1,60 @@
+#pragma once
+
+#include <jsi/jsi.h>
+#include <vector>
+
+using namespace facebook;
+
+const int UnistylesOrientationPortrait = 1;
+const int UnistylesOrientationLandscape = 2;
+
+const std::string UnistylesDarkScheme = "dark";
+const std::string UnistylesLightScheme = "light";
+const std::string UnistylesUnspecifiedScheme = "unspecified";
+
+const std::string UnistylesErrorBreakpointsCannotBeEmpty = "UNISTYLES_ERROR_BREAKPOINTS_CANNOT_BE_EMPTY'";
+const std::string UnistylesErrorBreakpointsMustStartFromZero = "UNISTYLES_ERROR_BREAKPOINTS_MUST_START_FROM_ZER0";
+const std::string UnistylesErrorThemesCannotBeEmpty = "UNISTYLES_ERROR_THEMES_CANNOT_BE_EMPTY";
+
+class JSI_EXPORT UnistylesRuntime : public jsi::HostObject {
+private:
+    std::function<void(std::string)> onThemeChangeCallback;
+    std::function<void(std::string breakpoint, int layout, int screenWidth, int screenHeight)> onLayoutChangeCallback;
+
+    int screenWidth;
+    int screenHeight;
+    std::string colorScheme;
+
+public:
+    UnistylesRuntime(
+        int screenWidth,
+        int screenHeight,
+        std::string colorScheme
+    ): screenWidth(screenWidth), screenHeight(screenHeight), colorScheme(colorScheme) {}
+
+    bool hasAdaptiveThemes;
+    bool supportsAutomaticColorScheme;
+
+    std::string themeName;
+    std::string breakpoint;
+    std::vector<std::string> themes;
+    std::vector<std::pair<std::string, double>> sortedBreakpointPairs;
+    
+    void onThemeChange(std::function<void(std::string)> callback) {
+        this->onThemeChangeCallback = callback;
+    }
+    
+    void onLayoutChange(std::function<void(std::string breakpoint, int layout, int screenWidth, int screenHeight)> callback) {
+        this->onLayoutChangeCallback = 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;
+    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(int width, const std::vector<std::pair<std::string, double>>& sortedBreakpointEntries);
+};

package/ios/UnistylesHelpers.h

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

package/ios/UnistylesHelpers.mm

@@ -0,0 +1,20 @@
+#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

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

package/ios/UnistylesModule.mm

@@ -0,0 +1,158 @@
+#import "UnistylesModule.h"
+#import "UnistylesHelpers.h"
+#import "UnistylesRuntime.h"
+
+#import <React/RCTAppearance.h>
+#import <React/RCTBridge+Private.h>
+#import <jsi/jsi.h>
+
+using namespace facebook;
+
+@implementation UnistylesModule
+
+RCT_EXPORT_MODULE(Unistyles)
+
+#pragma mark - Lifecycle
+
+- (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];
+    }
+
+    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 @[@"onChange"];
+}
+
+- (void)startObserving {
+    self.hasListeners = YES;
+}
+
+- (void)stopObserving {
+    self.hasListeners = NO;
+}
+
+- (void)emitEvent:(NSString *)eventName withBody:(NSDictionary *)body {
+    if (self.hasListeners) {
+        [self sendEventWithName:@"onChange" body:body];
+    }
+}
+
+#pragma mark - Core
+
+RCT_EXPORT_BLOCKING_SYNCHRONOUS_METHOD(install) {
+    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;
+}
+
+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
+    );
+
+    unistylesRuntime.get()->onThemeChange([=](std::string theme) {
+        NSDictionary *body = @{
+            @"type": @"theme",
+            @"payload": @{
+                @"themeName": cxxStringToNSString(theme)
+            }
+        };
+
+        [weakSelf emitEvent:@"onChange" withBody:body];
+    });
+
+    unistylesRuntime.get()->onLayoutChange([=](std::string breakpoint, int orientation, int width, int height) {
+        NSDictionary *body = @{
+            @"type": @"layout",
+            @"payload": @{
+                @"breakpoint": cxxStringToNSString(breakpoint),
+                @"orientation": @(orientation),
+                @"screen": @{
+                    @"width": @(width),
+                    @"height": @(height)
+                }
+            }
+        };
+
+        [weakSelf emitEvent:@"onChange" withBody:body];
+    });
+
+    weakSelf.unistylesRuntime = unistylesRuntime.get();
+
+    auto hostObject = jsi::Object::createFromHostObject(runtime, unistylesRuntime);
+
+    runtime.global().setProperty(runtime, "__UNISTYLES__", std::move(hostObject));
+}
+
+@end
+
+#pragma mark - End

package/lib/commonjs/common.js

@@ -0,0 +1,26 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.UnistylesError = exports.ScreenOrientation = exports.CxxUnistylesEventTypes = void 0;
+let CxxUnistylesEventTypes = exports.CxxUnistylesEventTypes = /*#__PURE__*/function (CxxUnistylesEventTypes) {
+  CxxUnistylesEventTypes["Theme"] = "theme";
+  CxxUnistylesEventTypes["Layout"] = "layout";
+  return CxxUnistylesEventTypes;
+}({});
+let UnistylesError = exports.UnistylesError = /*#__PURE__*/function (UnistylesError) {
+  UnistylesError["RuntimeUnavailable"] = "UNISTYLES_ERROR_RUNTIME_UNAVAILABLE";
+  UnistylesError["ThemeNotFound"] = "UNISTYLES_ERROR_THEME_NOT_FOUND";
+  UnistylesError["ThemeNotRegistered"] = "UNISTYLES_ERROR_THEME_NOT_REGISTERED";
+  UnistylesError["ThemesCannotBeEmpty"] = "UNISTYLES_ERROR_THEMES_CANNOT_BE_EMPTY";
+  UnistylesError["BreakpointsCannotBeEmpty"] = "UNISTYLES_ERROR_BREAKPOINTS_CANNOT_BE_EMPTY";
+  UnistylesError["BreakpointsMustStartFromZero"] = "UNISTYLES_ERROR_BREAKPOINTS_MUST_START_FROM_ZERO";
+  return UnistylesError;
+}({}); // todo to string?
+let ScreenOrientation = exports.ScreenOrientation = /*#__PURE__*/function (ScreenOrientation) {
+  ScreenOrientation[ScreenOrientation["Portrait"] = 1] = "Portrait";
+  ScreenOrientation[ScreenOrientation["Landscape"] = 2] = "Landscape";
+  return ScreenOrientation;
+}({});
+//# sourceMappingURL=common.js.map

package/lib/commonjs/common.js.map

@@ -0,0 +1 @@
+{"version":3,"names":["CxxUnistylesEventTypes","exports","UnistylesError","ScreenOrientation"],"sourceRoot":"../../src","sources":["common.ts"],"mappings":";;;;;;IAAYA,sBAAsB,GAAAC,OAAA,CAAAD,sBAAA,0BAAtBA,sBAAsB;EAAtBA,sBAAsB;EAAtBA,sBAAsB;EAAA,OAAtBA,sBAAsB;AAAA;AAAA,IAKtBE,cAAc,GAAAD,OAAA,CAAAC,cAAA,0BAAdA,cAAc;EAAdA,cAAc;EAAdA,cAAc;EAAdA,cAAc;EAAdA,cAAc;EAAdA,cAAc;EAAdA,cAAc;EAAA,OAAdA,cAAc;AAAA,OAS1B;AAAA,IACYC,iBAAiB,GAAAF,OAAA,CAAAE,iBAAA,0BAAjBA,iBAAiB;EAAjBA,iBAAiB,CAAjBA,iBAAiB;EAAjBA,iBAAiB,CAAjBA,iBAAiB;EAAA,OAAjBA,iBAAiB;AAAA"}

package/lib/commonjs/core/UnistyleRegistry.js

@@ -0,0 +1,38 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.UnistyleRegistry = void 0;
+class UnistyleRegistry {
+  config = {};
+  themeNames = [];
+  themes = {};
+  breakpoints = {};
+  sortedBreakpointPairs = [];
+  constructor(unistylesBridge) {
+    this.unistylesBridge = unistylesBridge;
+  }
+  addThemes = themes => {
+    this.themes = themes;
+    const keys = Object.keys(themes);
+    this.unistylesBridge.themes = keys;
+    this.themeNames = keys;
+    return this;
+  };
+  addBreakpoints = breakpoints => {
+    this.breakpoints = 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/core/UnistyleRegistry.js.map

@@ -0,0 +1 @@
+{"version":3,"names":["UnistyleRegistry","config","themeNames","themes","breakpoints","sortedBreakpointPairs","constructor","unistylesBridge","addThemes","keys","Object","addBreakpoints","useBreakpoints","addConfig","adaptiveThemes","useAdaptiveThemes","exports"],"sourceRoot":"../../../src","sources":["core/UnistyleRegistry.ts"],"mappings":";;;;;;AAGO,MAAMA,gBAAgB,CAAC;EACnBC,MAAM,GAAoB,CAAC,CAAC;EAC5BC,UAAU,GAAiC,EAAE;EAC7CC,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;IAEpB,MAAMM,IAAI,GAAGC,MAAM,CAACD,IAAI,CAACN,MAAM,CAAiC;IAEhE,IAAI,CAACI,eAAe,CAACJ,MAAM,GAAGM,IAAI;IAClC,IAAI,CAACP,UAAU,GAAGO,IAAI;IAEtB,OAAO,IAAI;EACf,CAAC;EAEME,cAAc,GAAIP,WAAiC,IAAK;IAC3D,IAAI,CAACA,WAAW,GAAGA,WAAW;IAC9B,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,GAAIZ,MAAuB,IAAK;IAC5C,IAAI,CAACA,MAAM,GAAGA,MAAM;IAEpB,IAAIA,MAAM,CAACa,cAAc,EAAE;MACvB,IAAI,CAACP,eAAe,CAACQ,iBAAiB,CAACd,MAAM,CAACa,cAAc,CAAC;IACjE;IAEA,OAAO,IAAI;EACf,CAAC;AACL;AAACE,OAAA,CAAAhB,gBAAA,GAAAA,gBAAA"}

package/lib/commonjs/core/Unistyles.js

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

package/lib/commonjs/core/Unistyles.js.map

@@ -0,0 +1 @@
+{"version":3,"names":["_UnistylesModule","require","_UnistylesRuntime","_UnistyleRegistry","_common","Unistyles","constructor","isInstalled","UnistylesModule","install","Error","UnistylesError","RuntimeUnavailable","_bridge","global","__UNISTYLES__","_registry","UnistyleRegistry","_runtime","UnistylesRuntime","registry","runtime","unistyles","exports"],"sourceRoot":"../../../src","sources":["core/Unistyles.ts"],"mappings":";;;;;;AAAA,IAAAA,gBAAA,GAAAC,OAAA;AACA,IAAAC,iBAAA,GAAAD,OAAA;AACA,IAAAE,iBAAA,GAAAF,OAAA;AAEA,IAAAG,OAAA,GAAAH,OAAA;AAEA,MAAMI,SAAS,CAAC;EAKZC,WAAWA,CAAA,EAAG;IACV,MAAMC,WAAW,GAAGC,gCAAe,EAAEC,OAAO,CAAC,CAAC,IAAI,KAAK;IAEvD,IAAI,CAACF,WAAW,EAAE;MACd,MAAM,IAAIG,KAAK,CAACC,sBAAc,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;EACtE;EAEA,IAAWI,QAAQA,CAAA,EAAG;IAClB,OAAO,IAAI,CAACJ,SAAS;EACzB;EAEA,IAAWK,OAAOA,CAAA,EAAG;IACjB,OAAO,IAAI,CAACH,QAAQ;EACxB;AACJ;AAEO,MAAMI,SAAS,GAAAC,OAAA,CAAAD,SAAA,GAAG,IAAIjB,SAAS,CAAC,CAAC"}

package/lib/commonjs/core/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/core/UnistylesModule.js.map

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