@osmix/geojson 0.0.15 → 0.0.16

package/src/entity-to-feature.ts

@@ -7,36 +7,28 @@
  * @module
  */
 
-import type { Osm } from "@osmix/core"
+import type { OsmReader } from "@osmix/core/contracts";
+import { buildRelationRings, getWayMembersByRole } from "@osmix/geo/relation-multipolygon";
+import { wayIsArea } from "@osmix/geo/way-is-area";
+import type { LonLat, OsmEntity, OsmNode, OsmRelation, OsmWay } from "@osmix/types";
 import {
-	buildRelationLineStrings,
-	collectRelationPoints,
-	getRelationKind,
-	isAreaRelation,
-} from "@osmix/shared/relation-kind"
-import {
-	buildRelationRings,
-	getWayMembersByRole,
-} from "@osmix/shared/relation-multipolygon"
-import type {
-	LonLat,
-	OsmEntity,
-	OsmNode,
-	OsmRelation,
-	OsmWay,
-} from "@osmix/shared/types"
-import { isNode, isRelation, isWay } from "@osmix/shared/utils"
-import { wayIsArea } from "@osmix/shared/way-is-area"
+  buildRelationLineStrings,
+  collectRelationPoints,
+  getRelationKind,
+  isAreaRelation,
+} from "@osmix/types/relation-kind";
+import { isNode, isRelation, isWay } from "@osmix/types/utils";
 import type {
-	GeometryCollection,
-	LineString,
-	MultiLineString,
-	MultiPoint,
-	MultiPolygon,
-	Point,
-	Polygon,
-} from "geojson"
-import type { OsmGeoJSONFeature } from "./types.ts"
+  GeometryCollection,
+  LineString,
+  MultiLineString,
+  MultiPoint,
+  MultiPolygon,
+  Point,
+  Polygon,
+} from "geojson";
+
+import type { OsmGeoJSONFeature } from "./types.ts";
 
 /**
  * Convert an OSM node to a GeoJSON Point feature.
@@ -51,20 +43,20 @@ import type { OsmGeoJSONFeature } from "./types.ts"
  * ```
  */
 export function nodeToFeature(node: OsmNode): OsmGeoJSONFeature<Point> {
-	return {
-		type: "Feature",
-		id: node.id,
-		geometry: {
-			type: "Point",
-			coordinates: [node.lon, node.lat],
-		},
-		properties: {
-			id: node.id,
-			type: "node",
-			...node.info,
-			...node.tags,
-		},
-	}
+  return {
+    type: "Feature",
+    id: node.id,
+    geometry: {
+      type: "Point",
+      coordinates: [node.lon, node.lat],
+    },
+    properties: {
+      id: node.id,
+      type: "node",
+      ...node.info,
+      ...node.tags,
+    },
+  };
 }
 
 /**
@@ -74,7 +66,7 @@ export function nodeToFeature(node: OsmNode): OsmGeoJSONFeature<Point> {
  * area-indicating tags (building, landuse, etc.) and ring closure.
  *
  * @param way - OSM way with id, refs, and optional tags.
- * @param refToPosition - Function to resolve node ID to [lon, lat] coordinates.
+ * @param refToPosition - Function to resolve node ID to coordinates, or null for a missing node.
  * @returns GeoJSON LineString or Polygon Feature with OSM properties.
  *
  * @example
@@ -83,28 +75,34 @@ export function nodeToFeature(node: OsmNode): OsmGeoJSONFeature<Point> {
  * ```
  */
 export function wayToFeature(
-	way: OsmWay,
-	refToPosition: (id: number) => [number, number],
+  way: OsmWay,
+  refToPosition: (id: number) => [number, number] | null | undefined,
 ): OsmGeoJSONFeature<LineString | Polygon> {
-	return {
-		type: "Feature",
-		id: way.id,
-		geometry: wayIsArea(way)
-			? {
-					type: "Polygon",
-					coordinates: [way.refs.map((r) => refToPosition(r))],
-				}
-			: {
-					type: "LineString",
-					coordinates: way.refs.map((r) => refToPosition(r)),
-				},
-		properties: {
-			id: way.id,
-			type: "way",
-			...way.info,
-			...way.tags,
-		},
-	}
+  const resolvedCoordinates: [number, number][] = [];
+  for (const ref of way.refs) {
+    const position = refToPosition(ref);
+    if (!position) throw Error(`Node reference missing for way ${way.id}`);
+    resolvedCoordinates.push(position);
+  }
+  return {
+    type: "Feature",
+    id: way.id,
+    geometry: wayIsArea(way)
+      ? {
+          type: "Polygon",
+          coordinates: [resolvedCoordinates],
+        }
+      : {
+          type: "LineString",
+          coordinates: resolvedCoordinates,
+        },
+    properties: {
+      id: way.id,
+      type: "way",
+      ...way.info,
+      ...way.tags,
+    },
+  };
 }
 
 /**
@@ -117,7 +115,7 @@ export function wayToFeature(
  * - **Other**: GeometryCollection (empty for logical relations)
  *
  * @param relation - OSM relation with id, members, and optional tags.
- * @param refToPosition - Function to resolve node ID to [lon, lat] coordinates.
+ * @param refToPosition - Function to resolve node ID to coordinates, or null for a missing node.
  * @param getWay - Optional function to resolve way ID to OsmWay (required for polygons/lines).
  * @returns GeoJSON Feature with appropriate geometry type.
  *
@@ -131,252 +129,245 @@ export function wayToFeature(
  * ```
  */
 export function relationToFeature(
-	relation: OsmRelation,
-	refToPosition: (id: number) => [number, number],
-	getWay?: (wayId: number) => OsmWay | null,
+  relation: OsmRelation,
+  refToPosition: (id: number) => [number, number] | null | undefined,
+  getWay?: (wayId: number) => OsmWay | null,
 ): OsmGeoJSONFeature<
