@rnmapbox/maps 10.0.0-beta.28

package/ios/RCTMGL-v10/RCTMGLFillExtrustionLayer.swift

@@ -0,0 +1,46 @@
+import MapboxMaps
+
+@objc(RCTMGLFillExtrusionLayer)
+class RCTMGLFillExtrusionLayer: RCTMGLVectorLayer {
+  typealias LayerType = FillExtrusionLayer
+
+  override func makeLayer(style: Style) throws -> Layer {
+    let vectorSource : VectorSource = try self.layerWithSourceID(in: style)
+    var layer = LayerType(id: self.id!)
+    layer.sourceLayer = self.sourceLayerID
+    layer.source = sourceID
+    return layer
+  }
+
+  override func layerType() -> Layer.Type {
+    return LayerType.self
+  }
+  
+  override func apply(style : Style) throws {
+    try style.updateLayer(withId: id, type: LayerType.self) { (layer : inout FillExtrusionLayer) in
+      if let styleLayer = self.styleLayer as? LayerType {
+        layer = styleLayer
+      }
+    }
+  }
+
+  override func addStyles() {
+    if let style : Style = self.style {
+      let styler =  RCTMGLStyle(style: self.style!)
+      styler.bridge = self.bridge
+      if var styleLayer = self.styleLayer as? LayerType,
+         let reactStyle = self.reactStyle  {
+        styler.fillExtrusionLayer(
+          layer: &styleLayer,
+          reactStyle: reactStyle,
+          applyUpdater: { (updater) in try! style.updateLayer(withId: self.id, type: LayerType.self) { (layer: inout LayerType) in updater(&layer) }},
+          isValid: { return self.isAddedToMap() })
+        self.styleLayer = styleLayer
+      }
+    }
+  }
+  
+  func isAddedToMap() -> Bool {
+    return true
+  }
+}

package/ios/RCTMGL-v10/RCTMGLFillLayer.swift

@@ -0,0 +1,50 @@
+import MapboxMaps
+
+@objc(RCTMGLFillLayer)
+class RCTMGLFillLayer: RCTMGLVectorLayer {
+  typealias LayerType = FillLayer
+
+  override func makeLayer(style: Style) throws -> Layer {
+    let vectorSource : VectorSource = try self.layerWithSourceID(in: style)
+    var layer: Layer = FillLayer(id: self.id!)
+    
+    setOptions(&layer)
+    
+    return layer
+  }
+
+  override func layerType() -> Layer.Type {
+    return LayerType.self
+  }
+  
+  override func apply(style : Style) throws {
+    try style.updateLayer(withId: id, type: LayerType.self) { (layer : inout FillLayer) in
+      if let styleLayer = self.styleLayer as? LayerType {
+        layer = styleLayer
+      }
+    }
+  }
+
+  override func addStyles() {
+    if let style : Style = self.style {
+      let styler = RCTMGLStyle(style: self.style!)
+      styler.bridge = self.bridge
+      
+      if var styleLayer = self.styleLayer as? FillLayer {
+        styler.fillLayer(
+          layer: &styleLayer,
+          reactStyle: reactStyle ?? [:],
+          applyUpdater: { (updater) in try! style.updateLayer(withId: self.id, type: LayerType.self) { (layer: inout FillLayer) in updater(&layer) }},
+          isValid: { return self.isAddedToMap() }
+        )
+        self.styleLayer = styleLayer
+      } else {
+        fatalError("[xxx] layer is not fill layer?!!! \(optional: self.styleLayer)")
+      }
+    }
+  }
+  
+  func isAddedToMap() -> Bool {
+    return true
+  }
+}

package/ios/RCTMGL-v10/RCTMGLFillLayerManager.m

@@ -0,0 +1,12 @@
+#import <React/RCTBridgeModule.h>
+#import <React/RCTViewManager.h>
+
+@interface RCT_EXTERN_MODULE(RCTMGLFillLayerManager, RCTViewManager)
+
+// circle layer props
+RCT_EXPORT_VIEW_PROPERTY(sourceLayerID, NSString)
+
+// standard layer props
+#include "CommonLayerProperties.H"
+
+@end

package/ios/RCTMGL-v10/RCTMGLFillLayerManager.swift

@@ -0,0 +1,13 @@
+@objc(RCTMGLFillLayerManager)
+class RCTMGLFillLayerManager: RCTViewManager {
+    @objc
+    override static func requiresMainQueueSetup() -> Bool {
+        return true
+    }
+  
+    override func view() -> UIView! {
+      let layer = RCTMGLFillLayer()
+      layer.bridge = self.bridge
+      return layer
+    }
+}

