@sbaiahmed1/react-native-blur 4.0.0 → 4.1.0

package/ios/ReactNativeProgressiveBlurView.mm

@@ -0,0 +1,213 @@
+#import "ReactNativeProgressiveBlurView.h"
+
+#import <react/renderer/components/ReactNativeBlurViewSpec/ComponentDescriptors.h>
+#import <react/renderer/components/ReactNativeBlurViewSpec/EventEmitters.h>
+#import <react/renderer/components/ReactNativeBlurViewSpec/Props.h>
+#import <react/renderer/components/ReactNativeBlurViewSpec/RCTComponentViewHelpers.h>
+
+#import "RCTFabricComponentsPlugins.h"
+
+#if __has_include("ReactNativeBlur-Swift.h")
+#import "ReactNativeBlur-Swift.h"
+#else
+#import <ReactNativeBlur/ReactNativeBlur-Swift.h>
+#endif
+
+using namespace facebook::react;
+
+@interface ReactNativeProgressiveBlurView () <RCTReactNativeProgressiveBlurViewViewProtocol>
+@end
+
+@implementation ReactNativeProgressiveBlurView {
+  ProgressiveBlurView *_progressiveBlurView;
+  Props::Shared _props;
+}
+
++ (UIColor *)colorFromString:(NSString *)colorString {
+  // Input validation
+  if (!colorString || [colorString isEqualToString:@""] || colorString.length == 0) {
+    return [UIColor clearColor];
+  }
+
+  if (colorString.length > 50) {
+    NSLog(@"[ReactNativeProgressiveBlurView] Warning: Color string too long, using default clear color");
+    return [UIColor clearColor];
+  }
+
+  // Handle common color names
+  NSDictionary *colorMap = @{
+    @"red": [UIColor redColor],
+    @"blue": [UIColor blueColor],
+    @"green": [UIColor greenColor],
+    @"yellow": [UIColor yellowColor],
+    @"orange": [UIColor orangeColor],
+    @"purple": [UIColor purpleColor],
+    @"black": [UIColor blackColor],
+    @"white": [UIColor whiteColor],
+    @"gray": [UIColor grayColor],
+    @"clear": [UIColor clearColor],
+    @"transparent": [UIColor clearColor]
+  };
+
+  UIColor *namedColor = colorMap[colorString.lowercaseString];
+  if (namedColor) {
+    return namedColor;
+  }
+
+  // Handle hex colors
+  NSString *hexString = colorString;
+  if ([hexString hasPrefix:@"#"]) {
+    if (hexString.length < 2) {
+      NSLog(@"[ReactNativeProgressiveBlurView] Warning: Invalid hex color format '%@'", colorString);
+      return [UIColor clearColor];
+    }
+    hexString = [hexString substringFromIndex:1];
+  }
+
+  NSCharacterSet *hexCharacterSet = [NSCharacterSet characterSetWithCharactersInString:@"0123456789ABCDEFabcdef"];
+  NSCharacterSet *invalidCharacters = [hexCharacterSet invertedSet];
+  if ([hexString rangeOfCharacterFromSet:invalidCharacters].location != NSNotFound) {
+    NSLog(@"[ReactNativeProgressiveBlurView] Warning: Invalid hex color format '%@'", colorString);
+    return [UIColor clearColor];
+  }
+
+  if (hexString.length == 6) {
+    unsigned int hexValue;
+    NSScanner *scanner = [NSScanner scannerWithString:hexString];
+    if ([scanner scanHexInt:&hexValue] && [scanner isAtEnd]) {
+      return [UIColor colorWithRed:((hexValue & 0xFF0000) >> 16) / 255.0
+                             green:((hexValue & 0x00FF00) >> 8) / 255.0
+                              blue:(hexValue & 0x0000FF) / 255.0
+                             alpha:1.0];
+    }
+  } else if (hexString.length == 8) {
+    unsigned long long hexValue;
+    NSScanner *scanner = [NSScanner scannerWithString:hexString];
+    if ([scanner scanHexLongLong:&hexValue] && [scanner isAtEnd]) {
+      return [UIColor colorWithRed:((hexValue & 0xFF000000) >> 24) / 255.0
+                             green:((hexValue & 0x00FF0000) >> 16) / 255.0
+                              blue:((hexValue & 0x0000FF00) >> 8) / 255.0
+                             alpha:(hexValue & 0x000000FF) / 255.0];
+    }
+  } else if (hexString.length == 3) {
+    unsigned int hexValue;
+    NSScanner *scanner = [NSScanner scannerWithString:hexString];
+    if ([scanner scanHexInt:&hexValue] && [scanner isAtEnd]) {
+      unsigned int r = (hexValue & 0xF00) >> 8;
+      unsigned int g = (hexValue & 0x0F0) >> 4;
+      unsigned int b = (hexValue & 0x00F);
+      return [UIColor colorWithRed:(r | (r << 4)) / 255.0
+                             green:(g | (g << 4)) / 255.0
+                              blue:(b | (b << 4)) / 255.0
+                             alpha:1.0];
+    }
+  }
+
+  NSLog(@"[ReactNativeProgressiveBlurView] Warning: Could not parse color '%@'", colorString);
+  return [UIColor clearColor];
+}
+
++ (ComponentDescriptorProvider)componentDescriptorProvider
+{
+  return concreteComponentDescriptorProvider<ReactNativeProgressiveBlurViewComponentDescriptor>();
+}
+
+- (instancetype)initWithFrame:(CGRect)frame
+{
+  if (self = [super initWithFrame:frame]) {
+    static const auto defaultProps = std::make_shared<const ReactNativeProgressiveBlurViewProps>();
+    _props = defaultProps;
+
+    const auto &pbvProps = *std::static_pointer_cast<const ReactNativeProgressiveBlurViewProps>(defaultProps);
+
+    _progressiveBlurView = [ReactNativeProgressiveBlurViewHelper createProgressiveBlurViewWithFrame:frame];
+
+    // Set initial properties from default props
+    [ReactNativeProgressiveBlurViewHelper updateProgressiveBlurView:_progressiveBlurView withBlurAmount:pbvProps.blurAmount];
+
+    if (pbvProps.blurType != facebook::react::ReactNativeProgressiveBlurViewBlurType::Xlight) {
+      NSString *blurTypeString = [[NSString alloc] initWithUTF8String:toString(pbvProps.blurType).c_str()];
+      [ReactNativeProgressiveBlurViewHelper updateProgressiveBlurView:_progressiveBlurView withBlurType:blurTypeString];
+    }
+
+    if (pbvProps.direction != facebook::react::ReactNativeProgressiveBlurViewDirection::BlurredTopClearBottom) {
+      NSString *directionString = [[NSString alloc] initWithUTF8String:toString(pbvProps.direction).c_str()];
+      [ReactNativeProgressiveBlurViewHelper updateProgressiveBlurView:_progressiveBlurView withDirection:directionString];
+    }
+
+    [ReactNativeProgressiveBlurViewHelper updateProgressiveBlurView:_progressiveBlurView withStartOffset:pbvProps.startOffset];
+
+    if (!pbvProps.reducedTransparencyFallbackColor.empty()) {
+      NSString *fallbackColorString = [[NSString alloc] initWithUTF8String:pbvProps.reducedTransparencyFallbackColor.c_str()];
+      UIColor *fallbackColor = [ReactNativeProgressiveBlurView colorFromString:fallbackColorString];
+      [ReactNativeProgressiveBlurViewHelper updateProgressiveBlurView:_progressiveBlurView withReducedTransparencyFallbackColor:fallbackColor];
+    }
+
+    [self addSubview:_progressiveBlurView];
+  }
+  return self;
+}
+
+- (void)updateProps:(Props::Shared const &)props oldProps:(Props::Shared const &)oldProps
+{
+  const auto &oldViewProps = *std::static_pointer_cast<ReactNativeProgressiveBlurViewProps const>(_props);
+  const auto &newViewProps = *std::static_pointer_cast<ReactNativeProgressiveBlurViewProps const>(props);
+
+  if (oldViewProps.blurAmount != newViewProps.blurAmount) {
+    [ReactNativeProgressiveBlurViewHelper updateProgressiveBlurView:_progressiveBlurView withBlurAmount:newViewProps.blurAmount];
+  }
+
+  if (oldViewProps.blurType != newViewProps.blurType) {
+    NSString *blurTypeString = [[NSString alloc] initWithUTF8String:toString(newViewProps.blurType).c_str()];
+    [ReactNativeProgressiveBlurViewHelper updateProgressiveBlurView:_progressiveBlurView withBlurType:blurTypeString];
+  }
+
+  if (oldViewProps.direction != newViewProps.direction) {
+    NSString *directionString = [[NSString alloc] initWithUTF8String:toString(newViewProps.direction).c_str()];
+    [ReactNativeProgressiveBlurViewHelper updateProgressiveBlurView:_progressiveBlurView withDirection:directionString];
+  }
+
+  if (oldViewProps.startOffset != newViewProps.startOffset) {
+    [ReactNativeProgressiveBlurViewHelper updateProgressiveBlurView:_progressiveBlurView withStartOffset:newViewProps.startOffset];
+  }
+
+  if (oldViewProps.reducedTransparencyFallbackColor != newViewProps.reducedTransparencyFallbackColor) {
+    if (!newViewProps.reducedTransparencyFallbackColor.empty()) {
+      NSString *fallbackColorString = [[NSString alloc] initWithUTF8String:newViewProps.reducedTransparencyFallbackColor.c_str()];
+      UIColor *fallbackColor = [ReactNativeProgressiveBlurView colorFromString:fallbackColorString];
+      [ReactNativeProgressiveBlurViewHelper updateProgressiveBlurView:_progressiveBlurView withReducedTransparencyFallbackColor:fallbackColor];
+    }
+  }
+
+  _props = props;
+  [super updateProps:props oldProps:oldProps];
+}
+
+- (void)layoutSubviews
+{
+  [super layoutSubviews];
+  _progressiveBlurView.frame = self.bounds;
+}
+
+- (void)mountChildComponentView:(UIView<RCTComponentViewProtocol> *)childComponentView index:(NSInteger)index
+{
+  [_progressiveBlurView addSubview:childComponentView];
+}
+
+- (void)unmountChildComponentView:(UIView<RCTComponentViewProtocol> *)childComponentView index:(NSInteger)index
+{
+  [childComponentView removeFromSuperview];
+}
+
+- (void)dealloc
+{
+  [_progressiveBlurView removeFromSuperview];
+  _progressiveBlurView = nil;
+}
+
+@end
+
+Class<RCTComponentViewProtocol> ProgressiveBlurryViewCls(void)
+{
+  return ReactNativeProgressiveBlurView.class;
+}

