@superrouteca/smap-react-native 0.0.0-stage → 1.0.1

package/ios/RNSMapHost.swift

@@ -0,0 +1,243 @@
+import CoreLocation
+import SMap
+import UIKit
+
+/// The native side of `<SMap>` on iOS: holds one `SMapView`, created by `start` with the first props (the config is
+/// read then; a new config arrives as a new view). The Fabric component view (`RNSMapNativeView`) forwards props and
+/// commands here and turns `onEvent` calls into React Native events.
+@objc(RNSMapHost)
+public final class RNSMapHost: UIView {
+    /// Called with an event name (`mapReady`, `mapError`, `layerTap`, `tokenRequest`) and its payload.
+    @objc public var onEvent: ((String, [String: Any]) -> Void)?
+
+    private var map: SMapView?
+    private var appliedStyle = ""
+    private var appliedLanguage = ""
+    private var appliedCamera = ""
+    private var appliedBuildings = false
+    private var nextTokenRequest = 0
+    private var tokenRequests: [Int: CheckedContinuation<String, Error>] = [:]
+
+    @objc public var isStarted: Bool { map != nil }
+
+    /// Creates the map. `config`: JSON {baseUrl, nodes, apiKey, token, nearest, getToken}.
+    @objc public func start(config: String, style: String, language: String, camera: String, buildings: Bool) {
+        guard map == nil else { return }
+        let c = RNSMapHost.object(config)
+        let cam = RNSMapHost.object(camera)
+        var options = SMapOptions()
+        if let base = c["baseUrl"] as? String, let url = URL(string: base) { options.baseURL = url }
+        options.nodes = (c["nodes"] as? [String] ?? []).compactMap { URL(string: $0) }
+        options.token = (c["token"] as? String).flatMap { $0.isEmpty ? nil : $0 }
+        options.apiKey = (c["apiKey"] as? String).flatMap { $0.isEmpty ? nil : $0 }
+        options.nearest = c["nearest"] as? Bool ?? true
+        if c["getToken"] as? Bool == true {
+            options.getToken = { [weak self] in
+                guard let self = self else { throw SMapError.notReady }
+                return try await self.requestToken()
+            }
+        }
+        options.style = SMapStyle(rawValue: style) ?? .light
+        options.language = language.isEmpty ? nil : language
+        if let lat = RNSMapHost.number(cam["lat"]), let lng = RNSMapHost.number(cam["lng"]) {
+            options.center = CLLocationCoordinate2D(latitude: lat, longitude: lng)
+        }
+        options.zoom = RNSMapHost.number(cam["zoom"])
+        options.bearing = RNSMapHost.number(cam["bearing"]) ?? 0
+        options.pitch = RNSMapHost.number(cam["pitch"]) ?? 0
+        appliedStyle = style
+        appliedLanguage = language
+        appliedCamera = camera
+        appliedBuildings = buildings
+
+        let m = SMapView(frame: bounds, options: options)
+        m.autoresizingMask = [.flexibleWidth, .flexibleHeight]
+        m.onError = { [weak self] error in self?.emit("mapError", ["message": error.localizedDescription]) }
+        m.onReady = { [weak self] ready in
+            let node = ready.node.map { "\($0.scheme ?? "https")://\($0.host ?? "")" } ?? ""
+            self?.emit("mapReady", ["node": node])
+        }
+        addSubview(m)
+        map = m
+        if buildings { m.setBuildings3D(true) }
+    }
+
+    /// Applies props that changed since the last call.
+    @objc public func update(style: String, language: String, camera: String, buildings: Bool) {
+        guard let m = map else { return }
+        if style != appliedStyle {
+            appliedStyle = style
+            m.setStyle(SMapStyle(rawValue: style) ?? .light)
+        }
+        if language != appliedLanguage {
+            appliedLanguage = language
+            if !language.isEmpty { m.setLanguage(language) }
+        }
+        if camera != appliedCamera {
+            appliedCamera = camera
+            move(m, RNSMapHost.object(camera))
+        }
+        if buildings != appliedBuildings {
+            appliedBuildings = buildings
+            m.setBuildings3D(buildings)
+        }
+    }
+
+    private func move(_ m: SMapView, _ cam: [String: Any]) {
+        let engine = m.mapView
+        let camera = engine.camera
+        if let lat = RNSMapHost.number(cam["lat"]), let lng = RNSMapHost.number(cam["lng"]) {
+            camera.centerCoordinate = CLLocationCoordinate2D(latitude: lat, longitude: lng)
+        }
+        if let bearing = RNSMapHost.number(cam["bearing"]) { camera.heading = bearing }
+        if let pitch = RNSMapHost.number(cam["pitch"]) { camera.pitch = CGFloat(pitch) }
+        engine.setCamera(camera, animated: false)
+        if let zoom = RNSMapHost.number(cam["zoom"]) { engine.setZoomLevel(zoom, animated: false) }
+    }
+
+    // MARK: - Commands
+
+    @objc public func addLayer(kind: String, id: String, data: String, options: String) {
+        guard let m = map else { return }
+        let o = RNSMapHost.object(options)
+        let d = SMapData.geoJSON(Data(data.utf8))
+        do {
+            switch kind {
+            case "points": try m.addPoints(id, data: d, options: RNSMapHost.pointOptions(o))
+            case "lines": try m.addLines(id, data: d, options: RNSMapHost.lineOptions(o))
+            case "polygons": try m.addPolygons(id, data: d, options: RNSMapHost.polygonOptions(o))
+            default:
+                emit("mapError", ["message": "sMap: unknown layer kind \(kind)"])
+                return
+            }
+            m.onTap(id) { [weak self] properties, coordinate in
+                let json = (try? JSONSerialization.data(withJSONObject: RNSMapHost.jsonSafe(properties))).flatMap { String(data: $0, encoding: .utf8) } ?? "{}"
+                self?.emit("layerTap", ["layerId": id, "properties": json, "lat": coordinate.latitude, "lng": coordinate.longitude])
+            }
+        } catch {
+            emit("mapError", ["message": error.localizedDescription])
+        }
+    }
+
+    @objc public func setData(id: String, data: String) {
+        do { try map?.setData(id, data: .geoJSON(Data(data.utf8))) } catch { emit("mapError", ["message": error.localizedDescription]) }
+    }
+
+    @objc public func setVisible(id: String, visible: Bool) { map?.setVisible(id, visible) }
+
+    @objc public func removeLayer(id: String) { map?.removeLayer(id) }
+
+    @objc public func fitLayer(id: String, padding: Double, maxZoom: Double) { map?.fitLayer(id, padding: padding, maxZoom: maxZoom) }
+
+    @objc public func flyTo(lat: Double, lng: Double, zoom: Double) {
+        map?.flyTo(CLLocationCoordinate2D(latitude: lat, longitude: lng), zoom: zoom < 0 ? nil : zoom)
+    }
+
+    @objc public func resolveToken(requestId: Int, token: String, error: String) {
+        guard let c = tokenRequests.removeValue(forKey: requestId) else { return }
+        if token.isEmpty {
+            c.resume(throwing: SMapError.network(url: "", message: error.isEmpty ? "no token" : error))
+        } else {
+            c.resume(returning: token)
+        }
+    }
+
+    /// Ends the map and fails any token request still waiting.
+    @objc public func stop() {
+        for (_, c) in tokenRequests { c.resume(throwing: SMapError.notReady) }
+        tokenRequests.removeAll()
+        map?.removeFromSuperview()
+        map = nil
+    }
+
+    private func requestToken() async throws -> String {
+        nextTokenRequest += 1
+        let id = nextTokenRequest
+        return try await withCheckedThrowingContinuation { c in
+            tokenRequests[id] = c
+            emit("tokenRequest", ["requestId": id])
+        }
+    }
+
+    private func emit(_ name: String, _ payload: [String: Any]) { onEvent?(name, payload) }
+
+    // MARK: - Options from JSON (the names every sMap SDK uses; `minzoom` / `maxzoom` as in the Web SDK too)
+
+    static func object(_ json: String) -> [String: Any] {
+        guard !json.isEmpty, let data = json.data(using: .utf8),
+              let o = try? JSONSerialization.jsonObject(with: data) as? [String: Any] else { return [:] }
+        return o
+    }
+
+    static func number(_ v: Any?) -> Double? {
+        guard let n = v as? NSNumber, !(v is Bool) else { return nil }
+        return n.doubleValue
+    }
+
+    private static func zoom(_ o: [String: Any], _ name: String) -> Double? {
+        number(o[name]) ?? number(o[name.lowercased()])
+    }
+
+    private static func color(_ v: Any?) -> UIColor? { (v as? String).map { UIColor(smapHex: $0) } }
+
+    private static func value(_ v: Any?, _ fallback: Double) -> SMapValue {
+        if let s = v as? String { return .property(s) }
+        return .number(number(v) ?? fallback)
+    }
+
+    static func pointOptions(_ o: [String: Any]) -> SMapPointOptions {
+        var p = SMapPointOptions()
+        if let c = o["cluster"] as? [String: Any] {
+            p.cluster = SMapCluster(radius: number(c["radius"]) ?? 50, maxZoom: number(c["maxZoom"]) ?? 14)
+        } else if o["cluster"] as? Bool == true {
+            p.cluster = SMapCluster()
+        }
+        if let c = color(o["color"]) { p.color = c }
+        if let r = number(o["radius"]) { p.radius = r }
+        if let c = color(o["strokeColor"]) { p.strokeColor = c }
+        if let w = number(o["strokeWidth"]) { p.strokeWidth = w }
+        p.icon = o["icon"] as? String
+        if let s = number(o["iconSize"]) { p.iconSize = s }
+        p.label = o["label"] as? String
+        p.minZoom = zoom(o, "minZoom")
+        p.maxZoom = zoom(o, "maxZoom")
+        p.zIndex = Int(number(o["zIndex"]) ?? 0)
+        return p
+    }
+
+    static func lineOptions(_ o: [String: Any]) -> SMapLineOptions {
+        var l = SMapLineOptions()
+        if let c = color(o["color"]) { l.color = c }
+        if let w = number(o["width"]) { l.width = w }
+        l.dash = (o["dash"] as? [NSNumber])?.map { $0.doubleValue }
+        if let a = number(o["opacity"]) { l.opacity = a }
+        l.minZoom = zoom(o, "minZoom")
+        l.maxZoom = zoom(o, "maxZoom")
+        l.zIndex = Int(number(o["zIndex"]) ?? 0)
+        return l
+    }
+
+    static func polygonOptions(_ o: [String: Any]) -> SMapPolygonOptions {
+        var p = SMapPolygonOptions()
+        if let c = color(o["fill"]) ?? color(o["color"]) { p.fill = c }
+        p.opacity = number(o["opacity"])
+        p.outline = color(o["outline"])
+        if let w = number(o["outlineWidth"]) { p.outlineWidth = w }
+        if let e = o["extrude"] as? [String: Any] {
+            p.extrude = SMapExtrude(height: value(e["height"], 20), base: value(e["base"], 0))
+        }
+        p.minZoom = zoom(o, "minZoom")
+        p.maxZoom = zoom(o, "maxZoom")
+        p.zIndex = Int(number(o["zIndex"]) ?? 0)
+        return p
+    }
+
+    private static func jsonSafe(_ value: Any) -> Any {
+        switch value {
+        case let d as [String: Any]: return d.mapValues { jsonSafe($0) }
+        case let a as [Any]: return a.map { jsonSafe($0) }
+        case is String, is NSNumber, is NSNull: return value
+        default: return String(describing: value)
+        }
+    }
+}

