react-native-platform-components 1.3.0 → 1.5.0

package/android/src/main/java/com/platformcomponents/PCFloatingActionButtonViewManager.kt

@@ -0,0 +1,109 @@
+package com.platformcomponents
+
+import com.facebook.react.bridge.Arguments
+import com.facebook.react.bridge.ReadableMap
+import com.facebook.react.bridge.WritableMap
+import com.facebook.react.uimanager.ReactStylesDiffMap
+import com.facebook.react.uimanager.SimpleViewManager
+import com.facebook.react.uimanager.StateWrapper
+import com.facebook.react.uimanager.ThemedReactContext
+import com.facebook.react.uimanager.UIManagerHelper
+import com.facebook.react.uimanager.ViewManagerDelegate
+import com.facebook.react.uimanager.events.Event
+import com.facebook.react.viewmanagers.PCFloatingActionButtonManagerDelegate
+import com.facebook.react.viewmanagers.PCFloatingActionButtonManagerInterface
+
+class PCFloatingActionButtonViewManager :
+  SimpleViewManager<PCFloatingActionButtonView>(),
+  PCFloatingActionButtonManagerInterface<PCFloatingActionButtonView> {
+
+  private val delegate: ViewManagerDelegate<PCFloatingActionButtonView> =
+    PCFloatingActionButtonManagerDelegate(this)
+
+  override fun getName(): String = "PCFloatingActionButton"
+
+  override fun getDelegate(): ViewManagerDelegate<PCFloatingActionButtonView> = delegate
+
+  override fun createViewInstance(reactContext: ThemedReactContext): PCFloatingActionButtonView =
+    PCFloatingActionButtonView(reactContext)
+
+  /**
+   * Pass the StateWrapper to the view so it can update Fabric state with its
+   * size, and report it right away so the first layout already fits.
+   */
+  override fun updateState(
+    view: PCFloatingActionButtonView,
+    props: ReactStylesDiffMap,
+    stateWrapper: StateWrapper
+  ): Any? {
+    view.stateWrapper = stateWrapper
+    view.reportIntrinsicSize()
+    return null
+  }
+
+  override fun addEventEmitters(reactContext: ThemedReactContext, view: PCFloatingActionButtonView) {
+    view.onPress = {
+      PCHaptics.perform(view, view.haptics)
+      UIManagerHelper.getEventDispatcherForReactTag(reactContext, view.id)?.dispatchEvent(
+        PressEvent(UIManagerHelper.getSurfaceId(view), view.id)
+      )
+    }
+  }
+
+  // icon: {iconType, iconName, iconUri, iconScale, iconTinted}
+  override fun setIcon(view: PCFloatingActionButtonView, value: ReadableMap?) {
+    view.applyIcon(PCButtonSupport.parseIcon(value))
+  }
+
+  override fun setLabel(view: PCFloatingActionButtonView, value: String?) {
+    view.applyLabel(value ?: "")
+  }
+
+  // "small" | "regular" | "medium" | "large"
+  override fun setSize(view: PCFloatingActionButtonView, value: String?) {
+    view.applySize(value)
+  }
+
+  // "true" | "false"
+  override fun setExtended(view: PCFloatingActionButtonView, value: String?) {
+    view.applyExtended(value != "false")
+  }
+
+  // Colors arrive already processed by React Native (ARGB ints)
+  override fun setColor(view: PCFloatingActionButtonView, value: Int?) {
+    view.applyColors(value, view.foregroundColor)
+  }
+
+  override fun setForegroundColor(view: PCFloatingActionButtonView, value: Int?) {
+    view.applyColors(view.containerColor, value)
+  }
+
+  override fun setInteractivity(view: PCFloatingActionButtonView, value: String?) {
+    view.applyInteractivity(value)
+  }
+
+  override fun setSpokenLabel(view: PCFloatingActionButtonView, value: String?) {
+    view.applySpokenLabel(value ?: "")
+  }
+
+  // "" (none added) | "none" | "selection" | "light" | "medium" | "heavy" | "success" | "warning" | "error"
+  override fun setHaptics(view: PCFloatingActionButtonView, value: String?) {
+    view.haptics = PCHaptics.configure(view, value)
+  }
+
+  override fun setScrollViewNativeID(view: PCFloatingActionButtonView, value: String?) {
+    view.applyScrollViewNativeID(value ?: "")
+  }
+
+  // --- Events ---
+
+  private class PressEvent(surfaceId: Int, viewTag: Int) : Event<PressEvent>(surfaceId, viewTag) {
+    // Every press counts; two quick presses must not merge into one
+    override fun canCoalesce(): Boolean = false
+
+    override fun getEventName(): String = "topFabPress"
+
+    // Fabric reads the payload from here
+    override fun getEventData(): WritableMap = Arguments.createMap()
+  }
+}

