@rnmapbox/maps 10.1.0-beta.2 → 10.1.0-beta.21

package/ios/RNMBX/RNMBXVectorSourceComponentView.mm

@@ -0,0 +1,139 @@
+#ifdef RCT_NEW_ARCH_ENABLED
+
+#import "RNMBXVectorSourceComponentView.h"
+#import "RNMBXFabricHelpers.h"
+
+#import <React/RCTConversions.h>
+#import <React/RCTFabricComponentsPlugins.h>
+
+#import <react/renderer/components/rnmapbox_maps_specs/ComponentDescriptors.h>
+#import <react/renderer/components/rnmapbox_maps_specs/EventEmitters.h>
+#import <react/renderer/components/rnmapbox_maps_specs/Props.h>
+#import <react/renderer/components/rnmapbox_maps_specs/RCTComponentViewHelpers.h>
+
+using namespace facebook::react;
+
+@interface RNMBXVectorSourceComponentView () <RCTRNMBXVectorSourceViewProtocol>
+@end
+
+@implementation RNMBXVectorSourceComponentView {
+    RNMBXVectorSource *_view;
+}
+
+
+- (instancetype)initWithFrame:(CGRect)frame
+{
+  if (self = [super initWithFrame:frame]) {
+    static const auto defaultProps = std::make_shared<const RNMBXVectorSourceProps>();
+    _props = defaultProps;
+    [self prepareView];
+  }
+
+  return self;
+}
+
+- (void)prepareView
+{
+    _view = [[RNMBXVectorSource alloc] init];
+      
+    // capture weak self reference to prevent retain cycle
+    __weak __typeof__(self) weakSelf = self;
+
+    [_view setOnPress:^(NSDictionary* event) {
+        __typeof__(self) strongSelf = weakSelf;
+
+        if (strongSelf != nullptr && strongSelf->_eventEmitter != nullptr) {
+            const auto [type, json] = RNMBXStringifyEventData(event);
+            std::dynamic_pointer_cast<const facebook::react::RNMBXVectorSourceEventEmitter>(strongSelf->_eventEmitter)->onMapboxVectorSourcePress({type, json});
+          }
+    }];
+
+    self.contentView = _view;
+}
+
+- (void)prepareForRecycle
+{
+  [super prepareForRecycle];
+  [self prepareView];
+}
+
+- (void)mountChildComponentView:(UIView<RCTComponentViewProtocol> *)childComponentView index:(NSInteger)index
+{
+    if ([childComponentView isKindOfClass:[RCTViewComponentView class]]) {
+        [_view insertReactSubviewInternal:((RCTViewComponentView *)childComponentView).contentView at:index];
+    } else {
+        RCTLogError(@"Tried to add view that is not RCTViewComponentView: %@", childComponentView);
+    }
+}
+
+- (void)unmountChildComponentView:(UIView<RCTComponentViewProtocol> *)childComponentView index:(NSInteger)index
+{
+    if ([childComponentView isKindOfClass:[RCTViewComponentView class]]) {
+        [_view removeReactSubviewInternal:((RCTViewComponentView *)childComponentView).contentView];
+    } else {
+        RCTLogError(@"Tried to remove view that is not RCTViewComponentView: %@", childComponentView);
+    }
+}
+
+#pragma mark - RCTComponentViewProtocol
+
++ (ComponentDescriptorProvider)componentDescriptorProvider
+{
+  return concreteComponentDescriptorProvider<RNMBXVectorSourceComponentDescriptor>();
+}
+
+- (void)updateProps:(const Props::Shared &)props oldProps:(const Props::Shared &)oldProps
+{
+  const auto &newProps = static_cast<const RNMBXVectorSourceProps &>(*props);
+    id idx = RNMBXConvertFollyDynamicToId(newProps.id);
+    if (idx != nil) {
+        _view.id = idx;
+    }
+    id existing = RNMBXConvertFollyDynamicToId(newProps.existing);
+    if (existing != nil) {
+        _view.existing = existing;
+    }
+    id url = RNMBXConvertFollyDynamicToId(newProps.url);
+    if (url != nil) {
+        _view.url = url;
+    }
+    id tileUrlTemplates = RNMBXConvertFollyDynamicToId(newProps.tileUrlTemplates);
+    if (tileUrlTemplates != nil) {
+        _view.tileUrlTemplates = tileUrlTemplates;
+    }
+    id minZoomLevel = RNMBXConvertFollyDynamicToId(newProps.minZoomLevel);
+    if (minZoomLevel != nil) {
+        _view.minZoomLevel = minZoomLevel;
+    }
+    id maxZoomLevel = RNMBXConvertFollyDynamicToId(newProps.maxZoomLevel);
+    if (maxZoomLevel != nil) {
+        _view.maxZoomLevel = maxZoomLevel;
+    }
+    id tms = RNMBXConvertFollyDynamicToId(newProps.tms);
+    if (tms != nil) {
+        _view.tms = tms;
+    }
+    id attribution = RNMBXConvertFollyDynamicToId(newProps.attribution);
+    if (attribution != nil) {
+        _view.attribution = attribution;
+    }
+    id hasPressListener = RNMBXConvertFollyDynamicToId(newProps.hasPressListener);
+    if (hasPressListener != nil) {
+        _view.hasPressListener = hasPressListener;
+    }
+    id hitbox = RNMBXConvertFollyDynamicToId(newProps.hitbox);
+    if (hitbox != nil) {
+        _view.hitbox = hitbox;
+    }
+    
+  [super updateProps:props oldProps:oldProps];
+}
+
+@end
+
+Class<RCTComponentViewProtocol> RNMBXVectorSourceCls(void)
+{
+  return RNMBXVectorSourceComponentView.class;
+}
+
+#endif // RCT_NEW_ARCH_ENABLED

