expo-arcgis 0.1.0 → 0.1.2

package/README.md

@@ -6,6 +6,8 @@ SDK-faithful component API to JS/TS — `<MapView>` / `<SceneView>` with layers,
 editing, query, analysis, geocoding, routing, geoprocessing, utility networks, offline, real-time and
 authentication.
 
+📖 **[Documentation & samples →](https://alex-krassavin.github.io/expo-arcgis)**
+
 > **Status — early / pre-1.0.** The full surface below is implemented and **compile-verified** on both
 > platforms (TypeScript · Android `compileDebugKotlin` · iOS pod build). On-device **runtime** validation
 > (rendering, network calls, device sensors) should be done in your own app. The API may still change
@@ -16,14 +18,14 @@ authentication.
 | Area | What's covered |
 |---|---|
 | **2D / 3D** | `<MapView>` + `<Map>`; `<SceneView>` + `<Scene>` (surface, camera, web scenes, light/shadows) |
-| **Layers** | Feature, Tile, MapImage, Vector-tile, Raster, WMS, WMTS, KML, Scene, IntegratedMesh, PointCloud, OGC 3D Tiles, WebTiled, OpenStreetMap, **WFS**, **OGC API Features**, **DynamicEntity** (stream) |
+| **Layers** | Feature, Tile, MapImage, Vector-tile, Raster, WMS, WMTS, KML, Scene, IntegratedMesh, PointCloud, OGC 3D Tiles, WebTiled, OpenStreetMap, WFS, OGC API Features, DynamicEntity (stream), Annotation, Dimension, BuildingScene (3D), OrientedImagery, SubtypeFeature, **Group** (container), **FeatureCollection** (in-memory), **GeoPackage** (local `.gpkg`) |
 | **Graphics** | `<GraphicsOverlay>` + `<Graphic>`, symbols (simple marker/line/fill, text, 3D scene symbol, picture-marker), renderers (simple / unique-value / class-breaks), labels, clustering |
 | **Geometry** | `geometryEngine` (buffer, project, distance, intersect, …), `coordinateFormatter`, codec for all geometry types |
 | **Query** | feature query / count / extent / statistics on a `<FeatureLayer>` ref; `identify` on a view ref |
 | **Editing** | add / update / delete features, `<GeometryEditor>` (tools), feature templates |
 | **Location** | device location, simulated location data source, `onLocationChange` |
 | **Geocoding** | `geocoder.geocode` / `reverseGeocode` / `suggest`, offline `.loc` locators |
-| **Routing** | `router.solveRoute` / directions, travel modes, point barriers, curb approach |
+| **Routing** | `router.solveRoute` / directions, travel modes, point barriers, curb approach; `router.createRouteTracker` turn-by-turn navigation |
 | **Analysis (3D)** | `<AnalysisOverlay>` + `<Viewshed>` / `<LineOfSight>` / `<DistanceMeasurement>` |
 | **Geoprocessing** | `geoprocessor.execute` → `JobRef` (progress + cancel), typed parameters |
 | **Utility network** | `<UtilityNetwork>` load + trace, named configs, associations, `describeNetwork` |
@@ -122,7 +124,9 @@ const [hit] = await geocoder.geocode('Los Angeles');
 - **Views & models** — `MapSettings`, `Map`, `Scene`, `MapView`, `SceneView`
 - **Layers** — `FeatureLayer`, `TileLayer`, `MapImageLayer`, `SceneLayer`, `VectorTileLayer`,
   `IntegratedMeshLayer`, `PointCloudLayer`, `Ogc3DTilesLayer`, `WebTiledLayer`, `OpenStreetMapLayer`,
-  `WmsLayer`, `WmtsLayer`, `RasterLayer`, `KmlLayer`, `WfsLayer`, `OgcFeatureLayer`, `DynamicEntityLayer`
+  `WmsLayer`, `WmtsLayer`, `RasterLayer`, `KmlLayer`, `WfsLayer`, `OgcFeatureLayer`, `DynamicEntityLayer`,
+  `AnnotationLayer`, `DimensionLayer`, `BuildingSceneLayer`, `OrientedImageryLayer`, `SubtypeFeatureLayer`,
+  `GroupLayer`, `FeatureCollectionLayer`, `GeoPackageLayer`
 - **Graphics & analysis** — `GraphicsOverlay`, `Graphic`, `AnalysisOverlay`, `Viewshed`, `LineOfSight`,
   `DistanceMeasurement`, `GeometryEditor`, `UtilityNetwork`
 - **Namespaces** — `geometryEngine`, `coordinateFormatter`, `geocoder`, `router`, `geoprocessor`, `offline`

package/android/src/main/java/expo/modules/arcgis/ExpoArcgisExtrasModule.kt

@@ -0,0 +1,87 @@
+package expo.modules.arcgis
+
+import expo.modules.kotlin.functions.Coroutine
+import expo.modules.kotlin.modules.Module
+import expo.modules.kotlin.modules.ModuleDefinition
+
+/**
+ * Third native module, hosting the heavier operational-layer SharedObject classes (currently
+ * [FeatureLayerRef]), exposed to JS as `ExpoArcgisExtras`. Split out of [ExpoArcgisGeometryModule]
+ * so that no module's `definition()` exceeds the JVM 64 KB method-size limit. SharedObjects are
+ * global, so a ref constructed here attaches to a `<MapView>` from the main module fine.
+ */
+class ExpoArcgisExtrasModule : Module() {
+  override fun definition() = ModuleDefinition {
+    Name("ExpoArcgisExtras")
+
+    Class(FeatureLayerRef::class) {
+      Constructor { props: Map<String, Any?> ->
+        FeatureLayerRef(appContext, props).also { it.applyProps(props) }
+      }
+      Function("applyProps") { ref: FeatureLayerRef, changed: Map<String, Any?> ->
+        ref.applyProps(changed)
+      }
+      AsyncFunction("queryFeatures") Coroutine { ref: FeatureLayerRef, query: Map<String, Any?>? ->
+        ref.queryFeatures(query)
+      }
+      AsyncFunction("queryFeatureCount") Coroutine { ref: FeatureLayerRef, query: Map<String, Any?>? ->
+        ref.queryFeatureCount(query)
+      }
+      AsyncFunction("queryExtent") Coroutine { ref: FeatureLayerRef, query: Map<String, Any?>? ->
+        ref.queryExtent(query)
+      }
+      AsyncFunction("queryStatistics") Coroutine { ref: FeatureLayerRef, query: Map<String, Any?> ->
+        ref.queryStatistics(query)
+      }
+      AsyncFunction("queryFeatureTemplates") Coroutine { ref: FeatureLayerRef ->
+        ref.queryFeatureTemplates()
+      }
+      AsyncFunction("addFeature") Coroutine { ref: FeatureLayerRef, attributes: Map<String, Any?>, geometry: Map<String, Any?>?, apply: Boolean? ->
+        ref.addFeature(attributes, geometry, apply)
+      }
+      AsyncFunction("updateFeature") Coroutine { ref: FeatureLayerRef, objectId: Long, changes: Map<String, Any?>, apply: Boolean? ->
+        ref.updateFeature(objectId, changes, apply)
+      }
+      AsyncFunction("deleteFeature") Coroutine { ref: FeatureLayerRef, objectId: Long, apply: Boolean? ->
+        ref.deleteFeature(objectId, apply)
+      }
+      AsyncFunction("applyEdits") Coroutine { ref: FeatureLayerRef ->
+        ref.applyEdits()
+      }
+      AsyncFunction("undoLocalEdits") Coroutine { ref: FeatureLayerRef ->
+        ref.undoLocalEdits()
+      }
+      AsyncFunction("queryRelatedFeatures") Coroutine { ref: FeatureLayerRef, objectId: Long ->
+        ref.queryRelatedFeatures(objectId)
+      }
+      AsyncFunction("queryAttachments") Coroutine { ref: FeatureLayerRef, objectId: Long ->
+        ref.queryAttachments(objectId)
+      }
+      AsyncFunction("addAttachment") Coroutine { ref: FeatureLayerRef, objectId: Long, name: String, contentType: String, dataBase64: String ->
+        ref.addAttachment(objectId, name, contentType, dataBase64)
+      }
+      AsyncFunction("fetchAttachment") Coroutine { ref: FeatureLayerRef, objectId: Long, attachmentId: Long ->
+        ref.fetchAttachment(objectId, attachmentId)
+      }
+      AsyncFunction("deleteAttachment") Coroutine { ref: FeatureLayerRef, objectId: Long, attachmentId: Long ->
+        ref.deleteAttachment(objectId, attachmentId)
+      }
+      AsyncFunction("updateAttachment") Coroutine { ref: FeatureLayerRef, objectId: Long, attachmentId: Long, name: String, contentType: String, dataBase64: String ->
+        ref.updateAttachment(objectId, attachmentId, name, contentType, dataBase64)
+      }
+    }
+
+    // Turn-by-turn navigation — solve a route and track device locations against it.
+    AsyncFunction("createRouteTracker") Coroutine { stops: List<Map<String, Any?>>, params: Map<String, Any?> ->
+      createRouteTracker(appContext, stops, params)
+    }
+    Class(RouteTrackerRef::class) {
+      AsyncFunction("trackLocation") Coroutine { ref: RouteTrackerRef, location: Map<String, Any?> ->
+        ref.trackLocation(location)
+      }
+      AsyncFunction("switchToNextDestination") Coroutine { ref: RouteTrackerRef ->
+        ref.switchToNextDestination()
+      }
+    }
+  }
+}

package/android/src/main/java/expo/modules/arcgis/ExpoArcgisGeometryModule.kt

@@ -1,5 +1,7 @@
 package expo.modules.arcgis
 
+import com.arcgismaps.ArcGISEnvironment
+import com.arcgismaps.httpcore.authentication.ArcGISCredentialStore
 import expo.modules.kotlin.functions.Coroutine
 import expo.modules.kotlin.modules.Module
 import expo.modules.kotlin.modules.ModuleDefinition
@@ -30,6 +32,12 @@ class ExpoArcgisGeometryModule : Module() {
     Function("geClip", ::geClip)
     Function("geCut", ::geCut)
     Function("geConvexHull", ::geConvexHull)
+    Function("geLabelPoint", ::geLabelPoint)
+    Function("geNormalizeCentralMeridian", ::geNormalizeCentralMeridian)
+    Function("geReshape", ::geReshape)
+    Function("geIntersections", ::geIntersections)
+    Function("geExtend", ::geExtend)
+    Function("geAutoComplete", ::geAutoComplete)
     Function("geBoundary", ::geBoundary)
     Function("geSimplify", ::geSimplify)
     Function("geDensify", ::geDensify)
@@ -90,6 +98,79 @@ class ExpoArcgisGeometryModule : Module() {
       AsyncFunction("cancel") Coroutine { ref: JobRef -> ref.cancel() }
     }
 
+    // Extended operational layers from a service URL — registered here (not in the main module) to
+    // keep ExpoArcgisModule's definition under the JVM 64 KB method limit. SharedObjects are global,
+    // so a layer constructed via this module attaches to a `<MapView>` from the main module fine.
+    Class(AnnotationLayerRef::class) {
+      Constructor { props: Map<String, Any?> ->
+        AnnotationLayerRef(appContext, props["url"] as? String ?: "").also { it.applyProps(props) }
+      }
+      Function("applyProps") { ref: AnnotationLayerRef, changed: Map<String, Any?> -> ref.applyProps(changed) }
+    }
+    Class(DimensionLayerRef::class) {
+      Constructor { props: Map<String, Any?> ->
+        DimensionLayerRef(appContext, props["url"] as? String ?: "").also { it.applyProps(props) }
+      }
+      Function("applyProps") { ref: DimensionLayerRef, changed: Map<String, Any?> -> ref.applyProps(changed) }
+    }
+    Class(BuildingSceneLayerRef::class) {
+      Constructor { props: Map<String, Any?> ->
+        BuildingSceneLayerRef(appContext, props["url"] as? String ?: "").also { it.applyProps(props) }
+      }
+      Function("applyProps") { ref: BuildingSceneLayerRef, changed: Map<String, Any?> -> ref.applyProps(changed) }
+    }
+    Class(OrientedImageryLayerRef::class) {
+      Constructor { props: Map<String, Any?> ->
+        OrientedImageryLayerRef(appContext, props["url"] as? String ?: "").also { it.applyProps(props) }
+      }
+      Function("applyProps") { ref: OrientedImageryLayerRef, changed: Map<String, Any?> -> ref.applyProps(changed) }
+    }
+    Class(SubtypeFeatureLayerRef::class) {
+      Constructor { props: Map<String, Any?> ->
+        SubtypeFeatureLayerRef(appContext, props["url"] as? String ?: "").also { it.applyProps(props) }
+      }
+      Function("applyProps") { ref: SubtypeFeatureLayerRef, changed: Map<String, Any?> -> ref.applyProps(changed) }
+    }
+    // GroupLayer — a container layer that hosts its own child layers (addLayer/removeLayer).
+    Class(GroupLayerRef::class) {
+      Constructor { props: Map<String, Any?> ->
+        GroupLayerRef(appContext).also { it.applyProps(props) }
+      }
+      Function("applyProps") { ref: GroupLayerRef, changed: Map<String, Any?> -> ref.applyProps(changed) }
+      Function("addLayer") { ref: GroupLayerRef, layer: LayerRef -> ref.addLayer(layer) }
+      Function("removeLayer") { ref: GroupLayerRef, layer: LayerRef -> ref.removeLayer(layer) }
+    }
+    // FeatureLayerRef moved to the third module (ExpoArcgisExtras) to keep this module's
+    // definition() under the 64 KB limit. SharedObjects are global, so it stays cross-module.
+    // In-memory FeatureCollectionLayer — built from a client-side schema + features (no service).
+    Class(FeatureCollectionLayerRef::class) {
+      Constructor { props: Map<String, Any?> ->
+        FeatureCollectionLayerRef(appContext, props).also { it.applyProps(props) }
+      }
+      Function("applyProps") { ref: FeatureCollectionLayerRef, changed: Map<String, Any?> -> ref.applyProps(changed) }
+    }
+    // GeoPackage layer — async-loads a local .gpkg, picks the feature table, wraps it in a FeatureLayer.
+    Class(GeoPackageLayerRef::class) {
+      Constructor { props: Map<String, Any?> ->
+        GeoPackageLayerRef(
+          appContext,
+          props["path"] as? String ?: "",
+          props["tableName"] as? String,
+        ).also { it.applyProps(props) }
+      }
+      Function("applyProps") { ref: GeoPackageLayerRef, changed: Map<String, Any?> -> ref.applyProps(changed) }
+    }
+
+    // Auth — persistent credential store (survives app restarts via Android encrypted storage).
+    // Registered here (not in the main module) because the main module is at the JVM 64 KB limit.
+    AsyncFunction("enablePersistentCredentialStore") Coroutine { ->
+      val store = ArcGISCredentialStore.createWithPersistence().getOrThrow()
+      ArcGISEnvironment.authenticationManager.arcGISCredentialStore = store
+    }
+    AsyncFunction("clearCredentialStore") Coroutine { ->
+      ArcGISEnvironment.authenticationManager.arcGISCredentialStore.removeAll()
+    }
+
     // Offline — take maps/data offline, exposed as the JS `offline` namespace.
     AsyncFunction("generateOfflineMap") Coroutine { portalItemId: String, areaOfInterest: Map<String, Any?>, downloadName: String ->
       generateOfflineMap(appContext, appContext.reactContext?.filesDir, portalItemId, areaOfInterest, downloadName)

package/android/src/main/java/expo/modules/arcgis/ExpoArcgisMapView.kt

@@ -196,6 +196,22 @@ class ExpoArcgisMapView(context: Context, appContext: AppContext) : ExpoView(con
     }
   }
 
+  /** Identifies popups under a screen point — evaluates each and returns `{ title, fields }`. */
+  fun identifyPopups(screenPoint: Map<String, Any?>, options: Map<String, Any?>?, promise: Promise) {
+    val x = (screenPoint["x"] as? Number)?.toDouble() ?: 0.0
+    val y = (screenPoint["y"] as? Number)?.toDouble() ?: 0.0
+    val tolerance = (options?.get("tolerance") as? Number)?.toDouble() ?: 12.0
+    val maxResults = (options?.get("maxResults") as? Number)?.toInt() ?: 1
+    scope.launch {
+      try {
+        val results = mapView.identifyLayers(ScreenCoordinate(x, y), tolerance, false, maxResults).getOrThrow()
+        promise.resolve(serializePopups(results))
+      } catch (e: Exception) {
+        promise.reject("IDENTIFY_ERROR", e.message ?: "Identify failed", e)
+      }
+    }
+  }
+
   /** Retries loading the map (Loadable pattern) — useful after a network outage. Re-emits the result. */
   fun retryLoad(promise: Promise) {
     val map = mapView.map ?: run { promise.resolve(null); return }

package/android/src/main/java/expo/modules/arcgis/ExpoArcgisModule.kt

@@ -96,38 +96,8 @@ class ExpoArcgisModule : Module() {
     }
 
     // Operational layers — SharedObjects the JS <FeatureLayer>/<TileLayer> construct.
-    Class(FeatureLayerRef::class) {
-      Constructor { props: Map<String, Any?> ->
-        FeatureLayerRef(appContext, props).also { it.applyProps(props) }
-      }
-      Function("applyProps") { ref: FeatureLayerRef, changed: Map<String, Any?> ->
-        ref.applyProps(changed)
-      }
-      AsyncFunction("queryFeatures") Coroutine { ref: FeatureLayerRef, query: Map<String, Any?>? ->
-        ref.queryFeatures(query)
-      }
-      AsyncFunction("queryFeatureCount") Coroutine { ref: FeatureLayerRef, query: Map<String, Any?>? ->
-        ref.queryFeatureCount(query)
-      }
-      AsyncFunction("queryExtent") Coroutine { ref: FeatureLayerRef, query: Map<String, Any?>? ->
-        ref.queryExtent(query)
-      }
-      AsyncFunction("queryStatistics") Coroutine { ref: FeatureLayerRef, query: Map<String, Any?> ->
-        ref.queryStatistics(query)
-      }
-      AsyncFunction("queryFeatureTemplates") Coroutine { ref: FeatureLayerRef ->
-        ref.queryFeatureTemplates()
-      }
-      AsyncFunction("addFeature") Coroutine { ref: FeatureLayerRef, attributes: Map<String, Any?>, geometry: Map<String, Any?>? ->
-        ref.addFeature(attributes, geometry)
-      }
-      AsyncFunction("updateFeature") Coroutine { ref: FeatureLayerRef, objectId: Long, changes: Map<String, Any?> ->
-        ref.updateFeature(objectId, changes)
-      }
-      AsyncFunction("deleteFeature") Coroutine { ref: FeatureLayerRef, objectId: Long ->
-        ref.deleteFeature(objectId)
-      }
-    }
+    // FeatureLayerRef is registered on the ExpoArcgisGeometry module to keep this module's
+    // definition() under the Android JVM 64 KB method-size limit (SharedObjects cross modules).
 
     Class(TiledLayerRef::class) {
       Constructor { props: Map<String, Any?> ->
@@ -358,6 +328,10 @@ class ExpoArcgisModule : Module() {
       AsyncFunction("associations") Coroutine { ref: UtilityNetworkRef, tableName: String, whereClause: String ->
         ref.associations(tableName, whereClause)
       }
+      AsyncFunction("getState") Coroutine { ref: UtilityNetworkRef -> ref.getState() }
+      Function("validateNetworkTopology") { ref: UtilityNetworkRef, extent: Map<String, Any?> ->
+        ref.validateNetworkTopology(extent)
+      }
     }
 
     // Interactive GeometryEditor — bound to a <MapView> for sketching; emits onGeometryChange.
@@ -401,6 +375,10 @@ class ExpoArcgisModule : Module() {
         view.identify(screenPoint, options, promise)
       }
 
+      AsyncFunction("identifyPopups") { view: ExpoArcgisMapView, screenPoint: Map<String, Any?>, options: Map<String, Any?>?, promise: Promise ->
+        view.identifyPopups(screenPoint, options, promise)
+      }
+
       AsyncFunction("retryLoad") { view: ExpoArcgisMapView, promise: Promise ->
         view.retryLoad(promise)
       }
@@ -446,6 +424,10 @@ class ExpoArcgisModule : Module() {
       AsyncFunction("identify") { view: ExpoArcgisSceneView, screenPoint: Map<String, Any?>, options: Map<String, Any?>?, promise: Promise ->
         view.identify(screenPoint, options, promise)
       }
+
+      AsyncFunction("identifyPopups") { view: ExpoArcgisSceneView, screenPoint: Map<String, Any?>, options: Map<String, Any?>?, promise: Promise ->
+        view.identifyPopups(screenPoint, options, promise)
+      }
     }
   }
 }

package/android/src/main/java/expo/modules/arcgis/ExpoArcgisSceneView.kt

@@ -101,6 +101,22 @@ class ExpoArcgisSceneView(context: Context, appContext: AppContext) : ExpoView(c
     }
   }
 
+  /** Identifies popups under a screen point — evaluates each and returns `{ title, fields }`. */
+  fun identifyPopups(screenPoint: Map<String, Any?>, options: Map<String, Any?>?, promise: Promise) {
+    val x = (screenPoint["x"] as? Number)?.toDouble() ?: 0.0
+    val y = (screenPoint["y"] as? Number)?.toDouble() ?: 0.0
+    val tolerance = (options?.get("tolerance") as? Number)?.toDouble() ?: 12.0
+    val maxResults = (options?.get("maxResults") as? Number)?.toInt() ?: 1
+    scope.launch {
+      try {
+        val results = sceneView.identifyLayers(ScreenCoordinate(x, y), tolerance, false, maxResults).getOrThrow()
+        promise.resolve(serializePopups(results))
+      } catch (e: Exception) {
+        promise.reject("IDENTIFY_ERROR", e.message ?: "Identify failed", e)
+      }
+    }
+  }
+
   /** Retries loading the scene (Loadable pattern) — useful after a network outage. Re-emits the result. */
   fun retryLoad(promise: Promise) {
     val scene = sceneView.scene ?: run { promise.resolve(null); return }

package/android/src/main/java/expo/modules/arcgis/GeocoderFunctions.kt

@@ -25,9 +25,19 @@ private fun locatorTask(params: Map<String, Any?>): LocatorTask {
   return locators.getOrPut(url) { LocatorTask(url) }
 }
 
-internal suspend fun geocode(searchText: String, params: Map<String, Any?>): List<Map<String, Any?>> =
-  locatorTask(params).geocode(searchText, buildGeocodeParameters(params)).getOrThrow()
-    .map { serializeGeocodeResult(it) }
+internal suspend fun geocode(searchText: String, params: Map<String, Any?>): List<Map<String, Any?>> {
+  val locator = locatorTask(params)
+  val parameters = buildGeocodeParameters(params)
+  @Suppress("UNCHECKED_CAST")
+  val searchValues = (params["searchValues"] as? Map<*, *>)
+    ?.mapNotNull { (k, v) -> if (k is String && v is String) k to v else null }
+    ?.toMap()
+  return if (!searchValues.isNullOrEmpty()) {
+    locator.geocode(searchValues, parameters).getOrThrow()
+  } else {
+    locator.geocode(searchText, parameters).getOrThrow()
+  }.map { serializeGeocodeResult(it) }
+}
 
 internal suspend fun reverseGeocode(point: Map<String, Any?>, params: Map<String, Any?>): List<Map<String, Any?>> {
   val location = geometryFromDict(point) as? Point ?: return emptyList()

package/android/src/main/java/expo/modules/arcgis/GeometryEngineFunctions.kt

@@ -3,7 +3,9 @@ package expo.modules.arcgis
 import com.arcgismaps.geometry.Envelope
 import com.arcgismaps.geometry.Geometry
 import com.arcgismaps.geometry.GeometryEngine
+import com.arcgismaps.geometry.Multipart
 import com.arcgismaps.geometry.Point
+import com.arcgismaps.geometry.Polygon
 import com.arcgismaps.geometry.Polyline
 
 /**
@@ -104,6 +106,39 @@ internal fun geCut(g: Map<String, Any?>, cutter: Map<String, Any?>): List<Map<St
 internal fun geConvexHull(g: Map<String, Any?>): Map<String, Any?>? =
   parseGeo(g)?.let { encode(GeometryEngine.convexHullOrNull(it)) }
 
+internal fun geLabelPoint(g: Map<String, Any?>): Map<String, Any?>? =
+  (parseGeo(g) as? Polygon)?.let { encode(GeometryEngine.labelPointOrNull(it)) }
+
+internal fun geNormalizeCentralMeridian(g: Map<String, Any?>): Map<String, Any?>? =
+  parseGeo(g)?.let { encode(GeometryEngine.normalizeCentralMeridian(it)) }
+
+internal fun geReshape(g: Map<String, Any?>, reshaper: Map<String, Any?>): Map<String, Any?>? {
+  val multipart = parseGeo(g) as? Multipart ?: return null
+  val line = parseGeo(reshaper) as? Polyline ?: return null
+  return encode(GeometryEngine.reshape(multipart, line))
+}
+
+internal fun geIntersections(a: Map<String, Any?>, b: Map<String, Any?>): List<Map<String, Any?>> {
+  val g1 = parseGeo(a) ?: return emptyList()
+  val g2 = parseGeo(b) ?: return emptyList()
+  return GeometryEngine.tryIntersections(g1, g2).mapNotNull { encode(it) }
+}
+
+internal fun geExtend(p: Map<String, Any?>, extender: Map<String, Any?>): Map<String, Any?>? {
+  val polyline = parseGeo(p) as? Polyline ?: return null
+  val ext = parseGeo(extender) as? Polyline ?: return null
+  return encode(GeometryEngine.extend(polyline, ext, emptySet()))
+}
+
+internal fun geAutoComplete(
+  existing: List<Map<String, Any?>>,
+  boundaries: List<Map<String, Any?>>,
+): List<Map<String, Any?>> {
+  val polygons = existing.mapNotNull { parseGeo(it) as? Polygon }
+  val lines = boundaries.mapNotNull { parseGeo(it) as? Polyline }
+  return GeometryEngine.tryAutoComplete(polygons, lines).mapNotNull { encode(it) }
+}
+
 internal fun geBoundary(g: Map<String, Any?>): Map<String, Any?>? =
   parseGeo(g)?.let { encode(GeometryEngine.boundaryOrNull(it)) }
 

package/android/src/main/java/expo/modules/arcgis/GraphicsOverlayRef.kt

@@ -15,8 +15,11 @@ import com.arcgismaps.mapping.symbology.SimpleFillSymbol
 import com.arcgismaps.mapping.symbology.SimpleFillSymbolStyle
 import com.arcgismaps.mapping.symbology.SimpleLineSymbol
 import com.arcgismaps.mapping.symbology.SimpleLineSymbolStyle
+import com.arcgismaps.mapping.symbology.DistanceCompositeSceneSymbol
+import com.arcgismaps.mapping.symbology.DistanceSymbolRange
 import com.arcgismaps.mapping.symbology.SimpleMarkerSceneSymbol
 import com.arcgismaps.mapping.symbology.SimpleMarkerSceneSymbolStyle
+import com.arcgismaps.mapping.symbology.PictureFillSymbol
 import com.arcgismaps.mapping.symbology.PictureMarkerSymbol
 import com.arcgismaps.mapping.symbology.SimpleMarkerSymbol
 import com.arcgismaps.mapping.symbology.SimpleMarkerSymbolStyle
@@ -188,6 +191,28 @@ private fun buildSymbol(s: Map<*, *>): Symbol? = when (s["type"]) {
       (s["height"] as? Number)?.toFloat()?.let { height = it }
     }
   }
+  "picture-fill" -> (s["url"] as? String)?.let { url ->
+    PictureFillSymbol(url).apply {
+      (s["width"] as? Number)?.toFloat()?.let { width = it }
+      (s["height"] as? Number)?.toFloat()?.let { height = it }
+      outline = outlineOf(s["outline"])
+    }
+  }
+  "distance-composite-scene" -> {
+    val composite = DistanceCompositeSceneSymbol()
+    val rangeList = s["ranges"] as? List<*> ?: emptyList<Any>()
+    for (rd in rangeList) {
+      val rdMap = rd as? Map<*, *> ?: continue
+      val sym = (rdMap["symbol"] as? Map<*, *>)?.let(::buildSymbol) ?: continue
+      val range = DistanceSymbolRange(
+        sym,
+        (rdMap["minDistance"] as? Number)?.toDouble(),
+        (rdMap["maxDistance"] as? Number)?.toDouble(),
+      )
+      composite.ranges.add(range)
+    }
+    composite
+  }
   else -> null
 }