react-native-unistyles 2.0.0-alpha.9 → 2.0.0-beta.2

package/android/CMakeLists.txt

@@ -0,0 +1,28 @@
+cmake_minimum_required(VERSION 3.9.0)
+
+project(unistyles)
+
+add_library(unistyles
+    SHARED
+    ../cxx/UnistylesRuntime.cpp
+    ./src/main/cxx/cpp-adapter.cpp
+    ../node_modules/react-native/ReactCommon/jsi/jsi/jsi.cpp
+)
+
+include_directories(
+    ../cxx
+    ../node_modules/react-native/React
+    ../node_modules/react-native/React/Base
+    ../node_modules/react-native/ReactCommon/jsi
+)
+
+set_target_properties(unistyles PROPERTIES
+    CXX_STANDARD 17
+    CXX_STANDARD_REQUIRED ON
+    CXX_EXTENSIONS OFF
+    POSITION_INDEPENDENT_CODE ON
+)
+
+target_link_libraries(unistyles
+    android
+)

package/android/build.gradle

@@ -0,0 +1,40 @@
+buildscript {
+    ext.safeExtGet = {prop, fallback ->
+        rootProject.ext.has(prop) ? rootProject.ext.get(prop) : fallback
+    }
+    repositories {
+        google()
+        gradlePluginPortal()
+    }
+    dependencies {
+        classpath("com.android.tools.build:gradle:7.3.1")
+        classpath("org.jetbrains.kotlin:kotlin-gradle-plugin:1.7.22")
+    }
+}
+
+apply plugin: 'com.android.library'
+apply plugin: 'org.jetbrains.kotlin.android'
+
+android {
+    compileSdkVersion safeExtGet('compileSdkVersion', 33)
+    namespace "com.unistyles"
+
+    defaultConfig {
+        minSdkVersion safeExtGet('minSdkVersion', 21)
+    }
+
+    externalNativeBuild {
+        cmake {
+            path "CMakeLists.txt"
+        }
+    }
+}
+
+repositories {
+    mavenCentral()
+    google()
+}
+
+dependencies {
+    implementation 'com.facebook.react:react-native'
+}

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

