react-native-unistyles 3.0.0-alpha.4 → 3.0.0-alpha.40

package/android/src/main/java/com/unistyles/NativePlatform+android.kt

@@ -0,0 +1,285 @@
+package com.unistyles
+
+import android.content.Context
+import android.content.res.Configuration
+import android.os.Build
+import android.util.DisplayMetrics
+import android.view.View
+import android.view.WindowManager
+import androidx.core.text.TextUtilsCompat
+import androidx.core.view.ViewCompat
+import androidx.core.view.WindowInsetsCompat
+import androidx.core.view.WindowInsetsControllerCompat
+import com.facebook.react.bridge.LifecycleEventListener
+import com.facebook.react.bridge.ReactApplicationContext
+import com.margelo.nitro.unistyles.ColorScheme
+import com.margelo.nitro.unistyles.Dimensions
+import com.margelo.nitro.unistyles.HybridNativePlatformSpec
+import com.margelo.nitro.unistyles.Insets
+import com.margelo.nitro.unistyles.Orientation
+import com.margelo.nitro.unistyles.UnistyleDependency
+import com.margelo.nitro.unistyles.UnistylesNativeMiniRuntime
+import java.util.Locale
+
+class NativePlatformAndroid(private val reactContext: ReactApplicationContext): HybridNativePlatformSpec(), LifecycleEventListener {
+    private val _insets = NativePlatformInsets(reactContext, this::getMiniRuntime) { this.diffMiniRuntime() }
+    private var _miniRuntime: UnistylesNativeMiniRuntime = buildMiniRuntime()
+    private val _listener = NativePlatformListener(reactContext, this::getMiniRuntime) { this.diffMiniRuntime() }
+
+    init {
+        checkEdgeToEdge()
+        reactContext.addLifecycleEventListener(this)
+    }
+
+    fun invalidate() {
+        reactContext.removeLifecycleEventListener(this)
+        _listener.invalidate()
+    }
+
+    override fun onHostResume() {
+        _insets.startInsetsListener()
+    }
+
+    override fun onHostPause() {
+        _insets.stopInsetsListener()
+    }
+
+    override fun onHostDestroy() {}
+
+    override val memorySize: Long
+        get() = 0
+
+    override fun getInsets(): Insets {
+        return _insets.getInsets()
+    }
+
+    override fun getColorScheme(): ColorScheme {
+        val uiMode = reactContext.resources.configuration.uiMode
+
+        val colorScheme = when (uiMode.and(Configuration.UI_MODE_NIGHT_MASK)) {
+            Configuration.UI_MODE_NIGHT_YES -> ColorScheme.DARK
+            Configuration.UI_MODE_NIGHT_NO -> ColorScheme.LIGHT
+            else -> ColorScheme.UNSPECIFIED
+        }
+
+        return colorScheme
+    }
+
+    override fun getFontScale(): Double {
+        return reactContext.resources.configuration.fontScale.toDouble()
+    }
+
+    override fun getPixelRatio(): Double {
+        return reactContext.resources.displayMetrics.density.toDouble()
+    }
+
+    override fun getOrientation(): Orientation {
+        val orientation = when (reactContext.resources.configuration.orientation) {
+            Configuration.ORIENTATION_PORTRAIT -> Orientation.PORTRAIT
+            Configuration.ORIENTATION_LANDSCAPE -> Orientation.LANDSCAPE
+            else -> Orientation.PORTRAIT
+        }
+
+        return orientation
+    }
+
+    override fun getContentSizeCategory(): String {
+        val fontScale = getFontScale()
+
+        val contentSizeCategory = when {
+            fontScale <= 0.85f -> "Small"
+            fontScale <= 1.0f -> "Default"
+            fontScale <= 1.15f -> "Large"
+            fontScale <= 1.3f -> "ExtraLarge"
+            fontScale <= 1.5f -> "Huge"
+            fontScale <= 1.8 -> "ExtraHuge"
+            else -> "ExtraExtraHuge"
+        }
+
+        return contentSizeCategory
+    }
+
+    override fun getScreenDimensions(): Dimensions {
+        // function takes in count edge-to-edge layout
+        when {
+            Build.VERSION.SDK_INT < Build.VERSION_CODES.R -> {
+                val windowManager = reactContext.getSystemService(Context.WINDOW_SERVICE) as WindowManager
+                val metrics = DisplayMetrics()
+
+                @Suppress("DEPRECATION")
+                windowManager.defaultDisplay.getRealMetrics(metrics)
+
+                val screenWidth = (metrics.widthPixels / metrics.density).toDouble()
+                val screenHeight = (metrics.heightPixels / metrics.density).toDouble()
+
+                return Dimensions(screenWidth, screenHeight)
+            }
+            else -> {
+                val displayMetrics = reactContext.resources.displayMetrics
+
+                reactContext.currentActivity?.windowManager?.currentWindowMetrics?.bounds?.let {
+                    val boundsWidth = (it.width() / displayMetrics.density).toDouble()
+                    val boundsHeight = (it.height() / displayMetrics.density).toDouble()
+
+                    return Dimensions(boundsWidth, boundsHeight)
+                } ?: run {
+                    val screenWidth = (displayMetrics.widthPixels / displayMetrics.density).toDouble()
+                    val screenHeight = (displayMetrics.heightPixels / displayMetrics.density).toDouble()
+
+                    return Dimensions(screenWidth, screenHeight)
+                }
+            }
+        }
+    }
+
+    override fun getStatusBarDimensions(): Dimensions {
+        val screenWidth = getScreenDimensions().width
+
+        return Dimensions(screenWidth, _insets.getInsets().top)
+    }
+
+    override fun getNavigationBarDimensions(): Dimensions {
+        val screenWidth = getScreenDimensions().width
+
+        return Dimensions(screenWidth, _insets.getInsets().bottom)
+    }
+
+    override fun getPrefersRtlDirection(): Boolean {
+        // forced by React Native
+        val sharedPrefs = reactContext.getSharedPreferences(
+            "com.facebook.react.modules.i18nmanager.I18nUtil",
+            Context.MODE_PRIVATE
+        )
+        val hasForcedRtl = sharedPrefs.getBoolean("RCTI18nUtil_forceRTL", false)
+        // user preferences
+        val isRtl = TextUtilsCompat.getLayoutDirectionFromLocale(Locale.getDefault()) == ViewCompat.LAYOUT_DIRECTION_RTL
+
+        return hasForcedRtl || isRtl
+    }
+
+    override fun setRootViewBackgroundColor(color: Double) {
+        reactContext.currentActivity?.let { activity ->
+            activity.window?.decorView?.let { decorView ->
+                activity.runOnUiThread {
+                    decorView.rootView.setBackgroundColor(color.toInt())
+                }
+            }
+        }
+    }
+
+    override fun setNavigationBarHidden(isHidden: Boolean) {
+        reactContext.currentActivity?.let { activity ->
+            WindowInsetsControllerCompat(activity.window, activity.window.decorView).apply {
+                activity.window?.decorView?.let { decorView ->
+                    @Suppress("DEPRECATION")
+                    activity.runOnUiThread {
+                        if (isHidden) {
+                            // below Android 11, we need to use window flags to hide the navigation bar
+                            if (Build.VERSION.SDK_INT <= Build.VERSION_CODES.Q) {
+                                decorView.systemUiVisibility = (View.SYSTEM_UI_FLAG_LAYOUT_HIDE_NAVIGATION
+                                    or View.SYSTEM_UI_FLAG_HIDE_NAVIGATION or View.SYSTEM_UI_FLAG_IMMERSIVE_STICKY)
+                            } else {
+                                hide(WindowInsetsCompat.Type.navigationBars())
+                                systemBarsBehavior =
+                                    WindowInsetsControllerCompat.BEHAVIOR_SHOW_TRANSIENT_BARS_BY_SWIPE
+                            }
+
+                            // dispatch new insets to invoke the insets listener
+                            val newInsets = WindowInsetsCompat.Builder()
+                                .setInsets(WindowInsetsCompat.Type.navigationBars(), androidx.core.graphics.Insets.of(0, 0, 0, 0))
+                                .build()
+
+                            ViewCompat.dispatchApplyWindowInsets(activity.findViewById(android.R.id.content), newInsets)
+                        } else {
+                            show(WindowInsetsCompat.Type.navigationBars())
+                        }
+                    }
+                }
+            }
+        }
+    }
+
+    override fun setStatusBarHidden(isHidden: Boolean) {
+        reactContext.currentActivity?.let { activity ->
+            WindowInsetsControllerCompat(activity.window, activity.window.decorView).apply {
+                activity.window?.let { window ->
+                    @Suppress("DEPRECATION")
+                    activity.runOnUiThread {
+                        if (isHidden) {
+                            if (Build.VERSION.SDK_INT <= Build.VERSION_CODES.Q) {
+                                window.addFlags(WindowManager.LayoutParams.FLAG_FULLSCREEN)
+                                window.clearFlags(WindowManager.LayoutParams.FLAG_FORCE_NOT_FULLSCREEN)
+                            } else {
+                                hide(WindowInsetsCompat.Type.statusBars())
+                            }
+                        } else {
+                            show(WindowInsetsCompat.Type.statusBars())
+                        }
+                    }
+                }
+            }
+        }
+    }
+
+    override fun setImmersiveMode(isEnabled: Boolean) {
+        this.setStatusBarHidden(isEnabled)
+        this.setNavigationBarHidden(isEnabled)
+    }
+
+    override fun getMiniRuntime(): UnistylesNativeMiniRuntime {
+        return _miniRuntime
+    }
+
+    private fun buildMiniRuntime(): UnistylesNativeMiniRuntime {
+        val orientation = this.getOrientation()
+
+        return UnistylesNativeMiniRuntime(
+            colorScheme = this.getColorScheme(),
+            screen = this.getScreenDimensions(),
+            contentSizeCategory = this.getContentSizeCategory(),
+            insets = this.getInsets(),
+            pixelRatio = this.getPixelRatio(),
+            fontScale = this.getFontScale(),
+            rtl = this.getPrefersRtlDirection(),
+            statusBar = this.getStatusBarDimensions(),
+            navigationBar = this.getNavigationBarDimensions(),
+            isPortrait = orientation == Orientation.PORTRAIT,
+            isLandscape = orientation == Orientation.LANDSCAPE
+        )
+    }
+
+    private fun diffMiniRuntime(): Array<UnistyleDependency> {
+        val newMiniRuntime = this.buildMiniRuntime()
+        val changedDependencies = diffMiniRuntimes(this._miniRuntime, newMiniRuntime)
+
+        if (changedDependencies.isNotEmpty()) {
+            this._miniRuntime = newMiniRuntime
+        }
+
+        return changedDependencies
+    }
+
+    override fun registerPlatformListener(callback: (dependencies: Array<UnistyleDependency>, miniRuntime: UnistylesNativeMiniRuntime) -> Unit) {
+        this._listener.addPlatformListener(callback)
+    }
+
+    override fun registerImeListener(callback: (miniRuntime: UnistylesNativeMiniRuntime) -> Unit) {
+        this._insets.addImeListener(callback)
+    }
+
+    override fun unregisterPlatformListeners() {
+        this._listener.removePlatformListeners()
+        this._insets.removeImeListeners()
+    }
+
+    private fun checkEdgeToEdge() {
+        // react-native-edge-to-edge will set setDecorFitsSystemWindows automatically
+        // if it's present we assume that edge-to-edge is enabled
+
+        try {
+            Class.forName("com.zoontek.rnedgetoedge.EdgeToEdgePackage")
+        } catch (exception: ClassNotFoundException) {
+            throw IllegalStateException("Unistyles: react-native-edge-to-edge is not installed.")
+        }
+    }
+}

