react-native-a11y-order 0.8.2 → 0.9.1-rc

package/android/src/main/java/com/a11yorder/services/order/linking/A11yOrderLinking.java

@@ -1,19 +1,15 @@
 package com.a11yorder.services.order.linking;
 
-
 import android.view.View;
 
 import java.util.HashMap;
 import java.util.Map;
 
 public class A11yOrderLinking {
-
   private static A11yOrderLinking instance;
-  private final Map<String, A11yLinkingQueue> relationships;
+  private final Map<String, A11yLinkingQueue> relationships = new HashMap<>();
 
-  private A11yOrderLinking() {
-    relationships = new HashMap<>();
-  }
+  private A11yOrderLinking() {}
 
   public static synchronized A11yOrderLinking getInstance() {
     if (instance == null) {
@@ -21,24 +17,25 @@ public class A11yOrderLinking {
     }
     return instance;
   }
-  public void addViewRelationship(View view, String key, int position) {
-    A11yLinkingQueue queue = relationships.get(key);
 
+  private A11yLinkingQueue getOrCreateQueue(String key) {
+    A11yLinkingQueue queue = relationships.get(key);
     if (queue == null) {
       queue = new A11yLinkingQueue();
       relationships.put(key, queue);
     }
-
-    queue.addPosition(view, position);
+    return queue;
   }
 
+  public void addViewRelationship(View view, String key, int position) {
+    getOrCreateQueue(key).addPosition(view, position);
+  }
 
-  public void removeRelationship(String key, int index) {
+  public void removeRelationship(String key, int position) {
     A11yLinkingQueue queue = relationships.get(key);
     if (queue == null) return;
-
-    queue.removeFromOrder(index);
-    if(queue.isEmpty()) {
+    queue.removeFromOrder(position);
+    if (queue.isEmpty()) {
       relationships.remove(key);
     }
   }

package/android/src/main/java/com/a11yorder/services/order/linking/WeakTreeMap.java

@@ -5,58 +5,80 @@ import android.view.View;
 import java.lang.ref.WeakReference;
 import java.util.Map;
 import java.util.NavigableMap;
-import java.util.Set;
 import java.util.TreeMap;
 
 public class WeakTreeMap {
-  public NavigableMap<Integer, WeakReference<View>> viewMap = new TreeMap<>();
+  private final NavigableMap<Integer, WeakReference<View>> viewMap = new TreeMap<>();
 
-  public static View unwrapViewRef(Map. Entry<Integer, WeakReference<View>> viewRef) {
-    if(viewRef == null || viewRef.getValue() == null) return null;
-    return viewRef.getValue().get();
+  public void put(int position, View view) {
+    viewMap.put(position, new WeakReference<>(view));
   }
 
-  public View getNext (int position) {
-    Map.Entry<Integer, WeakReference<View>> view = viewMap.higherEntry(position);
-    if(view == null || view.getValue() == null) return null;
-    return view.getValue().get();
+  public View get(int position) {
+    WeakReference<View> ref = viewMap.get(position);
+    return ref != null ? ref.get() : null;
   }
 
-  public View getPrev (int position) {
-    Map.Entry<Integer, WeakReference<View>> view = viewMap.lowerEntry(position);
-    if(view == null || view.getValue() == null) return null;
-    return view.getValue().get();
+  public void remove(int position) {
+    viewMap.remove(position);
+    // Purge zombie entries left by GC while we're already mutating the map.
+    viewMap.values().removeIf(ref -> ref.get() == null);
   }
 
-  public WeakReference<View> put (int position, View view) {
-   return viewMap.put(position, new WeakReference<>(view));
+  /**
+   * Returns the nearest live view at a position strictly greater than {@code position},
+   * skipping any GC'd entries along the way.
+   */
+  public View getNext(int position) {
+    for (WeakReference<View> ref : viewMap.tailMap(position, false).values()) {
+      View v = ref.get();
+      if (v != null) return v;
+    }
+    return null;
   }
 
-  public View last () {
-    Map.Entry<Integer, WeakReference<View>> lastView = viewMap.lastEntry();
-    if(lastView == null || lastView.getValue() == null) return null;
-    return lastView.getValue().get();
+  /**
+   * Returns the nearest live view at a position strictly less than {@code position},
+   * skipping any GC'd entries along the way.
+   */
+  public View getPrev(int position) {
+    for (WeakReference<View> ref : viewMap.headMap(position, false).descendingMap().values()) {
+      View v = ref.get();
+      if (v != null) return v;
+    }
+    return null;
   }
 
-  public void remove (int position) {
-    this.viewMap.remove(position);
+  /** Returns the live view with the highest position, skipping any GC'd entries. */
+  public View last() {
+    for (WeakReference<View> ref : viewMap.descendingMap().values()) {
+      View v = ref.get();
+      if (v != null) return v;
+    }
+    return null;
   }
 
-  public View get (int position) {
-    WeakReference<View> viewRef = this.viewMap.get(position);
-    if(viewRef == null) return null;
-    return viewRef.get();
+  public boolean containsKey(int position) {
+    return viewMap.containsKey(position);
   }
 
-  public Set<Map.Entry<Integer, WeakReference<View>>> entrySet() {
-    return this.viewMap.entrySet();
+  /** Returns {@code true} only if there are no live (non-GC'd) views in the map. */
+  public boolean isEmpty() {
+    for (WeakReference<View> ref : viewMap.values()) {
+      if (ref.get() != null) return false;
+    }
+    return true;
   }
 
-  public boolean containsKey(int position) {
-    return this.viewMap.containsKey(position);
+  /** Visits every live entry in ascending position order. */
+  public void forEachLive(LiveEntryAction action) {
+    for (Map.Entry<Integer, WeakReference<View>> entry : viewMap.entrySet()) {
+      View v = entry.getValue().get();
+      if (v != null) action.run(entry.getKey(), v);
+    }
   }
 
-  public boolean isEmpty() {
-    return this.viewMap.isEmpty();
+  public interface LiveEntryAction {
+    void run(int position, View view);
   }
 }

package/android/src/main/java/com/a11yorder/utils/A11yHelper.java

@@ -6,102 +6,82 @@ import android.view.ViewGroup;
 import android.view.accessibility.AccessibilityEvent;
 import android.view.accessibility.AccessibilityManager;
 
+import androidx.annotation.NonNull;
 import androidx.annotation.Nullable;
 import androidx.core.view.ViewCompat;
 
 public class A11yHelper {
+
   public static boolean isAccessible(@Nullable View view) {
     return view != null && ViewCompat.isImportantForAccessibility(view);
   }
 
-  public static View findFirstAccessible(@Nullable ViewGroup viewGroup, boolean ignoreRoot) {
-    if (viewGroup == null) {
-      return null;
-    }
-
-    if (!ignoreRoot && isAccessible(viewGroup)) {
-      return viewGroup;
-    }
-
-    for (int i = 0; i < viewGroup.getChildCount(); i++) {
-      View child = viewGroup.getChildAt(i);
-      if (isAccessible(child)) {
-        return child;
-      }
+  public static boolean isFocused(@Nullable View view) {
+    return view != null && view.isAccessibilityFocused();
+  }
 
-      if (child instanceof ViewGroup) {
-        View accessibleChild = findFirstAccessible((ViewGroup) child, true);
-        if (accessibleChild != null) {
-          return accessibleChild;
-        }
+  public static void focus(@Nullable View view) {
+    if (view == null || isFocused(view)) return;
+    ChoreographerUtils.run(() -> {
+      if (!isFocused(view)) {
+        view.sendAccessibilityEvent(AccessibilityEvent.TYPE_VIEW_FOCUSED);
       }
-    }
+    });
+  }
 
-    return null;
+  public static boolean isA11yServiceEnabled(@NonNull Context context) {
+    AccessibilityManager accessibilityManager =
+      (AccessibilityManager) context.getSystemService(Context.ACCESSIBILITY_SERVICE);
+    return accessibilityManager != null
+      && accessibilityManager.isEnabled()
+      && accessibilityManager.isTouchExplorationEnabled();
   }
 
   public static View findFirstAccessible(@Nullable ViewGroup viewGroup) {
     return findFirstAccessible(viewGroup, false);
   }
 
-  public static boolean isFocused(@Nullable View view) {
-    if (view == null) return false;
-    return view.isAccessibilityFocused();
-  }
-
-  private static void baseFocus(@Nullable View view) {
-    if (view != null) {
-      view.sendAccessibilityEvent(AccessibilityEvent.TYPE_VIEW_FOCUSED);
-    }
-  }
+  public static View findFirstAccessible(@Nullable ViewGroup viewGroup, boolean ignoreRoot) {
+    if (viewGroup == null) return null;
 
-  public static void focus(@Nullable View view) {
-    if (view == null || isFocused(view)) return;
-    ChoreographerUtils.run(() -> baseFocus(view));
-  }
+    if (!ignoreRoot && isAccessible(viewGroup)) return viewGroup;
 
-  public static boolean isA11yServiceEnabled(Context context) {
-    AccessibilityManager accessibilityManager =
-      (AccessibilityManager) context.getSystemService(Context.ACCESSIBILITY_SERVICE);
+    for (int i = 0; i < viewGroup.getChildCount(); i++) {
+      View child = viewGroup.getChildAt(i);
+      if (isAccessible(child)) return child;
 
-    if (accessibilityManager == null) {
-      return false;
+      if (child instanceof ViewGroup) {
+        View accessibleChild = findFirstAccessible((ViewGroup) child, true);
+        if (accessibleChild != null) return accessibleChild;
+      }
     }
 
-    return accessibilityManager.isEnabled() && accessibilityManager.isTouchExplorationEnabled();
+    return null;
   }
 
-  public static View findFirstFocusable(@Nullable ViewGroup viewGroup, boolean ignoreRoot) {
-    if (viewGroup == null) {
-      return null;
-    }
+  public static View findFirstFocusable(@Nullable ViewGroup viewGroup) {
+    return findFirstFocusable(viewGroup, false);
+  }
 
-    if (!ignoreRoot && isKeyboardFocusable(viewGroup)) {
-      return viewGroup;
-    }
+  private static View findFirstFocusable(@Nullable ViewGroup viewGroup, boolean ignoreRoot) {
+    if (viewGroup == null) return null;
+
+    if (!ignoreRoot && isKeyboardFocusable(viewGroup)) return viewGroup;
 
     for (int i = 0; i < viewGroup.getChildCount(); i++) {
       View child = viewGroup.getChildAt(i);
-      if (isKeyboardFocusable(child)) {
-        return child;
-      }
+      if (isKeyboardFocusable(child)) return child;
 
       if (child instanceof ViewGroup) {
         View focusableChild = findFirstFocusable((ViewGroup) child, true);
-        if (focusableChild != null) {
-          return focusableChild;
-        }
+        if (focusableChild != null) return focusableChild;
       }
     }
 
     return null;
   }
 
-  public static View findFirstFocusable(@Nullable ViewGroup viewGroup) {
-    return findFirstFocusable(viewGroup, false);
-  }
-
-  private static boolean isKeyboardFocusable(View view) {
+  private static boolean isKeyboardFocusable(@NonNull View view) {
     return view.isFocusable() && view.getVisibility() == View.VISIBLE && view.isEnabled();
   }
 }

package/android/src/main/java/com/a11yorder/utils/ChoreographerUtils.java

@@ -1,34 +1,29 @@
 package com.a11yorder.utils;
 
 import android.view.Choreographer;
-import androidx.annotation.Nullable;
+
+import androidx.annotation.NonNull;
 
 public class ChoreographerUtils {
 
-  public static void run(@Nullable Runnable task) {
+  public static void run(@NonNull Runnable task) {
     runAfterFrames(2, task);
   }
-  public static void runAfterFrames(int frameCount, @Nullable Runnable task) {
-    if (frameCount <= 0 || task == null) {
-      return;
-    }
 
+  private static void runAfterFrames(int frameCount, @NonNull Runnable task) {
     Choreographer choreographer = Choreographer.getInstance();
 
-    Choreographer.FrameCallback frameCallback = new Choreographer.FrameCallback() {
+    choreographer.postFrameCallback(new Choreographer.FrameCallback() {
       private int frameCounter = frameCount;
 
       @Override
       public void doFrame(long frameTimeNanos) {
-        frameCounter--;
-        if (frameCounter <= 0) {
+        if (--frameCounter <= 0) {
           task.run();
         } else {
           choreographer.postFrameCallback(this);
         }
       }
-    };
-
-    choreographer.postFrameCallback(frameCallback);
+    });
   }
 }

package/android/src/main/java/com/a11yorder/utils/FragmentUtils.java

@@ -1,68 +1,28 @@
 package com.a11yorder.utils;
 
-import android.app.Activity;
 import android.view.View;
-import android.view.animation.Animation;
 
 import androidx.annotation.NonNull;
 import androidx.annotation.Nullable;
 import androidx.fragment.app.Fragment;
-import androidx.fragment.app.FragmentActivity;
 import androidx.fragment.app.FragmentManager;
+import androidx.lifecycle.DefaultLifecycleObserver;
+import androidx.lifecycle.LifecycleOwner;
 
 public class FragmentUtils {
 
-  public static void waitForAnimationEnd(@NonNull Animation animation, @NonNull Runnable onAnimationEnd) {
-    animation.setAnimationListener(new Animation.AnimationListener() {
+  public static void waitForFragmentResume(@NonNull Fragment fragment, @NonNull Runnable onReady) {
+    fragment.getLifecycle().addObserver(new DefaultLifecycleObserver() {
       @Override
-      public void onAnimationStart(Animation animation) {
-      }
-
-      @Override
-      public void onAnimationEnd(Animation animation) {
-        onAnimationEnd.run();
-      }
-
-      @Override
-      public void onAnimationRepeat(Animation animation) {
-      }
-    });
-  }
-
-  public static void waitForFragmentAnimation (@NonNull Fragment fragment, @NonNull Runnable onReady) {
-    View fragmentView = fragment.getView();
-    if (fragmentView != null) {
-      Animation fragmentAnimation = fragmentView.getAnimation();
-      if (fragmentAnimation != null) {
-        waitForAnimationEnd(fragmentAnimation, onReady);
-      } else {
+      public void onResume(@NonNull LifecycleOwner owner) {
+        owner.getLifecycle().removeObserver(this);
         onReady.run();
       }
-    }
-  }
-
-  public static void waitForFragment(Activity activity, Fragment current, @NonNull Runnable onReady) {
-    if (!(activity instanceof FragmentActivity)) {
-      return;
-    }
-
-    FragmentManager fragmentManager = ((FragmentActivity) activity).getSupportFragmentManager();
-    fragmentManager.registerFragmentLifecycleCallbacks(
-      new FragmentManager.FragmentLifecycleCallbacks() {
-        @Override
-        public void onFragmentResumed(@NonNull FragmentManager fm, @NonNull Fragment f) {
-          super.onFragmentResumed(fm, f);
-          if (f == current) {
-            waitForFragmentAnimation(f, onReady);
-            fragmentManager.unregisterFragmentLifecycleCallbacks(this); // Unregister to prevent future callbacks
-          }
-        }
-      }, false);
+    });
   }
 
   @Nullable
-  public static
-  Fragment findFragmentSafely(View view) {
+  public static Fragment findFragmentSafely(View view) {
     try {
       return FragmentManager.findFragment(view);
     } catch (Exception ignored) {

package/android/src/main/java/com/a11yorder/views/A11yIndexView/A11yIndexView.java

@@ -29,7 +29,7 @@ public class A11yIndexView extends ReactViewGroup {
   }
 
   public void setOrderKey(String orderKey) {
-    this.orderService.orderKey = orderKey;
+    this.orderService.setOrderKey(orderKey);
   }
 
   @Override

package/android/src/main/java/com/a11yorder/views/A11yLockView/A11yLockViewManager.java

@@ -35,4 +35,9 @@ public class A11yLockViewManager extends com.a11yorder.A11yLockViewManagerSpec<A
   public void setLockDisabled(A11yLockView view, boolean value) {
     view.setLockDisabled(value);
   }
+
+  @Override
+  public void setForceLock(A11yLockView view, boolean value) {
+    //stub
+  }
 }

package/android/src/main/java/com/a11yorder/views/A11yView/A11yView.java

@@ -64,7 +64,7 @@ public class A11yView extends A11yViewGroup implements A11yFocusProtocol {
 
     if (eventType == AccessibilityEvent.TYPE_VIEW_ACCESSIBILITY_FOCUSED && autoFocus && !hasBeenFocused) {
       hasBeenFocused = true;
-      a11yFocusDelegate.onAccessibilityEvent(child, event);
+      a11yFocusDelegate.onFocused();
     }
 
     if (eventType == AccessibilityEvent.TYPE_VIEW_ACCESSIBILITY_FOCUSED && isSubChild) {

package/android/src/oldarch/A11yLockViewManagerSpec.java

@@ -9,5 +9,7 @@ public abstract class A11yLockViewManagerSpec<T extends A11yLockView> extends Re
   public abstract void setContainerKey(T view, String value);
 
   public abstract void setLockDisabled(T view, boolean value);
+
+  public abstract void setForceLock(A11yLockView view, boolean value);
 }
 

package/ios/delegates/RNAOViewItemDelegate/RNAOViewItemDelegate.mm

@@ -59,7 +59,7 @@
 
 - (void)clear {
   if(!_delegate) return;
-  [_delegate onFocusItemLinked: _linkView];
+  [_delegate onFocusItemRemoved: _linkView];
   _isLinked = false;
   _linkView = nil;
 }

package/ios/extensions/RCTModalHostViewComponentView+RNAOA11yOrder.mm

@@ -7,6 +7,7 @@
 
 #import <Foundation/Foundation.h>
 #import "RNAOSwizzleInstanceMethod.h"
+#import "RNAOSwizzleInstall.h"
 #import <objc/runtime.h>
 #import "RNAOA11yAnnounceService.h"
 #import "RCTModalHostViewComponentView+RNAOA11yOrder.h"
@@ -16,20 +17,19 @@
 
 @implementation RCTModalHostViewComponentView (RNAOA11yOrder)
 
-+ (void)load
-{
-    static dispatch_once_t once_token;
-
-    dispatch_once(&once_token, ^{
-      RNAOSwizzleInstanceMethod([self class],
-                @selector(dismissViewController:animated:completion:),
-                @selector(rnaoDismissViewController:animated:completion:));
-      RNAOSwizzleInstanceMethod([self class],
+static void RNAORegisterModalPresentationSwizzles(void) {
+    Class cls = objc_getClass("RCTModalHostViewComponentView");
+    if (!cls) return;
+    RNAOSwizzleInstanceMethod(cls,
+              @selector(dismissViewController:animated:completion:),
+              @selector(rnaoDismissViewController:animated:completion:));
+    RNAOSwizzleInstanceMethod(cls,
           @selector(presentViewController:animated:completion:),
           @selector(rnaoPresentViewController:animated:completion:));
-    });
 }
 
+RNAO_INSTALL_SWIZZLES(RNAORegisterModalPresentationSwizzles)
+
 - (void)rnaoPresentViewController:(UIViewController *)modalViewController
                         animated:(BOOL)animated
                       completion:(void (^)(void))completion
@@ -52,19 +52,19 @@
 
 @implementation RCTModalHostView (RNAOA11yOrder)
 
-+ (void)load
-{
-    static dispatch_once_t once_token;
-    dispatch_once(&once_token, ^{
-        RNAOSwizzleInstanceMethod([self class],
-            @selector(ensurePresentedOnlyIfNeeded),
-            @selector(rnao_ensurePresentedOnlyIfNeeded));
-        RNAOSwizzleInstanceMethod([self class],
-            @selector(dismissModalViewController),
-            @selector(rnao_dismissModalViewController));
-    });
+static void RNAORegisterModalPresentationSwizzles(void) {
+    Class cls = objc_getClass("RCTModalHostView");
+    if (!cls) return;
+    RNAOSwizzleInstanceMethod(cls,
+        @selector(ensurePresentedOnlyIfNeeded),
+        @selector(rnao_ensurePresentedOnlyIfNeeded));
+    RNAOSwizzleInstanceMethod(cls,
+        @selector(dismissModalViewController),
+        @selector(rnao_dismissModalViewController));
 }
 
+RNAO_INSTALL_SWIZZLES(RNAORegisterModalPresentationSwizzles)
+
 - (void)rnao_ensurePresentedOnlyIfNeeded
 {
     [self rnao_ensurePresentedOnlyIfNeeded];

package/ios/extensions/UIView+RNAOA11yOrder.mm

@@ -9,6 +9,7 @@
 
 #import "UIView+RNAOA11yOrder.h"
 #import "RNAOSwizzleInstanceMethod.h"
+#import "RNAOSwizzleInstall.h"
 #import <objc/runtime.h>
 
 #ifdef RCT_NEW_ARCH_ENABLED
@@ -55,28 +56,24 @@ static char kRNAOScreenReaderFocusDelegate;
 }
 
 
-+ (void)load {
-  static dispatch_once_t onceToken;
-  dispatch_once(&onceToken, ^{
-    #ifdef RCT_NEW_ARCH_ENABLED
-      Class swizzleClass = [RCTViewComponentView class];
-    #else
-      Class swizzleClass = [RCTView class];
-    #endif
-
-    RNAOSwizzleInstanceMethod(
-                              swizzleClass,
-                              @selector(accessibilityElementDidBecomeFocused),
-                              @selector(rnao_accessibilityElementDidBecomeFocused)
-                              );
-    RNAOSwizzleInstanceMethod(
-                              swizzleClass,
-                              @selector(accessibilityElementDidLoseFocus),
-                              @selector(rnao_accessibilityElementDidLoseFocus)
-                              );
-  });
+static void RNAORegisterViewFocusSwizzles(void) {
+  #ifdef RCT_NEW_ARCH_ENABLED
+    Class swizzleClass = objc_getClass("RCTViewComponentView");
+  #else
+    Class swizzleClass = objc_getClass("RCTView");
+  #endif
+  if (!swizzleClass) return;
+
+  RNAOSwizzleInstanceMethod(swizzleClass,
+                            @selector(accessibilityElementDidBecomeFocused),
+                            @selector(rnao_accessibilityElementDidBecomeFocused));
+  RNAOSwizzleInstanceMethod(swizzleClass,
+                            @selector(accessibilityElementDidLoseFocus),
+                            @selector(rnao_accessibilityElementDidLoseFocus));
 }
 
+RNAO_INSTALL_SWIZZLES(RNAORegisterViewFocusSwizzles)
+
 - (void)rnao_accessibilityElementDidBecomeFocused {
   [self rnao_accessibilityElementDidBecomeFocused];
   [self trigerScreenReaderFocusDelegate: true];

package/ios/extensions/UIViewController+RNAOA11yOrder.mm

@@ -9,6 +9,7 @@
 
 #import "UIViewController+RNAOA11yOrder.h"
 #import "RNAOSwizzleInstanceMethod.h"
+#import "RNAOSwizzleInstall.h"
 #import "RNAOA11yAnnounceService.h"
 #import <objc/runtime.h>
 
@@ -34,16 +35,15 @@ static char kRnaoFocusRestoreKey;
     return [objc_getAssociatedObject(self, &kRnaoFocusRestoreKey) boolValue];
 }
 
-+ (void)load
-{
-    static dispatch_once_t once_token;
-
-    dispatch_once(&once_token, ^{
-      RNAOSwizzleInstanceMethod([self class], @selector(viewDidAppear:), @selector(rnaoViewDidAppear:));
-      RNAOSwizzleInstanceMethod([self class], @selector(viewWillDisappear:), @selector(rnaoViewWillDisappear:));
-    });
+static void RNAORegisterViewControllerSwizzles(void) {
+    Class cls = objc_getClass("UIViewController");
+    if (!cls) return;
+    RNAOSwizzleInstanceMethod(cls, @selector(viewDidAppear:), @selector(rnaoViewDidAppear:));
+    RNAOSwizzleInstanceMethod(cls, @selector(viewWillDisappear:), @selector(rnaoViewWillDisappear:));
 }
 
+RNAO_INSTALL_SWIZZLES(RNAORegisterViewControllerSwizzles);
+
 
 - (void)saveAccessibilityFocusedView
 {

package/ios/helpers/RNAOSwizzleInstall.h

@@ -0,0 +1,30 @@
+//
+//  RNAOSwizzleInstall.h
+//  react-native-a11y-order
+//
+//  Created by Artur Kalach on 03/05/2026.
+//
+
+#ifndef RNAOSwizzleInstall_h
+#define RNAOSwizzleInstall_h
+
+#define RNAO_CONCAT_(a, b) a##b
+#define RNAO_CONCAT(a, b)  RNAO_CONCAT_(a, b)
+
+#ifdef RCT_DYNAMIC_FRAMEWORKS
+
+#define RNAO_INSTALL_SWIZZLES(registerFn)                                    \
+  __attribute__((constructor))                                               \
+  static void RNAO_CONCAT(RNAOInstall_, registerFn)(void) { registerFn(); }
+
+#else
+
+#define RNAO_INSTALL_SWIZZLES(registerFn)                                    \
+  +(void)load {                                                              \
+    static dispatch_once_t RNAO_CONCAT(once_, registerFn);                  \
+    dispatch_once(&RNAO_CONCAT(once_, registerFn), ^{ registerFn(); });     \
+  }
+
+#endif
+
+#endif /* RNAOSwizzleInstall_h */