@osmix/core 0.1.8 → 0.2.0

package/test/ids.bench.ts

@@ -0,0 +1,29 @@
+import { bench, describe } from "vitest";
+
+import { Ids } from "../src/ids";
+import { Osm } from "../src/osm";
+
+const values = Array.from({ length: 20_000 }, (_, index) => (index * 7919) % 100_000);
+
+function buildIds() {
+  const ids = new Ids();
+  for (const value of values) ids.add(value);
+  ids.buildIndex();
+  return ids;
+}
+
+const osm = new Osm();
+for (const value of values) osm.nodes.addNode({ id: value, lon: value, lat: value });
+osm.buildIndexes();
+
+describe("sorted ID iteration", () => {
+  bench("build shuffled sorted index", () => {
+    buildIds();
+  });
+
+  bench("iterate all sorted entities", () => {
+    let checksum = 0;
+    for (const node of osm.nodes.sorted()) checksum += node.id + node.lon;
+    if (checksum === 0) throw Error("Unexpected empty benchmark");
+  });
+});

package/test/ids.test.ts

@@ -0,0 +1,84 @@
+import { describe, expect, it, vi } from "vitest";
+
+import { Ids } from "../src/ids";
+import { Osm } from "../src/osm";
+
+function buildIds(values: number[]) {
+  const ids = new Ids();
+  for (const value of values) ids.add(value);
+  ids.buildIndex();
+  return ids;
+}
+
+describe("Ids sorted entries", () => {
+  it.each([
+    { name: "empty", values: [], entries: [] },
+    {
+      name: "ascending",
+      values: [1, 2, 3],
+      entries: [
+        [1, 0],
+        [2, 1],
+        [3, 2],
+      ],
+    },
+    {
+      name: "reverse",
+      values: [3, 2, 1],
+      entries: [
+        [1, 2],
+        [2, 1],
+        [3, 0],
+      ],
+    },
+    {
+      name: "sparse",
+      values: [100, 2, 50],
+      entries: [
+        [2, 1],
+        [50, 2],
+        [100, 0],
+      ],
+    },
+    {
+      name: "duplicates",
+      values: [5, 2, 5, 2],
+      entries: [
+        [2, 1],
+        [2, 3],
+        [5, 0],
+        [5, 2],
+      ],
+    },
+  ])("preserves sorted ID and original-position order for $name IDs", ({ values, entries }) => {
+    expect(Array.from(buildIds(values).sortedEntries())).toEqual(entries);
+  });
+
+  it("preserves sorted entries through transfer reconstruction", () => {
+    const source = buildIds([9, 3, 9, 1]);
+    const reconstructed = new Ids(source.transferables());
+
+    expect(Array.from(reconstructed.sortedEntries())).toEqual([
+      [1, 3],
+      [3, 1],
+      [9, 0],
+      [9, 2],
+    ]);
+  });
+
+  it("streams sorted entities without looking up each ID again", () => {
+    const osm = new Osm();
+    osm.nodes.addNode({ id: 2, lon: 20, lat: 20 });
+    osm.nodes.addNode({ id: 1, lon: 10, lat: 10 });
+    osm.nodes.addNode({ id: 1, lon: 11, lat: 11 });
+    osm.buildIndexes();
+    const getIndexFromId = vi.spyOn(osm.nodes.ids, "getIndexFromId");
+
+    expect([...osm.nodes.sorted()].map((node) => [node.id, node.lon])).toEqual([
+      [1, 10],
+      [1, 11],
+      [2, 20],
+    ]);
+    expect(getIndexFromId).not.toHaveBeenCalled();
+  });
+});

package/test/memory.test.ts