package/android/src/main/java/com/unistyles/NativePlatform+insets.kt

@@ -0,0 +1,152 @@
+package com.unistyles
+
+import android.graphics.Rect
+import android.os.Build
+import android.view.View
+import android.view.Window
+import android.view.WindowManager
+import androidx.core.view.ViewCompat
+import androidx.core.view.WindowInsetsAnimationCompat
+import androidx.core.view.WindowInsetsCompat
+import com.facebook.react.bridge.ReactApplicationContext
+import com.margelo.nitro.unistyles.Insets
+import com.margelo.nitro.unistyles.UnistyleDependency
+import com.margelo.nitro.unistyles.UnistylesNativeMiniRuntime
+
+typealias CxxImeListener = (miniRuntime: UnistylesNativeMiniRuntime) -> Unit
+
+class NativePlatformInsets(
+    private val reactContext: ReactApplicationContext,
+    private val getMiniRuntime: () -> UnistylesNativeMiniRuntime,
+    private val diffMiniRuntime: () -> Array<UnistyleDependency>
+) {
+    private val _imeListeners: MutableList<CxxImeListener> = mutableListOf()
+    private var _insets: Insets = Insets(0.0, 0.0, 0.0, 0.0, 0.0)
+
+    fun getInsets(): Insets {
+        val density = reactContext.resources.displayMetrics.density
+
+        return Insets(
+            this._insets.top / density,
+            this._insets.bottom / density,
+            this._insets.left / density,
+            this._insets.right / density,
+            this._insets.ime / density
+        )
+    }
+
+    fun setInsets(insetsCompat: WindowInsetsCompat, window: Window, animatedBottomInsets: Double?) {
+        // below Android 11, we need to use window flags to detect status bar visibility
+        val isStatusBarVisible = when(Build.VERSION.SDK_INT) {
+            in 30..Int.MAX_VALUE -> {
+                insetsCompat.isVisible(WindowInsetsCompat.Type.statusBars())
+            }
+            else -> {
+                @Suppress("DEPRECATION")
+                window.attributes.flags and WindowManager.LayoutParams.FLAG_FULLSCREEN != WindowManager.LayoutParams.FLAG_FULLSCREEN
+            }
+        }
+        // React Native is forcing insets to make status bar translucent
+        // so we need to calculate top inset manually, as WindowInsetCompat will always return 0
+        val statusBarTopInset = when(isStatusBarVisible) {
+            true -> {
+                val visibleRect = Rect()
+
+                window.decorView.getWindowVisibleDisplayFrame(visibleRect)
+
+                visibleRect.top
+            }
+            false -> 0
+        }
+
+        val insets = insetsCompat.getInsets(WindowInsetsCompat.Type.systemBars() or WindowInsetsCompat.Type.displayCutout())
+
+        // Android 10 and below - set bottom insets to 0 while keyboard is visible and use default bottom insets otherwise
+        // Android 11 and above - animate bottom insets while keyboard is appearing and disappearing
+        val imeInsets = when {
+            animatedBottomInsets != null && Build.VERSION.SDK_INT >= 30 -> animatedBottomInsets
+            Build.VERSION.SDK_INT < 30 -> {
+                val nextBottomInset = insetsCompat.getInsets(WindowInsetsCompat.Type.ime()).bottom - insets.bottom
+                maxOf(nextBottomInset, 0).toDouble()
+            }
+            else -> 0.0
+        }
+
+        val shouldEmitImeEvent = Build.VERSION.SDK_INT < 30 && imeInsets != this._insets.ime || animatedBottomInsets != null && Build.VERSION.SDK_INT >= 30
+
+        this._insets = Insets(
+            statusBarTopInset.toDouble(),
+            insets.bottom.toDouble(),
+            insets.left.toDouble(),
+            insets.right.toDouble(),
+            imeInsets
+        )
+
+        diffMiniRuntime()
+
+        if (shouldEmitImeEvent) {
+            this@NativePlatformInsets.emitImeEvent(this.getMiniRuntime())
+        }
+    }
+
+    fun startInsetsListener() {
+        reactContext.currentActivity?.let { activity ->
+            activity.findViewById<View>(android.R.id.content)?.let { mainView ->
+                ViewCompat.setOnApplyWindowInsetsListener(mainView) { _, insets ->
+                    setInsets(insets, activity.window, null)
+
+                    insets
+                }
+
+                // IME insets are available from Android 11
+                if (Build.VERSION.SDK_INT >= 30) {
+                    ViewCompat.setWindowInsetsAnimationCallback(
+                        mainView,
+                        object : WindowInsetsAnimationCompat.Callback(DISPATCH_MODE_STOP) {
+                            override fun onProgress(
+                                insets: WindowInsetsCompat,
+                                runningAnimations: List<WindowInsetsAnimationCompat>
+                            ): WindowInsetsCompat {
+                                runningAnimations.firstOrNull()?.let {
+                                    val bottomInset = insets.getInsets(WindowInsetsCompat.Type.ime()).bottom.toDouble() - this@NativePlatformInsets._insets.bottom
+                                    val nextBottomInset = if (bottomInset < 0) {
+                                        0.0
+                                    } else {
+                                        bottomInset
+                                    }
+
+                                    this@NativePlatformInsets.setInsets(insets, activity.window, nextBottomInset)
+                                }
+
+                                return insets
+                            }
+                        }
+                    )
+                }
+            }
+        }
+    }
+
+    fun emitImeEvent(miniRuntime: UnistylesNativeMiniRuntime) {
+        _imeListeners.forEach { listener ->
+            listener(miniRuntime)
+        }
+    }
+
+    fun stopInsetsListener() {
+        reactContext.currentActivity?.let { activity ->
+            activity.window?.decorView?.let { view ->
+                ViewCompat.setOnApplyWindowInsetsListener(view, null)
+                ViewCompat.setWindowInsetsAnimationCallback(view, null)
+            }
+        }
+    }
+
+    fun addImeListener(listener: CxxImeListener) {
+        this._imeListeners.add(listener)
+    }
+
+    fun removeImeListeners() {
+        this._imeListeners.clear()
+    }
+}

