@osmix/geojson 0.0.15 → 0.0.16

package/src/index.ts

@@ -30,6 +30,6 @@
  * @module @osmix/geojson
  */
 
-export * from "./entity-to-feature.ts"
-export * from "./osm-from-geojson.ts"
-export * from "./types.ts"
+export * from "./entity-to-feature.ts";
+export * from "./osm-from-geojson.ts";
+export * from "./types.ts";

package/src/osm-from-geojson.ts

@@ -7,23 +7,14 @@
  * @module
  */
 
-import { Osm, type OsmOptions } from "@osmix/core"
-import {
-	logProgress,
-	type ProgressEvent,
-	progressEvent,
-} from "@osmix/shared/progress"
-import type { OsmRelationMember, OsmTags } from "@osmix/shared/types"
-import { rewindFeature } from "@placemarkio/geojson-rewind"
-import type {
-	FeatureCollection,
-	LineString,
-	MultiPolygon,
-	Point,
-	Polygon,
-} from "geojson"
-import type { ReadOsmDataTypes } from "./types.ts"
-import { readDataAsGeoJSON } from "./utils.ts"
+import { Osm, type OsmOptions, type OsmWriter } from "@osmix/core";
+import { logProgress, type ProgressEvent, progressEvent } from "@osmix/shared/progress";
+import type { OsmRelationMember, OsmTags } from "@osmix/types";
+import { rewindFeature } from "@placemarkio/geojson-rewind";
+import type { FeatureCollection, LineString, MultiPolygon, Point, Polygon } from "geojson";
+
+import type { ReadOsmDataTypes } from "./types.ts";
+import { readDataAsGeoJSON } from "./utils.ts";
 
 /**
  * Create an Osm index from GeoJSON data.
@@ -56,18 +47,15 @@ import { readDataAsGeoJSON } from "./utils.ts"
  * ```
  */
 export async function fromGeoJSON(
-	data: ReadOsmDataTypes,
-	options: Partial<OsmOptions> = {},
-	onProgress: (progress: ProgressEvent) => void = logProgress,
+  data: ReadOsmDataTypes,
+  options: Partial<OsmOptions> = {},
+  onProgress: (progress: ProgressEvent) => void = logProgress,
 ): Promise<Osm> {
-	const osm = new Osm(options)
-	for (const update of startCreateOsmFromGeoJSON(
-		osm,
-		await readDataAsGeoJSON(data),
-	)) {
-		onProgress(update)
-	}
-	return osm
+  const osm = new Osm(options);
+  for (const update of startCreateOsmFromGeoJSON(osm, await readDataAsGeoJSON(data))) {
+    onProgress(update);
+  }
+  return osm;
 }
 
 /**
@@ -91,270 +79,261 @@ export async function fromGeoJSON(
  * @yields Progress events during conversion.
  */
 export function* startCreateOsmFromGeoJSON(
-	osm: Osm,
-	geojson: FeatureCollection<Point | LineString | Polygon | MultiPolygon>,
+  osm: OsmWriter,
+  geojson: FeatureCollection<Point | LineString | Polygon | MultiPolygon>,
 ): Generator<ProgressEvent> {
-	yield progressEvent("Converting GeoJSON to Osmix...")
-
-	// Map to track nodes by coordinate string for reuse when creating ways and relations
-	const nodeMap = new Map<string, number>()
-	let nextNodeId = -1
-	let nextWayId = -1
-	let nextRelationId = -1
-
-	// Helper to get or create a node for a coordinate
-	const getOrCreateNode = (lon: number, lat: number): number => {
-		const coordKey = `${lon},${lat}`
-		const existingNodeId = nodeMap.get(coordKey)
-		if (existingNodeId !== undefined) {
-			return existingNodeId
-		}
-
-		const nodeId = nextNodeId--
-		nodeMap.set(coordKey, nodeId)
-		osm.nodes.addNode({
-			id: nodeId,
-			lon,
-			lat,
-		})
-		return nodeId
-	}
-
-	// Process each feature
-	let count = 0
-	for (const feature of geojson.features) {
-		// Normalize winding order using rewind (outer rings counterclockwise, inner rings clockwise)
-		const normalizedFeature = rewindFeature(feature)
-		const tags = propertiesToTags(normalizedFeature.properties)
-		const featureId = extractFeatureId(normalizedFeature.id)
-
-		if (normalizedFeature.geometry?.type === "Point") {
-			const [lon, lat] = normalizedFeature.geometry.coordinates
-			if (lon === undefined || lat === undefined)
-				throw Error("Invalid GeoJSON coordinates in Point.")
-
-			const nodeId = featureId ?? nextNodeId--
-			osm.nodes.addNode({
-				id: nodeId,
-				lon,
-				lat,
-				tags,
-			})
-			nodeMap.set(`${lon},${lat}`, nodeId)
-		} else if (normalizedFeature.geometry?.type === "LineString") {
-			const coordinates = normalizedFeature.geometry.coordinates
-			if (coordinates.length < 2)
-				throw Error("Invalid GeoJSON coordinates in LineString.")
-
-			// Create or get nodes for each coordinate
-			const nodeRefs: number[] = []
-			for (const [lon, lat] of coordinates) {
-				if (lon === undefined || lat === undefined)
-					throw Error("Invalid GeoJSON coordinates in LineString.")
-				const nodeId = getOrCreateNode(lon, lat)
-				nodeRefs.push(nodeId)
-			}
-
-			// Create the way
-			const wayId = featureId ?? nextWayId--
-			osm.ways.addWay({
-				id: wayId,
-				refs: nodeRefs,
-				tags,
-			})
-		} else if (normalizedFeature.geometry?.type === "Polygon") {
-			const coordinates = normalizedFeature.geometry.coordinates
-			if (coordinates.length === 0) continue
-
-			// If the polygon contains holes, create a relation
-			const createRelation = coordinates.length > 1
-
-			// First ring is outer boundary, subsequent rings are holes
-			const outerRing = coordinates[0]
-			if (!outerRing || outerRing.length < 3) continue // Need at least 3 points for a polygon
-
-			// Create nodes for outer ring
-			const outerNodeRefs: number[] = []
-			for (const [lon, lat] of outerRing) {
-				if (lon === undefined || lat === undefined)
-					throw Error("Invalid GeoJSON coordinates in Polygon.")
-				const nodeId = getOrCreateNode(lon, lat)
-				outerNodeRefs.push(nodeId)
-			}
-
-			// Ensure the outer ring is closed (first and last node are the same)
-			if (outerNodeRefs[0] !== outerNodeRefs[outerNodeRefs.length - 1])
-				throw Error("Outer ring of Polygon is not closed.")
-
-			// Create way for outer ring with area tags
-			const outerWayId = createRelation
-				? nextWayId--
-				: (featureId ?? nextWayId--)
-			osm.ways.addWay({
-				id: outerWayId,
-				refs: outerNodeRefs,
-				tags: createRelation ? { area: "yes" } : { area: "yes", ...tags },
-			})
-
-			// Create separate ways for holes
-			const holeWayIds: number[] = []
-			for (let i = 1; i < coordinates.length; i++) {
-				const holeRing = coordinates[i]
-				if (!holeRing || holeRing.length < 3)
-					throw Error("Hole ring of Polygon has less than 3 coordinates.")
-
-				const holeNodeRefs: number[] = []
-				for (const [lon, lat] of holeRing) {
-					if (lon === undefined || lat === undefined)
-						throw Error("Invalid GeoJSON coordinates in Polygon.")
-					const nodeId = getOrCreateNode(lon, lat)
-					holeNodeRefs.push(nodeId)
-				}
-
-				// Ensure the ring is closed
-				if (holeNodeRefs[0] !== holeNodeRefs[holeNodeRefs.length - 1])
-					throw Error("Hole ring of Polygon is not closed.")
-
-				// Create way for hole
-				const holeWayId = nextWayId--
-				osm.ways.addWay({
-					id: holeWayId,
-					refs: holeNodeRefs,
-					tags: { area: "yes" },
-				})
-				holeWayIds.push(holeWayId)
-			}
-
-			if (createRelation) {
-				osm.relations.addRelation({
-					id: featureId ?? nextRelationId--,
-					members: [
-						{ type: "way", ref: outerWayId, role: "outer" },
-						...holeWayIds.map(
-							(id) =>
-								({ type: "way", ref: id, role: "inner" }) as OsmRelationMember,
-						),
-					],
-					tags: {
-						type: "multipolygon",
-						...tags,
-					},
-				})
-			}
-		} else if (normalizedFeature.geometry?.type === "MultiPolygon") {
-			const coordinates = normalizedFeature.geometry.coordinates
-			if (coordinates.length === 0) continue
-
-			// Process each polygon in the MultiPolygon
-			const relationMembers: OsmRelationMember[] = []
-			for (const polygon of coordinates) {
-				if (polygon.length === 0) continue
-
-				const outerRing = polygon[0]
-				if (!outerRing || outerRing.length < 3) continue
-
-				// Create nodes for outer ring
-				const outerNodeRefs: number[] = []
-				for (const [lon, lat] of outerRing) {
-					if (lon === undefined || lat === undefined)
-						throw Error("Invalid GeoJSON coordinates in Polygon.")
-					const nodeId = getOrCreateNode(lon, lat)
-					outerNodeRefs.push(nodeId)
-				}
-
-				// Ensure the ring is closed
-				if (outerNodeRefs[0] !== outerNodeRefs[outerNodeRefs.length - 1])
-					throw Error("Outer ring of Polygon is not closed.")
-
-				// Create way for outer ring
-				const outerWayId = nextWayId--
-				osm.ways.addWay({
-					id: outerWayId,
-					refs: outerNodeRefs,
-					tags: { area: "yes" },
-				})
-				relationMembers.push({ type: "way", ref: outerWayId, role: "outer" })
-
-				// Create separate ways for holes in this polygon
-				for (let i = 1; i < polygon.length; i++) {
-					const holeRing = polygon[i]
-					if (!holeRing || holeRing.length < 3)
-						throw Error("Hole ring of Polygon has less than 3 coordinates.")
-
-					const holeNodeRefs: number[] = []
-					for (const [lon, lat] of holeRing) {
-						if (lon === undefined || lat === undefined)
-							throw Error("Invalid GeoJSON coordinates in Polygon.")
-						const nodeId = getOrCreateNode(lon, lat)
-						holeNodeRefs.push(nodeId)
-					}
-
-					// Ensure the ring is closed
-					if (holeNodeRefs[0] !== holeNodeRefs[holeNodeRefs.length - 1])
-						throw Error("Hole ring of Polygon is not closed.")
-
-					const holeWayId = nextWayId--
-					osm.ways.addWay({
-						id: holeWayId,
-						refs: holeNodeRefs,
-						tags: { area: "yes" },
-					})
-
-					relationMembers.push({ type: "way", ref: holeWayId, role: "inner" })
-				}
-			}
-
-			if (relationMembers.length > 0) {
-				osm.relations.addRelation({
-					id: featureId ?? nextRelationId--,
-					members: relationMembers,
-					tags: { type: "multipolygon", ...tags },
-				})
-			}
-		}
-
-		yield progressEvent(`Processed ${count++} features...`)
-	}
-
-	yield progressEvent(
-		"Finished converting GeoJSON to Osmix, building indexes...",
-	)
-
-	// Build indexes
-	osm.buildIndexes()
-	osm.buildSpatialIndexes()
+  yield progressEvent("Converting GeoJSON to Osmix...");
+
+  // Map to track nodes by coordinate string for reuse when creating ways and relations
+  const nodeMap = new Map<string, number>();
+  let nextNodeId = -1;
+  let nextWayId = -1;
+  let nextRelationId = -1;
+
+  // Helper to get or create a node for a coordinate
+  const getOrCreateNode = (lon: number, lat: number): number => {
+    const coordKey = `${lon},${lat}`;
+    const existingNodeId = nodeMap.get(coordKey);
+    if (existingNodeId !== undefined) {
+      return existingNodeId;
+    }
+
+    const nodeId = nextNodeId--;
+    nodeMap.set(coordKey, nodeId);
+    osm.nodes.addNode({
+      id: nodeId,
+      lon,
+      lat,
+    });
+    return nodeId;
+  };
+
+  // Process each feature
+  let count = 0;
+  for (const feature of geojson.features) {
+    // Normalize winding order using rewind (outer rings counterclockwise, inner rings clockwise)
+    const normalizedFeature = rewindFeature(feature);
+    const tags = propertiesToTags(normalizedFeature.properties);
+    const featureId = extractFeatureId(normalizedFeature.id);
+
+    if (normalizedFeature.geometry?.type === "Point") {
+      const [lon, lat] = normalizedFeature.geometry.coordinates;
+      if (lon === undefined || lat === undefined)
+        throw Error("Invalid GeoJSON coordinates in Point.");
+
+      const nodeId = featureId ?? nextNodeId--;
+      osm.nodes.addNode({
+        id: nodeId,
+        lon,
+        lat,
+        tags,
+      });
+      nodeMap.set(`${lon},${lat}`, nodeId);
+    } else if (normalizedFeature.geometry?.type === "LineString") {
+      const coordinates = normalizedFeature.geometry.coordinates;
+      if (coordinates.length < 2) throw Error("Invalid GeoJSON coordinates in LineString.");
+
+      // Create or get nodes for each coordinate
+      const nodeRefs: number[] = [];
+      for (const [lon, lat] of coordinates) {
+        if (lon === undefined || lat === undefined)
+          throw Error("Invalid GeoJSON coordinates in LineString.");
+        const nodeId = getOrCreateNode(lon, lat);
+        nodeRefs.push(nodeId);
+      }
+
+      // Create the way
+      const wayId = featureId ?? nextWayId--;
+      osm.ways.addWay({
+        id: wayId,
+        refs: nodeRefs,
+        tags,
+      });
+    } else if (normalizedFeature.geometry?.type === "Polygon") {
+      const coordinates = normalizedFeature.geometry.coordinates;
+      if (coordinates.length === 0) continue;
+
+      // If the polygon contains holes, create a relation
+      const createRelation = coordinates.length > 1;
+
+      // First ring is outer boundary, subsequent rings are holes
+      const outerRing = coordinates[0];
+      if (!outerRing || outerRing.length < 3) continue; // Need at least 3 points for a polygon
+
+      // Create nodes for outer ring
+      const outerNodeRefs: number[] = [];
+      for (const [lon, lat] of outerRing) {
+        if (lon === undefined || lat === undefined)
+          throw Error("Invalid GeoJSON coordinates in Polygon.");
+        const nodeId = getOrCreateNode(lon, lat);
+        outerNodeRefs.push(nodeId);
+      }
+
+      // Ensure the outer ring is closed (first and last node are the same)
+      if (outerNodeRefs[0] !== outerNodeRefs[outerNodeRefs.length - 1])
+        throw Error("Outer ring of Polygon is not closed.");
+
+      // Create way for outer ring with area tags
+      const outerWayId = createRelation ? nextWayId-- : (featureId ?? nextWayId--);
+      osm.ways.addWay({
+        id: outerWayId,
+        refs: outerNodeRefs,
+        tags: createRelation ? { area: "yes" } : { area: "yes", ...tags },
+      });
+
+      // Create separate ways for holes
+      const holeWayIds: number[] = [];
+      for (let i = 1; i < coordinates.length; i++) {
+        const holeRing = coordinates[i];
+        if (!holeRing || holeRing.length < 3)
+          throw Error("Hole ring of Polygon has less than 3 coordinates.");
+
+        const holeNodeRefs: number[] = [];
+        for (const [lon, lat] of holeRing) {
+          if (lon === undefined || lat === undefined)
+            throw Error("Invalid GeoJSON coordinates in Polygon.");
+          const nodeId = getOrCreateNode(lon, lat);
+          holeNodeRefs.push(nodeId);
+        }
+
+        // Ensure the ring is closed
+        if (holeNodeRefs[0] !== holeNodeRefs[holeNodeRefs.length - 1])
+          throw Error("Hole ring of Polygon is not closed.");
+
+        // Create way for hole
+        const holeWayId = nextWayId--;
+        osm.ways.addWay({
+          id: holeWayId,
+          refs: holeNodeRefs,
+          tags: { area: "yes" },
+        });
+        holeWayIds.push(holeWayId);
+      }
+
+      if (createRelation) {
+        osm.relations.addRelation({
+          id: featureId ?? nextRelationId--,
+          members: [
+            { type: "way", ref: outerWayId, role: "outer" },
+            ...holeWayIds.map(
+              (id) => ({ type: "way", ref: id, role: "inner" }) as OsmRelationMember,
+            ),
+          ],
+          tags: {
+            type: "multipolygon",
+            ...tags,
+          },
+        });
+      }
+    } else if (normalizedFeature.geometry?.type === "MultiPolygon") {
+      const coordinates = normalizedFeature.geometry.coordinates;
+      if (coordinates.length === 0) continue;
+
+      // Process each polygon in the MultiPolygon
+      const relationMembers: OsmRelationMember[] = [];
+      for (const polygon of coordinates) {
+        if (polygon.length === 0) continue;
+
+        const outerRing = polygon[0];
+        if (!outerRing || outerRing.length < 3) continue;
+
+        // Create nodes for outer ring
+        const outerNodeRefs: number[] = [];
+        for (const [lon, lat] of outerRing) {
+          if (lon === undefined || lat === undefined)
+            throw Error("Invalid GeoJSON coordinates in Polygon.");
+          const nodeId = getOrCreateNode(lon, lat);
+          outerNodeRefs.push(nodeId);
+        }
+
+        // Ensure the ring is closed
+        if (outerNodeRefs[0] !== outerNodeRefs[outerNodeRefs.length - 1])
+          throw Error("Outer ring of Polygon is not closed.");
+
+        // Create way for outer ring
+        const outerWayId = nextWayId--;
+        osm.ways.addWay({
+          id: outerWayId,
+          refs: outerNodeRefs,
+          tags: { area: "yes" },
+        });
+        relationMembers.push({ type: "way", ref: outerWayId, role: "outer" });
+
+        // Create separate ways for holes in this polygon
+        for (let i = 1; i < polygon.length; i++) {
+          const holeRing = polygon[i];
+          if (!holeRing || holeRing.length < 3)
+            throw Error("Hole ring of Polygon has less than 3 coordinates.");
+
+          const holeNodeRefs: number[] = [];
+          for (const [lon, lat] of holeRing) {
+            if (lon === undefined || lat === undefined)
+              throw Error("Invalid GeoJSON coordinates in Polygon.");
+            const nodeId = getOrCreateNode(lon, lat);
+            holeNodeRefs.push(nodeId);
+          }
+
+          // Ensure the ring is closed
+          if (holeNodeRefs[0] !== holeNodeRefs[holeNodeRefs.length - 1])
+            throw Error("Hole ring of Polygon is not closed.");
+
+          const holeWayId = nextWayId--;
+          osm.ways.addWay({
+            id: holeWayId,
+            refs: holeNodeRefs,
+            tags: { area: "yes" },
+          });
+
+          relationMembers.push({ type: "way", ref: holeWayId, role: "inner" });
+        }
+      }
+
+      if (relationMembers.length > 0) {
+        osm.relations.addRelation({
+          id: featureId ?? nextRelationId--,
+          members: relationMembers,
+          tags: { type: "multipolygon", ...tags },
+        });
+      }
+    }
+
+    yield progressEvent(`Processed ${count++} features...`);
+  }
+
+  yield progressEvent("Finished converting GeoJSON to Osmix, building indexes...");
+
+  // Build indexes
+  osm.buildIndexes();
+  osm.buildSpatialIndexes();
 }
 
 // Helper to convert properties to tags
