@abeman/react-native-nitro-blur 0.1.0

package/android/src/main/java/com/margelo/nitro/nitroblur/NitroBlurTarget.kt

@@ -0,0 +1,149 @@
+package com.margelo.nitro.nitroblur
+
+import android.annotation.SuppressLint
+import android.view.View
+import android.view.ViewGroup
+import com.facebook.proguard.annotations.DoNotStrip
+import com.facebook.react.uimanager.ThemedReactContext
+import eightbitlab.com.blurview.BlurTarget
+
+@DoNotStrip
+class HybridNitroBlurTarget(val context: ThemedReactContext) : HybridNitroBlurTargetSpec() {
+
+  private val containerView = BlurTargetContainer(context)
+
+  override val view: View get() = containerView
+
+  val blurTargetView: BlurTarget get() = containerView.blurTargetView
+}
+
+/**
+ * A container view that delegates child management to an inner BlurTarget.
+ * This is needed because the Dimezis BlurView library requires a BlurTarget
+ * as the root view to capture and blur its content.
+ *
+ * When adding a child to this view, we want to actually add it to the blur target view.
+ * Because of this we need to override add, remove and measurement methods.
+ */
+@SuppressLint("ViewConstructor")
+class BlurTargetContainer(context: ThemedReactContext) : ViewGroup(context) {
+
+  internal val blurTargetView = ReactCompatibleBlurTarget(context)
+
+  init {
+    super.addView(
+      blurTargetView,
+      LayoutParams(LayoutParams.MATCH_PARENT, LayoutParams.MATCH_PARENT)
+    )
+  }
+
+  // region Child delegation to blurTargetView
+
+  override fun addView(child: View?) {
+    if (child === blurTargetView) {
+      super.addView(child)
+      return
+    }
+    blurTargetView.addView(child)
+  }
+
+  override fun addView(child: View?, index: Int) {
+    if (child === blurTargetView) {
+      super.addView(child, index)
+      return
+    }
+    blurTargetView.addView(child, index)
+  }
+
+  override fun addView(child: View?, params: LayoutParams?) {
+    if (child === blurTargetView) {
+      super.addView(child, toHostLayoutParams(params))
+      return
+    }
+    blurTargetView.addView(child, params)
+  }
+
+  override fun addView(child: View?, index: Int, params: LayoutParams?) {
+    if (child === blurTargetView) {
+      super.addView(child, index, toHostLayoutParams(params))
+      return
+    }
+    blurTargetView.addView(child, index, params)
+  }
+
+  override fun addView(child: View?, width: Int, height: Int) {
+    if (child === blurTargetView) {
+      super.addView(child, width, height)
+      return
+    }
+    blurTargetView.addView(child, width, height)
+  }
+
+  override fun updateViewLayout(view: View?, params: LayoutParams?) {
+    if (view === blurTargetView) {
+      super.updateViewLayout(view, toHostLayoutParams(params))
+      return
+    }
+    blurTargetView.updateViewLayout(view, params)
+  }
+
+  override fun removeView(view: View?) {
+    if (view === blurTargetView) {
+      super.removeView(view)
+      return
+    }
+    blurTargetView.removeView(view)
+  }
+
+  override fun removeViewAt(index: Int) = blurTargetView.removeViewAt(index)
+  override fun removeViews(start: Int, count: Int) = blurTargetView.removeViews(start, count)
+  override fun removeViewsInLayout(start: Int, count: Int) = blurTargetView.removeViewsInLayout(start, count)
+  override fun removeAllViews() = blurTargetView.removeAllViews()
+  override fun removeAllViewsInLayout() = blurTargetView.removeAllViewsInLayout()
+  override fun getChildCount(): Int = blurTargetView.childCount
+  override fun getChildAt(index: Int): View? = blurTargetView.getChildAt(index)
+  override fun indexOfChild(child: View?): Int = blurTargetView.indexOfChild(child)
+
+  // endregion
+
+  // region Layout
+
+  override fun onMeasure(widthMeasureSpec: Int, heightMeasureSpec: Int) {
+    val width = MeasureSpec.getSize(widthMeasureSpec)
+    val height = MeasureSpec.getSize(heightMeasureSpec)
+    setMeasuredDimension(width, height)
+    blurTargetView.measure(
+      MeasureSpec.makeMeasureSpec(width, MeasureSpec.EXACTLY),
+      MeasureSpec.makeMeasureSpec(height, MeasureSpec.EXACTLY)
+    )
+  }
+
+  override fun onLayout(changed: Boolean, left: Int, top: Int, right: Int, bottom: Int) {
+    blurTargetView.layout(0, 0, right - left, bottom - top)
+  }
+
+  // endregion
+
+  private fun toHostLayoutParams(params: LayoutParams?): LayoutParams = when (params) {
+    null -> LayoutParams(LayoutParams.MATCH_PARENT, LayoutParams.MATCH_PARENT)
+    is LayoutParams -> params
+    else -> LayoutParams(params)
+  }
+}
+
+/**
+ * A BlurTarget compatible with React Native's layout system.
+ * Overrides requestLayout and onLayout to avoid conflicts with React Native's UIManager,
+ * which handles all layout operations for RN-managed views.
+ */
+class ReactCompatibleBlurTarget(context: ThemedReactContext) : BlurTarget(context) {
+  override fun onLayout(changed: Boolean, left: Int, top: Int, right: Int, bottom: Int) {
+    // No-op since UIManager handles actually laying out children.
+  }
+
+  @SuppressLint("MissingSuperCall")
+  override fun requestLayout() {
+    // No-op, terminate requestLayout here, UIManager handles laying out children and
+    // layout is called on all RN-managed views by NativeViewHierarchyManager
+  }
+}