package/android/src/main/java/com/unistyles/NativePlatform+listener.kt

@@ -0,0 +1,59 @@
+package com.unistyles
+
+import android.content.BroadcastReceiver
+import android.content.Context
+import android.content.Intent
+import android.content.IntentFilter
+import android.os.Handler
+import android.os.Looper
+import com.facebook.react.bridge.ReactApplicationContext
+import com.margelo.nitro.unistyles.UnistyleDependency
+import com.margelo.nitro.unistyles.UnistylesNativeMiniRuntime
+
+typealias CxxDependencyListener = (dependencies: Array<UnistyleDependency>, miniRuntime: UnistylesNativeMiniRuntime) -> Unit
+
+class NativePlatformListener(
+    private val reactContext: ReactApplicationContext,
+    private val getMiniRuntime: () -> UnistylesNativeMiniRuntime,
+    private val diffMiniRuntime: () -> Array<UnistyleDependency>
+) {
+    private val _dependencyListeners: MutableList<CxxDependencyListener> = mutableListOf()
+
+    private val configurationChangeReceiver = object : BroadcastReceiver() {
+        override fun onReceive(context: Context, intent: Intent) {
+            Handler(Looper.getMainLooper()).postDelayed({
+                this@NativePlatformListener.onConfigChange()
+            }, 10)
+        }
+    }
+
+    init {
+        reactContext.registerReceiver(configurationChangeReceiver, IntentFilter(Intent.ACTION_CONFIGURATION_CHANGED))
+    }
+
+    fun invalidate() {
+        reactContext.unregisterReceiver(configurationChangeReceiver)
+    }
+
+    fun addPlatformListener(listener: CxxDependencyListener) {
+        this._dependencyListeners.add(listener)
+    }
+
+    fun removePlatformListeners() {
+        this._dependencyListeners.clear()
+    }
+
+    private fun emitCxxEvent(dependencies: Array<UnistyleDependency>, miniRuntime: UnistylesNativeMiniRuntime) {
+        this._dependencyListeners.forEach { listener ->
+            listener(dependencies, miniRuntime)
+        }
+    }
+
+    fun onConfigChange() {
+        val changedDependencies = diffMiniRuntime()
+
+        if (changedDependencies.isNotEmpty()) {
+            emitCxxEvent(changedDependencies, getMiniRuntime())
+        }
+    }
+}

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