@@ -0,0 +1,108 @@
+#include <jni.h>
+#include <jsi/jsi.h>
+#include "UnistylesRuntime.h"
+
+using namespace facebook;
+
+static jobject unistylesModule = nullptr;
+std::shared_ptr<UnistylesRuntime> unistylesRuntime = nullptr;
+
+void throwKotlinException(
+    JNIEnv *env,
+    const char *message
+) {
+    jclass runtimeExceptionClass = env->FindClass("java/lang/RuntimeException");
+
+    if (runtimeExceptionClass != nullptr) {
+        env->ThrowNew(runtimeExceptionClass, message);
+        env->DeleteLocalRef(runtimeExceptionClass);
+    }
+}
+
+extern "C"
+JNIEXPORT void JNICALL
+Java_com_unistyles_UnistylesModule_nativeInstall(
+        JNIEnv *env,
+        jobject thiz,
+        jlong jsi,
+        jint screenWidth,
+        jint screenHeight,
+        jstring colorScheme
+) {
+    auto runtime = reinterpret_cast<facebook::jsi::Runtime *>(jsi);
+
+    if (unistylesModule == nullptr) {
+        unistylesModule = env->NewGlobalRef(thiz);
+    }
+
+    if (runtime == nullptr || unistylesModule == nullptr) {
+        return throwKotlinException(env, "Something went wrong while initializing UnistylesModule");
+    }
+
+    const char *colorSchemeChars = env->GetStringUTFChars(colorScheme, nullptr);
+    std::string colorSchemeStr(colorSchemeChars);
+    env->ReleaseStringUTFChars(colorScheme, colorSchemeChars);
+
+    unistylesRuntime = std::make_shared<UnistylesRuntime>(
+        screenWidth,
+        screenHeight,
+        colorSchemeStr
+    );
+
+    unistylesRuntime->onThemeChange([=](const std::string &theme) {
+        jstring themeStr = env->NewStringUTF(theme.c_str());
+        jclass cls = env->GetObjectClass(unistylesModule);
+        jmethodID methodId = env->GetMethodID(cls, "onThemeChange", "(Ljava/lang/String;)V");
+
+        env->CallVoidMethod(unistylesModule, methodId, themeStr);
+        env->DeleteLocalRef(themeStr);
+        env->DeleteLocalRef(cls);
+    });
+
+    unistylesRuntime->onLayoutChange([=](const std::string &breakpoint, const std::string &orientation, int width, int height) {
+        jstring breakpointStr = env->NewStringUTF(breakpoint.c_str());
+        jstring orientationStr = env->NewStringUTF(orientation.c_str());
+        jclass cls = env->GetObjectClass(unistylesModule);
+        jmethodID methodId = env->GetMethodID(cls, "onLayoutChange", "(Ljava/lang/String;Ljava/lang/String;II)V");
+
+        env->CallVoidMethod(unistylesModule, methodId, breakpointStr, orientationStr, width, height);
+        env->DeleteLocalRef(breakpointStr);
+        env->DeleteLocalRef(orientationStr);
+        env->DeleteLocalRef(cls);
+    });
+
+    unistylesRuntime->onPluginChange([=]() {
+        jclass cls = env->GetObjectClass(unistylesModule);
+        jmethodID methodId = env->GetMethodID(cls, "onPluginChange", "()V");
+
+        env->CallVoidMethod(unistylesModule, methodId);
+        env->DeleteLocalRef(cls);
+    });
+
+    jsi::Object hostObject = jsi::Object::createFromHostObject(*runtime, unistylesRuntime);
+
+    runtime->global().setProperty(*runtime, "__UNISTYLES__", std::move(hostObject));
+}
+
+extern "C"
+JNIEXPORT void JNICALL
+Java_com_unistyles_UnistylesModule_nativeDestroy(JNIEnv *env, jobject thiz) {
+    unistylesRuntime.reset();
+    env->DeleteGlobalRef(unistylesModule);
+}
+
+extern "C"
+JNIEXPORT void JNICALL
+Java_com_unistyles_UnistylesModule_nativeOnOrientationChange(JNIEnv *env, jobject thiz, jint width, jint height) {
+    if (unistylesRuntime != nullptr) {
+        unistylesRuntime->handleScreenSizeChange(width, height);
+    }
+}
+
+extern "C"
+JNIEXPORT void JNICALL
+Java_com_unistyles_UnistylesModule_nativeOnAppearanceChange(JNIEnv *env, jobject thiz, jstring colorScheme) {
+    if (unistylesRuntime != nullptr) {
+        unistylesRuntime->handleAppearanceChange(env->GetStringUTFChars(colorScheme, nullptr));
+    }
+}

package/android/src/main/java/com/unistyles/UnistylesModule.kt