package/android/src/main/java/com/platformcomponents/PCFloatingToolbarView.kt

@@ -0,0 +1,247 @@
+package com.platformcomponents
+
+import android.content.Context
+import android.content.res.ColorStateList
+import android.graphics.Color
+import android.view.View
+import android.view.ViewTreeObserver
+import android.view.animation.AccelerateInterpolator
+import android.view.animation.DecelerateInterpolator
+import androidx.core.content.res.ResourcesCompat
+import com.facebook.react.uimanager.util.ReactFindViewUtil
+import com.google.android.material.R as MaterialR
+import com.google.android.material.color.MaterialColors
+import com.google.android.material.floatingtoolbar.FloatingToolbarLayout
+import com.google.android.material.shape.MaterialShapeDrawable
+
+/**
+ * A Material 3 floating toolbar. The Material container (shape, elevation,
+ * color) hosts React children, which Fabric lays out itself.
+ */
+class PCFloatingToolbarView(context: Context) :
+  FloatingToolbarLayout(
+    // Material widgets need a Material theme; fall back to Material 3 defaults instead of crashing.
+    PCThemeSupport.materialContext(context, "FloatingToolbar"),
+    null,
+    0,
+    R.style.PCFloatingToolbar
+  ) {
+
+  companion object {
+    private const val TAG = "PCFloatingToolbar"
+  }
+
+  // --- Props ---
+  var variant: String = "standard" // "standard" | "vibrant"
+  var color: Int? = null
+
+  /** The button overlay for Buttons inside this toolbar (see PCButtonView). */
+  val buttonOverlay: Int
+    get() = if (variant == "vibrant") R.style.PCToolbarOverlay_Vibrant else R.style.PCToolbarOverlay
+
+  // --- Native theme ---
+  private val nativeThemeListener = PCNativeTheme.Listener {
+    ResourcesCompat.clearCachesForTheme(context.theme)
+    applyColors()
+  }
+
+  // --- Linked scroll view ---
+  var scrollViewNativeID: String = ""
+  var hideOnScroll: Boolean = false
+  private var watchedScrollView: View? = null
+  private var watchedObserver: ViewTreeObserver? = null
+  private var lastScrollY = 0
+  private var scrollHidden = false
+  private val scrollViewFinder = object : ReactFindViewUtil.OnViewFoundListener {
+    override fun getNativeId(): String = scrollViewNativeID
+    override fun onViewFound(view: View) = watch(view)
+  }
+  // A tree observer rather than the view's own scroll listener, which a
+  // TabBar linked to the same ScrollView would replace
+  private val scrollListener = ViewTreeObserver.OnScrollChangedListener {
+    val view = watchedScrollView ?: return@OnScrollChangedListener
+    val scrollY = view.scrollY
+    val dy = scrollY - lastScrollY
+    lastScrollY = scrollY
+    onContentScrolled(scrollY, dy)
+  }
+
+  init {
+    clipChildren = false
+    clipToPadding = false
+    applyColors()
+  }
+
+  // ---- Public apply* (called by manager) ----
+
+  fun applyVariant(value: String?) {
+    val parsed = if (value == "vibrant") "vibrant" else "standard"
+    if (variant == parsed) return
+    variant = parsed
+    applyColors()
+    // Buttons inside take the toolbar's button styles
+    for (i in 0 until childCount) {
+      (getChildAt(i) as? PCButtonView)?.refreshToolbarStyle()
+    }
+  }
+
+  fun applyColor(value: Int?) {
+    if (color == value) return
+    color = value
+    applyColors()
+  }
+
+  /**
+   * A `backgroundColor` style would replace the Material shape; route it into
+   * the color instead. React Native resets it with transparent.
+   */
+  override fun setBackgroundColor(color: Int) {
+    applyColor(if (color == Color.TRANSPARENT) null else color)
+  }
+
+  private fun applyColors() {
+    val resolved = color ?: MaterialColors.getColor(
+      this,
+      if (variant == "vibrant") MaterialR.attr.colorPrimaryContainer else MaterialR.attr.colorSurfaceContainer,
+      Color.TRANSPARENT
+    )
+    val shape = background as? MaterialShapeDrawable
+    if (shape != null) {
+      shape.fillColor = ColorStateList.valueOf(resolved)
+    } else {
+      backgroundTintList = ColorStateList.valueOf(resolved)
+    }
+  }
+
+  // ---- Hide on scroll ----
+  // Material's HideViewOnScrollBehavior only works in a CoordinatorLayout,
+  // which a React Native screen doesn't have. The toolbar does its motion
+  // itself, as TabBar does: it slides past its edge of the linked ScrollView
+  // (175 ms out, 225 ms back) while the content scrolls down, and returns as
+  // it scrolls up or reaches the top. The host view moves, so React Native's
+  // touch targeting follows it and the content underneath takes the touches.
+
+  fun applyScrollViewNativeID(value: String) {
+    if (scrollViewNativeID == value) return
+    scrollViewNativeID = value
+    findScrollView()
+  }
+
+  fun applyHideOnScroll(value: Boolean) {
+    if (hideOnScroll == value) return
+    hideOnScroll = value
+    if (!value) setScrollHidden(false)
+  }
+
+  /** The ScrollView with scrollViewNativeID, now or once it mounts. */
+  private fun findScrollView() {
+    unwatch()
+    ReactFindViewUtil.removeViewListener(scrollViewFinder)
+    if (scrollViewNativeID.isEmpty() || !isAttachedToWindow) return
+    val found = ReactFindViewUtil.findView(rootView, scrollViewNativeID)
+    if (found != null) watch(found) else ReactFindViewUtil.addViewListener(scrollViewFinder)
+  }
+
+  private fun watch(view: View) {
+    ReactFindViewUtil.removeViewListener(scrollViewFinder)
+    unwatch()
+    watchedScrollView = view
+    lastScrollY = view.scrollY
+    watchedObserver = view.viewTreeObserver.also { it.addOnScrollChangedListener(scrollListener) }
+  }
+
+  private fun unwatch() {
+    watchedObserver?.takeIf { it.isAlive }?.removeOnScrollChangedListener(scrollListener)
+    watchedObserver = null
+    watchedScrollView = null
+    if (scrollHidden) {
+      scrollHidden = false
+      animate().cancel()
+      translationX = 0f
+      translationY = 0f
+    }
+  }
+
+  private fun onContentScrolled(scrollY: Int, dy: Int) {
+    if (!hideOnScroll || dy == 0) return
+    // Back at the top the toolbar always shows
+    setScrollHidden(scrollY > 0 && dy > 0)
+  }
+
+  private fun setScrollHidden(hide: Boolean) {
+    if (scrollHidden == hide) return
+    scrollHidden = hide
+    val (dx, dy) = if (hide) hiddenTranslation() else 0f to 0f
+    animate().cancel()
+    animate()
+      .translationX(dx)
+      .translationY(dy)
+      .setDuration(if (hide) 175L else 225L)
+      .setInterpolator(if (hide) AccelerateInterpolator() else DecelerateInterpolator())
+      .start()
+  }
+
+  /**
+   * How far to move to get past the linked edge: top or bottom for a
+   * horizontal toolbar, left or right for a vertical one, from the toolbar to
+   * that edge of the ScrollView plus the elevation shadow, and at least the
+   * toolbar's own size.
+   */
+  private fun hiddenTranslation(): Pair<Float, Float> {
+    val scrollView = watchedScrollView ?: return 0f to 0f
+    val here = IntArray(2).also { getLocationInWindow(it) }
+    val there = IntArray(2).also { scrollView.getLocationInWindow(it) }
+    // Where the toolbar sits without the translation it may have
+    val left = here[0] - translationX
+    val top = here[1] - translationY
+    val right = left + width
+    val bottom = top + height
+    val scrollLeft = there[0].toFloat()
+    val scrollTop = there[1].toFloat()
+    val scrollRight = scrollLeft + scrollView.width
+    val scrollBottom = scrollTop + scrollView.height
+    val shadow = elevation
+    return if (width >= height) {
+      if (top + bottom < scrollTop + scrollBottom) {
+        0f to minOf(scrollTop - bottom - shadow, -height.toFloat())
+      } else {
+        0f to maxOf(scrollBottom - top + shadow, height.toFloat())
+      }
+    } else {
+      if (left + right < scrollLeft + scrollRight) {
+        minOf(scrollLeft - right - shadow, -width.toFloat()) to 0f
+      } else {
+        maxOf(scrollRight - left + shadow, width.toFloat()) to 0f
+      }
+    }
+  }
+
+  override fun onAttachedToWindow() {
+    super.onAttachedToWindow()
+    PCNativeTheme.addListener(nativeThemeListener)
+    PCNativeTheme.attach(context)
+    if (watchedScrollView == null) findScrollView()
+  }
+
+  override fun onDetachedFromWindow() {
+    ReactFindViewUtil.removeViewListener(scrollViewFinder)
+    unwatch()
+    PCNativeTheme.removeListener(nativeThemeListener)
+    super.onDetachedFromWindow()
+  }
+
+  // ---- Layout ----
+  // Fabric sizes this view and positions its children; FrameLayout must not
+  // re-measure or re-position them against its own padding and gravity.
+
+  override fun onMeasure(widthMeasureSpec: Int, heightMeasureSpec: Int) {
+    setMeasuredDimension(
+      MeasureSpec.getSize(widthMeasureSpec),
+      MeasureSpec.getSize(heightMeasureSpec)
+    )
+  }
+
+  override fun onLayout(changed: Boolean, left: Int, top: Int, right: Int, bottom: Int) {
+    // No-op: Fabric lays out the children
+  }
+}

