react-native-blur-vibe 0.1.0

package/LICENSE

@@ -0,0 +1,20 @@
+MIT License
+
+Copyright (c) 2026 Pritam Nanda
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,232 @@
+# react-native-blur-vibe
+ 
+A modern, actively maintained blur view for React Native. Works on **iOS** and **Android** with full New Architecture (Fabric) 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.
+ 
+[![npm version](https://img.shields.io/npm/v/react-native-blur-vibe)](https://www.npmjs.com/package/react-native-blur-vibe)
+[![Build iOS](https://github.com/I-am-Pritam-20/react-native-blur-vibe/actions/workflows/build-ios.yml/badge.svg)](https://github.com/I-am-Pritam-20/react-native-blur-vibe/actions/workflows/build-ios.yml)
+[![Build Android](https://github.com/I-am-Pritam-20/react-native-blur-vibe/actions/workflows/build-android.yml/badge.svg)](https://github.com/I-am-Pritam-20/react-native-blur-vibe/actions/workflows/build-android.yml)
+[![License: MIT](https://img.shields.io/badge/License-MIT-yellow.svg)](https://opensource.org/licenses/MIT)
+ 
+---
+ 
+## Why another blur library?
+ 
+Existing libraries like `@react-native-community/blur` and `react-native-blurview` suffer from:
+- Build failures with React Native 0.73+ and the New Architecture
+- Android 16KB page size build errors
+- `overlayColor` only working on Android, not iOS
+- Unmaintained or slow to update
+`react-native-blur-vibe` is built from the ground up for modern React Native, with CI builds on every commit.
+ 
+---
+ 
+## The overlayColor concept
+ 
+Think of it exactly like CSS:
+ 
+```css
+/* Web equivalent of what this library does */
+.blur-view {
+  backdrop-filter: blur(10px);        /* ← blurAmount */
+  background-color: #00000050;        /* ← overlayColor */
+}
+```
+ 
+The `overlayColor` alpha channel is what controls blur visibility:
+ 
+| `overlayColor`  | Result                                      |
+|-----------------|---------------------------------------------|
+| `#00000000`     | Fully transparent → pure blur shows through |
+| `#00000080`     | Semi-transparent black tint over blur       |
+| `#FFFFFFFF`     | Fully opaque white → blur completely hidden |
+| `#FFFFFF30`     | Frosted glass / white tint effect           |
+ 
+**This works on both iOS and Android.** Not just Android like other libraries.
+ 
+---
+ 
+## Installation
+ 
+```sh
+yarn add react-native-blur-vibe
+# or
+npm install react-native-blur-vibe
+```
+ 
+### iOS
+ 
+```sh
+cd ios && pod install
+```
+ 
+Minimum iOS version: **13.0**
+ 
+### Android
+ 
+No extra steps needed. Minimum SDK: **21**
+ 
+- API 31+ (Android 12): Uses `RenderEffect` — hardware accelerated
+- API 21-30: Uses `RenderScript` — bitmap-based fallback
+---
+ 
+## Usage
+ 
+```tsx
+import { BlurView } from 'react-native-blur-vibe';
+import { StyleSheet, ImageBackground, Text } from 'react-native';
+ 
+export default function App() {
+  return (
+    <ImageBackground source={require('./background.jpg')} style={styles.image}>
+      {/* Pure blur — transparent overlay */}
+      <BlurView
+        blurAmount={15}
+        blurType="systemMaterial"
+        overlayColor="#00000000"
+        style={styles.blur}
+      />
+ 
+      {/* Dark tinted blur — like a modal backdrop */}
+      <BlurView
+        blurAmount={20}
+        overlayColor="#00000060"
+        style={styles.blur}
+      />
+ 
+      {/* Frosted glass card */}
+      <BlurView
+        blurAmount={10}
+        blurType="systemUltraThinMaterialLight"
+        overlayColor="#FFFFFF25"
+        style={styles.card}
+      >
+        <Text style={styles.text}>Frosted Glass Card</Text>
+      </BlurView>
+    </ImageBackground>
+  );
+}
+ 
+const styles = StyleSheet.create({
+  image: { flex: 1 },
+  blur: { ...StyleSheet.absoluteFillObject },
+  card: {
+    margin: 20,
+    padding: 20,
+    borderRadius: 16,
+  },
+  text: { color: 'white', fontSize: 18 },
+});
+```
+ 
+---
+ 
+## Props
+ 
+| Prop | Type | Default | Platform | Description |
+|------|------|---------|----------|-------------|
+| `blurAmount` | `number` (0–100) | `10` | iOS, Android | Blur intensity |
+| `blurType` | `BlurType` | `'light'` | iOS | Maps to `UIBlurEffectStyle` |
+| `overlayColor` | `string` (hex) | `'transparent'` on iOS, `'#00000030'` on Android | **iOS & Android** | Color composited on top of blur. Alpha controls blur visibility |
+| `reducedTransparencyFallbackColor` | `string` (hex) | `'#F2F2F2'` | iOS, Android | Shown when blur is unavailable (Reduce Transparency enabled, API < 18) |
+| `blurRadius` | `number` (1–8) | `4` | Android | Downscale factor for RenderScript path. Higher = faster, slightly softer |
+ 
+All standard `ViewProps` (style, children, onLayout, etc.) are also supported.
+ 
+---
+ 
+## BlurType values (iOS)
+ 
+```
+light · dark · extraLight · regular · prominent
+systemUltraThinMaterial · systemThinMaterial · systemMaterial
+systemThickMaterial · systemChromeMaterial
+systemUltraThinMaterialLight · systemThinMaterialLight · systemMaterialLight
+systemThickMaterialLight · systemChromeMaterialLight
+systemUltraThinMaterialDark · systemThinMaterialDark · systemMaterialDark
+systemThickMaterialDark · systemChromeMaterialDark
+```
+ 
+---
+ 
+## Recipes
+ 
+### Modal backdrop (dark blur)
+```tsx
+<BlurView
+  blurAmount={25}
+  overlayColor="#00000070"
+  style={StyleSheet.absoluteFill}
+/>
+```
+ 
+### Frosted glass navbar
+```tsx
+<BlurView
+  blurAmount={12}
+  blurType="systemChromeMaterial"
+  overlayColor="#FFFFFF20"
+  style={styles.navbar}
+/>
+```
+ 
+### Light frosted card
+```tsx
+<BlurView
+  blurAmount={8}
+  blurType="systemUltraThinMaterialLight"
+  overlayColor="#FFFFFF30"
+  style={{ borderRadius: 12, padding: 16 }}
+>
+  {children}
+</BlurView>
+```
+ 
+### Completely invisible overlay (just blur, no tint)
+```tsx
+<BlurView
+  blurAmount={15}
+  overlayColor="#00000000"
+  style={StyleSheet.absoluteFill}
+/>
+```
+ 
+---
+ 
+## Architecture support
+ 
+| Architecture | iOS | Android |
+|---|---|---|
+| Old Architecture (JSC/Bridge) | ✅ | ✅ |
+| New Architecture (Fabric/JSI) | ✅ | ✅ |
+| Expo (bare workflow) | ✅ | ✅ |
+| Expo Go | ❌ (native module) | ❌ |
+ 
+---
+ 
+## Android API compatibility
+ 
+| Android API | Blur Method | Notes |
+|---|---|---|
+| 31+ (Android 12) | `RenderEffect` | Hardware accelerated, best quality |
+| 21–30 | `RenderScript` | Bitmap-based, `blurRadius` tunable |
+| < 21 | `reducedTransparencyFallbackColor` | Solid color only |
+ 
+---
+
+## Contributing
+
+**See [CONTRIBUTING.md](./CONTRIBUTING.md).**
+
+- [Development workflow](CONTRIBUTING.md#development-workflow)
+- [Sending a pull request](CONTRIBUTING.md#sending-a-pull-request)
+- [Code of conduct](CODE_OF_CONDUCT.md)
+
+## License
+
+MIT © [Pritam Nanda](https://github.com/I-am-Pritam-20)
+
+---
+
+Made with [create-react-native-library](https://github.com/callstack/react-native-builder-bob)

package/android/build.gradle

@@ -0,0 +1,68 @@
+buildscript {
+  ext.BlurVibe = [
+    kotlinVersion: "2.0.21",
+    minSdkVersion: 24,
+    compileSdkVersion: 36,
+    targetSdkVersion: 36
+  ]
+
+  ext.getExtOrDefault = { prop ->
+    if (rootProject.ext.has(prop)) {
+      return rootProject.ext.get(prop)
+    }
+    return BlurVibe[prop]
+  }
+
+  repositories {
+    google()
+    mavenCentral()
+  }
+
+  dependencies {
+    classpath "com.android.tools.build:gradle:8.7.2"
+    classpath "org.jetbrains.kotlin:kotlin-gradle-plugin:${getExtOrDefault('kotlinVersion')}"
+  }
+}
+
+apply plugin: "com.android.library"
+apply plugin: "kotlin-android"
+apply plugin: "com.facebook.react"
+
+android {
+  namespace "com.blurvibe"
+
+  compileSdkVersion getExtOrDefault("compileSdkVersion")
+
+  defaultConfig {
+    minSdkVersion getExtOrDefault("minSdkVersion")
+    targetSdkVersion getExtOrDefault("targetSdkVersion")
+  }
+
+  buildFeatures {
+    buildConfig true
+  }
+
+  buildTypes {
+    release {
+      minifyEnabled false
+    }
+  }
+
+  lint {
+    disable "GradleCompatible"
+  }
+
+  compileOptions {
+    sourceCompatibility JavaVersion.VERSION_17
+    targetCompatibility JavaVersion.VERSION_17
+  }
+
+  kotlinOptions {
+    jvmTarget = "17"
+    freeCompilerArgs += ["-nowarn"]
+  }
+}
+
+dependencies {
+  implementation "com.facebook.react:react-android"
+}

package/android/src/main/AndroidManifest.xml

@@ -0,0 +1,2 @@
+<manifest xmlns:android="http://schemas.android.com/apk/res/android">
+</manifest>

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

@@ -0,0 +1,12 @@
+package com.blurvibe
+
+import com.facebook.react.ReactPackage
+import com.facebook.react.bridge.NativeModule
+import com.facebook.react.bridge.ReactApplicationContext
+import com.facebook.react.uimanager.ViewManager
+
+class BlurVibePackage : ReactPackage {
+  override fun createNativeModules(reactContext: ReactApplicationContext): List<NativeModule> = emptyList()
+  override fun createViewManagers(reactContext: ReactApplicationContext): List<ViewManager<*, *>> =
+    listOf(BlurVibeViewManager())
+}

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

@@ -0,0 +1,128 @@
+package com.blurvibe
+
+import android.annotation.SuppressLint
+import android.content.Context
+import android.graphics.Bitmap
+import android.graphics.Canvas
+import android.graphics.Color
+import android.graphics.RenderEffect
+import android.graphics.Shader
+import android.os.Build
+import android.renderscript.Allocation
+import android.renderscript.Element
+import android.renderscript.RenderScript
+import android.renderscript.ScriptIntrinsicBlur
+import android.view.View
+import android.view.ViewGroup
+import android.widget.FrameLayout
+
+/**
+ * BlurVibeView — Android implementation
+ *
+ * API 31+ : RenderEffect (hardware accelerated)
+ * API 24-30: RenderScript (built into Android SDK, no extra dep needed)
+ *
+ * overlayColor sits on top of blur — like CSS:
+ *   backdrop-filter: blur(Xpx) + background-color: overlayColor
+ */
+@SuppressLint("NewApi")
+class BlurVibeView(context: Context) : FrameLayout(context) {
+
+  private val overlayView = View(context)
+  private var blurAmountValue: Float = 10f
+  private var overlayColorValue: Int = Color.TRANSPARENT
+  private var reducedTransparencyFallbackColorValue: Int = Color.parseColor("#F2F2F2")
+  private var blurRadiusDownscale: Int = 4
+
+  init {
+    setWillNotDraw(false)
+    overlayView.layoutParams = LayoutParams(LayoutParams.MATCH_PARENT, LayoutParams.MATCH_PARENT)
+    overlayView.isClickable = false
+    overlayView.isFocusable = false
+    addView(overlayView)
+    applyBlur()
+  }
+
+  fun setBlurAmount(amount: Float) {
+    blurAmountValue = amount.coerceIn(0f, 100f)
+    applyBlur()
+  }
+
+  fun setOverlayColor(color: Int) {
+    overlayColorValue = color
+    updateOverlay()
+  }
+
+  fun setReducedTransparencyFallbackColor(color: Int) {
+    reducedTransparencyFallbackColorValue = color
+  }
+
+  fun setBlurRadius(radius: Int) {
+    blurRadiusDownscale = radius.coerceIn(1, 8)
+    applyBlur()
+  }
+
+  private fun applyBlur() {
+    if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.S) {
+      applyRenderEffect()
+    } else {
+      post { renderScriptBlur() }
+    }
+    updateOverlay()
+  }
+
+  private fun applyRenderEffect() {
+    if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.S) {
+      val sigma = (blurAmountValue * 0.5f).coerceAtLeast(0.01f)
+      setRenderEffect(
+        RenderEffect.createBlurEffect(sigma, sigma, Shader.TileMode.MIRROR)
+      )
+    }
+  }
+
+  @Suppress("DEPRECATION")
+  private fun renderScriptBlur() {
+    val parentView = parent as? ViewGroup ?: return
+    if (width <= 0 || height <= 0) return
+    try {
+      val scaledW = (width / blurRadiusDownscale).coerceAtLeast(1)
+      val scaledH = (height / blurRadiusDownscale).coerceAtLeast(1)
+      val bitmap = Bitmap.createBitmap(scaledW, scaledH, Bitmap.Config.ARGB_8888)
+      val canvas = Canvas(bitmap)
+      canvas.scale(1f / blurRadiusDownscale, 1f / blurRadiusDownscale)
+      canvas.translate(-left.toFloat(), -top.toFloat())
+      parentView.draw(canvas)
+
+      val rs = RenderScript.create(context)
+      val input = Allocation.createFromBitmap(rs, bitmap)
+      val output = Allocation.createTyped(rs, input.type)
+      val script = ScriptIntrinsicBlur.create(rs, Element.U8_4(rs))
+      val sigma = (blurAmountValue / 100f * 25f).coerceIn(1f, 25f)
+      script.setRadius(sigma)
+      script.setInput(input)
+      script.forEach(output)
+      output.copyTo(bitmap)
+      rs.destroy()
+
+      background = android.graphics.drawable.BitmapDrawable(resources, bitmap)
+    } catch (e: Exception) {
+      setBackgroundColor(reducedTransparencyFallbackColorValue)
+    }
+  }
+
+  private fun updateOverlay() {
+    overlayView.setBackgroundColor(overlayColorValue)
+    bringChildToFront(overlayView)
+    for (i in 0 until childCount) {
+      val child = getChildAt(i)
+      if (child !== overlayView) bringChildToFront(child)
+    }
+  }
+
+  override fun onLayout(changed: Boolean, l: Int, t: Int, r: Int, b: Int) {
+    super.onLayout(changed, l, t, r, b)
+    if (changed && Build.VERSION.SDK_INT < Build.VERSION_CODES.S) {
+      post { renderScriptBlur() }
+    }
+  }
+}

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

@@ -0,0 +1,37 @@
+package com.blurvibe
+
+import com.facebook.react.uimanager.SimpleViewManager
+import com.facebook.react.uimanager.ThemedReactContext
+import com.facebook.react.uimanager.annotations.ReactProp
+
+class BlurVibeViewManager : SimpleViewManager<BlurVibeView>() {
+
+  override fun getName() = "BlurVibeView"
+
+  override fun createViewInstance(context: ThemedReactContext) = BlurVibeView(context)
+
+  @ReactProp(name = "blurAmount", defaultFloat = 10f)
+  fun setBlurAmount(view: BlurVibeView, amount: Float) {
+    view.setBlurAmount(amount)
+  }
+
+  @ReactProp(name = "blurType")
+  fun setBlurType(view: BlurVibeView, type: String?) {
+    // No-op on Android — blurType is iOS UIBlurEffectStyle only
+  }
+
+  @ReactProp(name = "overlayColor")
+  fun setOverlayColor(view: BlurVibeView, color: Int) {
+    view.setOverlayColor(color)
+  }
+
+  @ReactProp(name = "reducedTransparencyFallbackColor")
+  fun setReducedTransparencyFallbackColor(view: BlurVibeView, color: Int) {
+    view.setReducedTransparencyFallbackColor(color)
+  }
+
+  @ReactProp(name = "blurRadius", defaultInt = 4)
+  fun setBlurRadius(view: BlurVibeView, radius: Int) {
+    view.setBlurRadius(radius)
+  }
+}

package/ios/BlurVibeView.m

@@ -0,0 +1,3 @@
+// BlurVibeView.m
+// Required for Swift-ObjC interop. All logic is in BlurVibeView.swift
+#import <UIKit/UIKit.h>

package/ios/BlurVibeView.swift

@@ -0,0 +1,132 @@
+import UIKit
+
+@objc(BlurVibeView)
+class BlurVibeView: UIView {
+
+  // MARK: - Private Views
+  private var blurEffectView: UIVisualEffectView?
+  private let overlayView = UIView()
+
+  // MARK: - Properties
+
+  @objc var blurAmount: NSNumber = 10 { didSet { updateBlur() } }
+  @objc var blurType: NSString = "light" { didSet { updateBlur() } }
+
+  /// Overlay color ON TOP of blur layer — works on iOS AND Android.
+  /// Alpha channel controls visibility, just like CSS:
+  ///   backdrop-filter: blur(Xpx) + background-color: overlayColor
+  /// "#00000000" = pure blur, "#00000080" = tinted blur, "#000000FF" = hidden blur
+  @objc var overlayColor: NSString = "transparent" { didSet { updateOverlay() } }
+  @objc var reducedTransparencyFallbackColor: NSString = "#F2F2F2" { didSet { updateBlur() } }
+
+  // MARK: - Init
+  override init(frame: CGRect) { super.init(frame: frame); commonInit() }
+  required init?(coder: NSCoder) { super.init(coder: coder); commonInit() }
+
+  private func commonInit() {
+    backgroundColor = .clear
+    clipsToBounds = true
+    overlayView.autoresizingMask = [.flexibleWidth, .flexibleHeight]
+    overlayView.isUserInteractionEnabled = false
+    updateBlur()
+  }
+
+  // MARK: - Layout
+  override func layoutSubviews() {
+    super.layoutSubviews()
+    blurEffectView?.frame = bounds
+    overlayView.frame = bounds
+    bringSubviewToFront(overlayView)
+    for subview in subviews where subview !== blurEffectView && subview !== overlayView {
+      bringSubviewToFront(subview)
+    }
+  }
+
+  // MARK: - Blur
+  private func updateBlur() {
+    if UIAccessibility.isReduceTransparencyEnabled {
+      blurEffectView?.removeFromSuperview()
+      blurEffectView = nil
+      backgroundColor = parseColor(reducedTransparencyFallbackColor as String) ?? UIColor(white: 0.95, alpha: 1)
+      return
+    }
+    backgroundColor = .clear
+    let effect = UIBlurEffect(style: blurEffectStyle(for: blurType as String))
+    if let existing = blurEffectView {
+      existing.effect = effect
+    } else {
+      let newBlurView = UIVisualEffectView(effect: effect)
+      newBlurView.frame = bounds
+      newBlurView.autoresizingMask = [.flexibleWidth, .flexibleHeight]
+      blurEffectView = newBlurView
+      insertSubview(newBlurView, at: 0)
+    }
+    if overlayView.superview == nil {
+      insertSubview(overlayView, aboveSubview: blurEffectView!)
+    }
+    updateOverlay()
+  }
+
+  private func updateOverlay() {
+    let colorString = overlayColor as String
+    if colorString.lowercased() == "transparent" {
+      overlayView.backgroundColor = .clear
+    } else {
+      overlayView.backgroundColor = parseColor(colorString) ?? .clear
+    }
+  }
+
+  // MARK: - Blur Style Map
+  private func blurEffectStyle(for type: String) -> UIBlurEffect.Style {
+    switch type {
+    case "dark":                           return .dark
+    case "extraLight":                     return .extraLight
+    case "regular":                        return .regular
+    case "prominent":                      return .prominent
+    case "systemUltraThinMaterial":        return .systemUltraThinMaterial
+    case "systemThinMaterial":             return .systemThinMaterial
+    case "systemThickMaterial":            return .systemThickMaterial
+    case "systemChromeMaterial":           return .systemChromeMaterial
+    case "systemUltraThinMaterialLight":   return .systemUltraThinMaterialLight
+    case "systemThinMaterialLight":        return .systemThinMaterialLight
+    case "systemMaterialLight":            return .systemMaterialLight
+    case "systemThickMaterialLight":       return .systemThickMaterialLight
+    case "systemChromeMaterialLight":      return .systemChromeMaterialLight
+    case "systemUltraThinMaterialDark":    return .systemUltraThinMaterialDark
+    case "systemThinMaterialDark":         return .systemThinMaterialDark
+    case "systemMaterialDark":             return .systemMaterialDark
+    case "systemThickMaterialDark":        return .systemThickMaterialDark
+    case "systemChromeMaterialDark":       return .systemChromeMaterialDark
+    case "systemMaterial":                 return .systemMaterial
+    default:                               return .light
+    }
+  }
+
+  // MARK: - Color Parser — supports #RGB, #RRGGBB, #RRGGBBAA
+  private func parseColor(_ colorString: String) -> UIColor? {
+    var hex = colorString.trimmingCharacters(in: .whitespacesAndNewlines)
+    guard hex.hasPrefix("#") else { return nil }
+    hex.removeFirst()
+    var rgbValue: UInt64 = 0
+    Scanner(string: hex).scanHexInt64(&rgbValue)
+    switch hex.count {
+    case 3:
+      return UIColor(
+        red: CGFloat((rgbValue & 0xF00) >> 8) / 15,
+        green: CGFloat((rgbValue & 0x0F0) >> 4) / 15,
+        blue: CGFloat(rgbValue & 0x00F) / 15, alpha: 1)
+    case 6:
+      return UIColor(
+        red: CGFloat((rgbValue & 0xFF0000) >> 16) / 255,
+        green: CGFloat((rgbValue & 0x00FF00) >> 8) / 255,
+        blue: CGFloat(rgbValue & 0x0000FF) / 255, alpha: 1)
+    case 8: // #RRGGBBAA
+      return UIColor(
+        red: CGFloat((rgbValue & 0xFF000000) >> 24) / 255,
+        green: CGFloat((rgbValue & 0x00FF0000) >> 16) / 255,
+        blue: CGFloat((rgbValue & 0x0000FF00) >> 8) / 255,
+        alpha: CGFloat(rgbValue & 0x000000FF) / 255)
+    default: return nil
+    }
+  }
+}

package/ios/BlurVibeViewManager.m

@@ -0,0 +1,9 @@
+#import <React/RCTViewManager.h>
+#import <React/RCTUIManager.h>
+
+RCT_EXTERN_MODULE(BlurVibeViewManager, RCTViewManager)
+
+RCT_EXPORT_VIEW_PROPERTY(blurAmount, NSNumber)
+RCT_EXPORT_VIEW_PROPERTY(blurType, NSString)
+RCT_EXPORT_VIEW_PROPERTY(overlayColor, NSString)
+RCT_EXPORT_VIEW_PROPERTY(reducedTransparencyFallbackColor, NSString)

package/ios/BlurVibeViewManager.swift

@@ -0,0 +1,17 @@
+import Foundation
+
+@objc(BlurVibeViewManager)
+class BlurVibeViewManager: RCTViewManager {
+
+  override func view() -> UIView! {
+    return BlurVibeView()
+  }
+
+  override static func requiresMainQueueSetup() -> Bool {
+    return true
+  }
+
+  @objc override func constantsToExport() -> [AnyHashable: Any]! {
+    return [:]
+  }
+}

package/ios/react-native-blur-vibe.podspec

@@ -0,0 +1,21 @@
+require "json"
+
+package = JSON.parse(File.read(File.join(__dir__, "..", "package.json")))
+
+Pod::Spec.new do |s|
+  s.name         = "react-native-blur-vibe"
+  s.version      = package["version"]
+  s.summary      = package["description"]
+  s.homepage     = package["homepage"]
+  s.license      = package["license"]
+  s.authors      = package["author"]
+  s.platforms    = { :ios => "13.0" }
+  s.source       = { :git => "https://github.com/I-am-Pritam-20/react-native-blur-vibe.git", :tag => "#{s.version}" }
+  s.source_files = "ios/**/*.{h,m,mm,swift}"
+  s.requires_arc = true
+
+  s.dependency "React-Core"
+
+  # New Architecture (Fabric) support
+  install_modules_dependencies(s)
+end