@osmix/shared 0.0.1 → 0.0.6

package/test/utils.test.ts

@@ -0,0 +1,103 @@
+import { describe, expect, it } from "bun:test"
+import type {
+	OsmNode,
+	OsmRelation,
+	OsmRelationMember,
+	OsmWay,
+} from "../src/types"
+import {
+	entityPropertiesEqual,
+	getEntityType,
+	isMultipolygonRelation,
+	isNode,
+	isNodeEqual,
+	isRelation,
+	isRelationEqual,
+	isWay,
+	isWayEqual,
+} from "../src/utils"
+
+describe("utils", () => {
+	const node: OsmNode = {
+		id: 1,
+		lat: 10,
+		lon: 20,
+		tags: { name: "node" },
+	}
+	const way: OsmWay = {
+		id: 2,
+		refs: [1, 2, 3],
+		tags: { highway: "residential" },
+	}
+	const members: OsmRelationMember[] = [
+		{
+			type: "node",
+			ref: 1,
+		},
+	]
+	const relation: OsmRelation = {
+		id: 3,
+		members,
+		tags: { type: "multipolygon" },
+	}
+
+	it("narrows entity types", () => {
+		expect(isNode(node)).toBe(true)
+		expect(isWay(way)).toBe(true)
+		expect(isRelation(relation)).toBe(true)
+	})
+
+	it("compares entity equality", () => {
+		expect(isNodeEqual(node, { ...node })).toBe(true)
+		expect(isWayEqual(way, { ...way })).toBe(true)
+		expect(isRelationEqual(relation, { ...relation })).toBe(true)
+	})
+
+	it("detects property differences", () => {
+		expect(
+			entityPropertiesEqual(node, { ...node, tags: { name: "changed" } }),
+		).toBe(false)
+		expect(entityPropertiesEqual(way, { ...way, refs: [1, 2, 4] })).toBe(false)
+		expect(
+			entityPropertiesEqual(relation, {
+				...relation,
+				members: [{ type: "node", ref: 2 }],
+			}),
+		).toBe(false)
+	})
+
+	it("provides entity type", () => {
+		expect(getEntityType(node)).toBe("node")
+		expect(getEntityType(way)).toBe("way")
+		expect(getEntityType(relation)).toBe("relation")
+	})
+
+	describe("isMultipolygonRelation", () => {
+		it("identifies multipolygon relations", () => {
+			const relation: OsmRelation = {
+				id: 1,
+				tags: { type: "multipolygon" },
+				members: [],
+			}
+			expect(isMultipolygonRelation(relation)).toBe(true)
+		})
+
+		it("rejects non-multipolygon relations", () => {
+			const relation: OsmRelation = {
+				id: 1,
+				tags: { type: "route" },
+				members: [],
+			}
+			expect(isMultipolygonRelation(relation)).toBe(false)
+		})
+
+		it("rejects relations without type tag", () => {
+			const relation: OsmRelation = {
+				id: 1,
+				tags: { name: "test" },
+				members: [],
+			}
+			expect(isMultipolygonRelation(relation)).toBe(false)
+		})
+	})
+})

package/test/way-is-area.test.ts

@@ -0,0 +1,42 @@
+import { describe, expect, it } from "bun:test"
+import { wayIsArea } from "../src/way-is-area"
+
+describe("wayIsArea", () => {
+	it("returns false for open ways", () => {
+		const refs = [1, 2, 3]
+		expect(wayIsArea({ id: 0, refs, tags: { building: "yes" } })).toBe(false)
+	})
+
+	it("returns true for closed way without tags", () => {
+		const refs = [1, 2, 3, 1]
+		expect(wayIsArea({ id: 0, refs })).toBe(true)
+	})
+
+	it("honors explicit area override", () => {
+		const refs = [1, 2, 3, 1]
+		expect(
+			wayIsArea({ id: 0, refs, tags: { area: "no", building: "yes" } }),
+		).toBe(false)
+		expect(wayIsArea({ id: 0, refs, tags: { area: "yes" } })).toBe(true)
+	})
+
+	it("treats implied tags as areas", () => {
+		const refs = [1, 2, 3, 1]
+		expect(wayIsArea({ id: 0, refs, tags: { building: "yes" } })).toBe(true)
+	})
+
+	it("considers included values", () => {
+		const refs = [1, 2, 3, 1]
+		expect(wayIsArea({ id: 0, refs, tags: { highway: "rest_area" } })).toBe(
+			true,
+		)
+		expect(wayIsArea({ id: 0, refs, tags: { highway: "primary" } })).toBe(false)
+	})
+
+	it("rejects excluded values", () => {
+		const refs = [1, 2, 3, 1]
+		expect(wayIsArea({ id: 0, refs, tags: { natural: "coastline" } })).toBe(
+			false,
+		)
+	})
+})