package/android/src/main/java/com/platformcomponents/PCFloatingToolbarViewManager.kt

@@ -0,0 +1,73 @@
+package com.platformcomponents
+
+import android.view.View
+import com.facebook.react.bridge.ReadableMap
+import com.facebook.react.uimanager.ThemedReactContext
+import com.facebook.react.uimanager.ViewGroupManager
+import com.facebook.react.uimanager.ViewManagerDelegate
+import com.facebook.react.viewmanagers.PCFloatingToolbarManagerDelegate
+import com.facebook.react.viewmanagers.PCFloatingToolbarManagerInterface
+import com.platformcomponents.PCButtonSupport.stringOr
+
+/**
+ * Android ViewManager for FloatingToolbar. Uses ViewGroupManager since the
+ * toolbar hosts React children.
+ */
+class PCFloatingToolbarViewManager :
+  ViewGroupManager<PCFloatingToolbarView>(),
+  PCFloatingToolbarManagerInterface<PCFloatingToolbarView> {
+
+  companion object {
+    private const val TAG = "PCFloatingToolbar"
+  }
+
+  private val delegate: ViewManagerDelegate<PCFloatingToolbarView> =
+    PCFloatingToolbarManagerDelegate(this)
+
+  override fun getName(): String = "PCFloatingToolbar"
+
+  override fun getDelegate(): ViewManagerDelegate<PCFloatingToolbarView> = delegate
+
+  override fun createViewInstance(reactContext: ThemedReactContext): PCFloatingToolbarView {
+    return PCFloatingToolbarView(reactContext)
+  }
+
+  // Colors arrive already processed by React Native (ARGB ints)
+  override fun setColor(view: PCFloatingToolbarView, value: Int?) {
+    view.applyColor(value)
+  }
+
+  override fun setScrollViewNativeID(view: PCFloatingToolbarView, value: String?) {
+    view.applyScrollViewNativeID(value ?: "")
+  }
+
+  override fun setHideOnScroll(view: PCFloatingToolbarView, value: Boolean) {
+    view.applyHideOnScroll(value)
+  }
+
+  override fun setIos(view: PCFloatingToolbarView, value: ReadableMap?) {
+    // iOS props are ignored on Android
+  }
+
+  // android: {variant}
+  override fun setAndroid(view: PCFloatingToolbarView, value: ReadableMap?) {
+    view.applyVariant(value?.stringOr("variant", "standard"))
+  }
+
+  // --- ViewGroupManager child management ---
+  override fun addView(parent: PCFloatingToolbarView, child: View, index: Int) {
+    parent.addView(child, index)
+  }
+
+  override fun removeViewAt(parent: PCFloatingToolbarView, index: Int) {
+    parent.removeViewAt(index)
+  }
+
+  override fun getChildCount(parent: PCFloatingToolbarView): Int {
+    return parent.childCount
+  }
+
+  override fun getChildAt(parent: PCFloatingToolbarView, index: Int): View? {
+    return parent.getChildAt(index)
+  }
+}