package/ios/RCTMGL-v10/RCTMGLHeatmapLayer.swift

@@ -0,0 +1,50 @@
+import MapboxMaps
+
+@objc(RCTMGLHeatmapLayer)
+class RCTMGLHeatmapLayer: RCTMGLVectorLayer {
+  typealias LayerType = HeatmapLayer
+
+  override func makeLayer(style: Style) throws -> Layer {
+    let vectorSource : VectorSource = try self.layerWithSourceID(in: style)
+    var layer: Layer = LayerType(id: self.id!)
+    
+    setOptions(&layer)
+    
+    return layer
+  }
+
+  override func layerType() -> Layer.Type {
+    return LayerType.self
+  }
+  
+  override func apply(style : Style) throws {
+    try style.updateLayer(withId: id, type: LayerType.self) { (layer : inout HeatmapLayer) in
+      if let styleLayer = self.styleLayer as? LayerType {
+        layer = styleLayer
+      }
+    }
+  }
+
+  override func addStyles() {
+    if let style : Style = self.style {
+      let styler =  RCTMGLStyle(style: self.style!)
+      styler.bridge = self.bridge
+      
+      if var styleLayer = self.styleLayer as? HeatmapLayer {
+        styler.heatmapLayer(
+          layer: &styleLayer,
+          reactStyle: reactStyle!,
+          applyUpdater: { (updater) in try! style.updateLayer(withId: self.id, type: LayerType.self) { (layer: inout HeatmapLayer) in updater(&layer) }},
+          isValid: { return self.isAddedToMap() }
+        )
+        self.styleLayer = styleLayer
+      } else {
+        fatalError("[xxx] layer is not heatmap layer?!!! \(self.styleLayer)")
+      }
+    }
+  }
+  
+  func isAddedToMap() -> Bool {
+    return true
+  }
+}

package/ios/RCTMGL-v10/RCTMGLHeatmapLayerManager.m

@@ -0,0 +1,12 @@
+#import <React/RCTBridgeModule.h>
+#import <React/RCTViewManager.h>
+
+@interface RCT_EXTERN_MODULE(RCTMGLHeatmapLayerManager, RCTViewManager)
+
+// circle layer props
+RCT_EXPORT_VIEW_PROPERTY(sourceLayerID, NSString)
+
+// standard layer props
+#include "CommonLayerProperties.H"
+
+@end

package/ios/RCTMGL-v10/RCTMGLHeatmapLayetManager.swift

@@ -0,0 +1,13 @@
+@objc(RCTMGLHeatmapLayerManager)
+class RCTMGLHeatmapLayerManager: RCTViewManager {
+    @objc
+    override static func requiresMainQueueSetup() -> Bool {
+        return true
+    }
+  
+    override func view() -> UIView! {
+      let layer = RCTMGLHeatmapLayer()
+      layer.bridge = self.bridge
+      return layer
+    }
+}

package/ios/RCTMGL-v10/RCTMGLImageQueue.swift