@@ -1,38 +1,37 @@
-import { describe, expect, it } from "bun:test"
-import { Nodes, Relations, Ways } from "../src"
+import { describe, expect, it } from "vitest";
+
+import { Nodes, Relations, Ways } from "../src";
 
 export function getOsmCoreMemoryRequirements(
-	nodeCount: number,
-	wayCount: number,
-	relationCount: number,
+  nodeCount: number,
+  wayCount: number,
+  relationCount: number,
 ) {
-	const nodesBytes = Nodes.getBytesRequired(nodeCount)
-	const waysBytes = Ways.getBytesRequired(wayCount)
-	const relationsBytes = Relations.getBytesRequired(relationCount)
+  const nodesBytes = Nodes.getBytesRequired(nodeCount);
+  const waysBytes = Ways.getBytesRequired(wayCount);
+  const relationsBytes = Relations.getBytesRequired(relationCount);
 
-	return {
-		nodes: nodesBytes,
-		ways: waysBytes,
-		relations: relationsBytes,
-		total: nodesBytes + waysBytes + relationsBytes,
-	}
+  return {
+    nodes: nodesBytes,
+    ways: waysBytes,
+    relations: relationsBytes,
+    total: nodesBytes + waysBytes + relationsBytes,
+  };
 }
 
 describe("Memory Requirements", () => {
-	it("computes memory requirements for small datasets", () => {
-		const breakdown = getOsmCoreMemoryRequirements(10, 2, 1)
-		expect(breakdown.nodes).toBeGreaterThan(0)
-		expect(breakdown.ways).toBeGreaterThan(0)
-		expect(breakdown.relations).toBeGreaterThan(0)
-		expect(breakdown.total).toBe(
-			breakdown.nodes + breakdown.ways + breakdown.relations,
-		)
-	})
+  it("computes memory requirements for small datasets", () => {
+    const breakdown = getOsmCoreMemoryRequirements(10, 2, 1);
+    expect(breakdown.nodes).toBeGreaterThan(0);
+    expect(breakdown.ways).toBeGreaterThan(0);
+    expect(breakdown.relations).toBeGreaterThan(0);
+    expect(breakdown.total).toBe(breakdown.nodes + breakdown.ways + breakdown.relations);
+  });
 
-	it("computes memory requirements for large datasets", () => {
-		const breakdown = getOsmCoreMemoryRequirements(70000, 20000, 0)
-		expect(breakdown.nodes).toBeGreaterThan(0)
-		expect(breakdown.ways).toBeGreaterThan(0)
-		expect(breakdown.total).toBe(breakdown.nodes + breakdown.ways)
-	})
-})
+  it("computes memory requirements for large datasets", () => {
+    const breakdown = getOsmCoreMemoryRequirements(70000, 20000, 0);
+    expect(breakdown.nodes).toBeGreaterThan(0);
+    expect(breakdown.ways).toBeGreaterThan(0);
+    expect(breakdown.total).toBe(breakdown.nodes + breakdown.ways);
+  });
+});

package/test/relations.bench.ts

@@ -0,0 +1,27 @@
+import { bench, describe } from "vitest";
+
+import { Osm } from "../src/osm";
+
+function createManyMemberRelations() {
+  const osm = new Osm({ id: "relations-benchmark" });
+  for (let relationId = 0; relationId < 100; relationId++) {
+    osm.relations.addRelation({
+      id: relationId,
+      members: Array.from({ length: 100 }, (_, index) => ({
+        type: "way" as const,
+        ref: relationId * 100 + index,
+        role: "",
+      })),
+    });
+  }
+  return osm;
+}
+
+const osm = createManyMemberRelations();
+osm.relations.getWayMemberIds();
+
+describe("relation way membership cache", () => {
+  bench("1000 repeated cached lookups", () => {
+    for (let i = 0; i < 1000; i++) osm.relations.getWayMemberIds();
+  });
+});

package/test/relations.test.ts

