@osmix/core 0.1.10 → 0.3.0

package/src/renumber.ts

@@ -0,0 +1,80 @@
+import { Osm } from "./osm.ts";
+
+/** Old ID → new ID for each renumbered entity, by type. JSON- and structured-clone-safe. */
+export interface OsmIdMap {
+  nodes: Record<number, number>;
+  ways: Record<number, number>;
+  relations: Record<number, number>;
+}
+
+/** New positive IDs for one type's negative IDs, after its highest positive ID, in −1, −2, … order. */
+function positiveIds(ids: { size: number; at(index: number): number }): Map<number, number> {
+  let max = 0;
+  const negative: number[] = [];
+  for (let index = 0; index < ids.size; index++) {
+    const id = ids.at(index);
+    if (id < 0) negative.push(id);
+    else max = Math.max(max, id);
+  }
+  negative.sort((a, b) => b - a);
+  return new Map(negative.map((id, index) => [id, max + index + 1]));
+}
+
+/**
+ * A copy of `osm` whose negative node, way and relation IDs are replaced by positive ones, for
+ * tools that reject negative IDs. In OSM files a negative ID conventionally marks a new, not yet
+ * uploaded entity, so only do this when the consumer needs it. Each type gets IDs after its own
+ * highest positive ID, in −1, −2, … order, so the result is deterministic. Way refs and relation
+ * members follow. `osm` is unchanged; the copy has its indexes built.
+ */
+export function renumberNegativeIds(osm: Osm, options: { id?: string } = {}) {
+  const nodeIds = positiveIds(osm.nodes.ids);
+  const wayIds = positiveIds(osm.ways.ids);
+  const relationIds = positiveIds(osm.relations.ids);
+  const mapped = { node: nodeIds, way: wayIds, relation: relationIds } as const;
+  const renumbered = new Osm({ id: options.id ?? osm.id, header: osm.header });
+  for (const node of osm.nodes.sorted()) {
+    renumbered.nodes.addNode({ ...node, id: nodeIds.get(node.id) ?? node.id });
+  }
+  for (const way of osm.ways.sorted()) {
+    renumbered.ways.addWay({
+      ...way,
+      id: wayIds.get(way.id) ?? way.id,
+      refs: way.refs.map((ref) => nodeIds.get(ref) ?? ref),
+    });
+  }
+  for (const relation of osm.relations.sorted()) {
+    renumbered.relations.addRelation({
+      ...relation,
+      id: relationIds.get(relation.id) ?? relation.id,
+      members: relation.members.map((member) => ({
+        ...member,
+        ref: mapped[member.type].get(member.ref) ?? member.ref,
+      })),
+    });
+  }
+  renumbered.buildIndexes();
+  renumbered.buildSpatialIndexes();
+  return { osm: renumbered, idMap: toIdMap(nodeIds, wayIds, relationIds) };
+}
+
+function toIdMap(
+  nodes: Map<number, number>,
+  ways: Map<number, number>,
+  relations: Map<number, number>,
+): OsmIdMap {
+  return {
+    nodes: Object.fromEntries(nodes),
+    ways: Object.fromEntries(ways),
+    relations: Object.fromEntries(relations),
+  };
+}
+
+/** The ID map `renumberNegativeIds(osm)` would apply, without copying the data. */
+export function negativeIdMap(osm: Osm): OsmIdMap {
+  return toIdMap(
+    positiveIds(osm.nodes.ids),
+    positiveIds(osm.ways.ids),
+    positiveIds(osm.relations.ids),
+  );
+}

package/src/stringtable.ts

@@ -7,201 +7,206 @@
  * @module
  */
 