@@ -0,0 +1,140 @@
+class RCTMGLImageQueueOperation : Operation {
+  enum State : Equatable {
+    case Initial
+    case Executing
+    case Finished
+    case CancelDoNotExecute
+    case None
+    case All
+  }
+  
+  weak var bridge: RCTBridge? = nil
+  var completionHandler: ((Error?, UIImage?) -> Void)?
+  var cancellationBlock: RCTImageLoaderCancellationBlock?
+  var urlRequest : URLRequest! = nil
+  var scale:Double! = 1.0
+  
+  var state: State = .Initial
+  
+  func syncronized<T>(_ body: () throws -> T) rethrows ->  T {
+    objc_sync_enter(self)
+    defer { objc_sync_exit(self) }
+    return try body()
+  }
+  
+  func setState(state newState: State, only: State, except: State) -> State {
+    var prevState : State = .None;
+    self.willChangeValue(forKey: "isExecuting")
+    self.willChangeValue(forKey: "isFinished")
+    self.willChangeValue(forKey: "isCancelled")
+
+    syncronized {
+      var allowed = true
+      prevState = self.state
+      if !(only == State.All || prevState == only) {
+          allowed = false;
+      }
+      if (prevState == except) {
+          allowed = false;
+      }
+      if (allowed) {
+          self.state = newState;
+      }
+    }
+    
+    self.didChangeValue(forKey: "isExecuting")
+    self.didChangeValue(forKey: "isFinished")
+    self.didChangeValue(forKey: "isCancelled")
+    return prevState;
+  }
+  
+  func setState(state newState: State, except: State) -> State {
+    setState(state: newState, only: .All, except: except)
+  }
+  
+  func setState(state newState: State, only: State) -> State {
+    setState(state: newState, only: only, except: .None)
+  }
+  
+  func callCancellationBlock() {
+    if let cancellationBlock = cancellationBlock {
+      cancellationBlock()
+    }
+  }
+  
+  override func start() {
+    weak var weakSelf : RCTMGLImageQueueOperation! = self
+    
+    DispatchQueue.global(qos: .default).async {
+      
+      let loader : RCTImageLoaderProtocol = weakSelf.bridge!.module(forName: "ImageLoader", lazilyLoadIfNecessary: true) as! RCTImageLoaderProtocol
+        
+      let cancellationBlock = loader.loadImage(with: weakSelf.urlRequest, size: .zero, scale: CGFloat(weakSelf.scale), clipped: true, resizeMode: .stretch, progressBlock: { _,_  in }, partialLoad: { _ in }) { error, image in
+        if let completionHandler = weakSelf.completionHandler {
+          completionHandler(error, image)
+        }
+        _ = weakSelf.setState(state:.Finished, except:.Finished)
+      }
+
+      if let weakSelf = weakSelf {
+        weakSelf.cancellationBlock = cancellationBlock
+        if (weakSelf.setState(state:.Executing, only:.Initial) == .CancelDoNotExecute) {
+          weakSelf.callCancellationBlock()
+        }
+      }
+    }
+  }
+  
+  override func cancel() {
+    if self.setState(state: .CancelDoNotExecute, except:.Finished) == .Executing {
+      self.callCancellationBlock()
+    }
+  }
+  
+  override var isExecuting: Bool {
+    get {
+      return syncronized {
+        return self.state == .Executing
+      }
+    }
+  }
+
+  override var isFinished: Bool {
+    get {
+      return syncronized {
+        return self.state == .Finished || self.state == .CancelDoNotExecute
+      }
+    }
+  }
+  
+  override var isCancelled: Bool {
+    get {
+      return syncronized {
+        return self.state == .CancelDoNotExecute
+      }
+    }
+  }
+}
+
+class RCTMGLImageQueue {
+   static let sharedInstance: RCTMGLImageQueue = {
+        let instance = RCTMGLImageQueue()
+        // setup code
+        return instance
+    }()
+  
+  var imageQueue : OperationQueue = {
+    let result = OperationQueue()
+    result.name = "comp.mapbox.rctmgl.DownloadImageQueue"
+    return result
+  }()
+  
+  public func addImage(_ json : Any!, scale: Double?, bridge: RCTBridge, handler: @escaping (Error?, UIImage?) -> Void) {
+    let operation = RCTMGLImageQueueOperation()
+    operation.bridge = bridge
+    operation.urlRequest = RCTConvert.nsurlRequest(json)
+    operation.completionHandler = handler;
+    operation.scale = scale;
+    imageQueue.addOperation(operation)
+  }
+}

package/ios/RCTMGL-v10/RCTMGLImageSource.swift

@@ -0,0 +1,61 @@
+import MapboxMaps
+
+@objc
+class RCTMGLImageSource : RCTMGLSource {
+  
+  @objc var url: String? = nil {
+    didSet {
+      if var source = source as? ImageSource {
+        source.url = url
+        self.doUpdate { (style) in
+          try! style.setSourceProperty(for: id, property: "url", value: url)
+        }
+      }
+    }
+  }
+  
+  @objc var coordinates: [[NSNumber]]? = nil {
+    didSet {
+      if var source = source as? ImageSource {
+        if let coordinates = coordinates {
+          source.coordinates = coordinates.map { $0.map { $0.doubleValue }}
+        } else {
+          source.coordinates = nil
+        }
+        self.doUpdate { (style) in
+          try! style.setSourceProperty(for: id, property: "coordinates", value: source.coordinates)
+        }
+      }
+    }
+  }
+  
+  override func sourceType() -> Source.Type {
+    return ImageSource.self
+  }
+
+  override func makeSource() -> Source
+  {
+    var result = ImageSource()
+    if let url = url {
+      result.url = url
+    }
+    
+    if let coordinates = coordinates {
+      result.coordinates = coordinates.map { $0.map { $0.doubleValue }}
+    }
+    
+    return result
+  }
+  
+  func doUpdate(_ update:(Style) -> Void) {
+    guard let map = self.map,
+          let _ = self.source,
+          map.mapboxMap.style.sourceExists(withId: id) else {
+      return
+    }
+    
+    let style = map.mapboxMap.style
+    update(style)
+  }
+  
+}