-function propertiesToTags(
-	properties: Record<string, unknown> | null,
-): OsmTags | undefined {
-	if (!properties || Object.keys(properties).length === 0) {
-		return undefined
-	}
-
-	const tags: OsmTags = {}
-	for (const [key, value] of Object.entries(properties)) {
-		// Convert value to string or number
-		if (typeof value === "string" || typeof value === "number") {
-			tags[key] = value
-		} else if (value != null) {
-			// Convert other types to string
-			tags[key] = String(value)
-		}
-	}
-	return Object.keys(tags).length > 0 ? tags : undefined
+function propertiesToTags(properties: Record<string, unknown> | null): OsmTags | undefined {
+  if (!properties || Object.keys(properties).length === 0) {
+    return undefined;
+  }
+
+  const tags: OsmTags = {};
+  for (const [key, value] of Object.entries(properties)) {
+    // Convert value to string or number
+    if (typeof value === "string" || typeof value === "number") {
+      tags[key] = value;
+    } else if (typeof value === "boolean") {
+      tags[key] = String(value);
+    } else if (value != null && typeof value === "object") {
+      tags[key] = JSON.stringify(value);
+    }
+  }
+  return Object.keys(tags).length > 0 ? tags : undefined;
 }
 
 // Helper to extract numeric ID from feature
-function extractFeatureId(
-	featureId: string | number | undefined,
-): number | undefined {
-	if (featureId === undefined) return undefined
-	if (typeof featureId === "number") return featureId
-	if (typeof featureId === "string") {
-		const numId = Number.parseInt(featureId, 10)
-		if (!Number.isNaN(numId)) return numId
-	}
-	return undefined
+function extractFeatureId(featureId: string | number | undefined): number | undefined {
+  if (featureId === undefined) return undefined;
+  if (typeof featureId === "number") return featureId;
+  if (typeof featureId === "string") {
+    const numId = Number.parseInt(featureId, 10);
+    if (!Number.isNaN(numId)) return numId;
+  }
+  return undefined;
 }