@osmix/geojson 0.0.4

package/src/osm-from-geojson.ts

@@ -0,0 +1,360 @@
+/**
+ * GeoJSON-to-OSM conversion utilities.
+ *
+ * Imports GeoJSON FeatureCollections into Osm indexes, mapping geometry
+ * types to appropriate OSM entity structures.
+ *
+ * @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"
+import { readDataAsGeoJSON } from "./utils"
+
+/**
+ * Create an Osm index from GeoJSON data.
+ *
+ * Accepts various input formats (string, stream, buffer, or parsed object)
+ * and converts features to OSM entities:
+ * - Point → Node
+ * - LineString → Way with nodes
+ * - Polygon → Way (simple) or Relation (with holes)
+ * - MultiPolygon → Relation
+ *
+ * Feature IDs are preserved if numeric; otherwise sequential negative IDs are assigned.
+ * Feature properties become OSM tags.
+ *
+ * @param data - GeoJSON data in any supported format.
+ * @param options - Osm index options (id, header).
+ * @param onProgress - Progress callback for UI feedback.
+ * @returns Populated Osm index with built indexes.
+ *
+ * @example
+ * ```ts
+ * import { fromGeoJSON } from "@osmix/geojson"
+ *
+ * // From file
+ * const geojson = await Bun.file('./roads.geojson').json()
+ * const osm = await fromGeoJSON(geojson, { id: "roads" })
+ *
+ * // Query the imported data
+ * const highways = osm.ways.search("highway")
+ * ```
+ */
+export async function fromGeoJSON(
+	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
+}
+
+/**
+ * Generator that converts GeoJSON features to OSM entities.
+ *
+ * This is the core conversion logic, yielding progress events as features
+ * are processed. Called by `fromGeoJSON` with progress handling.
+ *
+ * Geometry mapping:
+ * - **Point**: Creates a single node with feature properties as tags.
+ * - **LineString**: Creates nodes for each coordinate, then a way referencing them.
+ * - **Polygon**: Creates a way for simple polygons; for polygons with holes,
+ *   creates separate ways for outer and inner rings plus a multipolygon relation.
+ * - **MultiPolygon**: Creates a multipolygon relation with all rings as way members.
+ *
+ * Coordinates are normalized using `rewind` to ensure correct winding order
+ * (outer rings counterclockwise, inner rings clockwise per OSM conventions).
+ *
+ * @param osm - Target Osm index to populate.
+ * @param geojson - Parsed GeoJSON FeatureCollection.
+ * @yields Progress events during conversion.
+ */
+export function* startCreateOsmFromGeoJSON(
+	osm: Osm,
+	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()
+}
+
+// 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
+}
+
+// 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
+}

package/src/types.ts

@@ -0,0 +1,77 @@
+/**
+ * Type definitions for OSM-GeoJSON conversion.
+ * @module
+ */
+
+import type { OsmEntityType, OsmInfoParsed, OsmTags } from "@osmix/shared/types"
+import type {
+	Feature,
+	GeometryCollection,
+	LineString,
+	MultiLineString,
+	MultiPoint,
+	MultiPolygon,
+	Point,
+	Polygon,
+} from "geojson"
+
+/**
+ * GeoJSON Feature properties for OSM entities.
+ *
+ * Includes the OSM entity ID, type, and optionally tags and metadata.
+ * All OSM tags are spread into the properties object.
+ */
+export type OsmGeoJSONProperties = {
+	/** OSM entity ID. */
+	id: number
+	/** Entity type: "node", "way", or "relation". */
+	type: OsmEntityType
+	/** OSM tags (key-value pairs). */
+	tags?: OsmTags
+	/** Entity metadata (version, timestamp, user, etc.). */
+	info?: OsmInfoParsed
+}
+
+/**
+ * GeoJSON Feature with OSM-specific properties.
+ *
+ * Generic over geometry type to support all OSM entity conversions:
+ * - Nodes → Point
+ * - Ways → LineString or Polygon
+ * - Relations → MultiPolygon, MultiLineString, MultiPoint, or GeometryCollection
+ */
+export type OsmGeoJSONFeature<
+	T extends
+		| Point
+		| LineString
+		| Polygon
+		| MultiPolygon
+		| MultiLineString
+		| MultiPoint
+		| GeometryCollection,
+> = Feature<T, OsmGeoJSONProperties>
+
+/**
+ * GeoJSON FeatureCollection types that can be imported into an Osm index.
+ *
+ * Supports Point, LineString, Polygon, and MultiPolygon geometries.
+ * Other geometry types are not supported for import.
+ */
+export type ImportableGeoJSON = GeoJSON.FeatureCollection<
+	GeoJSON.Point | GeoJSON.LineString | GeoJSON.Polygon | GeoJSON.MultiPolygon
+>
+
+/**
+ * Input types accepted by `fromGeoJSON`.
+ *
+ * Supports multiple formats:
+ * - `ArrayBufferLike` - Binary GeoJSON data
+ * - `ReadableStream` - Streaming GeoJSON
+ * - `string` - JSON string
+ * - `ImportableGeoJSON` - Already-parsed FeatureCollection
+ */
+export type ReadOsmDataTypes =
+	| ArrayBufferLike
+	| ReadableStream
+	| string
+	| ImportableGeoJSON