package/ios/ReactNativeProgressiveBlurViewManager.h

@@ -0,0 +1,4 @@
+#import <React/RCTViewManager.h>
+
+@interface ReactNativeProgressiveBlurViewManager : RCTViewManager
+@end

package/ios/ReactNativeProgressiveBlurViewManager.mm

@@ -0,0 +1,137 @@
+#import "ReactNativeProgressiveBlurViewManager.h"
+
+#if __has_include("ReactNativeBlur-Swift.h")
+#import "ReactNativeBlur-Swift.h"
+#else
+#import <ReactNativeBlur/ReactNativeBlur-Swift.h>
+#endif
+
+#import <React/RCTUIManager.h>
+#import <React/RCTBridge.h>
+
+@interface ReactNativeProgressiveBlurViewManager ()
+
+@end
+
+@implementation ReactNativeProgressiveBlurViewManager
+
+RCT_EXPORT_MODULE(ReactNativeProgressiveBlurView)
+
+- (UIView *)view
+{
+  return [ReactNativeProgressiveBlurViewHelper createProgressiveBlurViewWithFrame:CGRectZero];
+}
+
+// Export properties
+
+RCT_CUSTOM_VIEW_PROPERTY(blurAmount, NSNumber, ProgressiveBlurView)
+{
+  double amount = json ? [RCTConvert double:json] : 20.0;
+  [ReactNativeProgressiveBlurViewHelper updateProgressiveBlurView:view withBlurAmount:amount];
+}
+
+RCT_CUSTOM_VIEW_PROPERTY(blurType, NSString, ProgressiveBlurView)
+{
+  NSString *blurType = json ? [RCTConvert NSString:json] : @"regular";
+  [ReactNativeProgressiveBlurViewHelper updateProgressiveBlurView:view withBlurType:blurType];
+}
+
+RCT_CUSTOM_VIEW_PROPERTY(direction, NSString, ProgressiveBlurView)
+{
+  NSString *direction = json ? [RCTConvert NSString:json] : @"blurredTopClearBottom";
+  [ReactNativeProgressiveBlurViewHelper updateProgressiveBlurView:view withDirection:direction];
+}
+
+RCT_CUSTOM_VIEW_PROPERTY(startOffset, NSNumber, ProgressiveBlurView)
+{
+  double offset = json ? [RCTConvert double:json] : 0.0;
+  [ReactNativeProgressiveBlurViewHelper updateProgressiveBlurView:view withStartOffset:offset];
+}
+
+RCT_CUSTOM_VIEW_PROPERTY(reducedTransparencyFallbackColor, NSString, ProgressiveBlurView)
+{
+  NSString *colorString = json ? [RCTConvert NSString:json] : @"#FFFFFF";
+  UIColor *color = [self colorFromString:colorString];
+  [ReactNativeProgressiveBlurViewHelper updateProgressiveBlurView:view withReducedTransparencyFallbackColor:color];
+}
+
+// Color parsing helper method
+- (UIColor *)colorFromString:(NSString *)colorString {
+  if (!colorString || [colorString isEqualToString:@""] || colorString.length == 0) {
+    return [UIColor clearColor];
+  }
+
+  if (colorString.length > 50) {
+    NSLog(@"[ReactNativeProgressiveBlurViewManager] Warning: Color string too long");
+    return [UIColor clearColor];
+  }
+
+  NSDictionary *colorMap = @{
+    @"red": [UIColor redColor],
+    @"blue": [UIColor blueColor],
+    @"green": [UIColor greenColor],
+    @"yellow": [UIColor yellowColor],
+    @"orange": [UIColor orangeColor],
+    @"purple": [UIColor purpleColor],
+    @"black": [UIColor blackColor],
+    @"white": [UIColor whiteColor],
+    @"gray": [UIColor grayColor],
+    @"clear": [UIColor clearColor],
+    @"transparent": [UIColor clearColor]
+  };
+
+  UIColor *namedColor = colorMap[colorString.lowercaseString];
+  if (namedColor) {
+    return namedColor;
+  }
+
+  NSString *hexString = colorString;
+  if ([hexString hasPrefix:@"#"]) {
+    if (hexString.length < 2) {
+      return [UIColor clearColor];
+    }
+    hexString = [hexString substringFromIndex:1];
+  }
+
+  NSCharacterSet *hexCharacterSet = [NSCharacterSet characterSetWithCharactersInString:@"0123456789ABCDEFabcdef"];
+  NSCharacterSet *invalidCharacters = [hexCharacterSet invertedSet];
+  if ([hexString rangeOfCharacterFromSet:invalidCharacters].location != NSNotFound) {
+    return [UIColor clearColor];
+  }
+
+  if (hexString.length == 6) {
+    unsigned int hexValue;
+    NSScanner *scanner = [NSScanner scannerWithString:hexString];
+    if ([scanner scanHexInt:&hexValue] && [scanner isAtEnd]) {
+      return [UIColor colorWithRed:((hexValue & 0xFF0000) >> 16) / 255.0
+                             green:((hexValue & 0x00FF00) >> 8) / 255.0
+                              blue:(hexValue & 0x0000FF) / 255.0
+                             alpha:1.0];
+    }
+  } else if (hexString.length == 8) {
+    unsigned long long hexValue;
+    NSScanner *scanner = [NSScanner scannerWithString:hexString];
+    if ([scanner scanHexLongLong:&hexValue] && [scanner isAtEnd]) {
+      return [UIColor colorWithRed:((hexValue & 0xFF000000) >> 24) / 255.0
+                             green:((hexValue & 0x00FF0000) >> 16) / 255.0
+                              blue:((hexValue & 0x0000FF00) >> 8) / 255.0
+                             alpha:(hexValue & 0x000000FF) / 255.0];
+    }
+  } else if (hexString.length == 3) {
+    unsigned int hexValue;
+    NSScanner *scanner = [NSScanner scannerWithString:hexString];
+    if ([scanner scanHexInt:&hexValue] && [scanner isAtEnd]) {
+      unsigned int r = (hexValue & 0xF00) >> 8;
+      unsigned int g = (hexValue & 0x0F0) >> 4;
+      unsigned int b = (hexValue & 0x00F);
+      return [UIColor colorWithRed:(r | (r << 4)) / 255.0
+                             green:(g | (g << 4)) / 255.0
+                              blue:(b | (b << 4)) / 255.0
+                             alpha:1.0];
+    }
+  }
+
+  return [UIColor clearColor];
+}
+
+@end

