@osmix/geojson 0.0.8 → 0.0.10

package/dist/test/osm-from-geojson.test.js

@@ -1,778 +0,0 @@
-import { describe, expect, it } from "bun:test";
-import { fromGeoJSON } from "../src/osm-from-geojson";
-describe("@osmix/geojson: createOsmFromGeoJSON", () => {
-    it("should convert Point features to Nodes", async () => {
-        const geojson = {
-            type: "FeatureCollection",
-            features: [
-                {
-                    type: "Feature",
-                    geometry: {
-                        type: "Point",
-                        coordinates: [-122.4194, 37.7749],
-                    },
-                    properties: {
-                        name: "San Francisco",
-                        population: 873965,
-                    },
-                },
-                {
-                    type: "Feature",
-                    geometry: {
-                        type: "Point",
-                        coordinates: [-122.4094, 37.7849],
-                    },
-                    properties: {
-                        name: "Another Point",
-                    },
-                },
-            ],
-        };
-        const osm = await fromGeoJSON(geojson);
-        expect(osm.nodes.size).toBe(2);
-        expect(osm.ways.size).toBe(0);
-        const node1 = osm.nodes.getById(-1);
-        expect(node1).toBeDefined();
-        expect(node1?.lon).toBe(-122.4194);
-        expect(node1?.lat).toBe(37.7749);
-        expect(node1?.tags?.["name"]).toBe("San Francisco");
-        // OSM tags are stored as strings, so numbers are converted
-        expect(node1?.tags?.["population"]).toBe("873965");
-        const node2 = osm.nodes.getById(-2);
-        expect(node2).toBeDefined();
-        expect(node2?.lon).toBe(-122.4094);
-        expect(node2?.lat).toBe(37.7849);
-        expect(node2?.tags?.["name"]).toBe("Another Point");
-    });
-    it("should convert LineString features to Ways with Nodes", async () => {
-        const geojson = {
-            type: "FeatureCollection",
-            features: [
-                {
-                    type: "Feature",
-                    geometry: {
-                        type: "LineString",
-                        coordinates: [
-                            [-122.4194, 37.7749],
-                            [-122.4094, 37.7849],
-                            [-122.3994, 37.7949],
-                        ],
-                    },
-                    properties: {
-                        highway: "primary",
-                        name: "Main Street",
-                    },
-                },
-            ],
-        };
-        const osm = await fromGeoJSON(geojson);
-        expect(osm.nodes.size).toBe(3);
-        expect(osm.ways.size).toBe(1);
-        const way = osm.ways.getById(-1);
-        expect(way).toBeDefined();
-        expect(way?.refs).toHaveLength(3);
-        expect(way?.tags?.["highway"]).toBe("primary");
-        expect(way?.tags?.["name"]).toBe("Main Street");
-        // Verify nodes were created
-        const node1 = osm.nodes.getById(way.refs[0]);
-        const node2 = osm.nodes.getById(way.refs[1]);
-        const node3 = osm.nodes.getById(way.refs[2]);
-        expect(node1?.lon).toBe(-122.4194);
-        expect(node1?.lat).toBe(37.7749);
-        expect(node2?.lon).toBe(-122.4094);
-        expect(node2?.lat).toBe(37.7849);
-        expect(node3?.lon).toBe(-122.3994);
-        expect(node3?.lat).toBe(37.7949);
-    });
-    it("should use feature IDs when present", async () => {
-        const geojson = {
-            type: "FeatureCollection",
-            features: [
-                {
-                    type: "Feature",
-                    id: 100,
-                    geometry: {
-                        type: "Point",
-                        coordinates: [-122.4194, 37.7749],
-                    },
-                    properties: {
-                        name: "Point with ID",
-                    },
-                },
-                {
-                    type: "Feature",
-                    id: "200",
-                    geometry: {
-                        type: "LineString",
-                        coordinates: [
-                            [-122.4194, 37.7749],
-                            [-122.4094, 37.7849],
-                        ],
-                    },
-                    properties: {
-                        highway: "primary",
-                    },
-                },
-            ],
-        };
-        const osm = await fromGeoJSON(geojson);
-        // Point should use ID 100
-        const node = osm.nodes.getById(100);
-        expect(node).toBeDefined();
-        expect(node?.tags?.["name"]).toBe("Point with ID");
-        // Way should use ID 200
-        const way = osm.ways.getById(200);
-        expect(way).toBeDefined();
-        expect(way?.tags?.["highway"]).toBe("primary");
-    });
-    it("should generate sequential IDs when feature IDs are not present", async () => {
-        const geojson = {
-            type: "FeatureCollection",
-            features: [
-                {
-                    type: "Feature",
-                    geometry: {
-                        type: "Point",
-                        coordinates: [-122.4194, 37.7749],
-                    },
-                    properties: {},
-                },
-                {
-                    type: "Feature",
-                    geometry: {
-                        type: "Point",
-                        coordinates: [-122.4094, 37.7849],
-                    },
-                    properties: {},
-                },
-                {
-                    type: "Feature",
-                    geometry: {
-                        type: "LineString",
-                        coordinates: [
-                            [-122.3994, 37.7949],
-                            [-122.3894, 37.8049],
-                        ],
-                    },
-                    properties: {},
-                },
-            ],
-        };
-        const osm = await fromGeoJSON(geojson);
-        // Nodes should have sequential IDs starting from 1
-        expect(osm.nodes.getById(-1)).toBeDefined();
-        expect(osm.nodes.getById(-2)).toBeDefined();
-        expect(osm.nodes.getById(-3)).toBeDefined();
-        expect(osm.nodes.getById(-4)).toBeDefined();
-        // Way should have ID 1
-        expect(osm.ways.getById(-1)).toBeDefined();
-    });
-    it("should convert all properties to OSM tags", async () => {
-        const geojson = {
-            type: "FeatureCollection",
-            features: [
-                {
-                    type: "Feature",
-                    geometry: {
-                        type: "Point",
-                        coordinates: [-122.4194, 37.7749],
-                    },
-                    properties: {
-                        name: "Test",
-                        population: 1000,
-                        boolean: true,
-                        nullValue: null,
-                        undefinedValue: undefined,
-                    },
-                },
-            ],
-        };
-        const osm = await fromGeoJSON(geojson);
-        const node = osm.nodes.getById(-1);
-        expect(node?.tags?.["name"]).toBe("Test");
-        // OSM tags are stored as strings, so numbers are converted
-        expect(node?.tags?.["population"]).toBe("1000");
-        expect(node?.tags?.["boolean"]).toBe("true");
-        expect(node?.tags?.["nullValue"]).toBeUndefined();
-        expect(node?.tags?.["undefinedValue"]).toBeUndefined();
-    });
-    it("should reuse nodes when LineStrings share coordinates", async () => {
-        const geojson = {
-            type: "FeatureCollection",
-            features: [
-                {
-                    type: "Feature",
-                    geometry: {
-                        type: "LineString",
-                        coordinates: [
-                            [-122.4194, 37.7749],
-                            [-122.4094, 37.7849],
-                        ],
-                    },
-                    properties: {
-                        highway: "primary",
-                    },
-                },
-                {
-                    type: "Feature",
-                    geometry: {
-                        type: "LineString",
-                        coordinates: [
-                            [-122.4094, 37.7849], // Shared coordinate
-                            [-122.3994, 37.7949],
-                        ],
-                    },
-                    properties: {
-                        highway: "secondary",
-                    },
-                },
-            ],
-        };
-        const osm = await fromGeoJSON(geojson);
-        // Should have 3 nodes (shared coordinate is reused)
-        expect(osm.nodes.size).toBe(3);
-        expect(osm.ways.size).toBe(2);
-        const way1 = osm.ways.getById(-1);
-        const way2 = osm.ways.getById(-2);
-        // Each way should have its own nodes
-        expect(way1?.refs).toHaveLength(2);
-        expect(way2?.refs).toHaveLength(2);
-        // Nodes at the same coordinate are reused
-        expect(way1?.refs[1]).toBe(way2?.refs[0]);
-    });
-    it("should error on LineStrings with less than 2 coordinates", () => {
-        const geojson = {
-            type: "FeatureCollection",
-            features: [
-                {
-                    type: "Feature",
-                    geometry: {
-                        type: "LineString",
-                        coordinates: [[-122.4194, 37.7749]], // Only one coordinate
-                    },
-                    properties: {},
-                },
-            ],
-        };
-        expect(() => fromGeoJSON(geojson)).toThrow("Invalid GeoJSON coordinates in LineString.");
-    });
-    it("should error on LineStrings with invalid coordinates that result in less than 2 valid nodes", () => {
-        const geojson = {
-            type: "FeatureCollection",
-            features: [
-                {
-                    type: "Feature",
-                    geometry: {
-                        type: "LineString",
-                        coordinates: [
-                            [-122.4194, 37.7749], // Valid coordinate
-                            [undefined, undefined],
-                        ],
-                    },
-                    properties: {
-                        highway: "primary",
-                    },
-                },
-                {
-                    type: "Feature",
-                    geometry: {
-                        type: "LineString",
-                        coordinates: [
-                            [-122.4194, 37.7749],
-                            [-122.4094, 37.7849],
-                        ],
-                    },
-                    properties: {
-                        highway: "secondary",
-                    },
-                },
-            ],
-        };
-        expect(() => fromGeoJSON(geojson)).toThrow();
-    });
-    it("should handle mixed Point and LineString features", async () => {
-        const geojson = {
-            type: "FeatureCollection",
-            features: [
-                {
-                    type: "Feature",
-                    geometry: {
-                        type: "Point",
-                        coordinates: [-122.4194, 37.7749],
-                    },
-                    properties: {
-                        name: "Start Point",
-                    },
-                },
-                {
-                    type: "Feature",
-                    geometry: {
-                        type: "LineString",
-                        coordinates: [
-                            [-122.4194, 37.7749], // Same as point
-                            [-122.4094, 37.7849],
-                        ],
-                    },
-                    properties: {
-                        highway: "primary",
-                    },
-                },
-                {
-                    type: "Feature",
-                    geometry: {
-                        type: "Point",
-                        coordinates: [-122.3994, 37.7949],
-                    },
-                    properties: {
-                        name: "End Point",
-                    },
-                },
-            ],
-        };
-        const osm = await fromGeoJSON(geojson);
-        // Should have 3 nodes (point node is reused by LineString)
-        expect(osm.nodes.size).toBe(3);
-        expect(osm.ways.size).toBe(1);
-        const way = osm.ways.getById(-1);
-        expect(way?.refs).toHaveLength(2);
-        // First node of way should be the same as the point node
-        const pointNode = osm.nodes.getById(-1);
-        expect(way?.refs[0]).toBe(-1);
-        expect(pointNode?.lon).toBe(-122.4194);
-        expect(pointNode?.lat).toBe(37.7749);
-    });
-    it("should build indexes after conversion", async () => {
-        const geojson = {
-            type: "FeatureCollection",
-            features: [
-                {
-                    type: "Feature",
-                    geometry: {
-                        type: "Point",
-                        coordinates: [-122.4194, 37.7749],
-                    },
-                    properties: {},
-                },
-            ],
-        };
-        const osm = await fromGeoJSON(geojson);
-        expect(osm.isReady()).toBe(true);
-        expect(osm.nodes.isReady()).toBe(true);
-        expect(osm.ways.isReady()).toBe(true);
-    });
-    it("should handle features without properties", async () => {
-        const geojson = {
-            type: "FeatureCollection",
-            features: [
-                {
-                    type: "Feature",
-                    geometry: {
-                        type: "Point",
-                        coordinates: [-122.4194, 37.7749],
-                    },
-                    properties: null,
-                },
-            ],
-        };
-        const osm = await fromGeoJSON(geojson);
-        const node = osm.nodes.getById(-1);
-        expect(node).toBeDefined();
-        expect(node?.tags).toBeUndefined();
-    });
-    it("should convert Polygon features to Ways with area tags", async () => {
-        const geojson = {
-            type: "FeatureCollection",
-            features: [
-                {
-                    type: "Feature",
-                    geometry: {
-                        type: "Polygon",
-                        coordinates: [
-                            [
-                                [-122.4194, 37.7749],
-                                [-122.4094, 37.7749],
-                                [-122.4094, 37.7849],
-                                [-122.4194, 37.7849],
-                                [-122.4194, 37.7749], // Closed ring
-                            ],
-                        ],
-                    },
-                    properties: {
-                        building: "yes",
-                        name: "Test Building",
-                    },
-                },
-            ],
-        };
-        const osm = await fromGeoJSON(geojson);
-        expect(osm.nodes.size).toBe(4); // 4 unique nodes (last is duplicate)
-        expect(osm.ways.size).toBe(1);
-        expect(osm.relations.size).toBe(0); // No relation for simple polygon
-        const way = osm.ways.getById(-1);
-        expect(way).toBeDefined();
-        expect(way?.tags?.["building"]).toBe("yes");
-        expect(way?.tags?.["name"]).toBe("Test Building");
-        expect(way?.tags?.["area"]).toBe("yes");
-        expect(way?.refs).toHaveLength(5); // 4 nodes + closing node
-        expect(way?.refs[0]).toBe(way?.refs[4]); // Ring is closed
-    });
-    it("should convert Polygon with holes to relation with multiple Ways", async () => {
-        const geojson = {
-            type: "FeatureCollection",
-            features: [
-                {
-                    type: "Feature",
-                    geometry: {
-                        type: "Polygon",
-                        coordinates: [
-                            // Outer ring
-                            [
-                                [-122.4194, 37.7749],
-                                [-122.4094, 37.7749],
-                                [-122.4094, 37.7849],
-                                [-122.4194, 37.7849],
-                                [-122.4194, 37.7749],
-                            ],
-                            // Hole
-                            [
-                                [-122.4164, 37.7779],
-                                [-122.4144, 37.7779],
-                                [-122.4144, 37.7799],
-                                [-122.4164, 37.7799],
-                                [-122.4164, 37.7779],
-                            ],
-                        ],
-                    },
-                    properties: {
-                        building: "yes",
-                    },
-                },
-            ],
-        };
-        const osm = await fromGeoJSON(geojson);
-        // Should have outer ring way + hole way + relation
-        expect(osm.ways.size).toBe(2);
-        expect(osm.relations.size).toBe(1);
-        const outerWay = osm.ways.getById(-1);
-        expect(outerWay).toBeDefined();
-        expect(outerWay?.tags?.["area"]).toBe("yes");
-        expect(outerWay?.tags?.["building"]).toBeUndefined(); // Tags go on relation
-        const holeWay = osm.ways.getById(-2);
-        expect(holeWay).toBeDefined();
-        expect(holeWay?.tags?.["area"]).toBe("yes");
-        expect(holeWay?.tags?.["building"]).toBeUndefined(); // Tags go on relation
-        const relation = osm.relations.getById(-1);
-        expect(relation).toBeDefined();
-        expect(relation?.tags?.["type"]).toBe("multipolygon");
-        expect(relation?.tags?.["building"]).toBe("yes");
-        expect(relation?.members).toHaveLength(2);
-        expect(relation?.members[0]?.type).toBe("way");
-        expect(relation?.members[0]?.ref).toBe(-1);
-        expect(relation?.members[0]?.role).toBe("outer");
-        expect(relation?.members[1]?.type).toBe("way");
-        expect(relation?.members[1]?.ref).toBe(-2);
-        expect(relation?.members[1]?.role).toBe("inner");
-    });
-    it("should convert MultiPolygon features to relation with multiple Ways", async () => {
-        const geojson = {
-            type: "FeatureCollection",
-            features: [
-                {
-                    type: "Feature",
-                    geometry: {
-                        type: "MultiPolygon",
-                        coordinates: [
-                            // First polygon
-                            [
-                                [
-                                    [-122.4194, 37.7749],
-                                    [-122.4094, 37.7749],
-                                    [-122.4094, 37.7849],
-                                    [-122.4194, 37.7849],
-                                    [-122.4194, 37.7749],
-                                ],
-                            ],
-                            // Second polygon
-                            [
-                                [
-                                    [-122.3994, 37.7649],
-                                    [-122.3894, 37.7649],
-                                    [-122.3894, 37.7749],
-                                    [-122.3994, 37.7749],
-                                    [-122.3994, 37.7649],
-                                ],
-                            ],
-                        ],
-                    },
-                    properties: {
-                        landuse: "residential",
-                    },
-                },
-            ],
-        };
-        const osm = await fromGeoJSON(geojson);
-        // Should have 2 ways + 1 relation
-        expect(osm.ways.size).toBe(2);
-        expect(osm.relations.size).toBe(1);
-        const way1 = osm.ways.getById(-1);
-        expect(way1).toBeDefined();
-        expect(way1?.tags?.["landuse"]).toBeUndefined(); // Tags go on relation
-        expect(way1?.tags?.["area"]).toBe("yes");
-        const way2 = osm.ways.getById(-2);
-        expect(way2).toBeDefined();
-        expect(way2?.tags?.["landuse"]).toBeUndefined(); // Tags go on relation
-        expect(way2?.tags?.["area"]).toBe("yes");
-        const relation = osm.relations.getById(-1);
-        expect(relation).toBeDefined();
-        expect(relation?.tags?.["type"]).toBe("multipolygon");
-        expect(relation?.tags?.["landuse"]).toBe("residential");
-        expect(relation?.members).toHaveLength(2);
-        expect(relation?.members[0]?.type).toBe("way");
-        expect(relation?.members[0]?.ref).toBe(-1);
-        expect(relation?.members[0]?.role).toBe("outer");
-        expect(relation?.members[1]?.type).toBe("way");
-        expect(relation?.members[1]?.ref).toBe(-2);
-        expect(relation?.members[1]?.role).toBe("outer");
-    });
-    it("should convert MultiPolygon with holes to relation with multiple Ways", async () => {
-        const geojson = {
-            type: "FeatureCollection",
-            features: [
-                {
-                    type: "Feature",
-                    geometry: {
-                        type: "MultiPolygon",
-                        coordinates: [
-                            // First polygon with hole
-                            [
-                                // Outer ring
-                                [
-                                    [-122.4194, 37.7749],
-                                    [-122.4094, 37.7749],
-                                    [-122.4094, 37.7849],
-                                    [-122.4194, 37.7849],
-                                    [-122.4194, 37.7749],
-                                ],
-                                // Hole
-                                [
-                                    [-122.4164, 37.7779],
-                                    [-122.4144, 37.7779],
-                                    [-122.4144, 37.7799],
-                                    [-122.4164, 37.7799],
-                                    [-122.4164, 37.7779],
-                                ],
-                            ],
-                            // Second polygon (no holes)
-                            [
-                                [
-                                    [-122.3994, 37.7649],
-                                    [-122.3894, 37.7649],
-                                    [-122.3894, 37.7749],
-                                    [-122.3994, 37.7749],
-                                    [-122.3994, 37.7649],
-                                ],
-                            ],
-                        ],
-                    },
-                    properties: {
-                        landuse: "residential",
-                    },
-                },
-            ],
-        };
-        const osm = await fromGeoJSON(geojson);
-        // Should have 3 ways + 1 relation
-        expect(osm.ways.size).toBe(3);
-        expect(osm.relations.size).toBe(1);
-        const outerWay = osm.ways.getById(-1);
-        expect(outerWay).toBeDefined();
-        expect(outerWay?.tags?.["area"]).toBe("yes");
-        const holeWay = osm.ways.getById(-2);
-        expect(holeWay).toBeDefined();
-        expect(holeWay?.tags?.["area"]).toBe("yes");
-        const secondPolyWay = osm.ways.getById(-3);
-        expect(secondPolyWay).toBeDefined();
-        expect(secondPolyWay?.tags?.["area"]).toBe("yes");
-        const relation = osm.relations.getById(-1);
-        expect(relation).toBeDefined();
-        expect(relation?.tags?.["type"]).toBe("multipolygon");
-        expect(relation?.tags?.["landuse"]).toBe("residential");
-        expect(relation?.members).toHaveLength(3);
-        expect(relation?.members[0]?.type).toBe("way");
-        expect(relation?.members[0]?.ref).toBe(-1);
-        expect(relation?.members[0]?.role).toBe("outer");
-        expect(relation?.members[1]?.type).toBe("way");
-        expect(relation?.members[1]?.ref).toBe(-2);
-        expect(relation?.members[1]?.role).toBe("inner");
-        expect(relation?.members[2]?.type).toBe("way");
-        expect(relation?.members[2]?.ref).toBe(-3);
-        expect(relation?.members[2]?.role).toBe("outer");
-    });
-    it("should error on Polygon with unclosed ring", () => {
-        const geojson = {
-            type: "FeatureCollection",
-            features: [
-                {
-                    type: "Feature",
-                    geometry: {
-                        type: "Polygon",
-                        coordinates: [
-                            [
-                                [-122.4194, 37.7749],
-                                [-122.4094, 37.7749],
-                                [-122.4094, 37.7849],
-                                [-122.4194, 37.7849],
-                                // Not closed - should throw error
-                            ],
-                        ],
-                    },
-                    properties: {
-                        building: "yes",
-                    },
-                },
-            ],
-        };
-        expect(() => fromGeoJSON(geojson)).toThrow("Outer ring of Polygon is not closed.");
-    });
-    it("should skip invalid Polygons with less than 3 coordinates", async () => {
-        const geojson = {
-            type: "FeatureCollection",
-            features: [
-                {
-                    type: "Feature",
-                    geometry: {
-                        type: "Polygon",
-                        coordinates: [
-                            [
-                                [-122.4194, 37.7749],
-                                [-122.4094, 37.7749],
-                                // Only 2 coordinates - invalid
-                            ],
-                        ],
-                    },
-                    properties: {},
-                },
-                {
-                    type: "Feature",
-                    geometry: {
-                        type: "Polygon",
-                        coordinates: [
-                            [
-                                [-122.4194, 37.7749],
-                                [-122.4094, 37.7749],
-                                [-122.4094, 37.7849],
-                                [-122.4194, 37.7849],
-                                [-122.4194, 37.7749],
-                            ],
-                        ],
-                    },
-                    properties: {
-                        building: "yes",
-                    },
-                },
-            ],
-        };
-        const osm = await fromGeoJSON(geojson);
-        // Should only have one way (the valid one)
-        expect(osm.ways.size).toBe(1);
-        expect(osm.ways.getById(-1)?.tags?.["building"]).toBe("yes");
-    });
-    it("should normalize winding order using rewind", async () => {
-        // Create a polygon with clockwise winding (should be normalized to counterclockwise)
-        const geojson = {
-            type: "FeatureCollection",
-            features: [
-                {
-                    type: "Feature",
-                    geometry: {
-                        type: "Polygon",
-                        coordinates: [
-                            // Clockwise ring (will be normalized by rewind)
-                            [
-                                [-122.4194, 37.7749],
-                                [-122.4194, 37.7849],
-                                [-122.4094, 37.7849],
-                                [-122.4094, 37.7749],
-                                [-122.4194, 37.7749],
-                            ],
-                        ],
-                    },
-                    properties: {
-                        building: "yes",
-                    },
-                },
-            ],
-        };
-        const osm = await fromGeoJSON(geojson);
-        // Should still create the way successfully (rewind normalizes winding)
-        expect(osm.ways.size).toBe(1);
-        const way = osm.ways.getById(-1);
-        expect(way).toBeDefined();
-        expect(way?.tags?.["building"]).toBe("yes");
-        expect(way?.tags?.["area"]).toBe("yes");
-    });
-    it("should error on unclosed hole ring", () => {
-        const geojson = {
-            type: "FeatureCollection",
-            features: [
-                {
-                    type: "Feature",
-                    geometry: {
-                        type: "Polygon",
-                        coordinates: [
-                            // Outer ring (closed)
-                            [
-                                [-122.4194, 37.7749],
-                                [-122.4094, 37.7749],
-                                [-122.4094, 37.7849],
-                                [-122.4194, 37.7849],
-                                [-122.4194, 37.7749],
-                            ],
-                            // Hole ring (not closed - should throw error)
-                            [
-                                [-122.4164, 37.7779],
-                                [-122.4144, 37.7779],
-                                [-122.4144, 37.7799],
-                                [-122.4164, 37.7799],
-                                // Missing closing coordinate
-                            ],
-                        ],
-                    },
-                    properties: {
-                        building: "yes",
-                    },
-                },
-            ],
-        };
-        expect(() => fromGeoJSON(geojson)).toThrow("Hole ring of Polygon is not closed.");
-    });
-    it("should error on unclosed MultiPolygon ring", () => {
-        const geojson = {
-            type: "FeatureCollection",
-            features: [
-                {
-                    type: "Feature",
-                    geometry: {
-                        type: "MultiPolygon",
-                        coordinates: [
-                            [
-                                [
-                                    [-122.4194, 37.7749],
-                                    [-122.4094, 37.7749],
-                                    [-122.4094, 37.7849],
-                                    [-122.4194, 37.7849],
-                                    // Not closed - should throw error
-                                ],
-                            ],
-                        ],
-                    },
-                    properties: {
-                        landuse: "residential",
-                    },
-                },
-            ],
-        };
-        expect(() => fromGeoJSON(geojson)).toThrow("Outer ring of Polygon is not closed.");
-    });
-});
-//# sourceMappingURL=osm-from-geojson.test.js.map