package/src/utils.ts

@@ -0,0 +1,58 @@
+/**
+ * Utility functions for GeoJSON data handling.
+ * @module
+ */
+
+import type { ImportableGeoJSON, ReadOsmDataTypes } from "./types"
+
+/**
+ * Parse GeoJSON from various input formats.
+ *
+ * Supports multiple input types for flexibility:
+ * - **string**: JSON string to parse
+ * - **ReadableStream**: Streaming JSON data
+ * - **ArrayBuffer/SharedArrayBuffer**: Binary data to decode and parse
+ * - **Object**: Already-parsed FeatureCollection (passed through)
+ *
+ * @param data - GeoJSON data in any supported format.
+ * @returns Parsed GeoJSON FeatureCollection.
+ * @throws If data is null or an unsupported type.
+ *
+ * @example
+ * ```ts
+ * // From string
+ * const geojson = await readDataAsGeoJSON('{"type":"FeatureCollection","features":[]}')
+ *
+ * // From fetch response
+ * const response = await fetch('/data.geojson')
+ * const geojson = await readDataAsGeoJSON(response.body!)
+ * ```
+ */
+export async function readDataAsGeoJSON(
+	data: ReadOsmDataTypes,
+): Promise<ImportableGeoJSON> {
+	if (data == null) throw new Error("Data is null")
+	if (typeof data === "string") return JSON.parse(data) as ImportableGeoJSON
+
+	if (data instanceof ReadableStream) {
+		const reader = data.pipeThrough(new TextDecoderStream()).getReader()
+		let result = ""
+		while (true) {
+			const { done, value } = await reader.read()
+			result += value
+			if (done) break
+		}
+		return JSON.parse(result) as ImportableGeoJSON
+	}
+	if (data instanceof ArrayBuffer || data instanceof SharedArrayBuffer) {
+		const decoder = new TextDecoder()
+		const text = decoder.decode(new Uint8Array(data))
+		return JSON.parse(text) as ImportableGeoJSON
+	}
+	if (typeof data === "object" && "type" in data && "features" in data) {
+		return data as ImportableGeoJSON
+	}
+	throw new Error(
+		"Invalid data type. Accepts string, ReadableStream, ArrayBufferLike, or GeoJSON FeatureCollection.",
+	)
+}

package/test/entity-to-feature.test.ts

@@ -0,0 +1,65 @@
+import { describe, expect, it } from "bun:test"
+import type { OsmNode, OsmRelation, OsmWay } from "@osmix/shared/types"
+import {
+	nodeToFeature,
+	relationToFeature,
+	wayToFeature,
+} from "../src/entity-to-feature"
+
+describe("geojson helpers", () => {
+	const node0: OsmNode = { id: 1, lat: 0, lon: 0, tags: { amenity: "cafe" } }
+	const node1: OsmNode = { id: 2, lat: 1, lon: 1 }
+	const nodes: OsmNode[] = [node0, node1]
+	const nodeMap = new Map(nodes.map((n) => [n.id, n]))
+	const refToPosition = (id: number) => {
+		const node = nodeMap.get(id)
+		if (!node) throw new Error(`Node ${id} not found`)
+		return [node.lon, node.lat] as [number, number]
+	}
+
+	it("converts node to GeoJSON Point", () => {
+		const feature = nodeToFeature(node0)
+		expect(feature.type).toBe("Feature")
+		expect(feature.geometry.type).toBe("Point")
+		expect(feature.geometry.coordinates).toEqual([node0.lon, node0.lat])
+		expect(feature.properties).toEqual({
+			id: node0.id,
+			type: "node",
+			...node0.tags,
+			...node0.info,
+		})
+	})
+
+	it("creates polygon for closed ways", () => {
+		const way: OsmWay = {
+			id: 10,
+			refs: [1, 2, 1],
+			tags: { area: "yes" },
+		}
+		const feature = wayToFeature(way, refToPosition)
+		expect(feature.geometry.type).toBe("Polygon")
+	})
+
+	it("builds relation geometry collection", () => {
+		// Create a way that forms a closed ring
+		const way: OsmWay = {
+			id: 10,
+			refs: [1, 2, 1], // Closed way
+			tags: { area: "yes" },
+		}
+		const wayMap = new Map([[way.id, way]])
+		const getWay = (wayId: number) => wayMap.get(wayId) ?? null
+
+		const relation: OsmRelation = {
+			id: 20,
+			members: [{ type: "way", ref: 10, role: "outer" }],
+			tags: { type: "multipolygon" },
+		}
+		const feature = relationToFeature(relation, refToPosition, getWay)
+		expect(feature.geometry.type).toBe("Polygon")
+		if (feature.geometry.type === "Polygon") {
+			expect(feature.geometry.coordinates?.[0]).toBeDefined()
+			expect(feature.geometry.coordinates[0]).toHaveLength(3) // Should have 3 coordinates (closed ring)
+		}
+	})
+})