package/android/src/main/java/com/platformcomponents/PCHaptics.kt

@@ -0,0 +1,46 @@
+package com.platformcomponents
+
+import android.os.Build
+import android.view.HapticFeedbackConstants
+import android.view.View
+
+/**
+ * The shared `haptics` prop: `View.performHapticFeedback` with the matching
+ * `HapticFeedbackConstants`, played when a control reports the user's action.
+ * The system touch-feedback setting applies (no ignore flags are passed).
+ */
+object PCHaptics {
+  /**
+   * Applies a `haptics` value to [view]: "none" turns off the haptics the view
+   * plays itself (such as a long press), anything else turns them back on.
+   * Returns the value for the view to keep ("" when unset).
+   */
+  fun configure(view: View, value: String?): String {
+    val kind = value ?: ""
+    view.isHapticFeedbackEnabled = kind != "none"
+    return kind
+  }
+
+  /** Plays [kind] on [view]; "" and "none" play nothing. */
+  fun perform(view: View, kind: String) {
+    val constant = constantFor(kind) ?: return
+    view.performHapticFeedback(constant)
+  }
+
+  /** The feedback constant for a `haptics` value, with fallbacks below the API level that added it. */
+  fun constantFor(kind: String): Int? = when (kind) {
+    "selection" ->
+      if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.UPSIDE_DOWN_CAKE) HapticFeedbackConstants.SEGMENT_TICK
+      else HapticFeedbackConstants.CLOCK_TICK
+    "light" -> HapticFeedbackConstants.CONTEXT_CLICK
+    "medium" -> HapticFeedbackConstants.VIRTUAL_KEY
+    "heavy" -> HapticFeedbackConstants.LONG_PRESS
+    "success" ->
+      if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.R) HapticFeedbackConstants.CONFIRM
+      else HapticFeedbackConstants.VIRTUAL_KEY
+    "warning", "error" ->
+      if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.R) HapticFeedbackConstants.REJECT
+      else HapticFeedbackConstants.LONG_PRESS
+    else -> null
+  }
+}