package/ios/RNMBX/RNMBXVectorSourceViewManager.m

@@ -0,0 +1,22 @@
+#import <React/RCTBridgeModule.h>
+#import <React/RCTViewManager.h>
+
+@interface RCT_EXTERN_REMAP_MODULE(RNMBXVectorSource, RNMBXVectorSourceViewManager, RCTViewManager)
+
+RCT_EXPORT_VIEW_PROPERTY(id, NSString)
+RCT_EXPORT_VIEW_PROPERTY(existing, BOOL)
+RCT_EXPORT_VIEW_PROPERTY(url, NSString)
+
+RCT_EXPORT_VIEW_PROPERTY(tileUrlTemplates, NSArray)
+
+RCT_EXPORT_VIEW_PROPERTY(attribution, NSString)
+
+RCT_EXPORT_VIEW_PROPERTY(minZoomLevel, NSNumber)
+RCT_EXPORT_VIEW_PROPERTY(maxZoomLevel, NSNumber)
+
+RCT_EXPORT_VIEW_PROPERTY(tms, BOOL)
+RCT_EXPORT_VIEW_PROPERTY(hasPressListener, BOOL)
+RCT_EXPORT_VIEW_PROPERTY(hitbox, NSDictionary)
+RCT_REMAP_VIEW_PROPERTY(onMapboxVectorSourcePress, onPress, RCTBubblingEventBlock)
+
+@end

package/ios/RNMBX/RNMBXVectorSourceViewManager.swift

@@ -0,0 +1,11 @@
+@objc(RNMBXVectorSourceViewManager)
+class RNMBXVectorSourceViewManager: RCTViewManager {
+  @objc
+  override static func requiresMainQueueSetup() -> Bool {
+    return true
+  }
+ 
+  @objc override func view() -> UIView {
+    return RNMBXVectorSource()
+  }
+}

package/ios/RNMBX/RNMBXViewport.swift