package/ios/RNSMapNativeView.mm

@@ -0,0 +1,161 @@
+// The Fabric component view of `SMapNativeView`: forwards props and commands to the sMap iOS SDK (through RNSMapHost)
+// and its events to React Native. It has no public header: React Native finds it by name (codegenConfig
+// componentProvider), and a header importing the C++ component headers would break the pod's Swift module.
+#import <React/RCTViewComponentView.h>
+#import <UIKit/UIKit.h>
+
+#import <react/renderer/components/SMapReactNativeSpec/ComponentDescriptors.h>
+#import <react/renderer/components/SMapReactNativeSpec/EventEmitters.h>
+#import <react/renderer/components/SMapReactNativeSpec/Props.h>
+#import <react/renderer/components/SMapReactNativeSpec/RCTComponentViewHelpers.h>
+
+#import <React/RCTFabricComponentsPlugins.h>
+
+#if __has_include(<SMapReactNative/SMapReactNative-Swift.h>)
+#import <SMapReactNative/SMapReactNative-Swift.h>
+#else
+#import "SMapReactNative-Swift.h"
+#endif
+
+using namespace facebook::react;
+
+static NSString *RNSMapString(const std::string &value)
+{
+  return [NSString stringWithUTF8String:value.c_str()] ?: @"";
+}
+
+static std::string RNSMapStd(id value)
+{
+  NSString *s = [value isKindOfClass:[NSString class]] ? value : @"";
+  return std::string([s UTF8String] ?: "");
+}
+
+static double RNSMapDouble(id value)
+{
+  return [value isKindOfClass:[NSNumber class]] ? [value doubleValue] : 0;
+}
+
+@interface RNSMapNativeView : RCTViewComponentView <RCTSMapNativeViewViewProtocol>
+@end
+
+@implementation RNSMapNativeView {
+  RNSMapHost *_host;
+}
+
++ (ComponentDescriptorProvider)componentDescriptorProvider
+{
+  return concreteComponentDescriptorProvider<SMapNativeViewComponentDescriptor>();
+}
+
+- (instancetype)initWithFrame:(CGRect)frame
+{
+  if (self = [super initWithFrame:frame]) {
+    static const auto defaultProps = std::make_shared<const SMapNativeViewProps>();
+    _props = defaultProps;
+    [self makeHost];
+  }
+  return self;
+}
+
+- (void)makeHost
+{
+  _host = [[RNSMapHost alloc] initWithFrame:self.bounds];
+  __weak RNSMapNativeView *weakSelf = self;
+  _host.onEvent = ^(NSString *name, NSDictionary<NSString *, id> *payload) {
+    [weakSelf emit:name payload:payload];
+  };
+  self.contentView = _host;
+}
+
+- (void)updateProps:(Props::Shared const &)props oldProps:(Props::Shared const &)oldProps
+{
+  const auto &p = *std::static_pointer_cast<SMapNativeViewProps const>(props);
+  NSString *style = RNSMapString(p.mapStyle);
+  NSString *language = RNSMapString(p.language);
+  NSString *camera = RNSMapString(p.camera);
+  if (!_host.isStarted) {
+    [_host startWithConfig:RNSMapString(p.config) style:style language:language camera:camera buildings:p.buildings3D];
+  } else {
+    [_host updateWithStyle:style language:language camera:camera buildings:p.buildings3D];
+  }
+  [super updateProps:props oldProps:oldProps];
+}
+
+- (void)prepareForRecycle
+{
+  // A recycled view may be given another config: start again from nothing.
+  [_host stop];
+  [self makeHost];
+  [super prepareForRecycle];
+}
+
+- (void)emit:(NSString *)name payload:(NSDictionary<NSString *, id> *)payload
+{
+  if (!_eventEmitter) {
+    return;
+  }
+  auto emitter = std::static_pointer_cast<const SMapNativeViewEventEmitter>(_eventEmitter);
+  if ([name isEqualToString:@"mapReady"]) {
+    emitter->onMapReady({.node = RNSMapStd(payload[@"node"])});
+  } else if ([name isEqualToString:@"mapError"]) {
+    emitter->onMapError({.message = RNSMapStd(payload[@"message"])});
+  } else if ([name isEqualToString:@"layerTap"]) {
+    emitter->onLayerTap({
+        .layerId = RNSMapStd(payload[@"layerId"]),
+        .properties = RNSMapStd(payload[@"properties"]),
+        .lat = RNSMapDouble(payload[@"lat"]),
+        .lng = RNSMapDouble(payload[@"lng"]),
+    });
+  } else if ([name isEqualToString:@"tokenRequest"]) {
+    emitter->onTokenRequest({.requestId = (int)RNSMapDouble(payload[@"requestId"])});
+  }
+}
+
+#pragma mark - Commands
+
+- (void)handleCommand:(const NSString *)commandName args:(const NSArray *)args
+{
+  RCTSMapNativeViewHandleCommand(self, commandName, args);
+}
+
+- (void)addLayer:(NSString *)kind id:(NSString *)layerId data:(NSString *)data options:(NSString *)options
+{
+  [_host addLayerWithKind:kind id:layerId data:data options:options];
+}
+
+- (void)setData:(NSString *)layerId data:(NSString *)data
+{
+  [_host setDataWithId:layerId data:data];
+}
+
+- (void)setVisible:(NSString *)layerId visible:(BOOL)visible
+{
+  [_host setVisibleWithId:layerId visible:visible];
+}
+
+- (void)removeLayer:(NSString *)layerId
+{
+  [_host removeLayerWithId:layerId];
+}
+
+- (void)fitLayer:(NSString *)layerId padding:(double)padding maxZoom:(double)maxZoom
+{
+  [_host fitLayerWithId:layerId padding:padding maxZoom:maxZoom];
+}
+
+- (void)flyTo:(double)lat lng:(double)lng zoom:(double)zoom
+{
+  [_host flyToLat:lat lng:lng zoom:zoom];
+}
+
+- (void)resolveToken:(NSInteger)requestId token:(NSString *)token error:(NSString *)error
+{
+  [_host resolveTokenWithRequestId:requestId token:token error:error];
+}
+
+@end
+
+Class<RCTComponentViewProtocol> RNSMapNativeViewCls(void)
+{
+  return RNSMapNativeView.class;
+}