@@ -0,0 +1,101 @@
+import { describe, expect, it, vi } from "vitest";
+
+import { Osm, type Osm as OsmType } from "../src/osm";
+
+function createOsmWithRelations(): OsmType {
+  const osm = new Osm({ id: "relations" });
+  osm.nodes.addNode({ id: 1, lon: -120, lat: 46 });
+  osm.nodes.addNode({ id: 2, lon: -120.01, lat: 46.01 });
+  osm.nodes.addNode({ id: 3, lon: -120.02, lat: 46.02 });
+  osm.ways.addWay({ id: 10, refs: [1, 2], tags: { highway: "primary" } });
+  osm.ways.addWay({ id: 20, refs: [2, 3], tags: { highway: "secondary" } });
+  osm.relations.addRelation({
+    id: 100,
+    members: [
+      { type: "way", ref: 10, role: "outer" },
+      { type: "node", ref: 1, role: "label" },
+      { type: "way", ref: 10, role: "outer" },
+    ],
+  });
+  osm.relations.addRelation({
+    id: 200,
+    members: [
+      { type: "way", ref: 20, role: "outer" },
+      { type: "relation", ref: 100, role: "child" },
+    ],
+  });
+  osm.buildIndexes();
+  return osm;
+}
+
+describe("relation way membership cache", () => {
+  it("returns an empty cached set for empty relations", () => {
+    const osm = new Osm();
+
+    const first = osm.relations.getWayMemberIds();
+    const second = osm.relations.getWayMemberIds();
+
+    expect(first).toBe(second);
+    expect(first).toEqual(new Set());
+  });
+
+  it("collects unique direct and nested way members", () => {
+    const wayIds = createOsmWithRelations().relations.getWayMemberIds();
+
+    expect(wayIds).toEqual(new Set([10, 20]));
+  });
+
+  it("does not traverse relations again while the cache is warm", () => {
+    const osm = createOsmWithRelations();
+    const getByIndex = vi.spyOn(osm.relations, "getByIndex");
+
+    const first = osm.relations.getWayMemberIds();
+    const callsAfterFirstLookup = getByIndex.mock.calls.length;
+    const second = osm.relations.getWayMemberIds();
+
+    expect(second).toBe(first);
+    expect(callsAfterFirstLookup).toBeGreaterThan(0);
+    expect(getByIndex).toHaveBeenCalledTimes(callsAfterFirstLookup);
+  });
+
+  it("invalidates the cache when a relation is added", () => {
+    const osm = new Osm();
+    osm.relations.addRelation({ id: 1, members: [{ type: "way", ref: 10, role: "" }] });
+    const first = osm.relations.getWayMemberIds();
+
+    osm.relations.addRelation({ id: 2, members: [{ type: "way", ref: 20, role: "" }] });
+    const second = osm.relations.getWayMemberIds();
+
+    expect(second).not.toBe(first);
+    expect(second).toEqual(new Set([10, 20]));
+  });
+
+  it("invalidates the cache when relations are added in bulk", () => {
+    const osm = new Osm();
+    osm.stringTable.add("");
+    osm.relations.addRelation({ id: 1, members: [{ type: "way", ref: 10, role: "" }] });
+    osm.relations.getWayMemberIds();
+
+    osm.relations.addRelations(
+      [{ id: 2, keys: [], vals: [], memids: [20], roles_sid: [0], types: [1] }],
+      new Uint32Array([0]),
+    );
+
+    expect(osm.relations.getWayMemberIds()).toEqual(new Set([10, 20]));
+  });
+
+  it("starts with an empty cache after transfer and reconstruction", () => {
+    const source = createOsmWithRelations();
+    const reconstructed = new Osm(source);
+    const getByIndex = vi.spyOn(reconstructed.relations, "getByIndex");
+
+    const first = reconstructed.relations.getWayMemberIds();
+    const callsAfterFirstLookup = getByIndex.mock.calls.length;
+    const second = reconstructed.relations.getWayMemberIds();
+
+    expect(first).toEqual(new Set([10, 20]));
+    expect(second).toBe(first);
+    expect(callsAfterFirstLookup).toBeGreaterThan(0);
+    expect(getByIndex).toHaveBeenCalledTimes(callsAfterFirstLookup);
+  });
+});

package/test/tags-search.test.ts

