@chelone/core 0.5.0 → 0.7.0

package/dist/geo/geojson.js

@@ -1,57 +1,69 @@
-function isRecord(value) {
-  return typeof value === "object" && value !== null && !Array.isArray(value);
-}
+import { isJsonObject, isRecord } from "../guards.js";
+// src/geo/geojson.ts
 function isFiniteNumber(value) {
-  return typeof value === "number" && Number.isFinite(value);
+	return typeof value === "number" && Number.isFinite(value);
 }
 function isPosition(value) {
-  return Array.isArray(value) && value.length >= 2 && value.every(isFiniteNumber);
+	return Array.isArray(value) && value.length >= 2 && value.every(isFiniteNumber);
 }
+/** Checks `depth` levels of arrays above the positions (0 is a position). */
 function isNested(value, depth) {
-  if (depth === 0) return isPosition(value);
-  return Array.isArray(value) && value.every((item) => isNested(item, depth - 1));
-}
-const COORDINATE_DEPTH = {
-  Point: 0,
-  MultiPoint: 1,
-  LineString: 1,
-  MultiLineString: 2,
-  Polygon: 2,
-  MultiPolygon: 3
+	if (depth === 0) return isPosition(value);
+	return Array.isArray(value) && value.every((item) => isNested(item, depth - 1));
+}
+/** Array depth above the positions, per geometry type. */
+var COORDINATE_DEPTH = {
+	Point: 0,
+	MultiPoint: 1,
+	LineString: 1,
+	MultiLineString: 2,
+	Polygon: 2,
+	MultiPolygon: 3
 };
+/** True for exactly four finite numbers. */
 function isGeoBBox(value) {
-  return Array.isArray(value) && value.length === 4 && value.every(isFiniteNumber);
+	return Array.isArray(value) && value.length === 4 && value.every(isFiniteNumber);
 }
+/** The `bbox` member of an object: 4 numbers, or 6 when it carries altitude. */
 function hasValidBBox(value) {
-  const { bbox } = value;
-  if (bbox === void 0) return true;
-  return Array.isArray(bbox) && (bbox.length === 4 || bbox.length === 6) && bbox.every(isFiniteNumber);
+	const { bbox } = value;
+	if (bbox === void 0) return true;
+	return Array.isArray(bbox) && (bbox.length === 4 || bbox.length === 6) && bbox.every(isFiniteNumber);
 }
 function isGeoGeometry(value) {
-  if (!isRecord(value) || !hasValidBBox(value)) return false;
-  if (value.type === "GeometryCollection") {
-    return Array.isArray(value.geometries) && value.geometries.every(isGeoGeometry);
-  }
-  const depth = typeof value.type === "string" && Object.hasOwn(COORDINATE_DEPTH, value.type) ? COORDINATE_DEPTH[value.type] : void 0;
-  return depth !== void 0 && isNested(value.coordinates, depth);
+	if (!isRecord(value) || !hasValidBBox(value)) return false;
+	if (value.type === "GeometryCollection") return Array.isArray(value.geometries) && value.geometries.every(isGeoGeometry);
+	const depth = typeof value.type === "string" && Object.hasOwn(COORDINATE_DEPTH, value.type) ? COORDINATE_DEPTH[value.type] : void 0;
+	return depth !== void 0 && isNested(value.coordinates, depth);
+}
+/** A Polygon or a MultiPolygon, the geometries turf's area operations take. */
+function isGeoArea(value) {
+	return isGeoGeometry(value) && (value.type === "Polygon" || value.type === "MultiPolygon");
 }
 function isGeoFeature(value) {
-  if (!isRecord(value) || value.type !== "Feature" || !hasValidBBox(value)) {
-    return false;
-  }
-  if (value.geometry !== null && !isGeoGeometry(value.geometry)) return false;
-  return value.properties === void 0 || value.properties === null || isRecord(value.properties);
+	if (!isRecord(value) || value.type !== "Feature" || !hasValidBBox(value)) return false;
+	if (value.geometry !== null && !isGeoGeometry(value.geometry)) return false;
+	return value.properties === void 0 || value.properties === null || isJsonObject(value.properties);
 }
 function isGeoFeatureCollection(value) {
-  return isRecord(value) && value.type === "FeatureCollection" && hasValidBBox(value) && Array.isArray(value.features) && value.features.every(isGeoFeature);
+	return isRecord(value) && value.type === "FeatureCollection" && hasValidBBox(value) && Array.isArray(value.features) && value.features.every(isGeoFeature);
 }
 function isGeoJsonValue(value) {
-  return isGeoGeometry(value) || isGeoFeature(value) || isGeoFeatureCollection(value);
-}
-export {
-  isGeoBBox,
-  isGeoFeature,
-  isGeoFeatureCollection,
-  isGeoGeometry,
-  isGeoJsonValue
-};
+	return isGeoGeometry(value) || isGeoFeature(value) || isGeoFeatureCollection(value);
+}
+/** The features MapLibre draws: a feature with a null geometry has nothing to draw. */
+function placedFeatures(collection) {
+	const features = [];
+	for (const feature of collection.features) {
+		const { geometry } = feature;
+		if (geometry !== null) features.push({
+			...feature,
+			geometry
+		});
+	}
+	return {
+		...collection,
+		features
+	};
+}
+export { isGeoArea, isGeoBBox, isGeoFeature, isGeoFeatureCollection, isGeoGeometry, isGeoJsonValue, placedFeatures };

