react-native-blur-vibe 0.1.13 → 0.1.15

package/README.md

@@ -1,9 +1,9 @@
 # React Native Blur-Vibe
 
-<img width="1500" height="500" alt="github-banner" src="https://github.com/user-attachments/assets/78b2e5ec-5b57-48c0-b984-69cb57cbcf26" />
+<a href="https://www.npmjs.com/package/react-native-blur-vibe"><img width="100%" height="35%" alt="github-banner" src="https://github.com/user-attachments/assets/78b2e5ec-5b57-48c0-b984-69cb57cbcf26" /></a>
 <br></br>
 
-A modern, actively maintained blur view for React Native. Works on **iOS** and **Android** with full New Architecture (Fabric) support.
+A modern, actively maintained blur view for React Native. Works on **iOS** and **Android** with both Old (Paper) and New (Fabric) Architecture support.
 
 > The key difference from other blur libraries: `overlayColor` works on **both iOS and Android** — letting you control blur visibility the same way CSS `backdrop-filter` + `background-color` works on the web.
 

package/android/src/main/java/com/blurvibe/BlurVibeViewApi31.kt

@@ -17,10 +17,6 @@ import android.os.Build
 import android.os.Handler
 import android.os.HandlerThread
 import android.os.Looper
-import android.renderscript.Allocation
-import android.renderscript.Element
-import android.renderscript.RenderScript
-import android.renderscript.ScriptIntrinsicBlur
 import android.util.TypedValue
 import android.view.Choreographer
 import android.view.View