@@ -0,0 +1,159 @@
+package com.unistyles
+
+import android.content.BroadcastReceiver
+import android.content.Context
+import android.content.Intent
+import android.content.IntentFilter
+import android.content.res.Configuration
+import android.os.Handler
+import android.os.Looper
+import android.util.Log
+import com.facebook.react.bridge.Arguments
+import com.facebook.react.bridge.LifecycleEventListener
+import com.facebook.react.bridge.ReactApplicationContext
+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) {
+            if (intent.action == Intent.ACTION_CONFIGURATION_CHANGED) {
+                Handler(Looper.getMainLooper()).postDelayed({
+                    this@UnistylesModule.onConfigChange()
+                }, 10)
+            }
+        }
+    }
+
+    override fun getName() = NAME
+    companion object {
+        const val NAME = "Unistyles"
+    }
+
+    //region Lifecycle
+    init {
+        reactApplicationContext.registerReceiver(configurationChangeReceiver, IntentFilter(Intent.ACTION_CONFIGURATION_CHANGED))
+    }
+
+    override fun onCatalystInstanceDestroy() {
+        reactApplicationContext.unregisterReceiver(configurationChangeReceiver)
+        this.nativeDestroy()
+    }
+
+    //endregion
+    //region Event handlers
+    private fun onConfigChange() {
+        val config = this.getConfig()
+
+        reactApplicationContext.runOnJSQueueThread {
+            this.nativeOnOrientationChange(
+                config["width"] as Int,
+                config["height"] as Int
+            )
+            this.nativeOnAppearanceChange(
+                config["colorScheme"] as String
+            )
+        }
+    }
+
+    private fun getConfig(): Map<String, Any> {
+        val displayMetrics = reactApplicationContext.resources.displayMetrics
+        val colorScheme = when (reactApplicationContext.resources.configuration.uiMode.and(Configuration.UI_MODE_NIGHT_MASK)) {
+            Configuration.UI_MODE_NIGHT_YES -> "dark"
+            Configuration.UI_MODE_NIGHT_NO -> "light"
+            else -> "unspecified"
+        }
+
+        return mapOf(
+            "width" to (displayMetrics.widthPixels / displayMetrics.density).toInt(),
+            "height" to (displayMetrics.heightPixels / displayMetrics.density).toInt(),
+            "colorScheme" to colorScheme
+        )
+    }
+
+    //endregion
+    //region Core
+    @ReactMethod(isBlockingSynchronousMethod = true)
+    fun install(): Boolean {
+        return try {
+            System.loadLibrary("unistyles")
+            val config = this.getConfig()
+
+            this.nativeInstall(
+                this.reactApplicationContext.javaScriptContextHolder.get(),
+                config["width"] as Int,
+                config["height"] as Int,
+                config["colorScheme"] as String
+            )
+
+            Log.i(NAME, "Installed Unistyles \uD83E\uDD84!")
+
+            true
+        } catch (e: Exception) {
+            false
+        }
+    }
+
+    private external fun nativeInstall(jsi: Long, width: Int, height: Int, colorScheme: String)
+    private external fun nativeDestroy()
+    private external fun nativeOnOrientationChange(width: Int, height: Int)
+    private external fun nativeOnAppearanceChange(colorScheme: String)
+
+    //endregion
+    //region Event emitter
+    private fun onLayoutChange(breakpoint: String, orientation: String, width: Int, height: Int) {
+        val body = Arguments.createMap().apply {
+            putString("type", "layout")
+            putMap("payload", Arguments.createMap().apply {
+                putString("breakpoint", breakpoint)
+                putString("orientation", orientation)
+                putMap("screen", Arguments.createMap().apply {
+                    putInt("width", width)
+                    putInt("height", height)
+                })
+            })
+        }
+
+        reactApplicationContext
+            .getJSModule(DeviceEventManagerModule.RCTDeviceEventEmitter::class.java)
+            .emit("__unistylesOnChange", body)
+    }
+
+    private fun onThemeChange(themeName: String) {
+        val body = Arguments.createMap().apply {
+            putString("type", "theme")
+            putMap("payload", Arguments.createMap().apply {
+                putString("themeName", themeName)
+            })
+        }
+
+        reactApplicationContext
+            .getJSModule(DeviceEventManagerModule.RCTDeviceEventEmitter::class.java)
+            .emit("__unistylesOnChange", body)
+    }
+
+    private fun onPluginChange() {
+        val body = Arguments.createMap().apply {
+            putString("type", "plugin")
+        }
+
+        reactApplicationContext
+            .getJSModule(DeviceEventManagerModule.RCTDeviceEventEmitter::class.java)
+            .emit("__unistylesOnChange", body)
+    }
+
+    @ReactMethod
+    fun addListener(eventName: String?) = Unit
+
+    @ReactMethod
+    fun removeListeners(count: Double) = Unit
+    override fun onHostResume() {
+        this.onConfigChange()
+    }
+
+    override fun onHostPause() {}
+
+    override fun onHostDestroy() {}
+    //endregion
+}

package/android/src/main/java/com/unistyles/UnistylesPackage.kt

@@ -0,0 +1,18 @@
+package com.unistyles
+
+import android.view.View
+import com.facebook.react.ReactPackage
+import com.facebook.react.bridge.NativeModule
+import com.facebook.react.bridge.ReactApplicationContext
+import com.facebook.react.uimanager.ReactShadowNode
+import com.facebook.react.uimanager.ViewManager
+
+class UnistylesPackage: ReactPackage {
+    override fun createNativeModules(reactContext: ReactApplicationContext): MutableList<NativeModule> {
+        return mutableListOf(UnistylesModule(reactContext))
+    }
+
+    override fun createViewManagers(reactContext: ReactApplicationContext): MutableList<ViewManager<View, ReactShadowNode<*>>> {
+        return mutableListOf()
+    }
+}

package/cxx/UnistylesRuntime.cpp

