expo-arcgis 0.1.8 → 0.2.0

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

@@ -41,6 +41,12 @@ class ExpoArcgisExtrasModule : Module() {
       AsyncFunction("addFeature") Coroutine { ref: FeatureLayerRef, attributes: Map<String, Any?>, geometry: Map<String, Any?>?, apply: Boolean? ->
         ref.addFeature(attributes, geometry, apply)
       }
+      AsyncFunction("addFeatureWithTemplate") Coroutine { ref: FeatureLayerRef, templateName: String, attributes: Map<String, Any?>?, geometry: Map<String, Any?>?, apply: Boolean? ->
+        ref.addFeatureWithTemplate(templateName, attributes, geometry, apply)
+      }
+      AsyncFunction("addFeatureWithSubtype") Coroutine { ref: FeatureLayerRef, subtypeName: String, attributes: Map<String, Any?>?, geometry: Map<String, Any?>?, apply: Boolean? ->
+        ref.addFeatureWithSubtype(subtypeName, attributes, geometry, apply)
+      }
       AsyncFunction("updateFeature") Coroutine { ref: FeatureLayerRef, objectId: Long, changes: Map<String, Any?>, apply: Boolean? ->
         ref.updateFeature(objectId, changes, apply)
       }
@@ -144,5 +150,47 @@ class ExpoArcgisExtrasModule : Module() {
       Function("getFeatureTableNames") { ref: GeodatabaseRef -> ref.getFeatureTableNames() }
       Function("getFeatureLayer") { ref: GeodatabaseRef, tableName: String -> ref.getFeatureLayer(tableName) }
     }
+
+    // Moved from the main module to stay under the Android 64 KB method-size limit on definition().
+    Class(UtilityNetworkRef::class) {
+      Constructor { props: Map<String, Any?> ->
+        UtilityNetworkRef(appContext, props["serviceGeodatabaseUrl"] as? String ?: "")
+      }
+      AsyncFunction("load") Coroutine { ref: UtilityNetworkRef, map: MapRef ->
+        ref.load(map)
+      }
+      Function("describeNetwork") { ref: UtilityNetworkRef -> ref.describeNetwork() }
+      AsyncFunction("trace") Coroutine { ref: UtilityNetworkRef, traceType: String, startingLocations: List<Map<String, Any?>> ->
+        ref.trace(traceType, startingLocations)
+      }
+      AsyncFunction("traceFromQuery") Coroutine { ref: UtilityNetworkRef, tableName: String, whereClause: String, traceType: String ->
+        ref.traceFromQuery(tableName, whereClause, traceType)
+      }
+      AsyncFunction("queryNamedTraceConfigurations") Coroutine { ref: UtilityNetworkRef ->
+        ref.queryNamedTraceConfigurations()
+      }
+      AsyncFunction("traceWithConfiguration") Coroutine { ref: UtilityNetworkRef, configGlobalId: String, tableName: String, whereClause: String ->
+        ref.traceWithConfiguration(configGlobalId, tableName, whereClause)
+      }
+      AsyncFunction("associations") Coroutine { ref: UtilityNetworkRef, tableName: String, whereClause: String ->
+        ref.associations(tableName, whereClause)
+      }
+      Function("getTerminalConfigurations") { ref: UtilityNetworkRef ->
+        ref.getTerminalConfigurations()
+      }
+      AsyncFunction("getState") Coroutine { ref: UtilityNetworkRef -> ref.getState() }
+      Function("validateNetworkTopology") { ref: UtilityNetworkRef, extent: Map<String, Any?> ->
+        ref.validateNetworkTopology(extent)
+      }
+    }
+
+    // Georeferenced image overlay (added to a <MapView> via <ImageOverlay>).
+    Class(ImageOverlayRef::class) {
+      Constructor { ImageOverlayRef(appContext) }
+      Function("setFrame") { ref: ImageOverlayRef, imagePath: String, extent: Map<String, Any?>, opacity: Double? ->
+        ref.setFrame(imagePath, extent, opacity)
+      }
+      Function("setOpacity") { ref: ImageOverlayRef, opacity: Double -> ref.setOpacity(opacity) }
+    }
   }
 }

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