@@ -41,8 +37,8 @@ class BlurVibeViewApi31(context: Context) : ReactViewGroup(context) {
 
   // ── Blur params ────────────────────────────────────────────────────────────
 
-  private var blurAmount   = 10f
-  private var overlayColor = Color.TRANSPARENT
+  private var blurAmount     = 10f
+  private var overlayColor   = Color.TRANSPARENT
   private var cornerRadiusPx = 0f
 
   // ── Progressive blur ──────────────────────────────────────────────────────
@@ -57,44 +53,33 @@ class BlurVibeViewApi31(context: Context) : ReactViewGroup(context) {
   private var noiseBitmap: Bitmap? = null
   private val noisePaint  = Paint()
 
-  // ── Double-buffer bitmap pool ─────────────────────────────────────────────
+  // ── Bitmap double-buffer ──────────────────────────────────────────────────
 
-  private var captureBitmap: Bitmap? = null
-  private var scaledBitmap:  Bitmap? = null
-  @Volatile private var readyBitmap:  Bitmap? = null
+  private var captureBitmap: Bitmap? = null   // full-size capture (main thread)
+  private var scaledBitmap:  Bitmap? = null   // downsampled + blurred (worker thread)
+  @Volatile
+  private var readyBitmap:   Bitmap? = null   // @Volatile pointer — RenderThread reads this
 
   private val capturePaint = Paint(Paint.FILTER_BITMAP_FLAG)
   private val bitmapPaint  = Paint(Paint.FILTER_BITMAP_FLAG or Paint.ANTI_ALIAS_FLAG)
 
-  // ── Worker thread — blur runs here, main thread never blocks ──────────────
+  // ── Worker thread ─────────────────────────────────────────────────────────
 
   private val workerThread  = HandlerThread("BlurVibeWorker31-${hashCode()}")
     .also { it.start() }
   private val workerHandler = Handler(workerThread.looper)
   private val mainHandler   = Handler(Looper.getMainLooper())
 
-  // ── RenderScript (deprecated API 31 but still functional through API 35) ──
-
-  @Suppress("DEPRECATION")
-  private var rs:         RenderScript?        = null
-  @Suppress("DEPRECATION")
-  private var blurScript: ScriptIntrinsicBlur? = null
-  @Suppress("DEPRECATION")
-  private var inAlloc:    Allocation?          = null
-  @Suppress("DEPRECATION")
-  private var outAlloc:   Allocation?          = null
-
-  // ── Root view ─────────────────────────────────────────────────────────────
+  // ── Root ──────────────────────────────────────────────────────────────────
 
   private var blurRoot: ViewGroup? = null
-  private val myLoc   = IntArray(2)
-  private val rootLoc = IntArray(2)
+  private val myLoc    = IntArray(2)
+  private val rootLoc  = IntArray(2)
 
   // ── State ─────────────────────────────────────────────────────────────────
 
-  // isCapturing: suppresses our own draw() during root.draw() capture
-  // so we don't paint stale blur into the capture bitmap (static blur bug)
-  var isCapturing    = false
+  // isCapturing: public read so BlurVibeViewApi31.draw() can check it
+  var isCapturing     = false
     private set
   private var blurEnabled    = true
   private var autoUpdate     = true
@@ -126,13 +111,9 @@ class BlurVibeViewApi31(context: Context) : ReactViewGroup(context) {
 
   init {
     setWillNotDraw(false)
-    // DO NOT call setBackgroundColor — it replaces ReactViewGroup's
-    // ReactViewBackgroundDrawable, killing all RN style prop handling.
-    //
-    // outlineProvider = BACKGROUND: ReactViewBackgroundDrawable implements
-    // getOutline() for all RN borderRadius variants. clipToOutline=false
-    // by default — only enabled when a non-zero radius is actually set,
-    // to avoid GPU clip stack issues with overflow:hidden + Reanimated.
+    // outlineProvider = BACKGROUND uses ReactViewBackgroundDrawable.getOutline()
+    // which correctly handles all RN borderRadius variants automatically.
+    // clipToOutline is set to true only when a non-zero radius is applied.
     outlineProvider = ViewOutlineProvider.BACKGROUND
   }
 
@@ -143,7 +124,6 @@ class BlurVibeViewApi31(context: Context) : ReactViewGroup(context) {
     blurRoot = findBlurRoot()
     safeAddPreDrawListener()
     generateNoiseBitmap()
-    workerHandler.post { initRenderScript() }
     scheduleFrame()
   }
 
@@ -156,8 +136,8 @@ class BlurVibeViewApi31(context: Context) : ReactViewGroup(context) {
     readyBitmap    = null
     noiseBitmap?.recycle(); noiseBitmap = null
     workerHandler.post {
-      releaseBitmapPool()
-      releaseRenderScript()
+      captureBitmap?.recycle(); captureBitmap = null
+      scaledBitmap?.recycle();  scaledBitmap  = null
     }
     super.onDetachedFromWindow()
   }
@@ -166,7 +146,10 @@ class BlurVibeViewApi31(context: Context) : ReactViewGroup(context) {
     super.onSizeChanged(w, h, oldw, oldh)
     if (w > 0 && h > 0) {
       readyBitmap = null
-      workerHandler.post { releaseBitmapPool() }
+      workerHandler.post {
+        captureBitmap?.recycle(); captureBitmap = null
+        scaledBitmap?.recycle();  scaledBitmap  = null
+      }
       scheduleFrame()
     }
   }
@@ -179,14 +162,10 @@ class BlurVibeViewApi31(context: Context) : ReactViewGroup(context) {
     }
   }
 
-  // ── draw() — no-op during root capture ────────────────────────────────────
-  //
-  // Prevents stale blur output from being captured into the background bitmap.
-  // When isCapturing=true, root.draw() is in progress — we skip ourselves
-  // so only the content BEHIND us is captured.
+  // ── draw() — skip self during root capture ────────────────────────────────
 
   override fun draw(canvas: Canvas) {
-    if (isCapturing) return
+    if (isCapturing) return   // prevents capturing own blur output
     super.draw(canvas)
   }
 
@@ -197,25 +176,25 @@ class BlurVibeViewApi31(context: Context) : ReactViewGroup(context) {
     val w = width.toFloat();  if (w <= 0f) return
     val h = height.toFloat(); if (h <= 0f) return
 
+    // Show overlay as placeholder while first blur is loading
     val bmp = readyBitmap?.takeIf { !it.isRecycled } ?: run {
-      // No blur ready yet — draw overlay only so view isn't invisible
       if (Color.alpha(overlayColor) > 0) {
         overlayPaint.color = overlayColor
         canvas.drawRect(0f, 0f, w, h, overlayPaint)
       }
-      super.onDraw(canvas)
+      background?.draw(canvas)
       return
     }
 
-    // Step 1: progressive mask layer
-    val saveCount = if (progressiveDirection != PROGRESSIVE_NONE) {
+    // Step 1: save layer for progressive mask compositing
+    val saveCount = if (progressiveDirection != PROGRESSIVE_NONE)
       canvas.saveLayer(0f, 0f, w, h, null)
-    } else -1
+    else -1
 
-    // Step 2: draw blurred bitmap
+    // Step 2: blurred bitmap — fills entire view
     canvas.drawBitmap(bmp, null, RectF(0f, 0f, w, h), bitmapPaint)
 
-    // Step 3: progressive alpha mask
+    // Step 3: progressive alpha mask (fades blur across view)
     if (progressiveDirection != PROGRESSIVE_NONE && saveCount >= 0) {
       buildProgressiveShader(w, h)?.let { shader ->
         maskPaint.shader = shader
@@ -237,24 +216,25 @@ class BlurVibeViewApi31(context: Context) : ReactViewGroup(context) {
       canvas.drawRect(0f, 0f, w, h, noisePaint)
     }
 
-    // Step 6: let ReactViewGroup draw borders/radius on top
-    super.onDraw(canvas)
+    // Step 6: redraw ReactViewBackgroundDrawable ON TOP of blur.
+    // View.draw() drew the background BEFORE onDraw(), but our bitmap
+    // covered it. Redrawing here makes borders/borderColor/borderRadius
+    // appear on top of the blur — not hidden underneath it.
+    background?.draw(canvas)
   }
 
-  // ── Capture + blur pipeline ───────────────────────────────────────────────
+  // ── Capture + blur pipeline ────────────────────────────────────────────────
 
   private fun captureAndBlur() {
     if (isCapturing) return
     val root = blurRoot ?: return
-    val rw   = root.width;  if (rw <= 0) return
-    val rh   = root.height; if (rh <= 0) return
-    val vw   = width;       if (vw <= 0) return
-    val vh   = height;      if (vh <= 0) return
+    val vw   = width;   if (vw <= 0) return
+    val vh   = height;  if (vh <= 0) return
 
     val sw = (vw / DOWNSAMPLE).toInt().coerceAtLeast(1)
     val sh = (vh / DOWNSAMPLE).toInt().coerceAtLeast(1)
 
-    // Compute offset — window coords, correct for split-screen/freeform/PiP
+    // Window-relative offset (correct for split-screen, freeform, PiP)
     root.getLocationInWindow(rootLoc)
     getLocationInWindow(myLoc)
     val offsetX = (myLoc[0] - rootLoc[0]).toFloat()
@@ -263,7 +243,8 @@ class BlurVibeViewApi31(context: Context) : ReactViewGroup(context) {
     val capture = reuseBitmap(captureBitmap, vw, vh).also { captureBitmap = it }
     val scaled  = reuseBitmap(scaledBitmap,  sw, sh).also { scaledBitmap  = it }
 
-    // Capture — isCapturing suppresses our own draw() so root.draw() skips us
+    // isCapturing = true → our draw() is a no-op → root.draw() skips us
+    // → capture contains ONLY the content behind us (not our own blur output)
     isCapturing = true
     val c = Canvas(capture)
     c.drawColor(Color.TRANSPARENT, PorterDuff.Mode.CLEAR)
@@ -276,68 +257,112 @@ class BlurVibeViewApi31(context: Context) : ReactViewGroup(context) {
     }
     isCapturing = false
 
-    // Downsample + blur on worker thread (never blocks main/RenderThread)
+    // Blur on worker thread — never blocks main/RenderThread
     val captureRef = capture
-    val scaledRef  = scaled
     val radius     = blurRadiusFromAmount(blurAmount)
 
     workerHandler.post {
       // Downsample
-      Canvas(scaledRef).drawBitmap(
+      Canvas(scaled).drawBitmap(
         captureRef,
         Rect(0, 0, captureRef.width, captureRef.height),
-        Rect(0, 0, scaledRef.width,  scaledRef.height),
+        Rect(0, 0, scaled.width, scaled.height),
         capturePaint
       )
-      // Multi-pass blur for wide frosted-glass spread
-      repeat(BLUR_ROUNDS) { blurBitmap(scaledRef, radius) }
-
-      // Atomic swap: readyBitmap is @Volatile — RenderThread sees new value immediately
-      // We never mutate scaledRef after this point until the next capture starts
-      readyBitmap = scaledRef
+      // Multi-pass StackBlur (pure Kotlin, no deprecated APIs, all API levels)
+      repeat(BLUR_ROUNDS) { stackBlur(scaled, radius.toInt().coerceAtLeast(1)) }
 
+      // Atomic @Volatile swap — RenderThread always reads a complete bitmap
+      readyBitmap = scaled
       mainHandler.post { invalidate() }
     }
   }
 
-  // ── RenderScript blur ─────────────────────────────────────────────────────
-
-  @Suppress("DEPRECATION")
-  private fun initRenderScript() {
-    try {
-      rs = RenderScript.create(context)
-      blurScript = ScriptIntrinsicBlur.create(rs, Element.U8_4(rs))
-    } catch (_: Exception) {}
-  }
-
-  @Suppress("DEPRECATION")
-  private fun blurBitmap(bmp: Bitmap, radius: Float) {
-    val r  = rs         ?: return softwareBlur(bmp, radius)
-    val sc = blurScript ?: return softwareBlur(bmp, radius)
-    try {
-      val iA = reuseAlloc(inAlloc,  bmp, r).also { inAlloc  = it }
-      val oA = reuseAlloc(outAlloc, bmp, r).also { outAlloc = it }
-      iA.copyFrom(bmp)
-      sc.setRadius(radius.coerceIn(1f, 25f))
-      sc.setInput(iA)
-      sc.forEach(oA)
-      oA.copyTo(bmp)
-    } catch (_: Exception) { softwareBlur(bmp, radius) }
-  }
-
-  private fun softwareBlur(bmp: Bitmap, radius: Float) {
-    val p = Paint(Paint.ANTI_ALIAS_FLAG).apply {
-      maskFilter = android.graphics.BlurMaskFilter(radius, android.graphics.BlurMaskFilter.Blur.NORMAL)
+  // ── StackBlur ─────────────────────────────────────────────────────────────
+  // Mario Klingemann's algorithm — O(w×h) regardless of radius.
+  // No RenderScript, no deprecated APIs. Works on all Android versions.
+
+  private fun stackBlur(bmp: Bitmap, radius: Int) {
+    val r = radius.coerceIn(1, 254)
+    val w = bmp.width; val h = bmp.height
+    val pixels = IntArray(w * h)
+    bmp.getPixels(pixels, 0, w, 0, 0, w, h)
+    val div = r + r + 1
+    val wm = w - 1; val hm = h - 1
+    val divSumSq = ((div + 1) shr 1).let { it * it }
+    val dv = IntArray(256 * divSumSq) { it / divSumSq }
+    val vmin = IntArray(maxOf(w, h))
+    val rStack = IntArray(div); val gStack = IntArray(div); val bStack = IntArray(div)
+    var yi = 0
+    for (y in 0 until h) {
+      var rSum = 0; var gSum = 0; var bSum = 0
+      var rOut = 0; var gOut = 0; var bOut = 0
+      var p = pixels[yi]
+      var pr = (p shr 16) and 0xFF; var pg = (p shr 8) and 0xFF; var pb = p and 0xFF
+      val ds = (div + 1) shr 1
+      for (i in 0 until ds) {
+        rStack[i] = pr; gStack[i] = pg; bStack[i] = pb
+        rSum += pr * (i + 1); gSum += pg * (i + 1); bSum += pb * (i + 1)
+        rOut += pr; gOut += pg; bOut += pb
+      }
+      for (i in 1 until ds) {
+        val xi = if (i <= wm) i else wm
+        p = pixels[yi + xi]; pr = (p shr 16) and 0xFF; pg = (p shr 8) and 0xFF; pb = p and 0xFF
+        rStack[i + r] = pr; gStack[i + r] = pg; bStack[i + r] = pb
+        rSum += pr * (ds - i); gSum += pg * (ds - i); bSum += pb * (ds - i)
+      }
+      var si = r
+      for (x in 0 until w) {
+        pixels[yi + x] = (-0x1000000 or (dv[rSum] shl 16) or (dv[gSum] shl 8) or dv[bSum])
+        rSum -= rOut; gSum -= gOut; bSum -= bOut
+        rOut -= rStack[si]; gOut -= gStack[si]; bOut -= bStack[si]
+        var sip = si + ds; if (sip >= div) sip -= div
+        pr = rStack[sip]; pg = gStack[sip]; pb = bStack[sip]
+        rOut += pr; gOut += pg; bOut += pb; rSum += rOut; gSum += gOut; bSum += bOut
+        vmin[x] = if (x + r < wm) x + r + 1 else wm
+        val sp = pixels[yi + vmin[x]]; val vp = pixels[yi + (if (x > r) x - r else 0)]
+        rStack[sip] = (sp shr 16) and 0xFF; gStack[sip] = (sp shr 8) and 0xFF; bStack[sip] = sp and 0xFF
+        rOut += rStack[sip] - ((vp shr 16) and 0xFF)
+        gOut += gStack[sip] - ((vp shr 8) and 0xFF)
+        bOut += bStack[sip] - (vp and 0xFF)
+        if (++si >= div) si = 0
+      }
+      yi += w
     }
-    Canvas(bmp).drawBitmap(bmp, 0f, 0f, p)
-  }
-
-  @Suppress("DEPRECATION")
-  private fun releaseRenderScript() {
-    inAlloc?.destroy();    inAlloc    = null
-    outAlloc?.destroy();   outAlloc   = null
-    blurScript?.destroy(); blurScript = null
-    rs?.destroy();         rs         = null
+    for (x in 0 until w) {
+      var rSum = 0; var gSum = 0; var bSum = 0
+      var rOut = 0; var gOut = 0; var bOut = 0
+      val ds = (div + 1) shr 1
+      var p = pixels[x]; var pr = (p shr 16) and 0xFF; var pg = (p shr 8) and 0xFF; var pb = p and 0xFF
+      for (i in 0 until ds) {
+        rStack[i] = pr; gStack[i] = pg; bStack[i] = pb
+        rSum += pr * (i + 1); gSum += pg * (i + 1); bSum += pb * (i + 1)
+        rOut += pr; gOut += pg; bOut += pb
+      }
+      for (i in 1 until ds) {
+        val yi2 = if (i <= hm) i * w else hm * w
+        p = pixels[x + yi2]; pr = (p shr 16) and 0xFF; pg = (p shr 8) and 0xFF; pb = p and 0xFF
+        rStack[i + r] = pr; gStack[i + r] = pg; bStack[i + r] = pb
+        rSum += pr * (ds - i); gSum += pg * (ds - i); bSum += pb * (ds - i)
+      }
+      var si = r
+      for (y in 0 until h) {
+        pixels[x + y * w] = (-0x1000000 or (dv[rSum] shl 16) or (dv[gSum] shl 8) or dv[bSum])
+        rSum -= rOut; gSum -= gOut; bSum -= bOut
+        rOut -= rStack[si]; gOut -= gStack[si]; bOut -= bStack[si]
+        var sip = si + ds; if (sip >= div) sip -= div
+        pr = rStack[sip]; pg = gStack[sip]; pb = bStack[sip]
+        rOut += pr; gOut += pg; bOut += pb; rSum += rOut; gSum += gOut; bSum += bOut
+        vmin[y] = if (y + r < hm) (y + r + 1) * w else hm * w
+        val sp = pixels[x + vmin[y]]; val vp = pixels[x + (if (y > r) (y - r) * w else 0)]
+        rStack[sip] = (sp shr 16) and 0xFF; gStack[sip] = (sp shr 8) and 0xFF; bStack[sip] = sp and 0xFF
+        rOut += rStack[sip] - ((vp shr 16) and 0xFF)
+        gOut += gStack[sip] - ((vp shr 8) and 0xFF)
+        bOut += bStack[sip] - (vp and 0xFF)
+        if (++si >= div) si = 0
+      }
+    }
+    bmp.setPixels(pixels, 0, w, 0, 0, w, h)
   }
 
   // ── Progressive shader ────────────────────────────────────────────────────
@@ -350,7 +375,7 @@ class BlurVibeViewApi31(context: Context) : ReactViewGroup(context) {
       PROGRESSIVE_BOTTOM_TO_TOP -> LinearGradient(0f,h,0f,0f,sc,ec,Shader.TileMode.CLAMP)
       PROGRESSIVE_LEFT_TO_RIGHT -> LinearGradient(0f,0f,w,0f,sc,ec,Shader.TileMode.CLAMP)
       PROGRESSIVE_RIGHT_TO_LEFT -> LinearGradient(w,0f,0f,0f,sc,ec,Shader.TileMode.CLAMP)
-      PROGRESSIVE_RADIAL        -> RadialGradient(w/2f,h/2f,min(w,h)/2f,sc,ec,Shader.TileMode.CLAMP)
+      PROGRESSIVE_RADIAL -> RadialGradient(w/2f,h/2f,min(w,h)/2f,sc,ec,Shader.TileMode.CLAMP)
       else -> null
     }
   }
@@ -383,9 +408,6 @@ class BlurVibeViewApi31(context: Context) : ReactViewGroup(context) {
     cornerRadiusPx = TypedValue.applyDimension(
       TypedValue.COMPLEX_UNIT_DIP, radiusDp, context.resources.displayMetrics
     )
-    // Only enable clipToOutline when radius > 0.
-    // Keeping it false when not needed avoids GPU clip stack issues
-    // when overflow:hidden is set on parent + Reanimated is animating.
     clipToOutline = cornerRadiusPx > 0f
     invalidate()
   }
@@ -413,9 +435,7 @@ class BlurVibeViewApi31(context: Context) : ReactViewGroup(context) {
     else {
       safeRemovePreDrawListener()
       Choreographer.getInstance().removeFrameCallback(frameCallback)
-      frameScheduled = false
-      readyBitmap = null
-      invalidate()
+      frameScheduled = false; readyBitmap = null; invalidate()
     }
   }
 
@@ -447,23 +467,19 @@ class BlurVibeViewApi31(context: Context) : ReactViewGroup(context) {
   private fun findBlurRoot(): ViewGroup? {
     var p = parent
     while (p != null) {
-      if ((p as? View)?.javaClass?.name == "com.swmansion.rnscreens.Screen") return p as? ViewGroup
+      if ((p as? View)?.javaClass?.name == "com.swmansion.rnscreens.Screen")
+        return p as? ViewGroup
       p = (p as? View)?.parent
     }
     p = parent
     while (p != null) {
-      if ((p as? View)?.javaClass?.name == "com.facebook.react.ReactRootView") return p as? ViewGroup
+      if ((p as? View)?.javaClass?.name == "com.facebook.react.ReactRootView")
+        return p as? ViewGroup
       p = (p as? View)?.parent
     }
     return rootView as? ViewGroup
   }
 
-  private fun releaseBitmapPool() {
-    captureBitmap?.recycle(); captureBitmap = null
-    scaledBitmap?.recycle();  scaledBitmap  = null
-  }
-
-  @Suppress("DEPRECATION")
   private fun reuseBitmap(existing: Bitmap?, w: Int, h: Int): Bitmap {
     if (existing != null && !existing.isRecycled
         && existing.width == w && existing.height == h) return existing
@@ -471,13 +487,9 @@ class BlurVibeViewApi31(context: Context) : ReactViewGroup(context) {
     return Bitmap.createBitmap(w, h, Bitmap.Config.ARGB_8888)
   }
 
-  @Suppress("DEPRECATION")
-  private fun reuseAlloc(existing: Allocation?, src: Bitmap, rs: RenderScript): Allocation {
-    if (existing != null && existing.type.x == src.width && existing.type.y == src.height)
-      return existing
-    existing?.destroy()
-    return Allocation.createFromBitmap(rs, src,
-      Allocation.MipmapControl.MIPMAP_NONE, Allocation.USAGE_SCRIPT)
+  private fun blurRadiusFromAmount(amount: Float): Float {
+    val t = amount.coerceIn(0f, 100f) / 100f
+    return 2f + t * 22f   // 2–24, with BLUR_ROUNDS=4 effective spread ≈ 4–48px
   }
 
   private fun parseHexColor(s: String): Int? {
@@ -502,19 +514,11 @@ class BlurVibeViewApi31(context: Context) : ReactViewGroup(context) {
     } catch (_: NumberFormatException) { null }
   }
 
-  private fun blurRadiusFromAmount(amount: Float): Float {
-    // Linear 0→100 maps to 1→25 (RenderScript kernel max is 25).
-    // With BLUR_ROUNDS=4 passes the effective spread is radius × √4 = radius × 2,
-    // so blurAmount=100 gives effective spread of ~50px — properly frosted glass.
-    val t = amount.coerceIn(0f, 100f) / 100f
-    return (1f + t * 24f)
-  }
-
   override fun onLayout(changed: Boolean, l: Int, t: Int, r: Int, b: Int) {}
 
   companion object {
     private const val DOWNSAMPLE  = 2f   // 1/4 pixels — higher quality than legacy
-    private const val BLUR_ROUNDS = 4    // 4 passes — wider Gaussian spread for API 31+
+    private const val BLUR_ROUNDS = 4    // 4 passes — wider spread than legacy's 3
     const val PROGRESSIVE_NONE          = 0
     const val PROGRESSIVE_TOP_TO_BOTTOM = 1
     const val PROGRESSIVE_BOTTOM_TO_TOP = 2

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "react-native-blur-vibe",
-  "version": "0.1.13",
+  "version": "0.1.15",
   "description": "React Native package implementing Blur View in iOS and Android",
   "main": "./lib/commonjs/index.js",
   "module": "./lib/module/index.js",