-	| Polygon
-	| MultiPolygon
-	| LineString
-	| MultiLineString
-	| Point
-	| MultiPoint
-	| GeometryCollection
+  Polygon | MultiPolygon | LineString | MultiLineString | Point | MultiPoint | GeometryCollection
 > {
-	const getNodeCoordinates = (nodeId: number): LonLat | undefined => {
-		const pos = refToPosition(nodeId)
-		return pos ? [pos[0], pos[1]] : undefined
-	}
+  const getNodeCoordinates = (nodeId: number): LonLat | undefined => {
+    const pos = refToPosition(nodeId);
+    return pos ? [pos[0], pos[1]] : undefined;
+  };
 
-	const kind = getRelationKind(relation)
+  const kind = getRelationKind(relation);
 
-	// Handle area relations (multipolygon, boundary)
-	if (isAreaRelation(relation) && getWay) {
-		const rings = buildRelationRings(relation, getWay, getNodeCoordinates)
+  // Handle area relations (multipolygon, boundary)
+  if (isAreaRelation(relation) && getWay) {
+    const rings = buildRelationRings(relation, getWay, getNodeCoordinates);
 
-		if (rings.length === 0) {
-			// Fallback to simple MultiPolygon if we can't build rings
-			return {
-				type: "Feature",
-				id: relation.id,
-				geometry: {
-					type: "MultiPolygon",
-					coordinates: [],
-				},
-				properties: {
-					id: relation.id,
-					type: "relation",
-					...relation.info,
-					...relation.tags,
-				},
-			}
-		}
+    if (rings.length === 0) {
+      // Fallback to simple MultiPolygon if we can't build rings
+      return {
+        type: "Feature",
+        id: relation.id,
+        geometry: {
+          type: "MultiPolygon",
+          coordinates: [],
+        },
+        properties: {
+          id: relation.id,
+          type: "relation",
+          ...relation.info,
+          ...relation.tags,
+        },
+      };
+    }
 
-		// If only one polygon, return Polygon; otherwise MultiPolygon
-		if (rings.length === 1) {
-			return {
-				type: "Feature",
-				id: relation.id,
-				geometry: {
-					type: "Polygon",
-					coordinates: rings[0]!,
-				},
-				properties: {
-					id: relation.id,
-					type: "relation",
-					...relation.info,
-					...relation.tags,
-				},
-			}
-		}
+    // If only one polygon, return Polygon; otherwise MultiPolygon
+    if (rings.length === 1) {
+      return {
+        type: "Feature",
+        id: relation.id,
+        geometry: {
+          type: "Polygon",
+          coordinates: rings[0]!,
+        },
+        properties: {
+          id: relation.id,
+          type: "relation",
+          ...relation.info,
+          ...relation.tags,
+        },
+      };
+    }
 
-		return {
-			type: "Feature",
-			id: relation.id,
-			geometry: {
-				type: "MultiPolygon",
-				coordinates: rings,
-			},
-			properties: {
-				id: relation.id,
-				type: "relation",
-				...relation.info,
-				...relation.tags,
-			},
-		}
-	}
+    return {
+      type: "Feature",
+      id: relation.id,
+      geometry: {
+        type: "MultiPolygon",
+        coordinates: rings,
+      },
+      properties: {
+        id: relation.id,
+        type: "relation",
+        ...relation.info,
+        ...relation.tags,
+      },
+    };
+  }
 
-	// Handle line relations (route, multilinestring)
-	if (kind === "line" && getWay) {
-		const lineStrings = buildRelationLineStrings(
-			relation,
-			getWay,
-			getNodeCoordinates,
-		)
+  // Handle line relations (route, multilinestring)
+  if (kind === "line" && getWay) {
+    const lineStrings = buildRelationLineStrings(relation, getWay, getNodeCoordinates);
 
-		if (lineStrings.length === 0) {
-			return {
-				type: "Feature",
-				id: relation.id,
-				geometry: {
-					type: "MultiLineString",
-					coordinates: [],
-				},
-				properties: {
-					id: relation.id,
-					type: "relation",
-					...relation.info,
-					...relation.tags,
-				},
-			}
-		}
+    if (lineStrings.length === 0) {
+      return {
+        type: "Feature",
+        id: relation.id,
+        geometry: {
+          type: "MultiLineString",
+          coordinates: [],
+        },
+        properties: {
+          id: relation.id,
+          type: "relation",
+          ...relation.info,
+          ...relation.tags,
+        },
+      };
+    }
 
-		if (lineStrings.length === 1) {
-			return {
-				type: "Feature",
-				id: relation.id,
-				geometry: {
-					type: "LineString",
-					coordinates: lineStrings[0]!,
-				},
-				properties: {
-					id: relation.id,
-					type: "relation",
-					...relation.info,
-					...relation.tags,
-				},
-			}
-		}
+    if (lineStrings.length === 1) {
+      return {
+        type: "Feature",
+        id: relation.id,
+        geometry: {
+          type: "LineString",
+          coordinates: lineStrings[0]!,
+        },
+        properties: {
+          id: relation.id,
+          type: "relation",
+          ...relation.info,
+          ...relation.tags,
+        },
+      };
+    }
 
-		return {
-			type: "Feature",
-			id: relation.id,
-			geometry: {
-				type: "MultiLineString",
-				coordinates: lineStrings,
-			},
-			properties: {
-				id: relation.id,
-				type: "relation",
-				...relation.info,
-				...relation.tags,
-			},
-		}
-	}
+    return {
+      type: "Feature",
+      id: relation.id,
+      geometry: {
+        type: "MultiLineString",
+        coordinates: lineStrings,
+      },
+      properties: {
+        id: relation.id,
+        type: "relation",
+        ...relation.info,
+        ...relation.tags,
+      },
+    };
+  }
 
-	// Handle point relations (multipoint)
-	if (kind === "point") {
-		const points = collectRelationPoints(relation, getNodeCoordinates)
+  // Handle point relations (multipoint)
+  if (kind === "point") {
+    const points = collectRelationPoints(relation, getNodeCoordinates);
 
-		if (points.length === 0) {
-			return {
-				type: "Feature",
-				id: relation.id,
-				geometry: {
-					type: "MultiPoint",
-					coordinates: [],
-				},
-				properties: {
-					id: relation.id,
-					type: "relation",
-					...relation.info,
-					...relation.tags,
-				},
-			}
-		}
+    if (points.length === 0) {
+      return {
+        type: "Feature",
+        id: relation.id,
+        geometry: {
+          type: "MultiPoint",
+          coordinates: [],
+        },
+        properties: {
+          id: relation.id,
+          type: "relation",
+          ...relation.info,
+          ...relation.tags,
+        },
+      };
+    }
 
-		if (points.length === 1) {
-			return {
-				type: "Feature",
-				id: relation.id,
-				geometry: {
-					type: "Point",
-					coordinates: points[0]!,
-				},
-				properties: {
-					id: relation.id,
-					type: "relation",
-					...relation.info,
-					...relation.tags,
-				},
-			}
-		}
+    if (points.length === 1) {
+      return {
+        type: "Feature",
+        id: relation.id,
+        geometry: {
+          type: "Point",
+          coordinates: points[0]!,
+        },
+        properties: {
+          id: relation.id,
+          type: "relation",
+          ...relation.info,
+          ...relation.tags,
+        },
+      };
+    }
 
-		return {
-			type: "Feature",
-			id: relation.id,
-			geometry: {
-				type: "MultiPoint",
-				coordinates: points,
-			},
-			properties: {
-				id: relation.id,
-				type: "relation",
-				...relation.info,
-				...relation.tags,
-			},
-		}
-	}
+    return {
+      type: "Feature",
+      id: relation.id,
+      geometry: {
+        type: "MultiPoint",
+        coordinates: points,
+      },
+      properties: {
+        id: relation.id,
+        type: "relation",
+        ...relation.info,
+        ...relation.tags,
+      },
+    };
+  }
 
-	// Fallback for logical relations or when getWay is not provided
-	// Return GeometryCollection or null geometry for logic-only relations
-	if (kind === "logic" || kind === "super") {
-		return {
-			type: "Feature",
-			id: relation.id,
-			geometry: {
-				type: "GeometryCollection",
-				geometries: [],
-			},
-			properties: {
-				id: relation.id,
-				type: "relation",
-				...relation.info,
-				...relation.tags,
-			},
-		}
-	}
+  // Fallback for logical relations or when getWay is not provided
+  // Return GeometryCollection or null geometry for logic-only relations
+  if (kind === "logic" || kind === "super") {
+    return {
+      type: "Feature",
+      id: relation.id,
+      geometry: {
+        type: "GeometryCollection",
+        geometries: [],
+      },
+      properties: {
+        id: relation.id,
+        type: "relation",
+        ...relation.info,
+        ...relation.tags,
+      },
+    };
+  }
 
-	// Final fallback: try to create a simple representation from way members
-	if (getWay) {
-		const { outer } = getWayMembersByRole(relation)
-		const coordinates: [number, number][][][] = []
+  // Final fallback: try to create a simple representation from way members
+  if (getWay) {
+    const { outer } = getWayMembersByRole(relation);
+    const coordinates: [number, number][][][] = [];
 
-		if (outer.length > 0) {
-			coordinates.push([outer.map((member) => refToPosition(member.ref))])
-		}
+    if (outer.length > 0) {
+      const outerCoordinates = outer
+        .map((member) => refToPosition(member.ref))
+        .filter((position): position is [number, number] => position != null);
+      if (outerCoordinates.length > 0) coordinates.push([outerCoordinates]);
+    }
 
-		return {
-			type: "Feature",
-			id: relation.id,
-			geometry: {
-				type: "MultiPolygon",
-				coordinates: coordinates.length > 0 ? coordinates : [],
-			},
-			properties: {
-				id: relation.id,
-				type: "relation",
-				...relation.info,
-				...relation.tags,
-			},
-		}
-	}
+    return {
+      type: "Feature",
+      id: relation.id,
+      geometry: {
+        type: "MultiPolygon",
+        coordinates: coordinates.length > 0 ? coordinates : [],
+      },
+      properties: {
+        id: relation.id,
+        type: "relation",
+        ...relation.info,
+        ...relation.tags,
+      },
+    };
+  }
 
-	// No geometry available
-	return {
-		type: "Feature",
-		id: relation.id,
-		geometry: {
-			type: "GeometryCollection",
-			geometries: [],
-		},
-		properties: {
-			id: relation.id,
-			type: "relation",
-			...relation.info,
-			...relation.tags,
-		},
-	}
+  // No geometry available
+  return {
+    type: "Feature",
+    id: relation.id,
+    geometry: {
+      type: "GeometryCollection",
+      geometries: [],
+    },
+    properties: {
+      id: relation.id,
+      type: "relation",
+      ...relation.info,
+      ...relation.tags,
+    },
+  };
 }
 
 /**
@@ -399,29 +390,33 @@ export function relationToFeature(
  * ```
  */
 export function osmEntityToGeoJSONFeature(
-	osm: Osm,
-	entity: OsmEntity,
+  osm: OsmReader,
+  entity: OsmEntity,
 ): OsmGeoJSONFeature<