package/android/src/main/java/com/margelo/nitro/nitroblur/NitroBlurTargetViewGroupManager.kt

@@ -0,0 +1,47 @@
+package com.margelo.nitro.nitroblur
+
+import android.view.ViewGroup
+import com.facebook.react.uimanager.ReactStylesDiffMap
+import com.facebook.react.uimanager.StateWrapper
+import com.facebook.react.uimanager.ThemedReactContext
+import com.facebook.react.uimanager.ViewGroupManager
+import com.margelo.nitro.R.id.associated_hybrid_view_tag
+
+/**
+ * Custom ViewGroupManager for NitroBlurTarget.
+ *
+ * The Nitrogen-generated HybridNitroBlurTargetManager extends SimpleViewManager,
+ * which does not support children. BlurTargetView must accept children so we need
+ * ViewGroupManager instead.
+ */
+class NitroBlurTargetViewGroupManager : ViewGroupManager<BlurTargetContainer>() {
+  override fun getName(): String = "NitroBlurTarget"
+
+  override fun createViewInstance(reactContext: ThemedReactContext): BlurTargetContainer {
+    val hybridView = HybridNitroBlurTarget(reactContext)
+    val view = hybridView.view as BlurTargetContainer
+    view.setTag(associated_hybrid_view_tag, hybridView)
+    return view
+  }
+
+  override fun updateState(view: BlurTargetContainer, props: ReactStylesDiffMap, stateWrapper: StateWrapper): Any? {
+    val hybridView = getHybridView(view)
+      ?: throw Error("Couldn't find view $view in local views table!")
+
+    hybridView.beforeUpdate()
+    com.margelo.nitro.nitroblur.views.HybridNitroBlurTargetStateUpdater.updateViewProps(hybridView, stateWrapper)
+    hybridView.afterUpdate()
+
+    return super.updateState(view, props, stateWrapper)
+  }
+
+  override fun onDropViewInstance(view: BlurTargetContainer) {
+    val hybridView = getHybridView(view)
+    hybridView?.onDropView()
+    return super.onDropViewInstance(view)
+  }
+
+  private fun getHybridView(view: ViewGroup): HybridNitroBlurTarget? {
+    return view.getTag(associated_hybrid_view_tag) as? HybridNitroBlurTarget
+  }
+}

package/android/src/main/java/com/margelo/nitro/nitroblur/TintStyle.kt