@@ -0,0 +1,51 @@
+package com.unistyles
+
+import com.facebook.fbreact.specs.NativeTurboUnistylesSpec
+import com.facebook.jni.HybridData
+import com.facebook.proguard.annotations.DoNotStrip
+import com.facebook.react.bridge.ReactApplicationContext
+import com.facebook.react.bridge.RuntimeExecutor
+import com.facebook.react.fabric.FabricUIManager
+import com.facebook.react.turbomodule.core.interfaces.BindingsInstallerHolder
+import com.facebook.react.turbomodule.core.interfaces.TurboModuleWithJSIBindings
+import com.facebook.react.uimanager.UIManagerHelper
+import com.facebook.react.uimanager.common.UIManagerType
+import com.margelo.nitro.unistyles.HybridNativePlatformSpec
+
+@Suppress("KotlinJniMissingFunction")
+class UnistylesModule(reactContext: ReactApplicationContext): NativeTurboUnistylesSpec(reactContext), TurboModuleWithJSIBindings {
+    @DoNotStrip
+    private var mHybridData: HybridData?
+    private val _nativePlatform = NativePlatformAndroid(reactContext)
+
+    companion object {
+        const val NAME = NativeTurboUnistylesSpec.NAME
+    }
+
+    init {
+        mHybridData = initializeHybridData(reactContext)
+    }
+
+    override fun invalidate() {
+        _nativePlatform.invalidate()
+    }
+
+    private fun initializeHybridData(reactContext: ReactApplicationContext): HybridData {
+        val runtimeExecutor = reactContext.catalystInstance?.runtimeExecutor
+            ?: throw IllegalStateException("Unistyles: React Native runtime executor is not available. Please follow installation guides.")
+        val fabricUIManager = UIManagerHelper.getUIManager(reactContext, UIManagerType.FABRIC) as? FabricUIManager
+            ?: throw IllegalStateException("Unistyles: Fabric UI Manager is not available. Please follow installation guides.")
+
+        return initHybrid(runtimeExecutor, fabricUIManager, _nativePlatform)
+    }
+
+    @DoNotStrip
+    external override fun getBindingsInstaller(): BindingsInstallerHolder
+
+    @DoNotStrip
+    private external fun initHybrid(
+        runtimeExecutor: RuntimeExecutor,
+        fabricUIManager: FabricUIManager,
+        nativePlatform: HybridNativePlatformSpec
+    ): HybridData
+}

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