package/dist/geo/geometry-math.d.ts

@@ -1,17 +1,17 @@
-import type { GeoGeometry } from "./geojson.js";
+import type { Geometry } from "geojson";
 /**
  * Area in square metres on a sphere of radius 6378137 m, as `@turf/area`
  * computes it. Holes are subtracted. `0` for every type but Polygon and
  * MultiPolygon.
  */
-export declare function geoAreaM2(geometry: GeoGeometry): number;
+export declare function geoAreaM2(geometry: Geometry): number;
 /**
  * True when two non-adjacent segments of a ring or a line cross or touch.
  * Rings of one polygon, or polygons of one collection, are not compared with
  * each other.
  */
-export declare function hasSelfIntersection(geometry: GeoGeometry): boolean;
-type Area = Extract<GeoGeometry, {
+export declare function hasSelfIntersection(geometry: Geometry): boolean;
+type Area = Extract<Geometry, {
     type: "Polygon" | "MultiPolygon";
 }>;
 /**

package/dist/geo/geometry-math.js

@@ -1,120 +1,127 @@
-const EARTH_RADIUS_M = 6378137;
+// src/geo/geometry-math.ts
+var EARTH_RADIUS_M = 6378137;
 function toRadians(degrees) {
-  return degrees * Math.PI / 180;
+	return degrees * Math.PI / 180;
 }
+/** An element of an array whose index the caller keeps in range. */
 function at(positions, index) {
-  return positions[index];
+	const position = positions[index];
+	if (!position) throw new RangeError(`No position at index ${index}`);
+	return position;
+}
+/** Longitude and latitude; `NaN` for one a short position lacks. */
+function xy([x = NaN, y = NaN]) {
+	return [x, y];
 }
 function samePosition(a, b) {
-  return a[0] === b[0] && a[1] === b[1];
+	const [ax, ay] = xy(a);
+	const [bx, by] = xy(b);
+	return ax === bx && ay === by;
 }
+/** Drops a closing position that repeats the first one. */
 function openRing(ring) {
-  const last = ring[ring.length - 1];
-  return ring.length > 1 && last && samePosition(at(ring, 0), last) ? ring.slice(0, -1) : ring;
+	const last = ring[ring.length - 1];
+	return ring.length > 1 && last && samePosition(at(ring, 0), last) ? ring.slice(0, -1) : ring;
 }
+/** Unsigned area of one ring on the sphere. */
 function ringAreaM2(ring) {
-  const points = openRing(ring);
-  const count = points.length;
-  if (count < 3) return 0;
-  let sum = 0;
-  for (let i = 0; i < count; i++) {
-    const before = at(points, (i + count - 1) % count);
-    const here = at(points, i);
-    const after = at(points, (i + 1) % count);
-    sum += (toRadians(after[0]) - toRadians(before[0])) * Math.sin(toRadians(here[1]));
-  }
-  return Math.abs(sum * EARTH_RADIUS_M * EARTH_RADIUS_M / 2);
+	const points = openRing(ring);
+	const count = points.length;
+	if (count < 3) return 0;
+	let sum = 0;
+	for (let i = 0; i < count; i++) {
+		const before = at(points, (i + count - 1) % count);
+		const here = at(points, i);
+		const after = at(points, (i + 1) % count);
+		sum += (toRadians(xy(after)[0]) - toRadians(xy(before)[0])) * Math.sin(toRadians(xy(here)[1]));
+	}
+	return Math.abs(sum * EARTH_RADIUS_M * EARTH_RADIUS_M / 2);
 }
 function polygonAreaM2(rings) {
-  const [outer, ...holes] = rings;
-  if (!outer) return 0;
-  return holes.reduce(
-    (area, hole) => area - ringAreaM2(hole),
-    ringAreaM2(outer)
-  );
+	const [outer, ...holes] = rings;
+	if (!outer) return 0;
+	return holes.reduce((area, hole) => area - ringAreaM2(hole), ringAreaM2(outer));
 }
+/**
+* Area in square metres on a sphere of radius 6378137 m, as `@turf/area`
+* computes it. Holes are subtracted. `0` for every type but Polygon and
+* MultiPolygon.
+*/
 function geoAreaM2(geometry) {
-  if (geometry.type === "Polygon") return polygonAreaM2(geometry.coordinates);
-  if (geometry.type === "MultiPolygon") {
-    return geometry.coordinates.reduce(
-      (total, polygon) => total + polygonAreaM2(polygon),
-      0
-    );
-  }
-  return 0;
+	if (geometry.type === "Polygon") return polygonAreaM2(geometry.coordinates);
+	if (geometry.type === "MultiPolygon") return geometry.coordinates.reduce((total, polygon) => total + polygonAreaM2(polygon), 0);
+	return 0;
 }
+/** Twice the signed area of the triangle `a`, `b`, `c`. */
 function cross(a, b, c) {
-  return (b[0] - a[0]) * (c[1] - a[1]) - (b[1] - a[1]) * (c[0] - a[0]);
+	const [ax, ay] = xy(a);
+	const [bx, by] = xy(b);
+	const [cx, cy] = xy(c);
+	return (bx - ax) * (cy - ay) - (by - ay) * (cx - ax);
 }
 function onSegment(a, b, point) {
-  return point[0] >= Math.min(a[0], b[0]) && point[0] <= Math.max(a[0], b[0]) && point[1] >= Math.min(a[1], b[1]) && point[1] <= Math.max(a[1], b[1]);
+	const [ax, ay] = xy(a);
+	const [bx, by] = xy(b);
+	const [px, py] = xy(point);
+	return px >= Math.min(ax, bx) && px <= Math.max(ax, bx) && py >= Math.min(ay, by) && py <= Math.max(ay, by);
 }
+/** True when the segments share any point, a touch or an overlap included. */
 function segmentsMeet(a, b, c, d) {
-  const abc = cross(a, b, c);
-  const abd = cross(a, b, d);
-  const cda = cross(c, d, a);
-  const cdb = cross(c, d, b);
-  if ((abc > 0 && abd < 0 || abc < 0 && abd > 0) && (cda > 0 && cdb < 0 || cda < 0 && cdb > 0)) {
-    return true;
-  }
-  return abc === 0 && onSegment(a, b, c) || abd === 0 && onSegment(a, b, d) || cda === 0 && onSegment(c, d, a) || cdb === 0 && onSegment(c, d, b);
+	const abc = cross(a, b, c);
+	const abd = cross(a, b, d);
+	const cda = cross(c, d, a);
+	const cdb = cross(c, d, b);
+	if ((abc > 0 && abd < 0 || abc < 0 && abd > 0) && (cda > 0 && cdb < 0 || cda < 0 && cdb > 0)) return true;
+	return abc === 0 && onSegment(a, b, c) || abd === 0 && onSegment(a, b, d) || cda === 0 && onSegment(c, d, a) || cdb === 0 && onSegment(c, d, b);
 }
+/**
+* True when two segments that do not follow each other share a point.
+* `closed` makes the last segment follow the first.
+*/
 function pathSelfIntersects(positions, closed) {
-  const points = positions.filter(
-    (position, index) => index === 0 || !samePosition(position, at(positions, index - 1))
-  );
-  const segments = closed ? points.length : points.length - 1;
-  for (let i = 0; i < segments; i++) {
-    for (let j = i + 2; j < segments; j++) {
-      if (closed && i === 0 && j === segments - 1) continue;
-      if (segmentsMeet(
-        at(points, i),
-        at(points, (i + 1) % points.length),
-        at(points, j),
-        at(points, (j + 1) % points.length)
-      )) {
-        return true;
-      }
-    }
-  }
-  return false;
+	const points = positions.filter((position, index) => index === 0 || !samePosition(position, at(positions, index - 1)));
+	const segments = closed ? points.length : points.length - 1;
+	for (let i = 0; i < segments; i++) for (let j = i + 2; j < segments; j++) {
+		if (closed && i === 0 && j === segments - 1) continue;
+		if (segmentsMeet(at(points, i), at(points, (i + 1) % points.length), at(points, j), at(points, (j + 1) % points.length))) return true;
+	}
+	return false;
 }
 function lineSelfIntersects(line) {
-  const first = line[0];
-  const last = line[line.length - 1];
-  const closed = line.length > 3 && first !== void 0 && last !== void 0 && samePosition(first, last);
-  return pathSelfIntersects(closed ? line.slice(0, -1) : line, closed);
+	const first = line[0];
+	const last = line[line.length - 1];
+	const closed = line.length > 3 && first !== void 0 && last !== void 0 && samePosition(first, last);
+	return pathSelfIntersects(closed ? line.slice(0, -1) : line, closed);
 }
+/**
+* True when two non-adjacent segments of a ring or a line cross or touch.
+* Rings of one polygon, or polygons of one collection, are not compared with
+* each other.
+*/
 function hasSelfIntersection(geometry) {
-  switch (geometry.type) {
-    case "LineString":
-      return lineSelfIntersects(geometry.coordinates);
-    case "MultiLineString":
-      return geometry.coordinates.some(lineSelfIntersects);
-    case "Polygon":
-      return geometry.coordinates.some(
-        (ring) => pathSelfIntersects(openRing(ring), true)
-      );
-    case "MultiPolygon":
-      return geometry.coordinates.some(
-        (polygon) => polygon.some((ring) => pathSelfIntersects(openRing(ring), true))
-      );
-    case "GeometryCollection":
-      return geometry.geometries.some(hasSelfIntersection);
-    default:
-      return false;
-  }
+	switch (geometry.type) {
+		case "LineString": return lineSelfIntersects(geometry.coordinates);
+		case "MultiLineString": return geometry.coordinates.some(lineSelfIntersects);
+		case "Polygon": return geometry.coordinates.some((ring) => pathSelfIntersects(openRing(ring), true));
+		case "MultiPolygon": return geometry.coordinates.some((polygon) => polygon.some((ring) => pathSelfIntersects(openRing(ring), true)));
+		case "GeometryCollection": return geometry.geometries.some(hasSelfIntersection);
+		default: return false;
+	}
 }
-const areaInTypeOf = (value, result) => {
-  if (value.type === "MultiPolygon") {
-    return result.type === "Polygon" ? { type: "MultiPolygon", coordinates: [result.coordinates] } : result;
-  }
-  if (result.type === "Polygon") return result;
-  const [only, ...rest] = result.coordinates;
-  return only && rest.length === 0 ? { type: "Polygon", coordinates: only } : null;
-};
-export {
-  areaInTypeOf,
-  geoAreaM2,
-  hasSelfIntersection
+/**
+* `result` in the type of `value`, so it stays editable by the input that owns
+* the field. `null` when a Polygon would have to hold several pieces.
+*/
+var areaInTypeOf = (value, result) => {
+	if (value.type === "MultiPolygon") return result.type === "Polygon" ? {
+		type: "MultiPolygon",
+		coordinates: [result.coordinates]
+	} : result;
+	if (result.type === "Polygon") return result;
+	const [only, ...rest] = result.coordinates;
+	return only && rest.length === 0 ? {
+		type: "Polygon",
+		coordinates: only
+	} : null;
 };
+export { areaInTypeOf, geoAreaM2, hasSelfIntersection };

package/dist/geo/index.d.ts

@@ -1,15 +1,16 @@
 export { aspectLockedBBox, bboxToPolygon, polygonToBBox } from "./bbox.js";
+export type { LngLatBox } from "./bounds.js";
 export { geoBounds, isLngLatBox } from "./bounds.js";
 export { countVertices, maxVertices, minAreaM2, minVertices, noSelfIntersection, } from "./constraints.js";
 export { latitude, longitude, toCoordinate } from "./coordinates.js";
-export type { EditorSnapshotFeature, EditorStyles } from "./editor.js";
+export type { EditorFeature, EditorSnapshotFeature, EditorStyles, } from "./editor.js";
 export { editorStyles, fromEditorFeatures, toEditorFeatures } from "./editor.js";
 export type { GeocodeQuery, GeocodeQueryOptions, GeocodeRequestOptions, GeocodeResult, GeocodeSearchOptions, GeocodingProvider, ReverseGeocodeQueryOptions, } from "./geocoding.js";
 export { geocodeQueryOptions, reverseGeocodeQueryOptions } from "./geocoding.js";
-export type { GeoBBox, GeoBBox3D, GeoFeature, GeoFeatureCollection, GeoGeometry, GeoGeometryCollection, GeoJsonValue, GeoLineString, GeoMultiLineString, GeoMultiPoint, GeoMultiPolygon, GeoPoint, GeoPolygon, GeoPosition, } from "./geojson.js";
-export { isGeoBBox, isGeoFeature, isGeoFeatureCollection, isGeoGeometry, isGeoJsonValue, } from "./geojson.js";
+export type { Feature, FeatureCollection, Geometry } from "./geojson.js";
+export { isGeoArea, isGeoBBox, isGeoFeature, isGeoFeatureCollection, isGeoGeometry, isGeoJsonValue, placedFeatures, } from "./geojson.js";
 export { areaInTypeOf, geoAreaM2, hasSelfIntersection, } from "./geometry-math.js";
-export type { ShapeLayerSpec, ShapeStyle } from "./map-layers.js";
+export type { CircleLayerSpec, FillLayerSpec, LineLayerSpec, ShapeLayerSpec, ShapeStyle, } from "./map-layers.js";
 export { asFeatureCollection, DEFAULT_SHAPE_STYLE, shapeLayerSpecs, } from "./map-layers.js";
 export type { MapStyleInput, MapStyleSpec, RasterTileStyleOptions, } from "./map-style.js";
 export { expandTileUrl, latLngToLngLat, lngLatToLatLng, rasterTileStyle, } from "./map-style.js";
@@ -20,8 +21,8 @@ export type { OsmElementType, OsmPreset, OsmPresetName, OverpassQuerySources, }
 export { buildOverpassQuery, findPresetForTags, OSM_PRESETS, } from "./osm-presets.js";
 export type { OsmTagFilter, OsmTagInput } from "./osm-tags.js";
 export { tagToFilter } from "./osm-tags.js";
-export type { OverpassProvider, OverpassProviderOptions, OverpassQuery, OverpassQueryOptions, OverpassRequestOptions, } from "./overpass.js";
-export { createOverpassProvider, OverpassError, OverpassRateLimitError, OverpassTimeoutError, overpassQueryOptions, } from "./overpass.js";
+export type { OverpassAnswer, OverpassElement, OverpassProvider, OverpassProviderOptions, OverpassQuery, OverpassQueryOptions, OverpassRequestOptions, } from "./overpass.js";
+export { createOverpassProvider, isOverpassAnswer, OverpassError, OverpassRateLimitError, OverpassTimeoutError, overpassQueryOptions, } from "./overpass.js";
 export type { FeaturesToShapeOptions, ShapeValue, ShapeValueKind, } from "./shape-value.js";
 export { featuresToShape, heldFeatures, shapeToFeatures } from "./shape-value.js";
 export type { OsrmProviderOptions, RoutingProvider } from "./snap-to-roads.js";

package/dist/geo/map-layers.d.ts

@@ -1,4 +1,5 @@
-import type { GeoFeatureCollection } from "./geojson.js";
+import type { FeatureCollection, Geometry } from "geojson";
+import type { JsonObject } from "../guards.js";
 export interface ShapeStyle {
     color?: string;
     /** Line width in pixels. */
@@ -19,19 +20,53 @@ export declare const DEFAULT_SHAPE_STYLE: {
     readonly pointColor: "#3b82f6";
     readonly pointRadius: 7;
 };
-export interface ShapeLayerSpec {
+/** `["==", ["geometry-type"], type]`: `geometry-type` is the base type for the Multi types. */
+type GeometryTypeTest<TType extends "Polygon" | "LineString" | "Point"> = [
+    "==",
+    [
+        "geometry-type"
+    ],
+    TType
+];
+export interface FillLayerSpec {
     id: string;
-    type: "fill" | "line" | "circle";
+    type: "fill";
     source: string;
-    filter: unknown[];
-    paint: Record<string, string | number>;
+    filter: GeometryTypeTest<"Polygon">;
+    paint: {
+        "fill-color": string;
+        "fill-opacity": number;
+    };
 }
+export interface LineLayerSpec {
+    id: string;
+    type: "line";
+    source: string;
+    filter: ["any", GeometryTypeTest<"LineString">, GeometryTypeTest<"Polygon">];
+    paint: {
+        "line-color": string;
+        "line-width": number;
+        "line-opacity": number;
+    };
+}
+export interface CircleLayerSpec {
+    id: string;
+    type: "circle";
+    source: string;
+    filter: GeometryTypeTest<"Point">;
+    paint: {
+        "circle-color": string;
+        "circle-radius": number;
+    };
+}
+export type ShapeLayerSpec = FillLayerSpec | LineLayerSpec | CircleLayerSpec;
 /**
  * Fill, line and point layers for one GeoJSON source. `geometry-type` returns
  * the base type for the Multi types too, so they need no filter of their own.
  * The line layer also matches Polygon, so `color`, `weight` and `opacity` give
  * polygons an outline.
  */
-export declare function shapeLayerSpecs(sourceId: string, style: ShapeStyle): [ShapeLayerSpec, ShapeLayerSpec, ShapeLayerSpec];
+export declare function shapeLayerSpecs(sourceId: string, style: ShapeStyle): [FillLayerSpec, LineLayerSpec, CircleLayerSpec];
 /** Never throws: anything that is not GeoJSON becomes an empty collection. */
-export declare function asFeatureCollection(value: unknown): GeoFeatureCollection;
+export declare function asFeatureCollection(value: unknown): FeatureCollection<Geometry | null, JsonObject | null>;
+export {};

package/dist/geo/map-layers.js

@@ -1,67 +1,93 @@
-import { isGeoFeatureCollection, isGeoFeature, isGeoGeometry } from "./geojson.js";
-const DEFAULT_SHAPE_STYLE = {
-  color: "#3388ff",
-  weight: 3,
-  opacity: 1,
-  fillOpacity: 0.2,
-  pointColor: "#3b82f6",
-  pointRadius: 7
+import { isGeoFeature, isGeoFeatureCollection, isGeoGeometry } from "./geojson.js";
+// src/geo/map-layers.ts
+var DEFAULT_SHAPE_STYLE = {
+	color: "#3388ff",
+	weight: 3,
+	opacity: 1,
+	fillOpacity: .2,
+	pointColor: "#3b82f6",
+	pointRadius: 7
 };
+/**
+* Fill, line and point layers for one GeoJSON source. `geometry-type` returns
+* the base type for the Multi types too, so they need no filter of their own.
+* The line layer also matches Polygon, so `color`, `weight` and `opacity` give
+* polygons an outline.
+*/
 function shapeLayerSpecs(sourceId, style) {
-  const color = style.color ?? DEFAULT_SHAPE_STYLE.color;
-  return [
-    {
-      id: `${sourceId}-fill`,
-      type: "fill",
-      source: sourceId,
-      filter: ["==", ["geometry-type"], "Polygon"],
-      paint: {
-        "fill-color": style.fillColor ?? color,
-        "fill-opacity": style.fillOpacity ?? DEFAULT_SHAPE_STYLE.fillOpacity
-      }
-    },
-    {
-      id: `${sourceId}-line`,
-      type: "line",
-      source: sourceId,
-      filter: [
-        "any",
-        ["==", ["geometry-type"], "LineString"],
-        ["==", ["geometry-type"], "Polygon"]
-      ],
-      paint: {
-        "line-color": color,
-        "line-width": style.weight ?? DEFAULT_SHAPE_STYLE.weight,
-        "line-opacity": style.opacity ?? DEFAULT_SHAPE_STYLE.opacity
-      }
-    },
-    {
-      id: `${sourceId}-point`,
-      type: "circle",
-      source: sourceId,
-      filter: ["==", ["geometry-type"], "Point"],
-      paint: {
-        "circle-color": style.pointColor ?? DEFAULT_SHAPE_STYLE.pointColor,
-        "circle-radius": style.pointRadius ?? DEFAULT_SHAPE_STYLE.pointRadius
-      }
-    }
-  ];
+	const color = style.color ?? DEFAULT_SHAPE_STYLE.color;
+	return [
+		{
+			id: `${sourceId}-fill`,
+			type: "fill",
+			source: sourceId,
+			filter: [
+				"==",
+				["geometry-type"],
+				"Polygon"
+			],
+			paint: {
+				"fill-color": style.fillColor ?? color,
+				"fill-opacity": style.fillOpacity ?? DEFAULT_SHAPE_STYLE.fillOpacity
+			}
+		},
+		{
+			id: `${sourceId}-line`,
+			type: "line",
+			source: sourceId,
+			filter: [
+				"any",
+				[
+					"==",
+					["geometry-type"],
+					"LineString"
+				],
+				[
+					"==",
+					["geometry-type"],
+					"Polygon"
+				]
+			],
+			paint: {
+				"line-color": color,
+				"line-width": style.weight ?? DEFAULT_SHAPE_STYLE.weight,
+				"line-opacity": style.opacity ?? DEFAULT_SHAPE_STYLE.opacity
+			}
+		},
+		{
+			id: `${sourceId}-point`,
+			type: "circle",
+			source: sourceId,
+			filter: [
+				"==",
+				["geometry-type"],
+				"Point"
+			],
+			paint: {
+				"circle-color": style.pointColor ?? DEFAULT_SHAPE_STYLE.pointColor,
+				"circle-radius": style.pointRadius ?? DEFAULT_SHAPE_STYLE.pointRadius
+			}
+		}
+	];
 }
+/** Never throws: anything that is not GeoJSON becomes an empty collection. */
 function asFeatureCollection(value) {
-  if (isGeoFeatureCollection(value)) return value;
-  if (isGeoFeature(value)) {
-    return { type: "FeatureCollection", features: [value] };
-  }
-  if (isGeoGeometry(value)) {
-    return {
-      type: "FeatureCollection",
-      features: [{ type: "Feature", geometry: value, properties: {} }]
-    };
-  }
-  return { type: "FeatureCollection", features: [] };
+	if (isGeoFeatureCollection(value)) return value;
+	if (isGeoFeature(value)) return {
+		type: "FeatureCollection",
+		features: [value]
+	};
+	if (isGeoGeometry(value)) return {
+		type: "FeatureCollection",
+		features: [{
+			type: "Feature",
+			geometry: value,
+			properties: {}
+		}]
+	};
+	return {
+		type: "FeatureCollection",
+		features: []
+	};
 }
-export {
-  DEFAULT_SHAPE_STYLE,
-  asFeatureCollection,
-  shapeLayerSpecs
-};
+export { DEFAULT_SHAPE_STYLE, asFeatureCollection, shapeLayerSpecs };