@truelies/osm-dybuf 0.2.0 → 0.2.2

package/grid_index.d.ts

@@ -8,6 +8,18 @@ export declare class Gridex {
   toString(): string;
   equals(other: Gridex): boolean;
 }
+export declare class GridexAtLv extends Gridex {
+  readonly level: number;
+  constructor(unit: GridUnit, londex: number, latdex: number);
+  boundsInt(applyTriangle?: boolean): [number, number, number, number];
+  boundsFine(applyTriangle?: boolean): [number, number, number, number];
+  boundsFloat(applyTriangle?: boolean): {
+    minLon: number;
+    minLat: number;
+    maxLon: number;
+    maxLat: number;
+  };
+}
 export declare class GridUnit {
   readonly unitFine: number;
   readonly level: number;
@@ -16,7 +28,9 @@ export declare class GridUnit {
   readonly minLatdex: number;
   readonly maxLatdex: number;
   constructor(level: number);
-  gridexesAt(longitudeInt: number, latitudeInt: number): Gridex[];
+  makeGridex(londex: number, latdex: number): GridexAtLv;
+  gridexesAt(longitudeInt: number, latitudeInt: number): GridexAtLv[];
+  gridexesWithExt(longitudeInt: number, latitudeInt: number, ext?: number): GridexAtLv[];
   boundsOfGridFine(gridex: Gridex, applyTriangle?: boolean): [number, number, number, number];
   boundsOfGrid(gridex: Gridex, applyTriangle?: boolean): [number, number, number, number];
   gridexRangeForBounds(

package/grid_index.mjs

@@ -25,6 +25,31 @@ export class Gridex {
   }
 }
 
+export class GridexAtLv extends Gridex {
+  constructor(unit, londex, latdex) {
+    super(londex, latdex);
+    this.unit = unit;
+  }
+  get level() {
+    return this.unit.level;
+  }
+  boundsInt(applyTriangle = false) {
+    return this.unit.boundsOfGrid(this, applyTriangle);
+  }
+  boundsFine(applyTriangle = false) {
+    return this.unit.boundsOfGridFine(this, applyTriangle);
+  }
+  boundsFloat(applyTriangle = false) {
+    const [minLon, minLat, maxLon, maxLat] = this.boundsInt(applyTriangle);
+    return {
+      minLon: minLon / INT_COORD_SCALE,
+      minLat: minLat / INT_COORD_SCALE,
+      maxLon: maxLon / INT_COORD_SCALE,
+      maxLat: maxLat / INT_COORD_SCALE,
+    };
+  }
+}
+
 export class GridUnit {
   constructor(level) {
     if (!Number.isInteger(level) || level < 0 || level > MAX_LEVEL) {
@@ -38,24 +63,18 @@ export class GridUnit {
     this.minLatdex = -this.maxLatdex;
   }
 
+  makeGridex(londex, latdex) {
+    return new GridexAtLv(this, londex, latdex);
+  }
+
   _axisIndices(valueFine, axis) {
     const max = axis === "lon" ? this.maxLondex : this.maxLatdex;
     const min = axis === "lon" ? this.minLondex : this.minLatdex;
     const unit = this.unitFine;
 
-    if (valueFine > MAX_LONGITUDE_FINE || valueFine < MIN_LONGITUDE_FINE) {
-      throw new Error("value out of range");
-    }
-
-    if (valueFine === 0) {
-      return [-1, 1];
-    }
-    if (valueFine === max * unit) {
-      return [max];
-    }
-    if (valueFine === min * unit) {
-      return [min];
-    }
+    if (valueFine === 0) return [-1, 1];
+    if (valueFine === max * unit) return [max];
+    if (valueFine === min * unit) return [min];
     if (valueFine % unit === 0) {
       const idx = valueFine / unit;
       return [idx, idx + (idx > 0 ? 1 : -1)];
@@ -76,8 +95,8 @@ export class GridUnit {
       const latdex = latFine > 0 ? this.maxLatdex : this.minLatdex;
       const res = [];
       for (let i = 0; i < this.maxLondex; i++) {
-        res.push(new Gridex(i + 1, latdex));
-        res.push(new Gridex(-(i + 1), latdex));
+        res.push(this.makeGridex(i + 1, latdex));
+        res.push(this.makeGridex(-(i + 1), latdex));
       }
       return res;
     }
@@ -86,12 +105,54 @@ export class GridUnit {
     const res = [];
     for (const lx of lonIdx) {
       for (const ly of latIdx) {
-        res.push(new Gridex(lx, ly));
+        res.push(this.makeGridex(lx, ly));
       }
     }
     return res;
   }
 
+  gridexesWithExt(longitudeInt, latitudeInt, ext = 0) {
+    const radius = Number(ext);
+    if (!Number.isInteger(radius) || radius < 0) {
+      throw new Error("ext must be a non-negative integer");
+    }
+    const baseLonFine = longitudeInt * GRID_FINE_RES;
+    const baseLatFine = latitudeInt * GRID_FINE_RES;
+    const seen = new Set();
+    const result = [];
+
+    const wrapLon = (lonFine) => {
+      const span = 2 * MAX_LONGITUDE_FINE;
+      let v = lonFine;
+      while (v > MAX_LONGITUDE_FINE) v -= span;
+      while (v < MIN_LONGITUDE_FINE) v += span;
+      return v;
+    };
+    const clampLat = (latFine) => {
+      if (latFine > MAX_LATITUDE_FINE) return MAX_LATITUDE_FINE;
+      if (latFine < MIN_LATITUDE_FINE) return MIN_LATITUDE_FINE;
+      return latFine;
+    };
+
+    for (let dx = -radius; dx <= radius; dx++) {
+      for (let dy = -radius; dy <= radius; dy++) {
+        const lonFine = wrapLon(baseLonFine + dx * this.unitFine);
+        const latFine = clampLat(baseLatFine + dy * this.unitFine);
+        const lonInt = lonFine / GRID_FINE_RES;
+        const latInt = latFine / GRID_FINE_RES;
+        const cells = this.gridexesAt(lonInt, latInt);
+        for (const cell of cells) {
+          const key = `${cell.level}:${cell.londex},${cell.latdex}`;
+          if (!seen.has(key)) {
+            seen.add(key);
+            result.push(cell);
+          }
+        }
+      }
+    }
+    return result;
+  }
+
   boundsOfGridFine(gridex, applyTriangle = false) {
     const { londex, latdex } = gridex;
     const minLonFine = (londex - (londex > 0 ? 1 : 0)) * this.unitFine;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@truelies/osm-dybuf",
-  "version": "0.2.0",
+  "version": "0.2.2",
   "description": "Gridex OSM DyBuf parser and schema utilities",
   "type": "module",
   "main": "./osm_dybuf.mjs",

package/schema_ids.mjs

@@ -1,7 +1,4 @@
-import { createRequire } from "node:module";
-
-const require = createRequire(import.meta.url);
-const REGION_CODES_RAW = require("./region_numeric_codes.json");
+import REGION_CODES_RAW from "./region_numeric_codes.js";
 
 export const ENTITY_TYPE_IDS = Object.freeze({
   c: 0,