package/ios/smap_react_native.rb

@@ -0,0 +1,96 @@
+# CocoaPods helpers of @superrouteca/smap-react-native.
+#
+# The sMap iOS SDK is a Swift package (product `SMap`) whose rendering engine is a dynamic binary framework of that
+# package. The pod gets the package through React Native's spm_dependency, which links it, but Xcode embeds a
+# package's binary frameworks only in an app target that depends on the package itself. Linking the package into the
+# app as well would link the SDK twice, so the app target is given a build phase that embeds the engine framework,
+# by `SMapReactNative.post_install(installer)` in the app's Podfile:
+#
+#   require Pod::Executable.execute_command('node', ['-p',
+#     'require.resolve("@superrouteca/smap-react-native/ios/smap_react_native.rb", {paths: [process.argv[1]]})',
+#     __dir__]).strip
+#   ...
+#   post_install do |installer|
+#     react_native_post_install(installer, ...)
+#     SMapReactNative.post_install(installer)
+#   end
+#
+# Which package is used: SMAP_IOS_PACKAGE_PATH (a checkout of the Swift package) when set; else, inside the sMap SDK
+# repository, the package next to this one; else the tag of this release from GitHub.
+require "json"
+
+module SMapReactNative
+  REMOTE = "https://github.com/Goodneo-Solutions/smap-sdk.git".freeze
+  PRODUCT = "SMap".freeze
+  PHASE = "[sMap] Embed map engine".freeze
+  ENGINE = "MapLibre.framework".freeze
+
+  # Copies the engine framework from the build products (where Xcode puts the package's binary framework) into the
+  # app's Frameworks folder and signs it as the app is signed.
+  EMBED_SCRIPT = <<~SH.freeze
+    set -e
+    src="${BUILT_PRODUCTS_DIR}/#{ENGINE}"
+    dst="${TARGET_BUILD_DIR}/${FRAMEWORKS_FOLDER_PATH}"
+    if [ ! -d "$src" ]; then
+      echo "error: #{ENGINE} not found in ${BUILT_PRODUCTS_DIR}; run pod install again"
+      exit 1
+    fi
+    mkdir -p "$dst"
+    rm -rf "$dst/#{ENGINE}"
+    cp -R "$src" "$dst/"
+    if [ "${CODE_SIGNING_ALLOWED}" = "YES" ] && [ -n "${EXPANDED_CODE_SIGN_IDENTITY}" ]; then
+      codesign --force --sign "${EXPANDED_CODE_SIGN_IDENTITY}" --preserve-metadata=identifier,entitlements "$dst/#{ENGINE}"
+    fi
+  SH
+
+  def self.package_root
+    File.realpath(File.join(__dir__, ".."))
+  end
+
+  def self.version
+    JSON.parse(File.read(File.join(package_root, "package.json")))["version"]
+  end
+
+  # The local Swift package directory, or nil for the published one.
+  def self.local_sdk
+    env = ENV["SMAP_IOS_PACKAGE_PATH"]
+    return File.expand_path(env) if env && !env.empty?
+    [File.join(package_root, "..", "ios"), File.join(package_root, "..")].map { |d| File.expand_path(d) }.find do |dir|
+      manifest = File.join(dir, "Package.swift")
+      File.exist?(manifest) && File.read(manifest).include?(".library(name: \"#{PRODUCT}\"")
+    end
+  end
+
+  # Called by the podspec.
+  def self.add_to_pod(spec)
+    local = local_sdk
+    if local
+      spm_dependency(spec, url: local, requirement: {}, products: [PRODUCT])
+    else
+      spm_dependency(spec, url: REMOTE, requirement: { kind: "exactVersion", version: version }, products: [PRODUCT])
+    end
+  end
+
+  # Adds the embed phase to every app target of the Podfile (once; kept up to date).
+  def self.post_install(installer)
+    inputs = ["${BUILT_PRODUCTS_DIR}/#{ENGINE}"]
+    outputs = ["${TARGET_BUILD_DIR}/${FRAMEWORKS_FOLDER_PATH}/#{ENGINE}"]
+    installer.aggregate_targets.each do |aggregate|
+      project = aggregate.user_project
+      next unless project
+      changed = false
+      aggregate.user_targets.each do |target|
+        next unless target.respond_to?(:product_type) && target.product_type == "com.apple.product-type.application"
+        phase = target.shell_script_build_phases.find { |p| p.name == PHASE } || target.new_shell_script_build_phase(PHASE)
+        next if phase.shell_script == EMBED_SCRIPT && phase.input_paths == inputs && phase.output_paths == outputs
+        phase.shell_path = "/bin/sh"
+        phase.shell_script = EMBED_SCRIPT
+        phase.input_paths = inputs
+        phase.output_paths = outputs
+        Pod::UI.puts "[sMap] #{target.name} embeds the map engine framework"
+        changed = true
+      end
+      project.save if changed
+    end
+  end
+end