@@ -0,0 +1,85 @@
+package com.margelo.nitro.nitroblur
+
+/**
+ * Extension function to convert BlurTint enum (generated by Nitrogen) to an overlay color int.
+ * Color values are based on Apple's iOS 14 Sketch Kit.
+ *
+ * Groups tint styles that share the same color base, then delegates to per-style
+ * color calculations for unique styles.
+ */
+fun BlurTint.toOverlayColor(blurRadius: Double): Int {
+  return when (this) {
+    // Light group
+    BlurTint.EXTRALIGHT,
+    BlurTint.LIGHT,
+    BlurTint.SYSTEMMATERIALLIGHT,
+    BlurTint.SYSTEMULTRATHINMATERIALLIGHT,
+    BlurTint.SYSTEMTHICKMATERIALLIGHT -> BlurTint.LIGHT.toColorInt(blurRadius)
+
+    // Default group
+    BlurTint.PROMINENT,
+    BlurTint.DEFAULT,
+    BlurTint.SYSTEMMATERIAL -> BlurTint.DEFAULT.toColorInt(blurRadius)
+
+    // Dark group
+    BlurTint.DARK,
+    BlurTint.SYSTEMMATERIALDARK -> BlurTint.DARK.toColorInt(blurRadius)
+
+    // Each has unique color mapping
+    BlurTint.REGULAR,
+    BlurTint.SYSTEMULTRATHINMATERIAL,
+    BlurTint.SYSTEMTHICKMATERIAL,
+    BlurTint.SYSTEMCHROMEMATERIAL,
+    BlurTint.SYSTEMCHROMEMATERIALLIGHT,
+    BlurTint.SYSTEMTHICKMATERIALDARK,
+    BlurTint.SYSTEMTHINMATERIALLIGHT,
+    BlurTint.SYSTEMTHINMATERIALDARK,
+    BlurTint.SYSTEMULTRATHINMATERIALDARK,
+    BlurTint.SYSTEMCHROMEMATERIALDARK,
+    BlurTint.SYSTEMTHINMATERIAL -> this.toColorInt(blurRadius)
+  }
+}
+
+/**
+ * Per-style ARGB color calculation.
+ * Color int represented by: a >> 24 + r >> 16 + g >> 8 + b
+ * From Apple iOS 14 Sketch Kit - https://developer.apple.com/design/resources/
+ */
+private fun BlurTint.toColorInt(blurRadius: Double): Int {
+  val intensity = blurRadius / 100.0
+  return when (this) {
+    BlurTint.DARK ->
+      colorInt(25, 25, 25, intensity * 0.69)
+    BlurTint.LIGHT ->
+      colorInt(249, 249, 249, intensity * 0.78)
+    BlurTint.REGULAR ->
+      colorInt(179, 179, 179, intensity * 0.82)
+    BlurTint.SYSTEMTHINMATERIALLIGHT ->
+      colorInt(199, 199, 199, intensity * 0.78)
+    BlurTint.SYSTEMTHINMATERIAL ->
+      colorInt(199, 199, 199, intensity * 0.97)
+    BlurTint.SYSTEMCHROMEMATERIAL ->
+      colorInt(255, 255, 255, intensity * 0.75)
+    BlurTint.SYSTEMCHROMEMATERIALLIGHT ->
+      colorInt(255, 255, 255, intensity * 0.97)
+    BlurTint.SYSTEMULTRATHINMATERIAL ->
+      colorInt(191, 191, 191, intensity * 0.44)
+    BlurTint.SYSTEMTHICKMATERIAL ->
+      colorInt(153, 153, 153, intensity * 0.97)
+    BlurTint.SYSTEMTHICKMATERIALDARK ->
+      colorInt(37, 37, 37, intensity * 0.9)
+    BlurTint.SYSTEMTHINMATERIALDARK ->
+      colorInt(37, 37, 37, intensity * 0.7)
+    BlurTint.SYSTEMULTRATHINMATERIALDARK ->
+      colorInt(37, 37, 37, intensity * 0.55)
+    BlurTint.SYSTEMCHROMEMATERIALDARK ->
+      colorInt(0, 0, 0, intensity * 0.75)
+    else ->
+      colorInt(255, 255, 255, intensity * 0.44)
+  }
+}
+
+private fun colorInt(r: Int, g: Int, b: Int, alpha: Double): Int {
+  val a = (255 * alpha).toInt().coerceIn(0, 255)
+  return (a shl 24) or (r shl 16) or (g shl 8) or b
+}

package/ios/NitroBlur.swift

