@orbat-mapper/control-measures 0.6.0 → 0.7.0

package/dist/patterns-CcQmmOuJ.d.mts

@@ -0,0 +1,116 @@
+//#region src/style.d.ts
+/**
+ * Framework-agnostic style hints attached to a `ControlMeasure`.
+ *
+ * Mirrors the per-feature subset of what map adapters render. The renderer
+ * fans these into each emitted feature's `properties.style` ([[StyleHints]]).
+ * Adapters merge them over their layer-level style; generator-emitted hints
+ * on individual features win over both.
+ */
+interface ControlMeasureStyle {
+  /**
+   * The single symbol color. Control measures are monocolor: one color paints
+   * every part, stroked or filled. Input-only — resolved into concrete
+   * `strokeColor` / `fillColor` per feature by the renderer and never emitted
+   * on output. `strokeColor` / `fillColor` act as optional per-channel
+   * overrides. See ADR-0011.
+   */
+  color?: string;
+  strokeColor?: string;
+  strokeWidth?: number;
+  strokeDash?: number[];
+  fillColor?: string;
+  /**
+   * How a filled part's interior is painted. `"solid"` is explicit so a
+   * measure can override a patterned layer default (e.g. a hatch fill set
+   * at the façade). Pattern lines are drawn in the resolved fill color —
+   * alpha included, there is no separate opacity field. Renderers that
+   * cannot draw a pattern degrade to solid.
+   */
+  fillPattern?: FillPattern;
+  /**
+   * Display-time graphic opacity multiplier in `[0, 1]`; absent = fully
+   * opaque. Unlike `color`'s alpha, this fades the whole graphic — stroke,
+   * fill, patterns, and baked labels — as one knob, independent of the
+   * authored color. The resolver folds it into each resolved part's color
+   * alpha (`final alpha = opacity × color alpha`) rather than adding a new
+   * paint channel, so adapters and `toSimpleStyle` need no changes.
+   * Display-only: hit-testing and selection reason about color alpha, not
+   * this multiplier, so a graphic at `opacity: 0` stays fully selectable.
+   * Out-of-range values clamp to `[0, 1]`. See ADR-0040.
+   */
+  opacity?: number;
+  /**
+   * Render a contrast-aware halo behind label glyphs so text stays legible on
+   * busy backgrounds. Cascades like any other hint (graphicsStyle → measure →
+   * generator), letting a host switch halos on for every labeled measure
+   * rather than only the generic Text graphic.
+   *
+   * Text-only: the renderer applies it to features that carry `text` and drops
+   * it everywhere else, so a layer-level `true` never leaks onto plain stroked
+   * or filled parts. The halo *color* is not authored here — it is derived per
+   * feature from the resolved text color, so each label gets a halo that
+   * actually contrasts with it. Unlike the other hints this one is consumed by
+   * the renderer and lifted to a top-level `textHalo` feature property; it is
+   * never emitted on `properties.style`. See ADR-0042.
+   */
+  textHalo?: boolean;
+}
+/**
+ * How a filled part's interior is painted. See `ControlMeasureStyle.fillPattern`.
+ */
+type FillPattern = "solid" | "hatch" | "reverse-hatch" | "cross-hatch" | "horizontal" | "vertical" | "dots" | "mine-unspecified" | "mine-antipersonnel" | "mine-antipersonnel-directional" | "mine-antitank" | "mine-antitank-antihandling" | "mine-wide-area-antitank" | "mine-cluster";
+//#endregion
+//#region src/patterns.d.ts
+type PatternId = Exclude<FillPattern, "solid">;
+type PatternPoint = readonly [x: number, y: number];
+interface PatternStroke {
+  readonly width: number;
+  readonly lineCap: "butt" | "round";
+  readonly dash?: readonly number[];
+}
+interface PatternPaint {
+  readonly fill?: "color";
+  readonly stroke?: PatternStroke;
+}
+type PatternPathOperation = {
+  readonly type: "move";
+  readonly to: PatternPoint;
+} | {
+  readonly type: "line";
+  readonly to: PatternPoint;
+} | {
+  readonly type: "cubic";
+  readonly control1: PatternPoint;
+  readonly control2: PatternPoint;
+  readonly to: PatternPoint;
+} | {
+  readonly type: "close";
+};
+type FillPatternCommand = {
+  readonly type: "path";
+  readonly operations: readonly PatternPathOperation[];
+  readonly paint: PatternPaint;
+} | {
+  readonly type: "circle";
+  readonly center: PatternPoint;
+  readonly radius: number;
+  readonly paint: PatternPaint;
+};
+interface FillPatternDefinition {
+  /** Stable identity matching the public FillPattern vocabulary. */
+  readonly id: PatternId;
+  /** Coordinates and paint widths are expressed in CSS pixels at 1x. */
+  readonly units: "css-pixel";
+  readonly tile: {
+    readonly width: number;
+    readonly height: number;
+  };
+  readonly commands: readonly FillPatternCommand[];
+}
+declare const FILL_PATTERN_DEFINITIONS: Readonly<Record<PatternId, FillPatternDefinition>>;
+/** Runtime vocabulary derived from the exhaustive definition record. */
+declare const NON_SOLID_FILL_PATTERNS: PatternId[];
+declare function getFillPatternDefinition(pattern: PatternId): FillPatternDefinition;
+//#endregion
+export { PatternId as a, PatternPoint as c, ControlMeasureStyle as d, FillPattern as f, NON_SOLID_FILL_PATTERNS as i, PatternStroke as l, FillPatternCommand as n, PatternPaint as o, FillPatternDefinition as r, PatternPathOperation as s, FILL_PATTERN_DEFINITIONS as t, getFillPatternDefinition as u };