@@ -19,6 +19,9 @@ std::vector<jsi::PropNameID> UnistylesRuntime::getPropertyNames(jsi::Runtime& ru
     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")));
+    properties.push_back(jsi::PropNameID::forUtf8(runtime, std::string("addPlugin")));
+    properties.push_back(jsi::PropNameID::forUtf8(runtime, std::string("removePlugin")));
+    properties.push_back(jsi::PropNameID::forUtf8(runtime, std::string("enabledPlugins")));
 
     // setters
     properties.push_back(jsi::PropNameID::forUtf8(runtime, std::string("themes")));
@@ -26,7 +29,6 @@ std::vector<jsi::PropNameID> UnistylesRuntime::getPropertyNames(jsi::Runtime& ru
     return properties;
 }
 
-
 jsi::Value UnistylesRuntime::get(jsi::Runtime& runtime, const jsi::PropNameID& propNameId) {
     std::string propName = propNameId.utf8(runtime);
 
@@ -57,6 +59,16 @@ jsi::Value UnistylesRuntime::get(jsi::Runtime& runtime, const jsi::PropNameID& p
     if (propName == "colorScheme") {
         return jsi::Value(jsi::String::createFromUtf8(runtime, this->colorScheme));
     }
+    
+    if (propName == "enabledPlugins") {
+        auto jsiArray = facebook::jsi::Array(runtime, this->pluginNames.size());
+        
+        for (size_t i = 0; i < this->pluginNames.size(); i++) {
+            jsiArray.setValueAtIndex(runtime, i, facebook::jsi::String::createFromUtf8(runtime, this->pluginNames[i]));
+        }
+        
+        return jsiArray;
+    }
 
     if (propName == "sortedBreakpointPairs") {
         std::unique_ptr<jsi::Array> sortedBreakpointEntriesArray = std::make_unique<jsi::Array>(runtime, this->sortedBreakpointPairs.size());
@@ -72,6 +84,47 @@ jsi::Value UnistylesRuntime::get(jsi::Runtime& runtime, const jsi::PropNameID& p
 
         return jsi::Value(runtime, *sortedBreakpointEntriesArray);
     }
+    
+    if (propName == "addPlugin") {
+        return jsi::Function::createFromHostFunction(
+            runtime,
+            jsi::PropNameID::forAscii(runtime, "addPlugin"),
+            1,
+            [this](jsi::Runtime &runtime, const jsi::Value &thisVal, const jsi::Value *arguments, size_t count) -> jsi::Value {
+                std::string pluginName = arguments[0].asString(runtime).utf8(runtime);
+                bool notify = arguments[1].asBool();
+                
+                this->pluginNames.push_back(pluginName);
+                
+                // registry enabled plugins won't notify listeners
+                if (notify) {
+                    this->onPluginChangeCallback();
+                }
+                
+                return jsi::Value::undefined();
+            }
+        );
+    }
+    
+    if (propName == "removePlugin") {
+        return jsi::Function::createFromHostFunction(
+            runtime,
+            jsi::PropNameID::forAscii(runtime, "removePlugin"),
+            1,
+            [this](jsi::Runtime &runtime, const jsi::Value &thisVal, const jsi::Value *arguments, size_t count) -> jsi::Value {
+                std::string pluginName = arguments[0].asString(runtime).utf8(runtime);
+                
+                auto it = std::find(this->pluginNames.begin(), this->pluginNames.end(), pluginName);
+                
+                if (it != this->pluginNames.end()) {
+                    this->pluginNames.erase(it);
+                    this->onPluginChangeCallback();
+                }
+ 
+                return jsi::Value::undefined();
+            }
+        );
+    }
 
     if (propName == "useBreakpoints") {
         return jsi::Function::createFromHostFunction(
@@ -218,7 +271,7 @@ void UnistylesRuntime::handleScreenSizeChange(int width, int height) {
     this->screenWidth = width;
     this->screenHeight = height;
 
-    int orientation = width > height
+    std::string orientation = width > height
         ? UnistylesOrientationLandscape
         : UnistylesOrientationPortrait;
 

package/cxx/UnistylesRuntime.h

@@ -5,21 +5,22 @@
 
 using namespace facebook;
 
-const int UnistylesOrientationPortrait = 1;
-const int UnistylesOrientationLandscape = 2;
+const std::string UnistylesOrientationPortrait = "portrait";
+const std::string UnistylesOrientationLandscape = "landscape";
 
 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";
+const std::string UnistylesErrorBreakpointsCannotBeEmpty = "You are trying to register empty breakpoints object";
+const std::string UnistylesErrorBreakpointsMustStartFromZero = "You are trying to register breakpoints that don't start from 0";
+const std::string UnistylesErrorThemesCannotBeEmpty = "You are trying to register empty themes object";
 
 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;
+    std::function<void(std::string breakpoint, std::string orientation, int screenWidth, int screenHeight)> onLayoutChangeCallback;
+    std::function<void()> onPluginChangeCallback;
 
     int screenWidth;
     int screenHeight;
@@ -37,17 +38,22 @@ public:
 
     std::string themeName;
     std::string breakpoint;
+    std::vector<std::string> pluginNames;
     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) {
+
+    void onLayoutChange(std::function<void(std::string breakpoint, std::string orientation, int screenWidth, int screenHeight)> callback) {
         this->onLayoutChangeCallback = callback;
     }
 
+    void onPluginChange(std::function<void()> callback) {
+        this->onPluginChangeCallback = 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;

package/ios/UnistylesModule.mm

@@ -65,7 +65,7 @@ RCT_EXPORT_MODULE(Unistyles)
 
 #pragma mark - Event emitter
 - (NSArray<NSString *> *)supportedEvents {
-    return @[@"onChange"];
+    return @[@"__unistylesOnChange"];
 }
 
 - (void)startObserving {
@@ -78,7 +78,7 @@ RCT_EXPORT_MODULE(Unistyles)
 
 - (void)emitEvent:(NSString *)eventName withBody:(NSDictionary *)body {
     if (self.hasListeners) {
-        [self sendEventWithName:@"onChange" body:body];
+        [self sendEventWithName:@"__unistylesOnChange" body:body];
     }
 }
 
@@ -127,15 +127,15 @@ void registerUnistylesHostObject(jsi::Runtime &runtime, UnistylesModule* weakSel
             }
         };
 
-        [weakSelf emitEvent:@"onChange" withBody:body];
+        [weakSelf emitEvent:@"__unistylesOnChange" withBody:body];
     });
 
-    unistylesRuntime.get()->onLayoutChange([=](std::string breakpoint, int orientation, int width, int height) {
+    unistylesRuntime.get()->onLayoutChange([=](std::string breakpoint, std::string orientation, int width, int height) {
         NSDictionary *body = @{
             @"type": @"layout",
             @"payload": @{
                 @"breakpoint": cxxStringToNSString(breakpoint),
-                @"orientation": @(orientation),
+                @"orientation": cxxStringToNSString(orientation),
                 @"screen": @{
                     @"width": @(width),
                     @"height": @(height)
@@ -143,7 +143,17 @@ void registerUnistylesHostObject(jsi::Runtime &runtime, UnistylesModule* weakSel
             }
         };
 
-        [weakSelf emitEvent:@"onChange" withBody:body];
+        [weakSelf emitEvent:@"__unistylesOnChange" withBody:body];
+    });
+    
+    unistylesRuntime.get()->onPluginChange([=]() {
+        NSDictionary *body = @{
+            @"type": @"plugin"
+        };
+
+        dispatch_after(dispatch_time(DISPATCH_TIME_NOW, (int64_t)(0.1 * NSEC_PER_SEC)), dispatch_get_main_queue(), ^{
+            [weakSelf emitEvent:@"__unistylesOnChange" withBody:body];
+        });
     });
 
     weakSelf.unistylesRuntime = unistylesRuntime.get();

package/lib/commonjs/common.js

@@ -3,24 +3,38 @@
 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;
+exports.warn = exports.isWeb = exports.isServer = exports.isMobile = exports.isIOS = exports.isAndroid = exports.UnistylesEventType = exports.UnistylesError = exports.ScreenOrientation = void 0;
+var _reactNative = require("react-native");
+const warn = message => {
+  console.warn(`🦄 [react-native-unistyles]: ${message}`);
+};
+exports.warn = warn;
+const isWeb = exports.isWeb = _reactNative.Platform.OS === 'web';
+const isIOS = exports.isIOS = _reactNative.Platform.OS === 'ios';
+const isAndroid = exports.isAndroid = _reactNative.Platform.OS === 'android';
+const isMobile = exports.isMobile = isIOS || isAndroid;
+const isServer = exports.isServer = typeof window === 'undefined';
+const ScreenOrientation = exports.ScreenOrientation = {
+  Landscape: 'landscape',
+  Portrait: 'portrait'
+};
+let UnistylesEventType = exports.UnistylesEventType = /*#__PURE__*/function (UnistylesEventType) {
+  UnistylesEventType["Theme"] = "theme";
+  UnistylesEventType["Layout"] = "layout";
+  UnistylesEventType["Plugin"] = "plugin";
+  return UnistylesEventType;
 }({});
 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";
+  UnistylesError["RuntimeUnavailable"] = "Unistyles runtime is not available. Make sure you followed the installation instructions";
+  UnistylesError["ThemeNotFound"] = "You are trying to get a theme that is not registered with UnistylesRegistry";
+  UnistylesError["ThemeNotRegistered"] = "You are trying to set a theme that was not registered with UnistylesRegistry";
+  UnistylesError["ThemeNotSelected"] = "Your themes are registered, but you didn't select the initial theme";
+  UnistylesError["ThemesCannotBeEmpty"] = "You are trying to register empty themes object";
+  UnistylesError["BreakpointsCannotBeEmpty"] = "You are trying to register empty breakpoints object";
+  UnistylesError["BreakpointsMustStartFromZero"] = "You are trying to register breakpoints that don't start from 0";
+  UnistylesError["InvalidPluginName"] = "Plugin name can't start from reserved prefix __unistyles";
+  UnistylesError["DuplicatePluginName"] = "You are trying to register a plugin with a name that is already registered";
+  UnistylesError["CantRemoveInternalPlugin"] = "You are trying to remove an internal unistyles plugin";
   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

@@ -1 +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"}
+{"version":3,"names":["_reactNative","require","warn","message","console","exports","isWeb","Platform","OS","isIOS","isAndroid","isMobile","isServer","window","ScreenOrientation","Landscape","Portrait","UnistylesEventType","UnistylesError"],"sourceRoot":"../../src","sources":["common.ts"],"mappings":";;;;;;AAAA,IAAAA,YAAA,GAAAC,OAAA;AAEO,MAAMC,IAAI,GAAIC,OAAe,IAAK;EACrCC,OAAO,CAACF,IAAI,CAAE,gCAA+BC,OAAQ,EAAC,CAAC;AAC3D,CAAC;AAAAE,OAAA,CAAAH,IAAA,GAAAA,IAAA;AAEM,MAAMI,KAAK,GAAAD,OAAA,CAAAC,KAAA,GAAGC,qBAAQ,CAACC,EAAE,KAAK,KAAK;AACnC,MAAMC,KAAK,GAAAJ,OAAA,CAAAI,KAAA,GAAGF,qBAAQ,CAACC,EAAE,KAAK,KAAK;AACnC,MAAME,SAAS,GAAAL,OAAA,CAAAK,SAAA,GAAGH,qBAAQ,CAACC,EAAE,KAAK,SAAS;AAC3C,MAAMG,QAAQ,GAAAN,OAAA,CAAAM,QAAA,GAAGF,KAAK,IAAIC,SAAS;AACnC,MAAME,QAAQ,GAAAP,OAAA,CAAAO,QAAA,GAAG,OAAOC,MAAM,KAAK,WAAW;AAE9C,MAAMC,iBAAiB,GAAAT,OAAA,CAAAS,iBAAA,GAAG;EAC7BC,SAAS,EAAE,WAAW;EACtBC,QAAQ,EAAE;AACd,CAAU;AAAA,IAEEC,kBAAkB,GAAAZ,OAAA,CAAAY,kBAAA,0BAAlBA,kBAAkB;EAAlBA,kBAAkB;EAAlBA,kBAAkB;EAAlBA,kBAAkB;EAAA,OAAlBA,kBAAkB;AAAA;AAAA,IAMlBC,cAAc,GAAAb,OAAA,CAAAa,cAAA,0BAAdA,cAAc;EAAdA,cAAc;EAAdA,cAAc;EAAdA,cAAc;EAAdA,cAAc;EAAdA,cAAc;EAAdA,cAAc;EAAdA,cAAc;EAAdA,cAAc;EAAdA,cAAc;EAAdA,cAAc;EAAA,OAAdA,cAAc;AAAA"}