@@ -0,0 +1,173 @@
+import UIKit
+
+class HybridNitroBlur: HybridNitroBlurSpec {
+
+  // MARK: - View
+
+  private let containerView = UIView()
+  private let blurEffectView = BlurEffectView()
+
+  var view: UIView {
+    return containerView
+  }
+
+  // MARK: - Props
+
+  var tint: BlurTint = .default {
+    didSet {
+      blurEffectView.tint = tint.toUIBlurEffectStyle()
+    }
+  }
+
+  var intensity: Double = 50 {
+    didSet {
+      blurEffectView.intensity = intensity / 100.0
+    }
+  }
+
+  var blurReductionFactor: Double = 4 {
+    didSet {
+      // blurReductionFactor is Android-only, no-op on iOS
+    }
+  }
+
+  var blurTargetId: Double = 0 {
+    didSet {
+      // blurTargetId is Android-only, no-op on iOS
+      // iOS UIVisualEffectView naturally blurs whatever is behind it
+    }
+  }
+
+  var blurMethod: BlurMethod = .none {
+    didSet {
+      // blurMethod is Android-only, no-op on iOS
+    }
+  }
+
+  // MARK: - Init
+
+  override init() {
+    super.init()
+    containerView.clipsToBounds = true
+    blurEffectView.autoresizingMask = [.flexibleWidth, .flexibleHeight]
+    containerView.addSubview(blurEffectView)
+
+    // Apply defaults
+    blurEffectView.tint = tint.toUIBlurEffectStyle()
+    blurEffectView.intensity = intensity / 100.0
+  }
+}
+
+// MARK: - BlurEffectView
+
+/**
+ * Based on https://gist.github.com/darrarski/29a2a4515508e385c90b3ffe6f975df7
+ */
+final class BlurEffectView: UIVisualEffectView {
+  var intensity: Double = 0.5 {
+    didSet {
+      // Clamp between 0.01 and 1.0
+      intensity = max(0.01, min(1.0, intensity))
+      setNeedsDisplay()
+    }
+  }
+
+  var tint: UIBlurEffect.Style = .regular {
+    didSet {
+      visualEffect = UIBlurEffect(style: tint)
+    }
+  }
+
+  private var visualEffect: UIVisualEffect = UIBlurEffect(style: .regular) {
+    didSet {
+      setNeedsDisplay()
+    }
+  }
+  private var animator: UIViewPropertyAnimator?
+
+  init() {
+    super.init(effect: nil)
+  }
+
+  required init?(coder aDecoder: NSCoder) { nil }
+
+  deinit {
+    animator?.stopAnimation(true)
+  }
+
+  override func draw(_ rect: CGRect) {
+    super.draw(rect)
+
+    // BlurView intensity relies on running an animation and making it partially complete.
+    // This means there is a continually running animation, which makes Detox hang
+    // (it waits for the animation to finish indefinitely).
+    // Detect if Detox is running and use on/off behaviour instead.
+    if BlurEffectView.isDetoxPresent() {
+      effect = intensity > 0 ? visualEffect : nil
+      return
+    }
+
+    effect = nil
+    animator?.stopAnimation(true)
+    animator = UIViewPropertyAnimator(duration: 1, curve: .linear) { [unowned self] in
+      self.effect = visualEffect
+    }
+    animator?.fractionComplete = CGFloat(intensity)
+  }
+
+  private static func isDetoxPresent() -> Bool {
+    let args = ProcessInfo.processInfo.arguments
+    return args.contains("-detoxServer") && args.contains("-detoxSessionId")
+  }
+}
+
+// MARK: - BlurTint → UIBlurEffect.Style
+
+extension BlurTint {
+  func toUIBlurEffectStyle() -> UIBlurEffect.Style {
+    switch self {
+    case .light:
+      return .light
+    case .dark:
+      return .dark
+    case .default:
+      return .regular
+    case .extralight:
+      return .extraLight
+    case .regular:
+      return .regular
+    case .prominent:
+      return .prominent
+    case .systemultrathinmaterial:
+      return .systemUltraThinMaterial
+    case .systemthinmaterial:
+      return .systemThinMaterial
+    case .systemmaterial:
+      return .systemMaterial
+    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
+    }
+  }
+}

package/ios/NitroBlurTarget.swift

@@ -0,0 +1,5 @@
+import UIKit
+
+class HybridNitroBlurTarget: HybridNitroBlurTargetSpec {
+  var view: UIView = UIView()
+}

package/lib/module/NitroBlur.nitro.js

@@ -0,0 +1,4 @@
+"use strict";
+
+export {};
+//# sourceMappingURL=NitroBlur.nitro.js.map

package/lib/module/NitroBlur.nitro.js.map