-import type { OsmPbfStringTable } from "@osmix/pbf"
-import type { ContentHasher } from "@osmix/shared/content-hasher"
-import { type BufferType, ResizeableTypedArray as RTA } from "./typed-arrays.ts"
+import type { OsmPbfStringTable } from "@osmix/pbf";
+import type { ContentHasher } from "@osmix/shared/content-hasher";
+
+import { MAX_STRING_BYTES, MAX_UINT32_OFFSET, assertCapacity } from "./limits.ts";
+import { type BufferType, ResizeableTypedArray as RTA } from "./typed-arrays.ts";
 
 /**
  * Serializable state for worker transfer.
  */
 export interface StringTableTransferables<T extends BufferType = BufferType> {
-	/** Concatenated UTF-8 bytes. */
-	bytes: T
-	/** Maps string index → byte offset. */
-	start: T
-	/** Maps string index → byte length. */
-	count: T
+  /** Concatenated UTF-8 bytes. */
+  bytes: T;
+  /** Maps string index → byte offset. */
+  start: T;
+  /** Maps string index → byte length. */
+  count: T;
 }
 
 /**
  * Append-only deduplicated string table.
  *
- * Limits: Max string length 65,535 bytes.
+ * Limits: a string holds at most `MAX_STRING_BYTES` (65,535) UTF-8 bytes, and the table
+ * holds at most `MAX_UINT32_OFFSET` bytes in total. Larger input throws `OsmCapacityError`.
  * Rebuilds reverse index lazily after transfer.
  */
 export default class StringTable {
-	/** UTF-8 encoder for string→bytes conversion */
-	private enc = new TextEncoder()
-	/** UTF-8 decoder for bytes→string conversion */
-	private dec = new TextDecoder() // UTF-8
-
-	// ─── Serializable State ────────────────────────────────────────────────────
-	/** Concatenated UTF-8 bytes of all strings */
-	bytes: RTA<Uint8Array>
-	/** Maps string index → byte offset in bytes array */
-	start: RTA<Uint32Array>
-	/** Maps string index → byte length */
-	count: RTA<Uint16Array>
-
-	// ─── Builder State (string → index) ────────────────────────────────────────
-	/** Forward lookup: string → index (populated during add) */
-	private stringToIndex = new Map<string, number>()
-
-	/** Whether the reverse index has been built (lazy after transfer) */
-	private reverseIndexBuilt = false
-
-	// ─── Retrieval Cache (index → string) ──────────────────────────────────────
-	/** Cache of decoded strings to avoid repeated UTF-8 decoding */
-	private indexToString = new Map<number, string>()
-
-	/**
-	 * Create a new StringTable.
-	 */
-	constructor(opts?: StringTableTransferables) {
-		this.bytes = opts?.bytes
-			? RTA.from(Uint8Array, opts.bytes)
-			: new RTA(Uint8Array)
-		this.start = opts?.start
-			? RTA.from(Uint32Array, opts.start)
-			: new RTA(Uint32Array)
-		this.count = opts?.count
-			? RTA.from(Uint16Array, opts.count)
-			: new RTA(Uint16Array)
-	}
-
-	/**
-	 * Get transferable objects for passing to another thread.
-	 */
-	transferables(): StringTableTransferables {
-		return {
-			bytes: this.bytes.array.buffer,
-			start: this.start.array.buffer,
-			count: this.count.array.buffer,
-		}
-	}
-
-	/**
-	 * Add a string to the table and return its index.
-	 */
-	add(str: string): number {
-		const existingIndex = this.stringToIndex.get(str)
-		if (existingIndex !== undefined) return existingIndex
-		const startIndex = this.start.length
-		const encoded = this.enc.encode(str)
-		this.start.push(this.bytes.length)
-		this.bytes.pushMany(encoded)
-		this.count.push(encoded.length)
-		this.stringToIndex.set(str, startIndex)
-		return startIndex
-	}
-
-	/**
-	 * Decode all the strings in a primitive block and add them to the string table.
-	 * Return a mapping of block index -> string table index
-	 */
-	createBlockIndexMap(blockStringtable: OsmPbfStringTable) {
-		const index = new Uint32Array(blockStringtable.length)
-		for (let i = 0; i < blockStringtable.length; i++) {
-			const bytesString = blockStringtable[i]
-			const str = this.dec.decode(bytesString)
-			const existingIndex = this.stringToIndex.get(str)
-			if (existingIndex !== undefined) {
-				index[i] = existingIndex
-				continue
-			}
-			index[i] = this.add(str)
-		}
-		return index
-	}
-
-	/**
-	 * Get a string by its index.
-	 * Caches results to avoid repeated UTF-8 decoding.
-	 */
-	get(index: number): string {
-		const string = this.indexToString.get(index)
-		if (string) return string
-		const bytes = this.getBytes(index)
-		const tempBuffer = new ArrayBuffer(bytes.byteLength)
-		const tempBytes = new Uint8Array(tempBuffer)
-		tempBytes.set(bytes)
-		const decoded = this.dec.decode(tempBytes)
-		this.indexToString.set(index, decoded)
-		return decoded
-	}
-
-	/**
-	 * Get the raw UTF-8 bytes of a string.
-	 * Returns a subarray view (not a copy).
-	 */
-	getBytes(index: number): Uint8Array {
-		if (index < 0 || index >= this.length)
-			throw Error(`String index out of range: ${index}`)
-		const start = this.start.at(index)
-		const count = this.count.at(index)
-		return this.bytes.array.subarray(start, start + count)
-	}
-
-	/** Number of strings in the table. */
-	get length() {
-		return this.start.length
-	}
-
-	/**
-	 * Finalize the string table by compacting internal arrays.
-	 *
-	 * This releases unused buffer capacity and marks the reverse index as built
-	 * (since all strings were added before this call).
-	 */
-	buildIndex() {
-		this.bytes.compact()
-		this.start.compact()
-		this.count.compact()
-		this.reverseIndexBuilt = true
-	}
-
-	/**
-	 * Convert the string table to an OSM PBF string table.
-	 */
-	toOsmPbfStringTable(): OsmPbfStringTable {
-		const stringTable: OsmPbfStringTable = []
-		for (let i = 0; i < this.length; i++) {
-			stringTable.push(this.getBytes(i))
-		}
-		return stringTable
-	}
-
-	/**
-	 * Lazily build the reverse index (string → index).
-	 * Decodes all strings once to populate the lookup map.
-	 */
-	private ensureReverseIndex() {
-		if (this.reverseIndexBuilt) return
-		// Decode all strings and populate the forward lookup map
-		for (let i = 0; i < this.length; i++) {
-			this.stringToIndex.set(this.get(i), i)
-		}
-		this.reverseIndexBuilt = true
-	}
-
-	/**
-	 * Find the index of a string.
-	 */
-	find(str: string): number {
-		const existing = this.stringToIndex.get(str)
-		if (existing !== undefined) return existing
-		this.ensureReverseIndex()
-		return this.stringToIndex.get(str) ?? -1
-	}
-
-	/**
-	 * Update a ContentHasher with the string table's data.
-	 * Hashes the bytes, start offsets, and counts.
-	 */
-	updateHash(hasher: ContentHasher): ContentHasher {
-		return hasher
-			.update(this.bytes.array)
-			.update(this.start.array)
-			.update(this.count.array)
-	}
+  /** UTF-8 encoder for string→bytes conversion */
+  private enc = new TextEncoder();
+  /** UTF-8 decoder for bytes→string conversion */
+  private dec = new TextDecoder(); // UTF-8
+
+  // ─── Serializable State ────────────────────────────────────────────────────
+  /** Concatenated UTF-8 bytes of all strings */
+  bytes: RTA<Uint8Array>;
+  /** Maps string index → byte offset in bytes array */
+  start: RTA<Uint32Array>;
+  /** Maps string index → byte length */
+  count: RTA<Uint16Array>;
+
+  // ─── Builder State (string → index) ────────────────────────────────────────
+  /** Forward lookup: string → index (populated during add) */
+  private stringToIndex = new Map<string, number>();
+
+  /** Whether the reverse index has been built (lazy after transfer) */
+  private reverseIndexBuilt = false;
+
+  // ─── Retrieval Cache (index → string) ──────────────────────────────────────
+  /** Cache of decoded strings to avoid repeated UTF-8 decoding */
+  private indexToString = new Map<number, string>();
+
+  /**
+   * Create a new StringTable.
+   */
+  constructor(opts?: StringTableTransferables) {
+    this.bytes = opts?.bytes ? RTA.from(Uint8Array, opts.bytes) : new RTA(Uint8Array);
+    this.start = opts?.start ? RTA.from(Uint32Array, opts.start) : new RTA(Uint32Array);
+    this.count = opts?.count ? RTA.from(Uint16Array, opts.count) : new RTA(Uint16Array);
+  }
+
+  /**
+   * Get transferable objects for passing to another thread.
+   */
+  transferables(): StringTableTransferables {
+    return {
+      bytes: this.bytes.array.buffer,
+      start: this.start.array.buffer,
+      count: this.count.array.buffer,
+    };
+  }
+
+  /**
+   * Add a string to the table and return its index.
+   */
+  add(str: string): number {
+    const existingIndex = this.stringToIndex.get(str);
+    if (existingIndex !== undefined) return existingIndex;
+    const startIndex = this.start.length;
+    const encoded = this.enc.encode(str);
+    assertCapacity(
+      "string-bytes",
+      encoded.length,
+      MAX_STRING_BYTES,
+      () => `String "${str.slice(0, 40)}…"`,
+    );
+    assertCapacity(
+      "total-string-bytes",
+      this.bytes.length + encoded.length,
+      MAX_UINT32_OFFSET,
+      () => "The string table",
+    );
+    this.start.push(this.bytes.length);
+    this.bytes.pushMany(encoded);
+    this.count.push(encoded.length);
+    this.stringToIndex.set(str, startIndex);
+    return startIndex;
+  }
+
+  /**
+   * Decode all the strings in a primitive block and add them to the string table.
+   * Return a mapping of block index -> string table index
+   */
+  createBlockIndexMap(blockStringtable: OsmPbfStringTable) {
+    const index = new Uint32Array(blockStringtable.length);
+    for (let i = 0; i < blockStringtable.length; i++) {
+      const bytesString = blockStringtable[i];
+      const str = this.dec.decode(bytesString);
+      const existingIndex = this.stringToIndex.get(str);
+      if (existingIndex !== undefined) {
+        index[i] = existingIndex;
+        continue;
+      }
+      index[i] = this.add(str);
+    }
+    return index;
+  }
+
+  /**
+   * Get a string by its index.
+   * Caches results to avoid repeated UTF-8 decoding.
+   */
+  get(index: number): string {
+    const string = this.indexToString.get(index);
+    if (string) return string;
+    const bytes = this.getBytes(index);
+    const tempBuffer = new ArrayBuffer(bytes.byteLength);
+    const tempBytes = new Uint8Array(tempBuffer);
+    tempBytes.set(bytes);
+    const decoded = this.dec.decode(tempBytes);
+    this.indexToString.set(index, decoded);
+    return decoded;
+  }
+
+  /**
+   * Get the raw UTF-8 bytes of a string.
+   * Returns a subarray view (not a copy).
+   */
+  getBytes(index: number): Uint8Array {
+    if (index < 0 || index >= this.length) throw Error(`String index out of range: ${index}`);
+    const start = this.start.at(index);
+    const count = this.count.at(index);
+    return this.bytes.array.subarray(start, start + count);
+  }
+
+  /** Number of strings in the table. */
+  get length() {
+    return this.start.length;
+  }
+
+  /**
+   * Finalize the string table by compacting internal arrays.
+   *
+   * This releases unused buffer capacity and marks the reverse index as built
+   * (since all strings were added before this call).
+   */
+  buildIndex() {
+    this.bytes.compact();
+    this.start.compact();
+    this.count.compact();
+    this.reverseIndexBuilt = true;
+  }
+
+  /**
+   * Convert the string table to an OSM PBF string table.
+   */
+  toOsmPbfStringTable(): OsmPbfStringTable {
+    const stringTable: OsmPbfStringTable = [];
+    for (let i = 0; i < this.length; i++) {
+      stringTable.push(this.getBytes(i));
+    }
+    return stringTable;
+  }
+
+  /**
+   * Lazily build the reverse index (string → index).
+   * Decodes all strings once to populate the lookup map.
+   */
+  private ensureReverseIndex() {
+    if (this.reverseIndexBuilt) return;
+    // Decode all strings and populate the forward lookup map
+    for (let i = 0; i < this.length; i++) {
+      this.stringToIndex.set(this.get(i), i);
+    }
+    this.reverseIndexBuilt = true;
+  }
+
+  /**
+   * Find the index of a string.
+   */
+  find(str: string): number {
+    const existing = this.stringToIndex.get(str);
+    if (existing !== undefined) return existing;
+    this.ensureReverseIndex();
+    return this.stringToIndex.get(str) ?? -1;
+  }
+
+  /**
+   * Update a ContentHasher with the string table's data.
+   * Hashes the bytes, start offsets, and counts.
+   */
+  updateHash(hasher: ContentHasher): ContentHasher {
+    return hasher.update(this.bytes.array).update(this.start.array).update(this.count.array);
+  }
 }