@@ -0,0 +1,293 @@
+@_spi(Experimental) import MapboxMaps
+
+#if RNMBX_11
+#else
+typealias ViewportManager = Viewport
+#endif
+
+@objc(RNMBXViewport)
+open class RNMBXViewport : UIView, RNMBXMapComponent, ViewportStatusObserver {
+  var mapView: MapView? = nil
+    
+  // MARK: React properties
+  @objc
+  public var onStatusChanged: RCTBubblingEventBlock? = nil
+  
+  @objc
+  public var hasStatusChanged: Bool = false {
+    didSet {
+      if let mapView = mapView {
+        applyHasStatusChanged(mapView: mapView)
+      }
+    }
+  }
+  
+  func applyHasStatusChanged(mapView: MapView) {
+    if (hasStatusChanged) {
+      mapView.viewport.addStatusObserver(self)
+    } else {
+      mapView.viewport.removeStatusObserver(self)
+    }
+  }
+  
+  public func viewportStatusDidChange(from fromStatus: ViewportStatus,
+                               to toStatus: ViewportStatus,
+                               reason: ViewportStatusChangeReason)
+  {
+    onStatusChanged?([
+      "type": "statuschanged",
+      "payload": [
+        "from": statusToMap(fromStatus),
+        "to": statusToMap(toStatus),
+        "reason": reasonToString(reason)
+      ]])
+  }
+  
+  @objc
+  public var transitionsToIdleUponUserInteraction: NSNumber? = nil {
+    didSet {
+      if let mapView = mapView {
+        apply(mapView: mapView)
+      }
+    }
+  }
+  
+  func waitForStyleLoad() -> Bool {
+    true
+  }
+
+  func addToMap(_ map: RNMBXMapView, style: Style) {
+    mapView = map.mapView
+    applyHasStatusChanged(mapView: mapView!)
+    apply(mapView: map.mapView)
+  }
+
+  func removeFromMap(_ map: RNMBXMapView, reason: RemovalReason) -> Bool {
+    if (hasStatusChanged) {
+      map.mapView.viewport.removeStatusObserver(self)
+    }
+    self.mapView = nil
+    return true
+  }
+
+  func apply(mapView: MapView) {
+    if let value = transitionsToIdleUponUserInteraction {
+      var origOptions = mapView.viewport.options
+      origOptions.transitionsToIdleUponUserInteraction = value.boolValue
+      mapView.viewport.options = origOptions
+    }
+  }
+  
+  func reasonToString(_ reason: ViewportStatusChangeReason) -> String {
+    switch (reason) {
+    case .idleRequested:
+      return "IdleRequested"
+    case .transitionFailed:
+      return "TransitionFailed"
+    case .transitionStarted:
+      return "TransitionStarted"
+    case .transitionSucceeded:
+      return "TransitionSucceeded"
+    case .userInteraction:
+      return "UserInteraction"
+    default:
+      return "Unknown:\(reason)"
+    }
+  }
+
+  func stateToMap(_ state: ViewportState) -> [String: Any] {
+    if let state = state as? FollowPuckViewportState {
+      return ["kind": "followPuck"]
+    } else if let state = state as? OverviewViewportState {
+      return ["kind": "overview"]
+    } else {
+      return ["kind": "custom", "impl": "\(type(of: state))"]
+    }
+  }
+  
+  func transitionToMap(_ transition: ViewportTransition) -> [String:Any] {
+    if let transition = transition as? DefaultViewportTransition {
+      return ["kind": "default", "maxDurationMs": transition.options.maxDuration * 1000.0] as [String:Any]
+    } else if let transition = transition as? ImmediateViewportTransition {
+      return ["kind": "immediate"]
+    } else {
+      return ["kind": "unknown", "impl": "\(type(of: transition))"]
+    }
+  }
+  
+  func statusToMap(_ status: ViewportStatus) -> [String: Any] {
+    switch (status) {
+    case .idle:
+      return ["kind": "idle"]
+    case .state(let state):
+      return ["kind": "state",
+       "state": stateToMap(state)
+      ] as [String : Any]
+    case .transition(let transition, let toState):
+      return ["kind": "transition",
+       "transition": transitionToMap(transition),
+       "toState": stateToMap(toState)
+      ] as [String:Any]
+    }
+  }
+  
+  func getState() -> [String:Any] {
+    guard let mapView = mapView else {
+      Logger.log(level:.error, message: "mapView is null in RNMBXViewport.getState")
+      return [:]
+    }
+    return statusToMap(mapView.viewport.status)
+  }
+  
+  func idle() {
+    guard let mapView = mapView else {
+      Logger.log(level:.error, message: "mapView is null in RNMBXViewport.idle")
+      return
+    }
+    mapView.viewport.idle()
+  }
+  
+  func toState(_ viewport: ViewportManager?,_ state: [String:Any]) -> ViewportState? {
+    guard let viewport = viewport else {
+      Logger.log(level:.error, message: "no viewport")
+      return nil
+    }
+    guard let kind = state["kind"] as? String else {
+      Logger.log(level:.error, message: "no kind found in state")
+      return nil
+    }
+    
+    switch (kind) {
+    case "followPuck":
+      return viewport.makeFollowPuckViewportState(options:
+        parseFollowViewportOptions(state)
+      )
+//  case "overview":
+//    viewport.makeOverviewViewportState(options: )
+    default:
+      Logger.log(level:.error, message: "unexpected state kind: \(kind)")
+      return nil
+    }
+  }
+  
+  func parseFollowViewportOptions(_ state: [String:Any]) -> FollowPuckViewportStateOptions {
+    var result = FollowPuckViewportStateOptions()
+    if let options = state["options"] as? [String:Any] {
+      if let zoom = options["zoom"] as? String, (zoom == "keep") {
+        result.zoom = nil
+      } else if let zoom = options["zoom"] as? Double {
+        result.zoom = zoom
+      } else if options["zoom"] != nil {
+        Logger.log(level: .error, message: "parseFollowViewportOptions expected zoom to be number or 'keep', but was \(options["zoom"])")
+      }
+      
+      if let pitch = options["pitch"] as? String, (pitch == "pitch") {
+        result.pitch = nil
+      } else if let pitch = options["pitch"] as? Double {
+        result.pitch = pitch
+      } else if options["pitch"] != nil{
+        Logger.log(level: .error, message: "parseFollowViewportOptions expected pitch to be number or 'keep', but was \(options["pitch"])")
+      }
+      
+      if let bearing = options["bearing"] as? String {
+        switch (bearing) {
+        case "keep":
+          result.bearing = nil
+        case "course":
+          result.bearing = .course
+        case "heading":
+          result.bearing = .heading
+        default:
+          Logger.log(level: .error, message: "bearing expected to be a number or 'keep' or 'course' or 'heading', but was \(options["bearing"])")
+        }
+      } else if let bearing = options["bearing"] as? NSNumber {
+        result.bearing = .constant(bearing.doubleValue)
+      } else if options["bearing"] != nil {
+        Logger.log(level: .error, message: "bearing expected to be a number or 'keep' or 'course' or 'heading', but was \(options["bearing"])")
+      }
+      
+      if let padding = options["padding"] as? String, (padding == "keep") {
+        result.padding = nil
+      } else if let padding = options["padding"] as? [String: NSNumber] {
+        result.padding = toPadding(padding)
+      } else if (options["padding"] != nil) {
+        Logger.log(level: .error, message: "padding expected to be an object or 'keep' or but was \(options["bearing"])")
+      }
+    }
+    
+    return result
+  }
+  
+  func toTransition(_ from: [String: Any], _ viewport: ViewportManager?) -> ViewportTransition? {
+    guard let viewport = viewport else {
+      Logger.log(level:.error, message: "no viewport")
+      return nil
+    }
+    guard let kind = from["kind"] as? String else {
+      Logger.log(level:.error, message: "no kind found in state")
+      return nil
+    }
+    
+    switch (kind) {
+    case "immediate":
+      return viewport.makeImmediateViewportTransition()
+    case "default":
+      var options = DefaultViewportTransitionOptions()
+      if let maxDurationMs = from["maxDurationMs"] as? NSNumber {
+        options.maxDuration = maxDurationMs.doubleValue/1000.0
+      }
+      return viewport.makeDefaultViewportTransition(
+        options: options
+      )
+        
+    default:
+      Logger.log(level:.error, message: "unexpected transition kind: \(kind)")
+      return nil
+    }
+  }
+  
+  func transitionTo(
+    state: [String: Any],
+    transition: [String: Any],
+    resolve: @escaping (NSNumber) -> Void
+  ) {
+    guard let mapView = mapView else {
+      Logger.log(level:.error, message: "mapView is null in RNMBXViewport.transitionTo")
+      return
+    }
+    guard let state = toState(mapView.viewport, state) else {
+      Logger.log(level:.error, message: "unable to parse toState in RNMBXViewport.transitionTo")
+      return
+    }
+    guard let transition = toTransition(transition, mapView.viewport) else {
+      Logger.log(level:.error, message: "unable to parse transition in RNMBXViewport.transitionTo")
+      return
+    }
+    mapView.viewport.transition(to: state, transition: transition) { completed in
+      resolve(NSNumber(booleanLiteral: completed))
+    }
+  }
+}
+
+
+func toPadding(_ value: [String: NSNumber]) -> UIEdgeInsets {
+  var result = UIEdgeInsets()
+  
+  if let top = value["top"] as? NSNumber {
+    result.top = top.CGFloat
+  }
+  
+  if let bottom = value["bottom"] as? NSNumber {
+    result.bottom = bottom.CGFloat
+  }
+  
+  if let left = value["left"] as? NSNumber {
+    result.left = left.CGFloat
+  }
+  
+  if let right = value["right"] as? NSNumber {
+    result.right = right.CGFloat
+  }
+  
+  return result
+}