@@ -0,0 +1 @@
+{"version":3,"names":[],"sourceRoot":"../../src","sources":["NitroBlur.nitro.ts"],"mappings":"","ignoreList":[]}

package/lib/module/NitroBlurTarget.nitro.js

@@ -0,0 +1,4 @@
+"use strict";
+
+export {};
+//# sourceMappingURL=NitroBlurTarget.nitro.js.map

package/lib/module/NitroBlurTarget.nitro.js.map

@@ -0,0 +1 @@
+{"version":3,"names":[],"sourceRoot":"../../src","sources":["NitroBlurTarget.nitro.ts"],"mappings":"","ignoreList":[]}

package/lib/module/index.js

@@ -0,0 +1,114 @@
+"use strict";
+'use client';
+
+import React from 'react';
+import { findNodeHandle, Platform, StyleSheet, View } from 'react-native';
+import { getHostComponent } from 'react-native-nitro-modules';
+import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+const NitroBlurConfig = require('../nitrogen/generated/shared/json/NitroBlurConfig.json');
+const NitroBlurTargetConfig = require('../nitrogen/generated/shared/json/NitroBlurTargetConfig.json');
+const NativeBlurView = getHostComponent('NitroBlur', () => NitroBlurConfig);
+const NativeBlurTargetView = getHostComponent('NitroBlurTarget', () => NitroBlurTargetConfig);
+
+// ----- BlurViewProps -----
+
+// ----- BlurView -----
+
+export class BlurView extends React.Component {
+  constructor(props) {
+    super(props);
+    this.state = {
+      blurTargetId: undefined
+    };
+  }
+  componentDidMount() {
+    this._updateBlurTargetId();
+    this._maybeWarnAboutBlurMethod();
+    if (this.props.experimentalBlurMethod != null) {
+      console.warn('The `experimentalBlurMethod` prop has been deprecated. Please use the `blurMethod` prop instead.');
+    }
+  }
+  componentDidUpdate(prevProps) {
+    if (prevProps.blurTarget?.current !== this.props.blurTarget?.current) {
+      this._updateBlurTargetId();
+    }
+  }
+  _maybeWarnAboutBlurMethod() {
+    const blurMethod = this._getBlurMethod();
+    if (Platform.OS === 'android' && (blurMethod === 'dimezisBlurView' || blurMethod === 'dimezisBlurViewSdk31Plus') && !this.props.blurTarget) {
+      // The fallback happens on the native side
+      console.warn(`You have selected the "${blurMethod}" blur method, but the \`blurTarget\` prop has not been configured. The blur view will fallback to "none" blur method to avoid errors.`);
+    }
+  }
+  _updateBlurTargetId = () => {
+    const blurTarget = this.props.blurTarget?.current;
+    const blurTargetId = blurTarget ? findNodeHandle(blurTarget) : undefined;
+    this.setState(() => ({
+      blurTargetId
+    }));
+  };
+  _getBlurMethod() {
+    const providedMethod = this.props.blurMethod ?? this.props.experimentalBlurMethod;
+    return providedMethod ?? 'none';
+  }
+  render() {
+    const {
+      tint = 'default',
+      intensity = 30,
+      blurReductionFactor = 4,
+      style,
+      children,
+      // eslint-disable-next-line @typescript-eslint/no-unused-vars
+      blurTarget,
+      // eslint-disable-next-line @typescript-eslint/no-unused-vars
+      blurMethod,
+      // eslint-disable-next-line @typescript-eslint/no-unused-vars
+      experimentalBlurMethod,
+      ...props
+    } = this.props;
+    return /*#__PURE__*/_jsxs(View, {
+      ...props,
+      style: [styles.container, style],
+      children: [/*#__PURE__*/_jsx(NativeBlurView, {
+        blurTargetId: this.state.blurTargetId ?? 0,
+        tint: tint,
+        intensity: intensity,
+        blurReductionFactor: blurReductionFactor,
+        blurMethod: this._getBlurMethod(),
+        style: StyleSheet.absoluteFill
+      }), children]
+    });
+  }
+}
+const styles = StyleSheet.create({
+  container: {
+    backgroundColor: 'transparent'
+  }
+});
+
+// ----- BlurTargetView -----
+
+/**
+ * A container view that can be used as a blur target on Android.
+ * Wrap the content you want to blur with this view, then pass
+ * a ref to it via the `blurTarget` prop of `BlurView`.
+ *
+ * On iOS, this is just a regular View since UIVisualEffectView
+ * naturally blurs whatever is behind it.
+ */
+export const BlurTargetView = /*#__PURE__*/React.forwardRef((props, ref) => {
+  if (Platform.OS === 'android') {
+    return /*#__PURE__*/_jsx(NativeBlurTargetView, {
+      ...props,
+      ref: ref
+    });
+  }
+  return /*#__PURE__*/_jsx(View, {
+    ...props,
+    ref: ref,
+    collapsable: false
+  });
+});
+
+// ----- Exports -----
+//# sourceMappingURL=index.js.map