package/ios/Views/LiquidGlassContainerView.swift

@@ -64,6 +64,10 @@ import UIKit
     let effectView = UIVisualEffectView()
     effectView.autoresizingMask = [.flexibleWidth, .flexibleHeight]
     effectView.frame = bounds
+    
+    // Don't clip bounds to allow interactive glass animations to be visible
+    effectView.clipsToBounds = false
+    
     addSubview(effectView)
     self.glassEffectView = effectView
     
@@ -74,30 +78,6 @@ import UIKit
   
   @objc public func setBorderRadius(_ radius: CGFloat) {
     allBorderRadius = radius
-    topLeftRadius = radius
-    topRightRadius = radius
-    bottomLeftRadius = radius
-    bottomRightRadius = radius
-    updateBorderRadius()
-  }
-  
-  @objc public func setBorderTopLeftRadius(_ radius: CGFloat) {
-    topLeftRadius = radius
-    updateBorderRadius()
-  }
-  
-  @objc public func setBorderTopRightRadius(_ radius: CGFloat) {
-    topRightRadius = radius
-    updateBorderRadius()
-  }
-  
-  @objc public func setBorderBottomLeftRadius(_ radius: CGFloat) {
-    bottomLeftRadius = radius
-    updateBorderRadius()
-  }
-  
-  @objc public func setBorderBottomRightRadius(_ radius: CGFloat) {
-    bottomRightRadius = radius
     updateBorderRadius()
   }
 