@@ -131,6 +131,11 @@ class ExpoArcgisMapView(context: Context, appContext: AppContext) : ExpoView(con
     mapView.graphicsOverlays.addAll(refs.map { it.overlay })
   }
 
+  fun setImageOverlays(refs: List<ImageOverlayRef>) {
+    mapView.imageOverlays.clear()
+    mapView.imageOverlays.addAll(refs.map { it.overlay })
+  }
+
   /** Animates the view to a runtime viewpoint sent from JS. */
   fun setViewpoint(vp: Map<String, Any?>?) {
     vp ?: return
@@ -231,6 +236,32 @@ class ExpoArcgisMapView(context: Context, appContext: AppContext) : ExpoView(con
     }
   }
 
+  /** Returns the names of the displayed map's bookmarks (e.g. those saved in a loaded web map). */
+  fun getBookmarkNames(promise: Promise) {
+    val map = mapView.map ?: run { promise.resolve(emptyList<String>()); return }
+    scope.launch {
+      map.load()
+        .onSuccess { promise.resolve(map.bookmarks.map { it.name }) }
+        .onFailure { e -> promise.reject("BOOKMARK_ERROR", e.message ?: "Failed to load map", e) }
+    }
+  }
+
+  /** Navigates to the named bookmark's viewpoint; resolves whether a matching bookmark was found. */
+  fun setBookmark(name: String, promise: Promise) {
+    val map = mapView.map ?: run { promise.resolve(false); return }
+    scope.launch {
+      try {
+        map.load().getOrThrow()
+        val viewpoint = map.bookmarks.firstOrNull { it.name == name }?.viewpoint
+          ?: run { promise.resolve(false); return@launch }
+        mapView.setViewpointAnimated(viewpoint, 0.5f)
+        promise.resolve(true)
+      } catch (e: Exception) {
+        promise.reject("BOOKMARK_ERROR", e.message ?: "Failed", e)
+      }
+    }
+  }
+
   override fun onAttachedToWindow() {
     super.onAttachedToWindow()
     // The view-based MapView renders only while observing a lifecycle.

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

@@ -336,37 +336,8 @@ class ExpoArcgisModule : Module() {
     }
 
     // Utility network — loaded from a feature service, attached to a <Map>; runs traces.
-    Class(UtilityNetworkRef::class) {
-      Constructor { props: Map<String, Any?> ->
-        UtilityNetworkRef(appContext, props["serviceGeodatabaseUrl"] as? String ?: "")
-      }
-      AsyncFunction("load") Coroutine { ref: UtilityNetworkRef, map: MapRef ->
-        ref.load(map)
-      }
-      Function("describeNetwork") { ref: UtilityNetworkRef -> ref.describeNetwork() }
-      AsyncFunction("trace") Coroutine { ref: UtilityNetworkRef, traceType: String, startingLocations: List<Map<String, Any?>> ->
-        ref.trace(traceType, startingLocations)
-      }
-      AsyncFunction("traceFromQuery") Coroutine { ref: UtilityNetworkRef, tableName: String, whereClause: String, traceType: String ->
-        ref.traceFromQuery(tableName, whereClause, traceType)
-      }
-      AsyncFunction("queryNamedTraceConfigurations") Coroutine { ref: UtilityNetworkRef ->
-        ref.queryNamedTraceConfigurations()
-      }
-      AsyncFunction("traceWithConfiguration") Coroutine { ref: UtilityNetworkRef, configGlobalId: String, tableName: String, whereClause: String ->
-        ref.traceWithConfiguration(configGlobalId, tableName, whereClause)
-      }
-      AsyncFunction("associations") Coroutine { ref: UtilityNetworkRef, tableName: String, whereClause: String ->
-        ref.associations(tableName, whereClause)
-      }
-      Function("getTerminalConfigurations") { ref: UtilityNetworkRef ->
-        ref.getTerminalConfigurations()
-      }
-      AsyncFunction("getState") Coroutine { ref: UtilityNetworkRef -> ref.getState() }
-      Function("validateNetworkTopology") { ref: UtilityNetworkRef, extent: Map<String, Any?> ->
-        ref.validateNetworkTopology(extent)
-      }
-    }
+    // UtilityNetworkRef is registered in ExpoArcgisExtras (this module's definition() hit the
+    // Android 64 KB method-size limit). SharedObjects are global, so it still attaches to a <Map> here.
 
     // Interactive GeometryEditor — bound to a <MapView> for sketching; emits onGeometryChange.
     Class(GeometryEditorRef::class) {
@@ -393,6 +364,10 @@ class ExpoArcgisModule : Module() {
         view.setGraphicsOverlays(refs)
       }
 
+      Prop("imageOverlays") { view: ExpoArcgisMapView, refs: List<ImageOverlayRef> ->
+        view.setImageOverlays(refs)
+      }
+
       Prop("viewpoint") { view: ExpoArcgisMapView, vp: Map<String, Any?>? ->
         view.setViewpoint(vp)
       }
@@ -420,6 +395,14 @@ class ExpoArcgisModule : Module() {
       AsyncFunction("retryLoad") { view: ExpoArcgisMapView, promise: Promise ->
         view.retryLoad(promise)
       }
+
+      AsyncFunction("getBookmarkNames") { view: ExpoArcgisMapView, promise: Promise ->
+        view.getBookmarkNames(promise)
+      }
+
+      AsyncFunction("setBookmark") { view: ExpoArcgisMapView, name: String, promise: Promise ->
+        view.setBookmark(name, promise)
+      }
     }
 
     // 3D scene host — named so JS resolves it via requireNativeView('ExpoArcgis', 'ExpoArcgisSceneView').

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

@@ -21,9 +21,15 @@ import com.arcgismaps.mapping.symbology.DistanceSymbolRange
 import com.arcgismaps.mapping.symbology.SimpleMarkerSceneSymbol
 import com.arcgismaps.mapping.symbology.SimpleMarkerSceneSymbolStyle
 import com.arcgismaps.mapping.symbology.MultilayerPointSymbol
+import com.arcgismaps.mapping.symbology.MultilayerPolygonSymbol
+import com.arcgismaps.mapping.symbology.MultilayerPolylineSymbol
 import com.arcgismaps.mapping.symbology.PictureFillSymbol
 import com.arcgismaps.mapping.symbology.PictureMarkerSymbol
 import com.arcgismaps.mapping.symbology.PictureMarkerSymbolLayer
+import com.arcgismaps.mapping.symbology.SolidFillSymbolLayer
+import com.arcgismaps.mapping.symbology.SolidStrokeSymbolLayer
+import com.arcgismaps.mapping.symbology.VectorMarkerSymbolElement
+import com.arcgismaps.mapping.symbology.VectorMarkerSymbolLayer
 import com.arcgismaps.mapping.symbology.SimpleMarkerSymbol
 import com.arcgismaps.mapping.symbology.SimpleMarkerSymbolStyle
 import com.arcgismaps.mapping.symbology.SimpleRenderer
@@ -375,10 +381,8 @@ private fun buildSymbol(s: Map<*, *>): Symbol? = when (s["type"]) {
     CompositeSymbol(symbolList)
   }
   "multilayer-point" -> {
-    // Build each picture-marker symbol layer and assemble a MultilayerPointSymbol.
+    // Build each symbol layer and assemble a MultilayerPointSymbol.
     // symbolLayers on MultilayerSymbol is a mutable List — populated via the constructor.
-    // DEFER: vector-marker layers (VectorMarkerSymbolLayer) require VectorMarkerSymbolElement
-    //   from geometry+symbol objects and cannot be cleanly constructed from a plain dict; skip.
     val layerDicts = s["symbolLayers"] as? List<*> ?: emptyList<Any>()
     val symbolLayers = layerDicts.mapNotNull { ld ->
       val ldMap = ld as? Map<*, *> ?: return@mapNotNull null
@@ -393,6 +397,44 @@ private fun buildSymbol(s: Map<*, *>): Symbol? = when (s["type"]) {
             (ldMap["offsetY"] as? Number)?.toDouble()?.let { offsetY = it }
           }
         }
+        "vector-marker" -> {
+          val geomMap = ldMap["geometry"] as? Map<*, *> ?: return@mapNotNull null
+          val geom = geometryFromDict(geomMap) ?: return@mapNotNull null
+          val elementSymbol = when (geomMap["type"]) {
+            "polygon" -> {
+              val fillColor = colorOf(ldMap["fillColor"]) ?: Color.fromRgba(255, 0, 0, 255)
+              val elementLayers = buildList {
+                add(SolidFillSymbolLayer(fillColor))
+                colorOf(ldMap["outlineColor"])?.let { outlineColor ->
+                  val outlineWidth = (ldMap["outlineWidth"] as? Number)?.toDouble() ?: 1.0
+                  add(SolidStrokeSymbolLayer(outlineWidth, outlineColor))
+                }
+              }
+              MultilayerPolygonSymbol(elementLayers)
+            }
+            "polyline" -> {
+              val strokeColor = colorOf(ldMap["fillColor"]) ?: colorOf(ldMap["outlineColor"]) ?: Color.fromRgba(255, 0, 0, 255)
+              val strokeWidth = (ldMap["outlineWidth"] as? Number)?.toDouble() ?: 1.0
+              MultilayerPolylineSymbol(listOf(SolidStrokeSymbolLayer(strokeWidth, strokeColor)))
+            }
+            "multipoint" -> {
+              val fillColor = colorOf(ldMap["fillColor"]) ?: Color.fromRgba(255, 0, 0, 255)
+              val elementLayers = buildList {
+                add(SolidFillSymbolLayer(fillColor))
+                colorOf(ldMap["outlineColor"])?.let { outlineColor ->
+                  val outlineWidth = (ldMap["outlineWidth"] as? Number)?.toDouble() ?: 1.0
+                  add(SolidStrokeSymbolLayer(outlineWidth, outlineColor))
+                }
+              }
+              MultilayerPointSymbol(elementLayers)
+            }
+            else -> return@mapNotNull null // unsupported geometry type — skip gracefully
+          }
+          val element = VectorMarkerSymbolElement(geom, elementSymbol)
+          VectorMarkerSymbolLayer(listOf(element)).apply {
+            (ldMap["size"] as? Number)?.toDouble()?.let { size = it }
+          }
+        }
         else -> null
       }
     }

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

@@ -0,0 +1,28 @@
+package expo.modules.arcgis
+
+import com.arcgismaps.geometry.Envelope
+import com.arcgismaps.mapping.view.ImageFrame
+import com.arcgismaps.mapping.view.ImageOverlay
+import expo.modules.kotlin.AppContext
+import expo.modules.kotlin.sharedobjects.SharedObject
+
+/**
+ * An [ImageOverlay] that displays a single georeferenced image frame — a local image file shown at a
+ * map extent, with adjustable opacity. Added to a `<MapView>` via the `<ImageOverlay>` component.
+ */
+class ImageOverlayRef(appContext: AppContext) : SharedObject(appContext) {
+  val overlay = ImageOverlay()
+
+  /** Sets the displayed frame from a local image file path and its geographic extent (clears on null). */
+  fun setFrame(imagePath: String, extent: Map<String, Any?>, opacity: Double?) {
+    val envelope = geometryFromDict(extent + ("type" to "envelope")) as? Envelope
+    if (envelope == null) {
+      overlay.imageFrame = null
+      return
+    }
+    overlay.imageFrame = ImageFrame(imagePath, envelope)
+    opacity?.let { overlay.opacity = it.toFloat() }
+  }
+
+  fun setOpacity(opacity: Double) { overlay.opacity = opacity.toFloat() }
+}

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

@@ -117,6 +117,45 @@ class FeatureLayerRef(appContext: AppContext, private val table: FeatureTable) :
     }
   }
 