package/lib/module/index.js.map

@@ -0,0 +1 @@
+{"version":3,"names":["React","findNodeHandle","Platform","StyleSheet","View","getHostComponent","jsx","_jsx","jsxs","_jsxs","NitroBlurConfig","require","NitroBlurTargetConfig","NativeBlurView","NativeBlurTargetView","BlurView","Component","constructor","props","state","blurTargetId","undefined","componentDidMount","_updateBlurTargetId","_maybeWarnAboutBlurMethod","experimentalBlurMethod","console","warn","componentDidUpdate","prevProps","blurTarget","current","blurMethod","_getBlurMethod","OS","setState","providedMethod","render","tint","intensity","blurReductionFactor","style","children","styles","container","absoluteFill","create","backgroundColor","BlurTargetView","forwardRef","ref","collapsable"],"sourceRoot":"../../src","sources":["index.tsx"],"mappings":";AAAA,YAAY;;AAEZ,OAAOA,KAAK,MAAM,OAAO;AACzB,SACEC,cAAc,EACdC,QAAQ,EACRC,UAAU,EACVC,IAAI,QAEC,cAAc;AACrB,SAASC,gBAAgB,QAAQ,4BAA4B;AAAC,SAAAC,GAAA,IAAAC,IAAA,EAAAC,IAAA,IAAAC,KAAA;AAY9D,MAAMC,eAAe,GAAGC,OAAO,CAAC,wDAAwD,CAAC;AACzF,MAAMC,qBAAqB,GAAGD,OAAO,CAAC,8DAA8D,CAAC;AAErG,MAAME,cAAc,GAAGR,gBAAgB,CACrC,WAAW,EACX,MAAMK,eACR,CAAC;AAED,MAAMI,oBAAoB,GAAGT,gBAAgB,CAG3C,iBAAiB,EAAE,MAAMO,qBAAqB,CAAC;;AAEjD;;AAyDA;;AAMA,OAAO,MAAMG,QAAQ,SAASf,KAAK,CAACgB,SAAS,CAA+B;EAC1EC,WAAWA,CAACC,KAAoB,EAAE;IAChC,KAAK,CAACA,KAAK,CAAC;IACZ,IAAI,CAACC,KAAK,GAAG;MACXC,YAAY,EAAEC;IAChB,CAAC;EACH;EAEAC,iBAAiBA,CAAA,EAAS;IACxB,IAAI,CAACC,mBAAmB,CAAC,CAAC;IAC1B,IAAI,CAACC,yBAAyB,CAAC,CAAC;IAEhC,IAAI,IAAI,CAACN,KAAK,CAACO,sBAAsB,IAAI,IAAI,EAAE;MAC7CC,OAAO,CAACC,IAAI,CACV,kGACF,CAAC;IACH;EACF;EAEAC,kBAAkBA,CAACC,SAAkC,EAAQ;IAC3D,IAAIA,SAAS,CAACC,UAAU,EAAEC,OAAO,KAAK,IAAI,CAACb,KAAK,CAACY,UAAU,EAAEC,OAAO,EAAE;MACpE,IAAI,CAACR,mBAAmB,CAAC,CAAC;IAC5B;EACF;EAEAC,yBAAyBA,CAAA,EAAS;IAChC,MAAMQ,UAAU,GAAG,IAAI,CAACC,cAAc,CAAC,CAAC;IACxC,IACE/B,QAAQ,CAACgC,EAAE,KAAK,SAAS,KACxBF,UAAU,KAAK,iBAAiB,IAC/BA,UAAU,KAAK,0BAA0B,CAAC,IAC5C,CAAC,IAAI,CAACd,KAAK,CAACY,UAAU,EACtB;MACA;MACAJ,OAAO,CAACC,IAAI,CACV,0BAA0BK,UAAU,wIACtC,CAAC;IACH;EACF;EAEAT,mBAAmB,GAAGA,CAAA,KAAM;IAC1B,MAAMO,UAAU,GAAG,IAAI,CAACZ,KAAK,CAACY,UAAU,EAAEC,OAAO;IACjD,MAAMX,YAAY,GAAGU,UAAU,GAAG7B,cAAc,CAAC6B,UAAU,CAAC,GAAGT,SAAS;IACxE,IAAI,CAACc,QAAQ,CAAC,OAAO;MACnBf;IACF,CAAC,CAAC,CAAC;EACL,CAAC;EAEDa,cAAcA,CAAA,EAAe;IAC3B,MAAMG,cAAc,GAClB,IAAI,CAAClB,KAAK,CAACc,UAAU,IAAI,IAAI,CAACd,KAAK,CAACO,sBAAsB;IAC5D,OAAOW,cAAc,IAAI,MAAM;EACjC;EAEAC,MAAMA,CAAA,EAAG;IACP,MAAM;MACJC,IAAI,GAAG,SAAS;MAChBC,SAAS,GAAG,EAAE;MACdC,mBAAmB,GAAG,CAAC;MACvBC,KAAK;MACLC,QAAQ;MACR;MACAZ,UAAU;MACV;MACAE,UAAU;MACV;MACAP,sBAAsB;MACtB,GAAGP;IACL,CAAC,GAAG,IAAI,CAACA,KAAK;IAEd,oBACET,KAAA,CAACL,IAAI;MAAA,GAAKc,KAAK;MAAEuB,KAAK,EAAE,CAACE,MAAM,CAACC,SAAS,EAAEH,KAAK,CAAE;MAAAC,QAAA,gBAChDnC,IAAA,CAACM,cAAc;QACbO,YAAY,EAAE,IAAI,CAACD,KAAK,CAACC,YAAY,IAAI,CAAE;QAC3CkB,IAAI,EAAEA,IAAK;QACXC,SAAS,EAAEA,SAAU;QACrBC,mBAAmB,EAAEA,mBAAoB;QACzCR,UAAU,EAAE,IAAI,CAACC,cAAc,CAAC,CAAE;QAClCQ,KAAK,EAAEtC,UAAU,CAAC0C;MAAa,CAChC,CAAC,EACDH,QAAQ;IAAA,CACL,CAAC;EAEX;AACF;AAEA,MAAMC,MAAM,GAAGxC,UAAU,CAAC2C,MAAM,CAAC;EAC/BF,SAAS,EAAE;IAAEG,eAAe,EAAE;EAAc;AAC9C,CAAC,CAAC;;AAEF;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,OAAO,MAAMC,cAAc,gBAAGhD,KAAK,CAACiD,UAAU,CAC5C,CAAC/B,KAAK,EAAEgC,GAAG,KAAK;EACd,IAAIhD,QAAQ,CAACgC,EAAE,KAAK,SAAS,EAAE;IAC7B,oBAAO3B,IAAA,CAACO,oBAAoB;MAAA,GAAKI,KAAK;MAAEgC,GAAG,EAAEA;IAAW,CAAE,CAAC;EAC7D;EACA,oBAAO3C,IAAA,CAACH,IAAI;IAAA,GAAKc,KAAK;IAAEgC,GAAG,EAAEA,GAAW;IAACC,WAAW,EAAE;EAAM,CAAE,CAAC;AACjE,CACF,CAAC;;AAED","ignoreList":[]}