package/dist/patterns.d.mts

@@ -0,0 +1,2 @@
+import { a as PatternId, c as PatternPoint, i as NON_SOLID_FILL_PATTERNS, l as PatternStroke, n as FillPatternCommand, o as PatternPaint, r as FillPatternDefinition, s as PatternPathOperation, t as FILL_PATTERN_DEFINITIONS, u as getFillPatternDefinition } from "./patterns-CcQmmOuJ.mjs";
+export { FILL_PATTERN_DEFINITIONS, FillPatternCommand, FillPatternDefinition, NON_SOLID_FILL_PATTERNS, PatternId, PatternPaint, PatternPathOperation, PatternPoint, PatternStroke, getFillPatternDefinition };

package/dist/patterns.mjs

@@ -0,0 +1,205 @@
+//#region src/patterns.ts
+const stroke = (width = 1, dash) => ({
+	width,
+	lineCap: "butt",
+	...dash ? { dash } : {}
+});
+const move = (x, y) => ({
+	type: "move",
+	to: [x, y]
+});
+const line = (x, y) => ({
+	type: "line",
+	to: [x, y]
+});
+const cubic = (x1, y1, x2, y2, x, y) => ({
+	type: "cubic",
+	control1: [x1, y1],
+	control2: [x2, y2],
+	to: [x, y]
+});
+const path = (operations, paint = { stroke: stroke() }) => ({
+	type: "path",
+	operations,
+	paint
+});
+const circle = (x, y, radius, paint) => ({
+	type: "circle",
+	center: [x, y],
+	radius,
+	paint
+});
+const HATCH = path([
+	move(-1, -1),
+	line(9, 9),
+	move(7, -1),
+	line(9, 1),
+	move(-1, 7),
+	line(1, 9)
+]);
+const REVERSE_HATCH = path([
+	move(9, -1),
+	line(-1, 9),
+	move(1, -1),
+	line(-1, 1),
+	move(9, 7),
+	line(7, 9)
+]);
+const MINE_DISC = circle(16, 16, 5, { fill: "color" });
+const AP_RAYS = [
+	move(12.867, 12.1),
+	line(9.333, 7.667),
+	move(19.133, 12.1),
+	line(22.667, 7.667)
+];
+const FILL_PATTERN_DEFINITIONS = {
+	hatch: {
+		id: "hatch",
+		units: "css-pixel",
+		tile: {
+			width: 8,
+			height: 8
+		},
+		commands: [HATCH]
+	},
+	"reverse-hatch": {
+		id: "reverse-hatch",
+		units: "css-pixel",
+		tile: {
+			width: 8,
+			height: 8
+		},
+		commands: [REVERSE_HATCH]
+	},
+	"cross-hatch": {
+		id: "cross-hatch",
+		units: "css-pixel",
+		tile: {
+			width: 8,
+			height: 8
+		},
+		commands: [HATCH, REVERSE_HATCH]
+	},
+	horizontal: {
+		id: "horizontal",
+		units: "css-pixel",
+		tile: {
+			width: 8,
+			height: 8
+		},
+		commands: [path([move(-1, 4), line(9, 4)])]
+	},
+	vertical: {
+		id: "vertical",
+		units: "css-pixel",
+		tile: {
+			width: 8,
+			height: 8
+		},
+		commands: [path([move(4, -1), line(4, 9)])]
+	},
+	dots: {
+		id: "dots",
+		units: "css-pixel",
+		tile: {
+			width: 8,
+			height: 8
+		},
+		commands: [circle(4, 4, 1.25, { fill: "color" })]
+	},
+	"mine-unspecified": {
+		id: "mine-unspecified",
+		units: "css-pixel",
+		tile: {
+			width: 32,
+			height: 32
+		},
+		commands: [circle(16, 16, 5, { stroke: stroke() })]
+	},
+	"mine-antipersonnel": {
+		id: "mine-antipersonnel",
+		units: "css-pixel",
+		tile: {
+			width: 32,
+			height: 32
+		},
+		commands: [MINE_DISC, path(AP_RAYS)]
+	},
+	"mine-antipersonnel-directional": {
+		id: "mine-antipersonnel-directional",
+		units: "css-pixel",
+		tile: {
+			width: 32,
+			height: 32
+		},
+		commands: [MINE_DISC, path([
+			...AP_RAYS,
+			move(21, 16),
+			line(22.1, 16),
+			move(23.667, 15.333),
+			line(24.333, 15.9),
+			line(23.667, 16.667),
+			{ type: "close" }
+		])]
+	},
+	"mine-antitank": {
+		id: "mine-antitank",
+		units: "css-pixel",
+		tile: {
+			width: 32,
+			height: 32
+		},
+		commands: [MINE_DISC]
+	},
+	"mine-antitank-antihandling": {
+		id: "mine-antitank-antihandling",
+		units: "css-pixel",
+		tile: {
+			width: 32,
+			height: 32
+		},
+		commands: [MINE_DISC, path([
+			move(16, 21),
+			line(16, 25.333),
+			line(18, 23.333)
+		])]
+	},
+	"mine-wide-area-antitank": {
+		id: "mine-wide-area-antitank",
+		units: "css-pixel",
+		tile: {
+			width: 32,
+			height: 32
+		},
+		commands: [MINE_DISC, path([
+			move(9.333, 21),
+			line(12, 24.333),
+			line(13.833, 20.667),
+			move(18.167, 20.667),
+			line(20, 24.333),
+			line(22.667, 21)
+		])]
+	},
+	"mine-cluster": {
+		id: "mine-cluster",
+		units: "css-pixel",
+		tile: {
+			width: 32,
+			height: 32
+		},
+		commands: [path([
+			move(22, 19.333),
+			line(10, 19.333),
+			cubic(10, 16, 11, 12.667, 16, 12.667),
+			cubic(21, 12.667, 22, 16, 22, 19.333),
+			{ type: "close" }
+		], { stroke: stroke(1, [2.5, 1.667]) })]
+	}
+};
+/** Runtime vocabulary derived from the exhaustive definition record. */
+const NON_SOLID_FILL_PATTERNS = Object.keys(FILL_PATTERN_DEFINITIONS);
+function getFillPatternDefinition(pattern) {
+	return FILL_PATTERN_DEFINITIONS[pattern];
+}
+//#endregion
+export { FILL_PATTERN_DEFINITIONS, NON_SOLID_FILL_PATTERNS, getFillPatternDefinition };