+  /**
+   * Adds a feature created from the named template (inheriting its prototype attributes), then
+   * optionally applies [attributes] on top and sets [geometry]. When [apply] is not `false`,
+   * pushes the edit and returns the new object id; pass `apply = false` for a local-only edit.
+   */
+  suspend fun addFeatureWithTemplate(templateName: String, attributes: Map<String, Any?>?, geometry: Map<String, Any?>?, apply: Boolean?): Long? {
+    table.load().getOrThrow()
+    val arcGISTable = table as? ArcGISFeatureTable
+      ?: throw IllegalStateException("addFeatureWithTemplate requires an ArcGIS feature table (not a shapefile or WFS table)")
+    val template = arcGISTable.getFeatureTemplate(templateName)
+      ?: throw IllegalArgumentException("No feature template named '$templateName' found in the table")
+    val geom = geometry?.let { geometryFromDict(it) }
+    val feature = arcGISTable.createFeature(template, geom)
+    if (attributes != null) applyAttributes(feature, attributes)
+    table.addFeature(feature).getOrThrow()
+    if (apply == false) return null
+    return persistEdits()
+  }
+
+  /**
+   * Adds a feature created from the named subtype (sets the subtype field and inherits its
+   * default attribute values), then optionally applies [attributes] on top and sets [geometry].
+   * When [apply] is not `false`, pushes the edit and returns the new object id; pass
+   * `apply = false` for a local-only edit.
+   */
+  suspend fun addFeatureWithSubtype(subtypeName: String, attributes: Map<String, Any?>?, geometry: Map<String, Any?>?, apply: Boolean?): Long? {
+    table.load().getOrThrow()
+    val arcGISTable = table as? ArcGISFeatureTable
+      ?: throw IllegalStateException("addFeatureWithSubtype requires an ArcGIS feature table (not a shapefile or WFS table)")
+    val subtype = arcGISTable.featureSubtypes.firstOrNull { it.name == subtypeName }
+      ?: throw IllegalArgumentException("No feature subtype named '$subtypeName' found in the table")
+    val geom = geometry?.let { geometryFromDict(it) }
+    val feature = arcGISTable.createFeature(subtype, geom)
+    if (attributes != null) applyAttributes(feature, attributes)
+    table.addFeature(feature).getOrThrow()
+    if (apply == false) return null
+    return persistEdits()
+  }
+
   /**
    * Adds a feature. When `apply` is not `false`, pushes the edit and returns the new object id;
    * pass `apply = false` to make a local-only edit (batch with `applyEdits`).

package/build/DynamicEntityLayer.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"DynamicEntityLayer.d.ts","sourceRoot":"","sources":["../src/DynamicEntityLayer.tsx"],"names":[],"mappings":"AAEA,OAAO,KAAK,EACV,gBAAgB,EAChB,mBAAmB,EACnB,wBAAwB,EAEzB,MAAM,oBAAoB,CAAC;AAO5B;;;;;GAKG;AACH,eAAO,MAAM,kBAAkB;;;;;mBAwD48hC,CAAC;gBAAkB,CAAC;;;;;;;4DAD9/hC,CAAC"}
+{"version":3,"file":"DynamicEntityLayer.d.ts","sourceRoot":"","sources":["../src/DynamicEntityLayer.tsx"],"names":[],"mappings":"AAEA,OAAO,KAAK,EACV,gBAAgB,EAChB,mBAAmB,EACnB,wBAAwB,EAEzB,MAAM,oBAAoB,CAAC;AAO5B;;;;;GAKG;AACH,eAAO,MAAM,kBAAkB;;;;;mBAwDkhmC,CAAC;gBAAkB,CAAC;;;;;;;4DADpkmC,CAAC"}

package/build/ExpoArcgis.types.d.ts

@@ -441,6 +441,10 @@ export type MapViewHandle = {
     }): Promise<PopupResult[]>;
     /** Retries loading the map after a failure (e.g. a network outage). Re-fires `onMapLoaded`/`onMapLoadError`. */
     retryLoad(): Promise<void>;