package/lib/module/package.json

@@ -0,0 +1 @@
+{"type":"module"}

package/lib/typescript/package.json

@@ -0,0 +1 @@
+{"type":"module"}

package/lib/typescript/src/NitroBlur.nitro.d.ts

@@ -0,0 +1,25 @@
+import type { HybridView, HybridViewMethods, HybridViewProps } from 'react-native-nitro-modules';
+export type BlurTint = 'light' | 'dark' | 'default' | 'extraLight' | 'regular' | 'prominent' | 'systemUltraThinMaterial' | 'systemThinMaterial' | 'systemMaterial' | 'systemThickMaterial' | 'systemChromeMaterial' | 'systemUltraThinMaterialLight' | 'systemThinMaterialLight' | 'systemMaterialLight' | 'systemThickMaterialLight' | 'systemChromeMaterialLight' | 'systemUltraThinMaterialDark' | 'systemThinMaterialDark' | 'systemMaterialDark' | 'systemThickMaterialDark' | 'systemChromeMaterialDark';
+/**
+ * Blur method to use on Android.
+ *
+ * - `'none'` - Renders a semi-transparent view instead of rendering a blur effect.
+ * - `'dimezisBlurView'` - Uses a native blur view implementation based on BlurView library.
+ *   This method may lead to decreased performance on Android SDK 30 and below.
+ * - `'dimezisBlurViewSdk31Plus'` - Uses BlurView library on Android SDK 31 and above,
+ *   for older versions falls back to 'none'.
+ *
+ * @platform android
+ */
+export type BlurMethod = 'none' | 'dimezisBlurView' | 'dimezisBlurViewSdk31Plus';
+export interface NitroBlurProps extends HybridViewProps {
+    tint: BlurTint;
+    intensity: number;
+    blurReductionFactor: number;
+    blurTargetId: number;
+    blurMethod: BlurMethod;
+}
+export interface NitroBlurMethods extends HybridViewMethods {
+}
+export type NitroBlur = HybridView<NitroBlurProps, NitroBlurMethods>;
+//# sourceMappingURL=NitroBlur.nitro.d.ts.map

