@rnmapbox/maps 10.1.0 → 10.1.1

package/ios/RNMBX/RNMBXStyleValue.swift

@@ -348,9 +348,7 @@ class RNMBXStyleValue {
       return .constant(valueObj.map { $0.doubleValue })
     } else {
       do {
-        let data = try JSONSerialization.data(withJSONObject: valueObj, options: .prettyPrinted)
-        let decodedExpression = try JSONDecoder().decode(Expression.self, from: data)
-        return .expression(decodedExpression)
+        return .expression(try _toExpressions(valueObj))
       } catch {
         Logger.log(level: .error, message: "Invalid value for array number: \(value) error: \(error) setting dummy value")
         return .constant([1.0,1.0])
@@ -358,6 +356,39 @@ class RNMBXStyleValue {
     }
   }
   
+  private func _toExpressions(_ valueObj: Any) throws -> Expression {
+    if let valueObj = valueObj as? NSNumber {
+      throw RNMBXError.parseError("valueObj is a single number and cannot be converted to expressions")
+    }
+
+    let data = try JSONSerialization.data(withJSONObject: valueObj, options: .prettyPrinted)
+    let decodedExpression = try JSONDecoder().decode(Expression.self, from: data)
+    return decodedExpression
+  }
+  
+  func mglStyleValueString() -> Value<String> {
+    if let value = value as? Dictionary<String,Any> {
+      let value = RNMBXStyleValue.convert(value["stylevalue"] as! [String:Any])
+        if let value = value as? String {
+            return Value.constant(value)
+        } else if let value = value as? [Any] {
+            if let parsedExpression = (logged("mglStyleValueEnum: failed to parse expression") {
+                try parseExpression(value)
+            }) {
+                return .expression(parsedExpression)
+            } else {
+                return Value.constant(value[0] as! String)
+            }
+        } else {
+            Logger.log(level: .error, message:"Invalid value for string (nor string, not array): \(value) returning something")
+            return Value.constant("")
+        }
+    } else {
+      Logger.log(level: .error, message:"Invalid value for enum: \(value) returning something")
+      return Value.constant("")
+    }
+  }
+  
   func mglStyleValueArrayString() -> Value<[String]> {
     guard let value = value as? Dictionary<String,Any> else {
       Logger.log(level: .error, message: "Invalid value for array of strings: \(value)")
@@ -525,7 +556,28 @@ class RNMBXStyleValue {
   }
   
   func mglStyleValueArrayTextVariableAnchor() -> Value<[TextAnchor]> {
-    return Value.constant([.left])
+    guard let value = value as? Dictionary<String,Any> else {
+      Logger.log(level: .error, message: "Invalid value for array of TextAnchor: \(value)")
+      return .constant([.left])
+    }
+    let valueObj = RNMBXStyleValue.convert(value["stylevalue"] as! [String:Any])
+
+    if let valueObj = valueObj as? [String] {
+      let convertedVal = valueObj.compactMap(TextAnchor.init(rawValue:))
+      return .constant(convertedVal)
+    } else {
+      do {
+        if valueObj is String {
+          throw StyleConversionError.unexpectedType(message: "should be array constant or expression")
+        }
+        let data = try JSONSerialization.data(withJSONObject: valueObj, options: .prettyPrinted)
+        let decodedExpression = try JSONDecoder().decode(Expression.self, from: data)
+        return .expression(decodedExpression)
+      } catch {
+        Logger.log(level: .error, message: "Invalid value for array => value: \(value) error: \(error) setting dummy value")
+        return .constant([.left])
+      }
+    }
   }
   
   #if RNMBX_11

package/ios/RNMBX/RNMBXUtils.swift

@@ -8,9 +8,8 @@ class RNMBXUtils {
     RNMBXImageQueue.sharedInstance.addImage(url, scale: scale, bridge: bridge, handler: callback)
   }
   
-  static func fetchImages(_ bridge: RCTBridge, style: Style, objects: [String:Any], forceUpdate: Bool, loaded: @escaping (_ name:String) -> Void, callback: @escaping ()->Void) {
+  static func fetchImages(_ bridge: RCTBridge, style: Style, objects: [String:Any], forceUpdate: Bool, loaded: @escaping (String, UIImage) -> Void) {
     guard !objects.isEmpty else {
-      callback()
       return
     }
     
@@ -19,9 +18,6 @@ class RNMBXUtils {
     
     let imageLoadedBlock = { () in
       imagesToLoad = imagesToLoad - 1;
-      if imagesToLoad == 0 {
-        callback()
-      }
     }
     
     for imageName in imageNames {
@@ -55,8 +51,7 @@ class RNMBXUtils {
                 if let image = image {
                   logged("RNMBXUtils.fetchImage-\(imageName)") {
                     try style.addImage(image, id: imageName, sdf:sdf, stretchX: stretchX, stretchY: stretchY, content: content)
-                    loaded(imageName)
-                    imageLoadedBlock()
+                    loaded(imageName, image)
                   }
                 }
               }

package/ios/RNMBX/RNMBXViewport.swift

@@ -0,0 +1,349 @@
+@_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":
+      if let options = parseOverviewViewportOptions(state) {
+        return viewport.makeOverviewViewportState(options: options)
+      } else {
+        Logger.log(level:.error, message: "Cannot parse overview options")
+        return nil
+      }
+    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 == "keep") {
+        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 parseOverviewViewportOptions(_ state: [String:Any]) -> OverviewViewportStateOptions? {
+    guard let options = state["options"] as? [String:Any] else {
+      return nil
+    }
+    guard let geometry = options["geometry"], let geometry = toGeometry(geometry) else {
+      return nil
+    }
+
+    var result = OverviewViewportStateOptions(geometry: geometry)
+
+    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 nil or but was \(options["padding"])")
+    }
+
+    if options["bearing"] == nil {
+      result.bearing = (CLLocationDirection?)(nil)
+    } else if let bearing = options["bearing"] as? NSNumber {
+      result.bearing = bearing.doubleValue
+    } else if options["bearing"] != nil {
+      Logger.log(level: .error, message: "bearing expected to be a number or nil but was \(options["bearing"])")
+    }
+
+    if options["pitch"] == nil {
+      result.pitch = (CGFloat?)(nil)
+    } else if let pitch = options["pitch"] as? Double {
+      result.pitch = pitch
+    } else if options["pitch"] != nil{
+      Logger.log(level: .error, message: "parseOverviewViewportOptions expected pitch to be number or nil, but was \(options["pitch"])")
+    }
+
+    if let animationDuration = options["animationDuration"] as? Double {
+      result.animationDuration = animationDuration
+    } else if let animationDuration = options["animationDuration"] as? NSNumber {
+      result.animationDuration = animationDuration.doubleValue
+    } else if options["animationDuration"] != nil {
+      Logger.log(level: .error, message: "parseOverviewViewportOptions expected animationDuration to be a number or nil but was \(options["animationDuration"])")
+    }
+
+    return result
+  }
+  
+  func toGeometry(_ geometry: Any) -> GeometryConvertible? {
+    return logged("toGeometry") {
+      let jsonData = try JSONSerialization.data(withJSONObject: geometry)
+      let geometry = try JSONDecoder().decode(Geometry.self, from: jsonData)
+      return geometry
+    }
+  }
+  
+  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
+