package/ios/RNMBX/RNMBXViewportComponentView.h

@@ -0,0 +1,17 @@
+#ifdef RCT_NEW_ARCH_ENABLED
+
+#import <UIKit/UIKit.h>
+
+#import <React/RCTUIManager.h>
+#import <React/RCTViewComponentView.h>
+
+NS_ASSUME_NONNULL_BEGIN
+
+
+@interface RNMBXViewportComponentView : RCTViewComponentView
+
+@end
+
+NS_ASSUME_NONNULL_END
+
+#endif // RCT_NEW_ARCH_ENABLED

package/ios/RNMBX/RNMBXViewportComponentView.mm

@@ -0,0 +1,119 @@
+#ifdef RCT_NEW_ARCH_ENABLED
+
+#import "RNMBXViewportComponentView.h"
+
+#import <React/RCTConversions.h>
+#import <React/RCTFabricComponentsPlugins.h>
+
+#import <react/renderer/components/rnmapbox_maps_specs/ComponentDescriptors.h>
+#import <react/renderer/components/rnmapbox_maps_specs/EventEmitters.h>
+#import <react/renderer/components/rnmapbox_maps_specs/Props.h>
+#import <react/renderer/components/rnmapbox_maps_specs/RCTComponentViewHelpers.h>
+
+#import "rnmapbox_maps-Swift.pre.h"
+
+#import "RCTFollyConvert.h"
+
+
+// TODO: use generated RNMBXViewportEventEmitter, but need 0.73+ for dynamic support
+class RNMBXViewportEventEmitter : public facebook::react::ViewEventEmitter {
+ public:
+  using facebook::react::ViewEventEmitter::ViewEventEmitter;
+
+  struct OnStatusChanged {
+    std::string type;
+    folly::dynamic payload;
+  };
+  void onStatusChanged(OnStatusChanged $event) const {
+    dispatchEvent("statusChanged", [$event=std::move($event)](facebook::jsi::Runtime &runtime) {
+      auto $payload = facebook::jsi::Object(runtime);
+      $payload.setProperty(runtime, "type", $event.type);
+      $payload.setProperty(runtime, "payload", facebook::jsi::valueFromDynamic(runtime, $event.payload));
+      return $payload;
+    });
+  }
+};
+
+using namespace facebook::react;
+
+NSNumber* convertDynamicToOptional_boolean(const folly::dynamic &dyn, NSString* propertyName) {
+  switch (dyn.type()) {
+    case folly::dynamic::NULLT:
+      return NULL;
+    case folly::dynamic::BOOL:
+      return [NSNumber numberWithBool:dyn.getBool()];
+    default:
+      std::stringstream ss;
+      ss << dyn;
+      [RNMBXLogger error:[NSString stringWithFormat:@"Property %@ expected to be a boolean or nil but was: $d",
+                          propertyName,
+                          ss.str().c_str()
+                         ]];
+  }
+}
+
+@implementation RNMBXViewportComponentView {
+    RNMBXViewport *_view;
+}
+
+- (instancetype)initWithFrame:(CGRect)frame
+{
+  if (self = [super initWithFrame:frame]) {
+    static const auto defaultProps = std::make_shared<const RNMBXViewportProps>();
+    _props = defaultProps;
+    _view = [[RNMBXViewport alloc] init];
+    [self prepareView];
+    
+    self.contentView = _view;
+  }
+  
+  return self;
+}
+
+- (void)prepareView
+{
+  __weak __typeof__(self) weakSelf = self;
+
+  [_view setOnStatusChanged:^(NSDictionary* event) {
+    __typeof__(self) strongSelf = weakSelf;
+    
+    if (strongSelf != nullptr && strongSelf->_eventEmitter != nullptr) {
+      auto type = std::string([[event objectForKey:@"type"] UTF8String]);
+      auto payload = convertIdToFollyDynamic([event objectForKey:@"payload"]);
+      ::RNMBXViewportEventEmitter::OnStatusChanged event = {type, payload};
+      std::reinterpret_pointer_cast<const ::RNMBXViewportEventEmitter>(strongSelf->_eventEmitter)->onStatusChanged(event);
+    }
+  }];
+}
+
+
+#pragma mark - RCTComponentViewProtocol
+
++ (ComponentDescriptorProvider)componentDescriptorProvider
+{
+  return concreteComponentDescriptorProvider<RNMBXViewportComponentDescriptor>();
+}
+
+- (void)updateProps:(const Props::Shared &)props oldProps:(const Props::Shared &)oldProps
+{
+  const auto &oldViewProps = static_cast<const RNMBXViewportProps &>(*oldProps);
+  const auto &newViewProps = static_cast<const RNMBXViewportProps &>(*props);
+
+  if (!oldProps.get() || oldViewProps.transitionsToIdleUponUserInteraction != newViewProps.transitionsToIdleUponUserInteraction) {
+    _view.transitionsToIdleUponUserInteraction = convertDynamicToOptional_boolean(newViewProps.transitionsToIdleUponUserInteraction, @"transitionsToIdleUponUserInteraction");
+  }
+  if (!oldProps.get() ||
+      oldViewProps.hasStatusChanged !=
+      newViewProps.hasStatusChanged) {
+    _view.hasStatusChanged = newViewProps.hasStatusChanged;
+  }
+  [super updateProps:props oldProps:oldProps];
+}
+@end
+
+Class<RCTComponentViewProtocol> RNMBXViewportCls(void)
+{
+  return RNMBXViewportComponentView.class;
+}
+
+#endif // RCT_NEW_ARCH_ENABLED