package/dist/preview/index.d.mts

@@ -1,18 +1,18 @@
-import { Mi as TextAmplifiers, Y as ControlMeasureId, Yr as FillPattern } from "../index-DCgWC2Q8.mjs";
+import { Ki as TextAmplifiers, X as ControlMeasureId } from "../index-B3LgMKpn.mjs";
+import { f as FillPattern } from "../patterns-CcQmmOuJ.mjs";
 import { FeatureCollection, Geometry } from "geojson";
 
 //#region src/preview/index.d.ts
 /** The hatch fill patterns a preview can render — the `FillPattern` vocabulary
  *  minus `"solid"` (a plain fill, not a pattern). */
 type PreviewFillPattern = Exclude<FillPattern, "solid">;
-/** Side length (SVG units) of the repeating hatch tile in {@link PREVIEW_FILL_PATTERNS}. */
+/** Side length (SVG units) of the repeating non-mine tile in {@link PREVIEW_FILL_PATTERNS}. */
 declare const PREVIEW_PATTERN_TILE = 8;
 /**
- * SVG `<pattern>` tile geometry every preview consumer (docs catalog, sidebar
- * thumbnail, README/`media` generator) renders so a `fillPattern` shape looks
- * identical everywhere; the `d` paths mirror the leaflet adapter's fill-pattern
- * tiles over a {@link PREVIEW_PATTERN_TILE}-unit tile. Kept here as the single
- * source so a new pattern is defined once, not copied per renderer.
+ * SVG-oriented projection of the public renderer-neutral pattern definitions.
+ * Mine tiles are shown at half scale so compact previews retain their historic
+ * 16-unit cadence; all geometry and paint metadata still come from the same
+ * canonical 32-unit definition used by live and raster renderers.
  */
 declare const PREVIEW_FILL_PATTERNS: readonly {
   readonly id: PreviewFillPattern;
@@ -23,7 +23,7 @@ declare const PREVIEW_FILL_PATTERNS: readonly {
   readonly dots?: readonly (readonly [number, number])[];
 }[];
 /** Radius (SVG units) of a {@link PREVIEW_FILL_PATTERNS} dot. */
-declare const PREVIEW_PATTERN_DOT_RADIUS = 1.25;
+declare const PREVIEW_PATTERN_DOT_RADIUS: number;
 /**
  * Renders a measure's representative preview to GeoJSON. Pure — no map engine,
  * so it runs identically at build time (docs catalog, README generator) and in
@@ -39,14 +39,18 @@ declare function renderRepresentative(id: ControlMeasureId, overrides?: {
   textAmplifiers?: TextAmplifiers;
   options?: Record<string, unknown>;
 }): FeatureCollection<Geometry, unknown>;
-/** A styling-free preview primitive. Consumers supply stroke, radius, font,
- *  and colors when they draw it. */
+/** A preview primitive. Consumers supply stroke width, radius, font, and
+ *  fallback colors when they draw it. */
 interface PreviewShape {
   type: "polyline" | "polygon" | "circle" | "text";
   /** SVG path data for `polyline`/`polygon`. */
   d?: string;
   /** Intrinsic dash pattern carried by a stroked feature. Empty means solid. */
   strokeDash?: number[];
+  /** Non-default resolved stroke/text color; absent uses the consumer default. */
+  strokeColor?: string;
+  /** Non-default resolved fill color; absent uses the consumer default. */
+  fillColor?: string;
   /** Center for `circle`/`text`. */
   cx?: number;
   cy?: number;
@@ -92,7 +96,7 @@ interface ProjectDimensions {
 }
 /**
  * Fits a rendered `FeatureCollection` into a `width`×`height` viewBox (inset by
- * `pad`) and emits styling-free {@link PreviewShape}s. North is up (y is
+ * `pad`) and emits preview-ready {@link PreviewShape}s. North is up (y is
  * flipped). Returns `ok: false` for an empty/degenerate render so consumers can
  * show a geometry-typed fallback glyph.
  */

package/dist/preview/index.mjs

@@ -1,84 +1,56 @@
-import { a as DEFINITIONS, t as renderControlMeasure } from "../renderControlMeasure-D6VScGE0.mjs";
+import { a as DEFINITIONS, t as renderControlMeasure } from "../renderControlMeasure-GsV4DV3r.mjs";
+import { FILL_PATTERN_DEFINITIONS, NON_SOLID_FILL_PATTERNS } from "../patterns.mjs";
 //#region src/preview/index.ts
-/** Side length (SVG units) of the repeating hatch tile in {@link PREVIEW_FILL_PATTERNS}. */
+/** Side length (SVG units) of the repeating non-mine tile in {@link PREVIEW_FILL_PATTERNS}. */
 const PREVIEW_PATTERN_TILE = 8;
+function svgNumber(value) {
+	return String(Number(value.toFixed(3)));
+}
+function previewPathData(command, scale) {
+	if (command.type === "circle") {
+		const [cx, cy] = command.center;
+		const x0 = (cx + command.radius) * scale;
+		const x1 = (cx - command.radius) * scale;
+		const y = cy * scale;
+		const radius = command.radius * scale;
+		return `M${svgNumber(x0)},${svgNumber(y)} A${svgNumber(radius)},${svgNumber(radius)} 0 1,1 ${svgNumber(x1)},${svgNumber(y)} A${svgNumber(radius)},${svgNumber(radius)} 0 1,1 ${svgNumber(x0)},${svgNumber(y)}${command.paint.fill ? " Z" : ""}`;
+	}
+	const point = ([x, y]) => `${svgNumber(x * scale)},${svgNumber(y * scale)}`;
+	const operation = (op) => {
+		switch (op.type) {
+			case "move": return `M${point(op.to)}`;
+			case "line": return `L${point(op.to)}`;
+			case "cubic": return `C${point(op.control1)} ${point(op.control2)} ${point(op.to)}`;
+			case "close": return "Z";
+		}
+	};
+	return command.operations.map(operation).join(" ");
+}
 /**
-* SVG `<pattern>` tile geometry every preview consumer (docs catalog, sidebar
-* thumbnail, README/`media` generator) renders so a `fillPattern` shape looks
-* identical everywhere; the `d` paths mirror the leaflet adapter's fill-pattern
-* tiles over a {@link PREVIEW_PATTERN_TILE}-unit tile. Kept here as the single
-* source so a new pattern is defined once, not copied per renderer.
+* SVG-oriented projection of the public renderer-neutral pattern definitions.
+* Mine tiles are shown at half scale so compact previews retain their historic
+* 16-unit cadence; all geometry and paint metadata still come from the same
+* canonical 32-unit definition used by live and raster renderers.
 */
-const PREVIEW_FILL_PATTERNS = [
-	{
-		id: "hatch",
-		paths: ["M-1,-1 L9,9 M7,-1 L9,1 M-1,7 L1,9"]
-	},
-	{
-		id: "reverse-hatch",
-		paths: ["M9,-1 L-1,9 M1,-1 L-1,1 M9,7 L7,9"]
-	},
-	{
-		id: "cross-hatch",
-		paths: ["M-1,-1 L9,9 M7,-1 L9,1 M-1,7 L1,9", "M9,-1 L-1,9 M1,-1 L-1,1 M9,7 L7,9"]
-	},
-	{
-		id: "horizontal",
-		paths: ["M-1,4 L9,4"]
-	},
-	{
-		id: "vertical",
-		paths: ["M4,-1 L4,9"]
-	},
-	{
-		id: "dots",
-		paths: [],
-		dots: [[4, 4]]
-	},
-	{
-		id: "mine-unspecified",
-		tileSize: 16,
-		paths: ["M10.5,8 A2.5,2.5 0 1,1 5.5,8 A2.5,2.5 0 1,1 10.5,8"]
-	},
-	{
-		id: "mine-antipersonnel",
-		tileSize: 16,
-		paths: ["M6.433,6.05 L4.667,3.833 M9.567,6.05 L11.333,3.833"],
-		filledPaths: ["M10.5,8 A2.5,2.5 0 1,1 5.5,8 A2.5,2.5 0 1,1 10.5,8 Z"]
-	},
-	{
-		id: "mine-antipersonnel-directional",
-		tileSize: 16,
-		paths: ["M6.433,6.05 L4.667,3.833 M9.567,6.05 L11.333,3.833 M10.5,8 L11.05,8 M11.833,7.667 L12.167,7.95 L11.833,8.333 Z"],
-		filledPaths: ["M10.5,8 A2.5,2.5 0 1,1 5.5,8 A2.5,2.5 0 1,1 10.5,8 Z"]
-	},
-	{
-		id: "mine-antitank",
-		tileSize: 16,
-		paths: [],
-		filledPaths: ["M10.5,8 A2.5,2.5 0 1,1 5.5,8 A2.5,2.5 0 1,1 10.5,8 Z"]
-	},
-	{
-		id: "mine-antitank-antihandling",
-		tileSize: 16,
-		paths: ["M8,10.5 L8,12.667 L9,11.667"],
-		filledPaths: ["M10.5,8 A2.5,2.5 0 1,1 5.5,8 A2.5,2.5 0 1,1 10.5,8 Z"]
-	},
-	{
-		id: "mine-wide-area-antitank",
-		tileSize: 16,
-		paths: ["M4.667,10.5 L6,12.167 L6.917,10.333 M9.083,10.333 L10,12.167 L11.333,10.5"],
-		filledPaths: ["M10.5,8 A2.5,2.5 0 1,1 5.5,8 A2.5,2.5 0 1,1 10.5,8 Z"]
-	},
-	{
-		id: "mine-cluster",
-		tileSize: 16,
-		paths: ["M11,9.667 L5,9.667 C5,8 5.5,6.333 8,6.333 C10.5,6.333 11,8 11,9.667 Z"],
-		strokeDash: [1.25, .833]
-	}
-];
+const PREVIEW_FILL_PATTERNS = NON_SOLID_FILL_PATTERNS.map((id) => {
+	const definition = FILL_PATTERN_DEFINITIONS[id];
+	const scale = id.startsWith("mine-") ? .5 : 1;
+	const dotCommand = id === "dots" ? definition.commands[0] : void 0;
+	const strokeDash = definition.commands.map((command) => command.paint.stroke?.dash).find((dash) => dash !== void 0);
+	return {
+		id,
+		paths: definition.commands.filter((command) => command.paint.stroke).map((command) => previewPathData(command, scale)),
+		...definition.commands.some((command) => command.paint.fill && id !== "dots") ? { filledPaths: definition.commands.filter((command) => command.paint.fill).map((command) => previewPathData(command, scale)) } : {},
+		...strokeDash ? { strokeDash: strokeDash.map((value) => value * scale) } : {},
+		...dotCommand?.type === "circle" ? { dots: [[dotCommand.center[0] * scale, dotCommand.center[1] * scale]] } : {},
+		...scale !== 1 ? { tileSize: definition.tile.width * scale } : {}
+	};
+});
 /** Radius (SVG units) of a {@link PREVIEW_FILL_PATTERNS} dot. */
-const PREVIEW_PATTERN_DOT_RADIUS = 1.25;
+const PREVIEW_PATTERN_DOT_RADIUS = (() => {
+	const command = FILL_PATTERN_DEFINITIONS.dots.commands[0];
+	return command?.type === "circle" ? command.radius : 0;
+})();
 /**
 * Unitless `previewSample` points (~`[-1, 1]`) are scaled by this degree offset
 * before reaching a generator. Most generators operate in projected meters, so
@@ -169,7 +141,7 @@ function renderRepresentative(id, overrides) {
 }
 /**
 * Fits a rendered `FeatureCollection` into a `width`×`height` viewBox (inset by
-* `pad`) and emits styling-free {@link PreviewShape}s. North is up (y is
+* `pad`) and emits preview-ready {@link PreviewShape}s. North is up (y is
 * flipped). Returns `ok: false` for an empty/degenerate render so consumers can
 * show a geometry-typed fallback glyph.
 */
@@ -395,6 +367,8 @@ function collectShapes(g, tx, out, bboxArea, textLimits, props) {
 	const styleProps = labelProps.style && typeof labelProps.style === "object" ? labelProps.style : {};
 	const fillPattern = PREVIEW_FILL_PATTERNS.some((p) => p.id === styleProps.fillPattern) ? styleProps.fillPattern : void 0;
 	const strokeDash = Array.isArray(styleProps.strokeDash) ? styleProps.strokeDash.filter((value) => typeof value === "number") : void 0;
+	const strokeColor = typeof styleProps.strokeColor === "string" && styleProps.strokeColor !== "#000000" ? styleProps.strokeColor : void 0;
+	const fillColor = typeof styleProps.fillColor === "string" && styleProps.fillColor !== "#000000" ? styleProps.fillColor : void 0;
 	const explicitlyFilled = typeof styleProps.fillColor === "string";
 	const polygonFilled = (ring) => bboxArea > 0 && ringArea(ring) / bboxArea < .25;
 	switch (g.type) {
@@ -413,12 +387,14 @@ function collectShapes(g, tx, out, bboxArea, textLimits, props) {
 					textBackground,
 					textHalo,
 					textJustify,
-					textStyle
+					textStyle,
+					strokeColor
 				});
 			} else out.push({
 				type: "circle",
 				cx: x,
-				cy: y
+				cy: y,
+				fillColor
 			});
 			break;
 		}
@@ -428,7 +404,8 @@ function collectShapes(g, tx, out, bboxArea, textLimits, props) {
 				out.push({
 					type: "circle",
 					cx: x,
-					cy: y
+					cy: y,
+					fillColor
 				});
 			});
 			break;