-	| GeoJSON.Point
-	| GeoJSON.LineString
-	| GeoJSON.Polygon
-	| GeoJSON.MultiPolygon
-	| GeoJSON.MultiLineString
-	| GeoJSON.MultiPoint
-	| GeoJSON.GeometryCollection
+  | GeoJSON.Point
+  | GeoJSON.LineString
+  | GeoJSON.Polygon
+  | GeoJSON.MultiPolygon
+  | GeoJSON.MultiLineString
+  | GeoJSON.MultiPoint
+  | GeoJSON.GeometryCollection
 > {
-	if (isNode(entity)) {
-		return nodeToFeature(entity)
-	}
-	if (isWay(entity)) {
-		return wayToFeature(entity, (ref) => osm.nodes.getNodeLonLat({ id: ref }))
-	}
-	if (isRelation(entity)) {
-		return relationToFeature(
-			entity,
-			(ref) => osm.nodes.getNodeLonLat({ id: ref }),
-			(ref) => osm.ways.getById(ref),
-		)
-	}
-	throw new Error("Unknown entity type")
+  if (isNode(entity)) {
+    return nodeToFeature(entity);
+  }
+  if (isWay(entity)) {
+    return wayToFeature(entity, (ref) => {
+      const coordinate = osm.nodes.getNodeLonLat({ id: ref });
+      if (!coordinate) throw Error(`Node ${ref} not found for way geometry`);
+      return coordinate;
+    });
+  }
+  if (isRelation(entity)) {
+    return relationToFeature(
+      entity,
+      (ref) => osm.nodes.getNodeLonLat({ id: ref }) ?? undefined,
+      (ref) => osm.ways.getById(ref),
+    );
+  }
+  throw new Error("Unknown entity type");
 }