package/ios/RNMBX/RNMBXViewportManager.m

@@ -0,0 +1,12 @@
+#import <React/RCTBridgeModule.h>
+#import <React/RCTViewManager.h>
+
+@interface RCT_EXTERN_REMAP_MODULE(RNMBXViewport, RNMBXViewportManager, RCTViewManager)
+
+RCT_EXPORT_VIEW_PROPERTY(transitionsToIdleUponUserInteraction, NSNumber)
+
+RCT_EXPORT_VIEW_PROPERTY(hasStatusChanged, BOOL)
+
+RCT_EXPORT_VIEW_PROPERTY(onStatusChanged, RCTBubblingEventBlock)
+
+@end

package/ios/RNMBX/RNMBXViewportManager.swift

@@ -0,0 +1,38 @@
+@objc(RNMBXViewportManager)
+public class RNMBXViewportManager : RCTViewManager {
+  @objc
+  public override static func requiresMainQueueSetup() -> Bool {
+    return true
+  }
+
+  public override func view() -> UIView! {
+    let layer = RNMBXViewport()
+    return layer
+  }
+  
+  @objc public static func getState(
+      _ view: RNMBXViewport,
+      resolve: @escaping RCTPromiseResolveBlock,
+      reject: @escaping RCTPromiseRejectBlock) {
+        resolve(view.getState())
+  }
+  
+  @objc public static func idle(
+    _ view: RNMBXViewport,
+    resolve: @escaping RCTPromiseResolveBlock,
+    reject: @escaping RCTPromiseRejectBlock) {
+      resolve(view.idle())
+    }
+      
+  @objc public static func transitionTo(
+    _ view: RNMBXViewport,
+    state: [String: Any],
+    transition: [String: Any],
+    resolve: @escaping RCTPromiseResolveBlock,
+    reject: @escaping RCTPromiseRejectBlock
+  ) {
+    view.transitionTo(state: state, transition: transition) { finished in
+      resolve(finished)
+    }
+  }
+}

package/ios/RNMBX/RNMBXViewportModule.h

@@ -0,0 +1,18 @@
+#import <Foundation/Foundation.h>
+#import <UIKit/UIKit.h>
+
+#ifdef RCT_NEW_ARCH_ENABLED
+#import "rnmapbox_maps_specs.h"
+#else
+#import <React/RCTBridge.h>
+#endif
+
+@interface RNMBXViewportModule : NSObject
+#ifdef RCT_NEW_ARCH_ENABLED
+<NativeRNMBXViewportModuleSpec>
+#else
+<RCTBridgeModule>
+#endif
+
+@end
+