@@ -129,17 +109,16 @@ import UIKit
     } else {
       backgroundColor = reducedTransparencyFallbackColor
       layer.cornerRadius = allBorderRadius
-      layer.masksToBounds = true
     }
   }
 
   private func updateBorderRadius() {
     if #available(iOS 26.0, *) {
       #if compiler(>=6.2)
-      let topLeft = UICornerRadius(floatLiteral: Double(topLeftRadius))
-      let topRight = UICornerRadius(floatLiteral: Double(topRightRadius))
-      let bottomLeft = UICornerRadius(floatLiteral: Double(bottomLeftRadius))
-      let bottomRight = UICornerRadius(floatLiteral: Double(bottomRightRadius))
+      let topLeft = UICornerRadius(floatLiteral: Double(allBorderRadius))
+      let topRight = UICornerRadius(floatLiteral: Double(allBorderRadius))
+      let bottomLeft = UICornerRadius(floatLiteral: Double(allBorderRadius))
+      let bottomRight = UICornerRadius(floatLiteral: Double(allBorderRadius))
       
       glassEffectView?.cornerConfiguration = .corners(
         topLeftRadius: topLeft,
@@ -153,7 +132,6 @@ import UIKit
       #endif
     } else {
       layer.cornerRadius = allBorderRadius
-      layer.masksToBounds = true
     }
   }
 