@@ -436,14 +413,16 @@ function collectShapes(g, tx, out, bboxArea, textLimits, props) {
 			out.push({
 				type: "polyline",
 				d: pathFromRing(g.coordinates, tx, false),
-				strokeDash
+				strokeDash,
+				strokeColor
 			});
 			break;
 		case "MultiLineString":
 			g.coordinates.forEach((line) => out.push({
 				type: "polyline",
 				d: pathFromRing(line, tx, false),
-				strokeDash
+				strokeDash,
+				strokeColor
 			}));
 			break;
 		case "Polygon":
@@ -451,7 +430,9 @@ function collectShapes(g, tx, out, bboxArea, textLimits, props) {
 				type: "polygon",
 				d: pathFromRing(ring, tx, true),
 				filled: explicitlyFilled || polygonFilled(ring),
-				fillPattern
+				fillPattern,
+				strokeColor,
+				fillColor
 			}));
 			break;
 		case "MultiPolygon":
@@ -459,7 +440,9 @@ function collectShapes(g, tx, out, bboxArea, textLimits, props) {
 				type: "polygon",
 				d: pathFromRing(ring, tx, true),
 				filled: polygonFilled(ring),
-				fillPattern
+				fillPattern,
+				strokeColor,
+				fillColor
 			})));
 			break;
 		case "GeometryCollection":