package/package.json

@@ -1,6 +1,69 @@
 {
   "name": "@superrouteca/smap-react-native",
-  "version": "0.0.0-stage",
-  "stub": true,
-  "description": "Temporary package placeholder for staged publishing"
-}
+  "version": "1.0.1",
+  "description": "sMap for React Native: a map view for Superroute's sMap service, over the sMap Android and iOS SDKs.",
+  "license": "MIT",
+  "author": "Goodneo Solutions",
+  "homepage": "https://github.com/Goodneo-Solutions/smap-sdk/tree/main/react-native#readme",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/Goodneo-Solutions/smap-sdk.git",
+    "directory": "react-native"
+  },
+  "keywords": ["react-native", "map", "maps", "smap", "superroute", "ios", "android"],
+  "main": "src/index.tsx",
+  "types": "src/index.tsx",
+  "react-native": "src/index.tsx",
+  "source": "src/index.tsx",
+  "files": [
+    "src",
+    "!src/__tests__",
+    "android/build.gradle",
+    "android/src",
+    "ios",
+    "SMapReactNative.podspec",
+    "README.md",
+    "CHANGELOG.md",
+    "LICENSE"
+  ],
+  "scripts": {
+    "test": "jest",
+    "typecheck": "tsc --noEmit",
+    "prepack": "cp ../LICENSE LICENSE"
+  },
+  "peerDependencies": {
+    "react": ">=18",
+    "react-native": ">=0.81"
+  },
+  "devDependencies": {
+    "@babel/core": "7.29.7",
+    "@react-native/babel-preset": "0.88.0",
+    "@react-native/jest-preset": "0.88.0",
+    "@types/jest": "29.5.14",
+    "@types/react": "19.3.0",
+    "@types/react-test-renderer": "19.3.0",
+    "jest": "29.7.0",
+    "react": "19.3.0",
+    "react-native": "0.88.0",
+    "react-test-renderer": "19.3.0",
+    "typescript": "6.0.3"
+  },
+  "jest": {
+    "preset": "@react-native/jest-preset",
+    "roots": ["<rootDir>/src"],
+    "modulePathIgnorePatterns": ["<rootDir>/example/"]
+  },
+  "codegenConfig": {
+    "name": "SMapReactNativeSpec",
+    "type": "components",
+    "jsSrcsDir": "src",
+    "android": {
+      "javaPackageName": "ca.superroute.smap.reactnative"
+    },
+    "ios": {
+      "componentProvider": {
+        "SMapNativeView": "RNSMapNativeView"
+      }
+    }
+  }
+}