@@ -1,28 +1,30 @@
 package com.unistyles
 
-import android.util.Log
 import com.facebook.react.TurboReactPackage
 import com.facebook.react.bridge.NativeModule
 import com.facebook.react.bridge.ReactApplicationContext
+import com.facebook.react.module.model.ReactModuleInfo
 import com.facebook.react.module.model.ReactModuleInfoProvider
 
 class UnistylesPackage: TurboReactPackage() {
-    companion object {
-        private const val TAG: String = "Unistyles"
-
-        init {
-            try {
-                System.loadLibrary("unistyles")
-                Log.i(TAG, "Installed Unistyles \uD83E\uDD84!")
-            } catch (e: Throwable) {
-                Log.e(TAG, "Failed to load Unistyles C++ library! Is it properly linked?", e)
-                throw e
-            }
+    override fun getModule(name: String, reactContext: ReactApplicationContext): NativeModule? {
+        return if (name == UnistylesModule.NAME) {
+            UnistylesModule(reactContext)
+        } else {
+            null
         }
     }
 
-    override fun getModule(name: String, reactContext: ReactApplicationContext): NativeModule? = null
     override fun getReactModuleInfoProvider(): ReactModuleInfoProvider {
-        return ReactModuleInfoProvider { emptyMap() }
+        return ReactModuleInfoProvider {
+            mapOf(UnistylesModule.NAME to ReactModuleInfo(
+                UnistylesModule.NAME,
+                UnistylesModule.NAME,
+                _canOverrideExistingModule = true,
+                _needsEagerInit = true,
+                isCxxModule = true,
+                isTurboModule = true
+            ))
+        }
     }
 }

package/cxx/NativePlatform.h

@@ -0,0 +1,11 @@
+#if __has_include("Unistyles-Swift-Cxx-Umbrella.hpp")
+    #include "Unistyles-Swift-Cxx-Umbrella.hpp"
+#elif __has_include("JHybridNativePlatformSpec.hpp")
+    #include "JHybridNativePlatformSpec.hpp"
+
+    namespace Unistyles {
+        using HybridNativePlatformSpecCxx = margelo::nitro::unistyles::JHybridNativePlatformSpec;
+    }
+#else
+    #error "Unistyles: Can't find platform specific header!"
+#endif

package/cxx/common/Constants.h

@@ -5,6 +5,9 @@ namespace margelo::nitro::unistyles::helpers {
 static const std::string UNISTYLES_ID = "__unid";
 static const std::string ADD_VARIANTS_FN = "useVariants";
 static const std::string STYLE_DEPENDENCIES = "uni__dependencies";
+static const std::string STYLE_VARIANTS = "uni__variants";
 static const std::string WEB_STYLE_KEY = "_web";
+static const std::string EXOTIC_STYLE_KEY = "_exotic";
+static const std::string NAME_STYLE_KEY = "__unistyles_name";
 
 }