package/ios/Views/ProgressiveBlurView.swift

@@ -0,0 +1,124 @@
+// ProgressiveBlurView.swift
+// React Native wrapper for VariableBlurView
+
+import SwiftUI
+import UIKit
+
+@objc public class ProgressiveBlurView: UIView {
+
+  private var variableBlurView: VariableBlurView?
+
+  @objc public var blurAmount: Double = 20.0 {
+    didSet {
+      updateBlur()
+    }
+  }
+
+  @objc public var direction: String = "blurredTopClearBottom" {
+    didSet {
+      updateBlur()
+    }
+  }
+
+  @objc public var startOffset: Double = 0.0 {
+    didSet {
+      updateBlur()
+    }
+  }
+
+  @objc public var blurTypeString: String = "regular" {
+    didSet {
+      updateBlur()
+    }
+  }
+
+  @objc public var reducedTransparencyFallbackColor: UIColor = .white {
+    didSet {
+      updateBlur()
+    }
+  }
+
+  public override init(frame: CGRect) {
+    super.init(frame: frame)
+    setupView()
+  }
+
+  required init?(coder: NSCoder) {
+    super.init(coder: coder)
+    setupView()
+  }
+
+  private func setupView() {
+    // Remove old view if exists
+    variableBlurView?.removeFromSuperview()
+
+    let blurStyle = blurStyleFromString(blurTypeString)
+    let blurDirection = VariableBlurDirection(fromString: direction)
+
+    let variableBlur = VariableBlurView(
+      maxBlurRadius: CGFloat(blurAmount),
+      direction: blurDirection,
+      startOffset: CGFloat(startOffset),
+      blurStyle: blurStyle
+    )
+
+    variableBlur.translatesAutoresizingMaskIntoConstraints = false
+    addSubview(variableBlur)
+
+    NSLayoutConstraint.activate([
+      variableBlur.topAnchor.constraint(equalTo: topAnchor),
+      variableBlur.leadingAnchor.constraint(equalTo: leadingAnchor),
+      variableBlur.trailingAnchor.constraint(equalTo: trailingAnchor),
+      variableBlur.bottomAnchor.constraint(equalTo: bottomAnchor)
+    ])
+
+    self.variableBlurView = variableBlur
+
+    // Handle reduced transparency
+    if UIAccessibility.isReduceTransparencyEnabled {
+      variableBlur.isHidden = true
+      backgroundColor = reducedTransparencyFallbackColor
+    } else {
+      variableBlur.isHidden = false
+      backgroundColor = .clear
+    }
+  }
+
+  private func updateBlur() {
+    guard let variableBlurView = variableBlurView else {
+      setupView()
+      return
+    }
+
+    let blurStyle = blurStyleFromString(blurTypeString)
+    let blurDirection = VariableBlurDirection(fromString: direction)
+
+    variableBlurView.updateBlur(
+      maxBlurRadius: CGFloat(blurAmount),
+      direction: blurDirection,
+      startOffset: CGFloat(startOffset),
+      blurStyle: blurStyle
+    )
+
+    // Handle reduced transparency
+    if UIAccessibility.isReduceTransparencyEnabled {
+      variableBlurView.isHidden = true
+      backgroundColor = reducedTransparencyFallbackColor
+    } else {
+      variableBlurView.isHidden = false
+      backgroundColor = .clear
+    }
+  }
+
+  public override func didMoveToWindow() {
+    super.didMoveToWindow()
+    if window != nil {
+      updateBlur()
+    }
+  }
+
+  deinit {
+    variableBlurView?.removeFromSuperview()
+    variableBlurView = nil
+  }
+}