package/lib/typescript/src/NitroBlur.nitro.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"NitroBlur.nitro.d.ts","sourceRoot":"","sources":["../../../src/NitroBlur.nitro.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EACV,UAAU,EACV,iBAAiB,EACjB,eAAe,EAChB,MAAM,4BAA4B,CAAC;AAEpC,MAAM,MAAM,QAAQ,GAChB,OAAO,GACP,MAAM,GACN,SAAS,GACT,YAAY,GACZ,SAAS,GACT,WAAW,GACX,yBAAyB,GACzB,oBAAoB,GACpB,gBAAgB,GAChB,qBAAqB,GACrB,sBAAsB,GACtB,8BAA8B,GAC9B,yBAAyB,GACzB,qBAAqB,GACrB,0BAA0B,GAC1B,2BAA2B,GAC3B,6BAA6B,GAC7B,wBAAwB,GACxB,oBAAoB,GACpB,yBAAyB,GACzB,0BAA0B,CAAC;AAE/B;;;;;;;;;;GAUG;AACH,MAAM,MAAM,UAAU,GAClB,MAAM,GACN,iBAAiB,GACjB,0BAA0B,CAAC;AAE/B,MAAM,WAAW,cAAe,SAAQ,eAAe;IACrD,IAAI,EAAE,QAAQ,CAAC;IACf,SAAS,EAAE,MAAM,CAAC;IAClB,mBAAmB,EAAE,MAAM,CAAC;IAC5B,YAAY,EAAE,MAAM,CAAC;IACrB,UAAU,EAAE,UAAU,CAAC;CACxB;AAED,MAAM,WAAW,gBAAiB,SAAQ,iBAAiB;CAAG;AAE9D,MAAM,MAAM,SAAS,GAAG,UAAU,CAAC,cAAc,EAAE,gBAAgB,CAAC,CAAC"}

package/lib/typescript/src/NitroBlurTarget.nitro.d.ts

@@ -0,0 +1,7 @@
+import type { HybridView, HybridViewMethods, HybridViewProps } from 'react-native-nitro-modules';
+export interface NitroBlurTargetProps extends HybridViewProps {
+}
+export interface NitroBlurTargetMethods extends HybridViewMethods {
+}
+export type NitroBlurTarget = HybridView<NitroBlurTargetProps, NitroBlurTargetMethods>;
+//# sourceMappingURL=NitroBlurTarget.nitro.d.ts.map

package/lib/typescript/src/NitroBlurTarget.nitro.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"NitroBlurTarget.nitro.d.ts","sourceRoot":"","sources":["../../../src/NitroBlurTarget.nitro.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EACV,UAAU,EACV,iBAAiB,EACjB,eAAe,EAChB,MAAM,4BAA4B,CAAC;AAEpC,MAAM,WAAW,oBAAqB,SAAQ,eAAe;CAAG;AAChE,MAAM,WAAW,sBAAuB,SAAQ,iBAAiB;CAAG;AAEpE,MAAM,MAAM,eAAe,GAAG,UAAU,CACtC,oBAAoB,EACpB,sBAAsB,CACvB,CAAC"}