+    /** Names of the displayed map's bookmarks (e.g. those saved in a loaded web map). */
+    getBookmarkNames(): Promise<string[]>;
+    /** Navigates to the named bookmark's viewpoint; resolves to whether a matching bookmark was found. */
+    setBookmark(name: string): Promise<boolean>;
 };
 /** Imperative handle exposed by `<SceneView>` via `ref`. */
 export type SceneViewHandle = {
@@ -513,6 +517,42 @@ export type FeatureLayerHandle = {
      * edit, then batch with `applyEdits`. Resolves to `null` for non-service tables or local edits.
      */
     addFeature(attributes: Record<string, unknown>, geometry?: Geometry, apply?: boolean): Promise<number | null>;
+    /**
+     * Creates a feature from the named editing template (so the new feature inherits the template's
+     * prototype attributes), then optionally overrides `attributes` on top and sets `geometry`.
+     * By default pushes the edit to the service and resolves to the new object id; pass
+     * `apply: false` to make a local-only edit. Rejects if no template with that name exists.
+     * Requires an ArcGIS feature table (service or mobile geodatabase) — rejects for shapefiles
+     * and WFS tables, which do not expose editing templates.
+     *
+     * @example
+     * ```ts
+     * const id = await layer.current.addFeatureWithTemplate(
+     *   'Residential',
+     *   { ADDRESS: '1 Main St' },
+     *   { type: 'point', x: -117.19, y: 34.05 }
+     * );
+     * ```
+     */
+    addFeatureWithTemplate(templateName: string, attributes?: Record<string, unknown>, geometry?: Geometry, apply?: boolean): Promise<number | null>;
+    /**
+     * Creates a feature from the named feature subtype (sets the subtype field and inherits the
+     * subtype's default attribute values), then optionally overrides `attributes` on top and sets
+     * `geometry`. By default pushes the edit to the service and resolves to the new object id;
+     * pass `apply: false` to make a local-only edit. Rejects if no subtype with that name exists.
+     * Requires an ArcGIS feature table (service or mobile geodatabase) — rejects for shapefiles
+     * and WFS tables, which do not expose feature subtypes.
+     *
+     * @example
+     * ```ts
+     * const id = await layer.current.addFeatureWithSubtype(
+     *   'Arterial',
+     *   { ROADNAME: 'Main St' },
+     *   { type: 'point', x: -117.19, y: 34.05 }
+     * );
+     * ```
+     */
+    addFeatureWithSubtype(subtypeName: string, attributes?: Record<string, unknown>, geometry?: Geometry, apply?: boolean): Promise<number | null>;
     /** Updates the feature with `objectId`. Pass `apply: false` for a local-only edit. */
     updateFeature(objectId: number, changes: {
         attributes?: Record<string, unknown>;
@@ -933,6 +973,15 @@ export type Envelope = {
     /** Coordinate system WKID. Defaults to `4326` (WGS84). */
     spatialReference?: SpatialReference;
 };
+/** Props for the `<ImageOverlay>` component — a georeferenced image displayed on a `<MapView>`. */
+export type ImageOverlayProps = {
+    /** Local image file path to display (e.g. a downloaded or bundled PNG/JPEG). */
+    imagePath: string;
+    /** The geographic extent (envelope) the image is stretched to fill. */
+    extent: Envelope;
+    /** Overlay opacity, 0–1. Defaults to `1`. */
+    opacity?: number;
+};
 /**
  * A geometry value. The `type` discriminator mirrors the ArcGIS web API
  * (`"point"` / `"multipoint"` / `"polyline"` / `"polygon"` / `"envelope"`) and
@@ -1712,10 +1761,6 @@ export type CompositeSymbolType = {
  * NOTE: `size` sets a uniform size (overrides `width`/`height` when all three are supplied).
  * `width` and `height` are applied in order, so supplying both sets size to the last one;
  * use `size` for a uniform value. `offsetX`/`offsetY` shift the layer in points.
- *
- * DEFER: `VectorMarkerSymbolLayer` (the vector-marker kind) requires constructing
- * `VectorMarkerSymbolElement` objects from geometry + symbol objects, which cannot be
- * expressed as a plain flat dict. It is not yet implemented.
  */
 export type PictureMarkerSymbolLayerSpec = {
     type: 'picture-marker';
@@ -1732,19 +1777,78 @@ export type PictureMarkerSymbolLayerSpec = {
     /** Vertical offset of the layer, in points. */
     offsetY?: number;
 };
+/**
+ * One vector-marker symbol layer within a `MultilayerPointSymbolType`.
+ * Mirrors the native `VectorMarkerSymbolLayer` (a shape drawn from a geometry with fill/stroke,
+ * requiring no image).
+ *
+ * Supported `geometry` types and how they are symbolised:
+ * - `polygon` — `MultilayerPolygonSymbol([SolidFillSymbolLayer, SolidStrokeSymbolLayer?])`;
+ *   `fillColor` is the fill, `outlineColor`/`outlineWidth` add an optional stroke.
+ * - `polyline` — `MultilayerPolylineSymbol([SolidStrokeSymbolLayer])`; `fillColor` is used as the
+ *   stroke color (falls back to `outlineColor`, then red), `outlineWidth` sets the stroke width.
+ * - `multipoint` — `MultilayerPointSymbol([SolidFillSymbolLayer, SolidStrokeSymbolLayer?])`;
+ *   same color/width props as `polygon`.
+ *
+ * Any other `geometry` type is silently skipped (the layer is omitted from the symbol).
+ * Geometries use a local coordinate space (not geographic) — use small integer-scale coordinates
+ * (e.g. `x` / `y` in the range `[-1, 1]`).
+ *
+ * @example — filled triangle (polygon)
+ * ```ts
+ * { type: 'multilayer-point', symbolLayers: [
+ *   { type: 'vector-marker', size: 24,
+ *     geometry: { type: 'polygon', points: [
+ *       { x: -1, y: -1 }, { x: 0, y: 1 }, { x: 1, y: -1 },
+ *     ] },
+ *     fillColor: '#e63946', outlineColor: '#1d3557', outlineWidth: 1 },
+ * ] }
+ * ```
+ */
+export type VectorMarkerSymbolLayerSpec = {
+    type: 'vector-marker';
+    /**
+     * The geometry that defines the marker shape. Supported types: `polygon`, `polyline`,
+     * `multipoint`. Unsupported types are silently skipped. The geometry is defined in a local
+     * coordinate space (not geographic) — use small integer-scale coordinates
+     * (e.g. `x` / `y` in the range `[-1, 1]`).
+     */
+    geometry: Geometry;
+    /** Overall size of the marker, in points. Scales the geometry uniformly. Defaults to 12. */
+    size?: number;
+    /** Fill color as a `#RRGGBB` / `#RRGGBBAA` hex string. Defaults to red. */
+    fillColor?: string;
+    /** Outline stroke color as a `#RRGGBB` / `#RRGGBBAA` hex string. Omit to suppress outline. */
+    outlineColor?: string;
+    /** Outline stroke width in points. Defaults to 1. */
+    outlineWidth?: number;
+};
 /** Union of all supported symbol layer kinds within a `MultilayerPointSymbolType`. */
-export type SymbolLayerSpec = PictureMarkerSymbolLayerSpec;
+export type SymbolLayerSpec = PictureMarkerSymbolLayerSpec | VectorMarkerSymbolLayerSpec;
 /**
  * A multilayer point symbol composed of one or more symbol layers.
  * Mirrors the native `MultilayerPointSymbol`. Useful for rich point icons built from stacked
- * picture images (e.g. a pin body + a badge overlay at different offsets).
+ * picture images or vector shapes (e.g. a filled triangle marker, or a pin body + badge).
  *
- * @example
+ * Supported layer kinds: `picture-marker` and `vector-marker`.
+ *
+ * @example — picture marker
  * ```ts
  * { type: 'multilayer-point', symbolLayers: [
  *   { type: 'picture-marker', url: 'https://example.com/pin.png', width: 30, height: 30 },
  * ] }
  * ```
+ *
+ * @example — vector marker (filled triangle)
+ * ```ts
+ * { type: 'multilayer-point', symbolLayers: [
+ *   { type: 'vector-marker', size: 24,
+ *     geometry: { type: 'polygon', points: [
+ *       { x: 0, y: 1 }, { x: 1, y: -1 }, { x: -1, y: -1 },
+ *     ] },
+ *     fillColor: '#e63946', outlineColor: '#1d3557', outlineWidth: 1.5 },
+ * ] }
+ * ```
  */
 export type MultilayerPointSymbolType = {
     type: 'multilayer-point';