package/tsconfig/base.json

@@ -17,9 +17,11 @@
 		"isolatedModules": true,
 		"erasableSyntaxOnly": true,
 		"skipLibCheck": true,
+		"forceConsistentCasingInFileNames": true,
 
 		"strict": true,
 		"noFallthroughCasesInSwitch": true,
+		"noImplicitOverride": true,
 		"noUncheckedIndexedAccess": true,
 		"noUnusedLocals": true,
 		"noUnusedParameters": true,

package/tsconfig/test.json

@@ -2,6 +2,7 @@
 	"$schema": "https://json.schemastore.org/tsconfig",
 	"display": "@osmix/tsconfig/test",
 	"extends": "./base.json",
+	"exclude": ["node_modules", "dist"],
 	"compilerOptions": {
 		"noEmit": true,
 

package/src/spherical-mercator.test.ts

@@ -1,42 +0,0 @@
-import { describe, expect, it } from "vitest"
-import SphericalMercatorTile from "./spherical-mercator"
-import type { Tile } from "./types"
-
-function lonLatForPixel(
-	merc: SphericalMercatorTile,
-	tileIndex: Tile,
-	tileSize: number,
-	px: number,
-	py: number,
-): [number, number] {
-	const [x, y, z] = tileIndex
-	return merc.ll([x * tileSize + px, y * tileSize + py], z) as [number, number]
-}
-
-describe("SphericalMercatorTile", () => {
-	it("projects lon/lat to tile-local pixels", () => {
-		const tile: Tile = [300, 300, 10]
-		const [tx, ty, tz] = tile
-		const tileSize = 256
-		const merc = new SphericalMercatorTile({ size: tileSize, tile })
-
-		const insideLonLat = lonLatForPixel(merc, tile, tileSize, 32, 16)
-		expect(merc.llToTilePx(insideLonLat)).toEqual([32, 16])
-
-		const outsideTopLeft = merc.ll(
-			[tx * tileSize - 10, ty * tileSize - 10],
-			tz,
-		) as [number, number]
-		expect(outsideTopLeft).toEqual([-74.54498291015625, 59.54128017205441])
-		expect(merc.llToTilePx(outsideTopLeft)).toEqual([-10, -10])
-
-		const outsideBottomRight = merc.ll(
-			[(tx + 1) * tileSize + 10, (ty + 1) * tileSize + 10],
-			tz,
-		) as [number, number]
-		expect(merc.llToTilePx(outsideBottomRight, tile)).toEqual([
-			tileSize + 10,
-			tileSize + 10,
-		])
-	})
-})

package/src/spherical-mercator.ts

@@ -1,42 +0,0 @@
-import { SphericalMercator } from "@mapbox/sphericalmercator"
-import type { GeoBbox2D, LonLat, Tile, XY } from "./types"
-
-/**
- * Extends the SphericalMercator class to provide tile-local pixel coordinate calculations and clamping.
- */
-export default class SphericalMercatorTile extends SphericalMercator {
-	tileSize: number
-	tile?: Tile
-	constructor(
-		options: ConstructorParameters<typeof SphericalMercator>[0] & {
-			tile?: Tile
-		},
-	) {
-		super(options)
-		this.tile = options?.tile
-		this.tileSize = options?.size ?? 256
-	}
-
-	llToTilePx(ll: LonLat, tile?: Tile): XY {
-		if (tile == null && this.tile == null)
-			throw Error("Tile must be set on construction or passed as an argument.")
-		const [tx, ty, tz] = (tile ?? this.tile)!
-		const merc = this.px(ll, tz)
-		const x = merc[0] - tx * this.tileSize
-		const y = merc[1] - ty * this.tileSize
-		return [x, y]
-	}
-
-	clampAndRoundPx(px: XY, bbox?: GeoBbox2D): XY {
-		const [minX, minY, maxX, maxY] = bbox ?? [
-			0,
-			0,
-			this.tileSize,
-			this.tileSize,
-		]
-		return [
-			Math.max(minX, Math.min(maxX, Math.round(px[0]))),
-			Math.max(minY, Math.min(maxY, Math.round(px[1]))),
-		]
-	}
-}