package/android/src/main/java/com/platformcomponents/PCImageLoader.kt

@@ -13,6 +13,8 @@ import android.util.LruCache
 import java.net.HttpURLConnection
 import java.net.URL
 import java.util.concurrent.Executors
+import org.json.JSONArray
+import org.json.JSONObject
 import kotlin.math.roundToInt
 
 /**
@@ -30,6 +32,9 @@ object PCImageLoader {
   private val executor = Executors.newFixedThreadPool(2)
   private val mainHandler = Handler(Looper.getMainLooper())
   private val cache = LruCache<String, Bitmap>(32)
+  private val cacheLock = Any()
+  private var nextGeneration = 0L
+  private val generations = mutableMapOf<String, Long>()
 
   /**
    * Loads [uri] and delivers the bitmap on the main thread. [scale] is the
@@ -38,37 +43,67 @@ object PCImageLoader {
    *
    * Cached images are delivered synchronously.
    */
-  fun load(context: Context, uri: String, scale: Float, callback: (Bitmap?) -> Unit) {
-    val key = "$uri@${scale}x"
-    cache.get(key)?.let {
+  fun load(context: Context, uri: String, scale: Float, request: String = "", callback: (Bitmap?) -> Unit) {
+    val options = try { if (request.isEmpty()) JSONObject() else JSONObject(request) }
+      catch (_: Exception) { callback(null); return }
+    val policy = options.optString("cache", "default")
+    options.remove("cache")
+    val key = JSONArray().put(uri).put(scale.toDouble()).put(options).toString()
+    val cached = if (policy == "reload") null else cache.get(key)
+    cached?.let {
       callback(it)
       return
     }
+    if (policy == "only-if-cached") { callback(null); return }
+    val generation = synchronized(cacheLock) {
+      nextGeneration += 1
+      generations[key] = nextGeneration
+      nextGeneration
+    }
 
     val appContext = context.applicationContext
     executor.execute {
+      var canCache = true
       val bitmap = try {
-        decode(appContext, uri)
+        decode(appContext, uri, options) { canCache = it }
       } catch (e: Exception) {
-        Log.w(TAG, "Failed to load $uri: ${e.message}")
+        // Image URIs may carry credentials or signed query parameters.
+        Log.w(TAG, "Failed to load image (${e.javaClass.simpleName})")
         null
       }
       if (bitmap != null) {
         bitmap.density = (scale.coerceAtLeast(0.01f) * DisplayMetrics.DENSITY_DEFAULT).roundToInt()
-        cache.put(key, bitmap)
+      }
+      synchronized(cacheLock) {
+        if (generations[key] == generation) {
+          if (bitmap != null && canCache) cache.put(key, bitmap) else cache.remove(key)
+          generations.remove(key)
+        }
       }
       mainHandler.post { callback(bitmap) }
     }
   }
 
-  private fun decode(context: Context, uri: String): Bitmap? {
+  private fun decode(context: Context, uri: String, options: JSONObject, cacheable: (Boolean) -> Unit): Bitmap? {
     val parsed = Uri.parse(uri)
     return when (parsed.scheme?.lowercase()) {
       "http", "https" -> {
         val connection = URL(uri).openConnection() as HttpURLConnection
         connection.connectTimeout = TIMEOUT_MS
         connection.readTimeout = TIMEOUT_MS
+        connection.useCaches = false
+        connection.instanceFollowRedirects = options.length() == 0
+        connection.requestMethod = options.optString("method", "GET")
+        options.optJSONObject("headers")?.let { headers ->
+          for (name in headers.keys()) connection.setRequestProperty(name, headers.getString(name))
+        }
         try {
+          if (options.has("body")) {
+            connection.doOutput = true
+            connection.outputStream.use { it.write(options.getString("body").toByteArray(Charsets.UTF_8)) }
+          }
+          if (connection.responseCode !in 200..299) return null
+          cacheable(!connection.getHeaderField("Cache-Control").orEmpty().contains("no-store", ignoreCase = true))
           connection.inputStream.use { BitmapFactory.decodeStream(it) }
         } finally {
           connection.disconnect()

package/android/src/main/java/com/platformcomponents/PCLiquidGlassContainerView.kt

@@ -0,0 +1,32 @@
+package com.platformcomponents
+
+import android.content.Context
+import android.view.ViewGroup
+
+/**
+ * Android implementation of LiquidGlassContainer.
+ *
+ * Glass containers are an iOS 26 feature, so on Android this is a plain
+ * container: React lays out the children, and `spacing` has no effect.
+ */
+class PCLiquidGlassContainerView(context: Context) : ViewGroup(context) {
+
+    init {
+        clipChildren = false
+        clipToPadding = false
+    }
+
+    // ---- Layout ----
+    // Fabric sizes this view and positions its children.
+
+    override fun onMeasure(widthMeasureSpec: Int, heightMeasureSpec: Int) {
+        setMeasuredDimension(
+            MeasureSpec.getSize(widthMeasureSpec),
+            MeasureSpec.getSize(heightMeasureSpec)
+        )
+    }
+
+    override fun onLayout(changed: Boolean, left: Int, top: Int, right: Int, bottom: Int) {
+        // No-op: Fabric lays out the children
+    }
+}

package/android/src/main/java/com/platformcomponents/PCLiquidGlassContainerViewManager.kt

@@ -0,0 +1,31 @@
+package com.platformcomponents
+
+import com.facebook.react.uimanager.ThemedReactContext
+import com.facebook.react.uimanager.ViewGroupManager
+import com.facebook.react.uimanager.ViewManagerDelegate
+import com.facebook.react.viewmanagers.PCLiquidGlassContainerManagerDelegate
+import com.facebook.react.viewmanagers.PCLiquidGlassContainerManagerInterface
+
+/**
+ * Android ViewManager for LiquidGlassContainer: a plain container, since
+ * glass containers are iOS 26 only.
+ */
+class PCLiquidGlassContainerViewManager :
+    ViewGroupManager<PCLiquidGlassContainerView>(),
+    PCLiquidGlassContainerManagerInterface<PCLiquidGlassContainerView> {
+
+    private val delegate: ViewManagerDelegate<PCLiquidGlassContainerView> =
+        PCLiquidGlassContainerManagerDelegate(this)
+
+    override fun getName(): String = "PCLiquidGlassContainer"
+
+    override fun getDelegate(): ViewManagerDelegate<PCLiquidGlassContainerView> = delegate
+
+    override fun createViewInstance(reactContext: ThemedReactContext): PCLiquidGlassContainerView {
+        return PCLiquidGlassContainerView(reactContext)
+    }
+
+    override fun setSpacing(view: PCLiquidGlassContainerView, value: Float) {
+        // Glass merging is iOS only
+    }
+}