package/ios/Views/VariableBlurView.swift

@@ -0,0 +1,142 @@
+// VariableBlurView.swift
+// Progressive/Variable Blur implementation based on VariableBlur library
+
+import SwiftUI
+import UIKit
+import CoreImage.CIFilterBuiltins
+import QuartzCore
+
+public enum VariableBlurDirection: String {
+  case blurredTopClearBottom
+  case blurredBottomClearTop
+
+  init(fromString string: String) {
+    switch string.lowercased() {
+    case "blurredbottomcleartop", "bottomtotop", "bottom":
+      self = .blurredBottomClearTop
+    default:
+      self = .blurredTopClearBottom
+    }
+  }
+}
+
+open class VariableBlurView: UIVisualEffectView {
+
+  private var maxBlurRadius: CGFloat = 20
+  private var direction: VariableBlurDirection = .blurredTopClearBottom
+  private var startOffset: CGFloat = 0
+
+  public init(
+    maxBlurRadius: CGFloat = 20,
+    direction: VariableBlurDirection = .blurredTopClearBottom,
+    startOffset: CGFloat = 0,
+    blurStyle: UIBlurEffect.Style = .regular
+  ) {
+    self.maxBlurRadius = maxBlurRadius
+    self.direction = direction
+    self.startOffset = startOffset
+
+    super.init(effect: UIBlurEffect(style: blurStyle))
+
+    setupVariableBlur()
+  }
+
+  required public init?(coder: NSCoder) {
+    super.init(coder: coder)
+    setupVariableBlur()
+  }
+
+  public func updateBlur(
+    maxBlurRadius: CGFloat,
+    direction: VariableBlurDirection,
+    startOffset: CGFloat,
+    blurStyle: UIBlurEffect.Style = .regular
+  ) {
+    self.maxBlurRadius = maxBlurRadius
+    self.direction = direction
+    self.startOffset = startOffset
+    self.effect = UIBlurEffect(style: blurStyle)
+
+    setupVariableBlur()
+  }
+
+  private func setupVariableBlur() {
+    // Creates filter via runtime reflection
+    // This uses a private Core Animation filter called "variableBlur"
+    let clsName = String("retliFAC".reversed()) // CAFilter
+    guard let Cls = NSClassFromString(clsName) as? NSObject.Type else {
+      print("[VariableBlur] Error: Can't find filter class")
+      return
+    }
+
+    let selName = String(":epyThtiWretlif".reversed()) // filterWithType:
+    guard let variableBlur = Cls.self.perform(
+      NSSelectorFromString(selName),
+      with: "variableBlur"
+    )?.takeUnretainedValue() as? NSObject else {
+      print("[VariableBlur] Error: Can't create variableBlur filter")
+      return
+    }
+
+    let gradientImage = makeGradientImage(
+      startOffset: startOffset,
+      direction: direction
+    )
+
+    variableBlur.setValue(maxBlurRadius, forKey: "inputRadius")
+    variableBlur.setValue(gradientImage, forKey: "inputMaskImage")
+    variableBlur.setValue(true, forKey: "inputNormalizeEdges")
+
+    let backdropLayer = subviews.first?.layer
+    backdropLayer?.filters = [variableBlur]
+
+    // Hide the default visual effect view overlays
+    for subview in subviews.dropFirst() {
+      subview.alpha = 0
+    }
+  }
+
+  open override func didMoveToWindow() {
+    super.didMoveToWindow()
+    guard let window, let backdropLayer = subviews.first?.layer else { return }
+    backdropLayer.setValue(
+      window.traitCollection.displayScale,
+      forKey: "scale"
+    )
+  }
+
+  open override func traitCollectionDidChange(
+    _ previousTraitCollection: UITraitCollection?
+  ) {
+    super.traitCollectionDidChange(previousTraitCollection)
+    // Re-setup blur if needed when trait collection changes
+    if let previousTraitCollection = previousTraitCollection,
+       traitCollection.userInterfaceStyle != previousTraitCollection.userInterfaceStyle {
+      setupVariableBlur()
+    }
+  }
+
+  private func makeGradientImage(
+    width: CGFloat = 100,
+    height: CGFloat = 100,
+    startOffset: CGFloat,
+    direction: VariableBlurDirection
+  ) -> CGImage {
+    // Try smoothLinearGradient for smoother transitions
+    let ciGradientFilter = CIFilter.smoothLinearGradient()
+    ciGradientFilter.color0 = CIColor.black
+    ciGradientFilter.color1 = CIColor.clear
+    ciGradientFilter.point0 = CGPoint(x: 0, y: height)
+    ciGradientFilter.point1 = CGPoint(x: 0, y: startOffset * height)
+
+    if case .blurredBottomClearTop = direction {
+      ciGradientFilter.point0.y = 0
+      ciGradientFilter.point1.y = height - ciGradientFilter.point1.y
+    }
+
+    return CIContext().createCGImage(
+      ciGradientFilter.outputImage!,
+      from: CGRect(x: 0, y: 0, width: width, height: height)
+    )!
+  }
+}