package/ios/RCTMGL-v10/RCTMGLImageSourceManager.m

@@ -0,0 +1,10 @@
+#import <React/RCTBridgeModule.h>
+#import <React/RCTViewManager.h>
+
+@interface RCT_EXTERN_MODULE(RCTMGLImageSourceManager, RCTViewManager)
+
+RCT_EXPORT_VIEW_PROPERTY(id, NSString)
+RCT_EXPORT_VIEW_PROPERTY(url, NSString)
+RCT_EXPORT_VIEW_PROPERTY(coordinates, NSArray)
+
+@end

package/ios/RCTMGL-v10/RCTMGLImageSourceManager.swift

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

package/ios/RCTMGL-v10/RCTMGLImages.swift

@@ -0,0 +1,197 @@
+import MapboxMaps
+
+class RCTMGLImages : UIView, RCTMGLMapComponent {
+  
+  var bridge : RCTBridge! = nil
+  var remoteImages : [String:String] = [:]
+  
+  @objc
+  var onImageMissing: RCTBubblingEventBlock? = nil
+  
+  @objc
+  var images : [String:Any] = [:]
+  
+  @objc
+  var nativeImages: [String] = []
+  
+  // MARK: - RCTMGLMapComponent
+
+  func waitForStyleLoad() -> Bool {
+    return false
+  }
+  
+  func addToMap(_ map: RCTMGLMapView, style: Style) {
+    map.images.append(self)
+    map.setupEvents()
+    
+    self.addNativeImages(style: style, nativeImages: nativeImages)
+    self.addRemoteImages(style: style, remoteImages: images)
+  }
+  
+  func removeFromMap(_ map: RCTMGLMapView) {
+    // v10todo
+  }
+  
+  func addRemoteImages(style: Style, remoteImages: [String: Any]) {
+    var missingImages : [String:Any] = [:]
+    
+    // Add image placeholder for images that are not yet available in the style. This way
+    // we can load the images asynchronously and add the ShapeSource to the map without delay.
+    // The same is required when this ShapeSource is updated with new/added images and the
+    // data references them. In which case addMissingImageToStyle will take care of loading
+    // them in a similar way.
+    //
+    // See also: https://github.com/mapbox/mapbox-gl-native/pull/14253#issuecomment-478827792
+    
+    for imageName in remoteImages.keys {
+      if style.styleManager.getStyleImage(forImageId: imageName) == nil {
+        try! style.addImage(placeholderImage, id: imageName, stretchX: [], stretchY: [])
+        missingImages[imageName] = remoteImages[imageName]
+      }
+    }
+    
+    if missingImages.count > 0 {
+      RCTMGLUtils.fetchImages(bridge, style: style, objects: missingImages, forceUpdate: true, callback: { })
+      
+    }
+  }
+  
+  public func addMissingImageToStyle(style: Style, imageName: String) -> Bool {
+    if nativeImages.contains(imageName) {
+      addNativeImages(style: style, nativeImages: [imageName])
+      return true
+    }
+    
+    if let remoteImage = images[imageName] {
+      addRemoteImages(style: style, remoteImages: [imageName: remoteImage])
+      return true
+    }
+    return false
+  }
+  
+  public func sendImageMissingEvent(imageName: String, event: Event) {
+    let payload = ["imageKey":imageName]
+    let event = RCTMGLEvent(type: .imageMissing, payload: payload)
+    if let onImageMissing = onImageMissing {
+      onImageMissing(event.toJSON())
+    }
+  }
+  
+  func addNativeImages(style: Style, nativeImages: [String]) {
+    for imageName in nativeImages {
+      if style.styleManager.getStyleImage(forImageId: imageName) == nil {
+        if let image = UIImage(named: imageName) {
+          try! style.addImage(image, id: imageName, stretchX: [], stretchY: [])
+        } else {
+          Logger.log(level:.error, message: "Cannot find nativeImage named \(imageName)")
+        }
+      }
+    }
+  }
+  
+  lazy var placeholderImage : UIImage = {
+    UIGraphicsBeginImageContextWithOptions(CGSize(width: 1, height: 1), false, 0.0)
+    let result = UIGraphicsGetImageFromCurrentImageContext()!
+    UIGraphicsEndImageContext()
+    return result
+  }()
+
+}
+/*
+#import "RCTMGLImages.h"
+#import "UIView+React.h"
+#import "RCTMGLMapView.h"
+#import "RCTMGLUtils.h"
+#import "RCTMGLEvent.h"
+#import "RCTMGLEventTypes.h"
+
+
+@implementation RCTMGLImages : UIView
+
+static UIImage * _placeHolderImage;
+
+- (void)addToMap
+{
+    if (self.map.style == nil) {
+        return;
+    }
+    [self _addNativeImages:_nativeImages];
+    [self _addRemoteImages:_images];
+}
+
+- (void)removeFromMap
+{
+    if (self.map.style == nil) {
+        return;
+    }
+    
+    [self _removeImages];
+}
+
+- (void)_removeImages
+{
+    if ([self _hasImages]) {
+        NSArray<NSString *> *imageNames = _images.allKeys;
+        
+        for (NSString *imageName in imageNames) {
+            [self.map.style removeImageForName:imageName];
+        }
+    }
+    
+    if ([self _hasNativeImages]) {
+        for (NSString *imageName in _nativeImages) {
+            [self.map.style removeImageForName:imageName];
+        }
+    }
+}
+
+- (void)_addNativeImages:(NSArray<NSString *>*)nativeImages
+{
+    if (!nativeImages) return;
+
+    for (NSString *imageName in nativeImages) {
+        // only add native images if they are not in the style yet (similar to [RCTMGLUtils fetchImages: style:])
+        if (![self.map.style imageForName:imageName]) {
+            UIImage *image = [UIImage imageNamed:imageName];
+            [self.map.style setImage:image forName:imageName];
+        }
+    }
+}
+
+- (void)_addRemoteImages:(NSDictionary<NSString *, NSString *>*)remoteImages
+{
+    if (!remoteImages) return;
+    NSDictionary<NSString *, NSString *> *missingImages = [NSMutableDictionary new];
+    
+    // Add image placeholder for images that are not yet available in the style. This way
+    // we can load the images asynchronously and add the ShapeSource to the map without delay.
+    // The same is required when this ShapeSource is updated with new/added images and the
+    // data references them. In which case addMissingImageToStyle will take care of loading
+    // them in a similar way.
+    //
+    // See also: https://github.com/mapbox/mapbox-gl-native/pull/14253#issuecomment-478827792
+    for (NSString *imageName in remoteImages.allKeys) {
+        if (![self.map.style imageForName:imageName]) {
+            [self.map.style setImage:[RCTMGLImages placeholderImage] forName:imageName];
+            [missingImages setValue:_images[imageName] forKey:imageName];
+        }
+    }
+    
+    if (missingImages.count > 0) {
+        // forceUpdate to ensure the placeholder images are updated
+        [RCTMGLUtils fetchImages:_bridge style:self.map.style objects:_images forceUpdate:true callback:^{ }];
+    }
+}
+
+- (BOOL)_hasImages
+{
+    return _images != nil && _images.count > 0;
+}
+
+- (BOOL)_hasNativeImages
+{
+    return _nativeImages != nil && _nativeImages.count > 0;
+}
+
+@end
+*/

package/ios/RCTMGL-v10/RCTMGLImagesManager.m

@@ -0,0 +1,11 @@
+#import <React/RCTBridgeModule.h>
+#import <React/RCTViewManager.h>
+
+@interface RCT_EXTERN_MODULE(RCTMGLImagesManager, RCTViewManager)
+
+RCT_EXPORT_VIEW_PROPERTY(id, NSString)
+RCT_EXPORT_VIEW_PROPERTY(images, NSDictionary)
+RCT_EXPORT_VIEW_PROPERTY(nativeImages, NSArray)
+RCT_REMAP_VIEW_PROPERTY(onImageMissing, onImageMissing, RCTBubblingEventBlock)
+
+@end

package/ios/RCTMGL-v10/RCTMGLImagesManager.swift

@@ -0,0 +1,14 @@
+
+@objc(RCTMGLImagesManager)
+class RCTMGLImagesManager : RCTViewManager {
+  @objc
+  override static func requiresMainQueueSetup() -> Bool {
+    return true
+  }
+
+  override func view() -> UIView! {
+    let layer = RCTMGLImages()
+    layer.bridge = self.bridge
+    return layer
+  }
+}