@@ -1,60 +1,80 @@
-import { describe, expect, it } from "bun:test"
-import type { OsmNode, OsmWay } from "@osmix/shared/types"
-import { Nodes } from "../src/nodes"
-import StringTable from "../src/stringtable"
-import { Ways } from "../src/ways"
+import type { OsmNode, OsmWay } from "@osmix/types";
+import { describe, expect, it } from "vitest";
+
+import { Nodes } from "../src/nodes";
+import StringTable from "../src/stringtable";
+import { Ways } from "../src/ways";
 
 describe("Tags.search on Nodes", () => {
-	it("finds by key and key+value", () => {
-		const st = new StringTable()
-		const nodes = new Nodes(st)
-		const node1: OsmNode = { id: 1, lon: -1, lat: 1, tags: { curb: "yes" } }
-		const node2: OsmNode = { id: 2, lon: -2, lat: 2, tags: { curb: "no" } }
-		const node3: OsmNode = { id: 3, lon: -3, lat: 3 }
-		nodes.addNode(node1)
-		nodes.addNode(node2)
-		nodes.addNode(node3)
-		nodes.buildIndex()
-
-		const allCurb = nodes.search("curb")
-		expect(allCurb).toEqual([node1, node2])
-		const curbYes = nodes.search("curb", "yes")
-		expect(curbYes).toEqual([node1])
-		const curbNo = nodes.search("curb", "no")
-		expect(curbNo).toEqual([node2])
-		const none = nodes.search("highway")
-		expect(none).toEqual([])
-	})
-})
+  it("returns null for an unknown ID in an empty collection", () => {
+    const nodes = new Nodes(new StringTable());
+    nodes.buildIndex();
+
+    expect(nodes.getNodeLonLat({ id: 999 })).toBeNull();
+  });
+
+  it("finds by key and key+value", () => {
+    const st = new StringTable();
+    const nodes = new Nodes(st);
+    const node1: OsmNode = { id: 1, lon: -1, lat: 1, tags: { curb: "yes" } };
+    const node2: OsmNode = { id: 2, lon: -2, lat: 2, tags: { curb: "no" } };
+    const node3: OsmNode = { id: 3, lon: -3, lat: 3 };
+    nodes.addNode(node1);
+    nodes.addNode(node2);
+    nodes.addNode(node3);
+    nodes.buildIndex();
+
+    expect(nodes.getNodeLonLat({ id: 999 })).toBeNull();
+
+    const allCurb = nodes.search("curb");
+    expect(allCurb).toEqual([node1, node2]);
+    const curbYes = nodes.search("curb", "yes");
+    expect(curbYes).toEqual([node1]);
+    const curbNo = nodes.search("curb", "no");
+    expect(curbNo).toEqual([node2]);
+    const none = nodes.search("highway");
+    expect(none).toEqual([]);
+  });
+});
 
 describe("Tags.search on Ways", () => {
-	it("finds by key and key+value", () => {
-		const st = new StringTable()
-		const nodes = new Nodes(st)
-		const ways = new Ways(st, nodes)
-		const way1: OsmWay = {
-			id: 10,
-			refs: [1, 2],
-			tags: { highway: "residential" },
-		}
-		const way2: OsmWay = { id: 11, refs: [2, 3], tags: { area: "yes" } }
-		const way3: OsmWay = {
-			id: 12,
-			refs: [3, 4],
-			tags: { highway: "primary", area: "no" },
-		}
-		ways.addWay(way1)
-		ways.addWay(way2)
-		ways.addWay(way3)
-		ways.buildIndex()
-
-		const allHighway = ways.search("highway")
-		expect(allHighway).toEqual([way1, way3])
-		const areaYes = ways.search("area", "yes")
-		expect(areaYes).toEqual([way2])
-		const areaAll = ways.search("area")
-		expect(areaAll).toEqual([way2, way3])
-		const areaNo = ways.search("area", "no")
-		expect(areaNo).toEqual([way3])
-	})
-})
+  it("rejects block-local tag indexes missing from the string table map", () => {
+    const st = new StringTable();
+    const nodes = new Nodes(st);
+    const ways = new Ways(st, nodes);
+
+    expect(() =>
+      ways.addWays([{ id: 1, keys: [9], vals: [0], refs: [1] }], new Uint32Array()),
+    ).toThrow("Tag key not found");
+  });
+
+  it("finds by key and key+value", () => {
+    const st = new StringTable();
+    const nodes = new Nodes(st);
+    const ways = new Ways(st, nodes);
+    const way1: OsmWay = {
+      id: 10,
+      refs: [1, 2],
+      tags: { highway: "residential" },
+    };
+    const way2: OsmWay = { id: 11, refs: [2, 3], tags: { area: "yes" } };
+    const way3: OsmWay = {
+      id: 12,
+      refs: [3, 4],
+      tags: { highway: "primary", area: "no" },
+    };
+    ways.addWay(way1);
+    ways.addWay(way2);
+    ways.addWay(way3);
+    ways.buildIndex();
+
+    const allHighway = ways.search("highway");
+    expect(allHighway).toEqual([way1, way3]);
+    const areaYes = ways.search("area", "yes");
+    expect(areaYes).toEqual([way2]);
+    const areaAll = ways.search("area");
+    expect(areaAll).toEqual([way2, way3]);
+    const areaNo = ways.search("area", "no");
+    expect(areaNo).toEqual([way3]);
+  });
+});