Added Vitest for testing in both API and web applications, updated package.json files, and enhanced utils with new geographic functions.

Author: bchapuis

apps/api/package.json

@@ -5,6 +5,8 @@
     "deploy": "wrangler deploy --minify",
     "lint": "eslint . --ext .ts",
     "lint:fix": "eslint . --ext .ts --fix",
+    "test": "vitest",
+    "test:run": "vitest run",
     "format": "prettier --write \"**/*.{ts,js,json,md}\"",
     "format:check": "prettier --check \"**/*.{ts,js,json,md}\""
   },
@@ -21,6 +23,7 @@
   "devDependencies": {
     "@cloudflare/workers-types": "^4.20250109.0",
     "prettier": "^3.5.0",
+    "vitest": "^3.2.4",
     "wrangler": "^4.14.4"
   }
 }

apps/api/src/utils/utils.test.ts

@@ -0,0 +1,197 @@
+import { describe, it, expect } from 'vitest'
+import { lonLatToTile, type BoundingRegion, degToRad } from './utils'
+
+describe('lonLatToTile', () => {
+  // Define a test root region covering a 2x2 degree area in radians
+  const testRoot: BoundingRegion = {
+    west: degToRad(-1),   // -1 degree
+    south: degToRad(-1),  // -1 degree  
+    east: degToRad(1),    // 1 degree
+    north: degToRad(1),   // 1 degree
+    minH: 0,
+    maxH: 100
+  }
+
+  describe('level 0 (single tile)', () => {
+    it('should return {x: 0, y: 0} for any point inside the root region', () => {
+      expect(lonLatToTile(testRoot, 0, degToRad(0), degToRad(0))).toEqual({ x: 0, y: 0 })
+      expect(lonLatToTile(testRoot, 0, degToRad(-0.5), degToRad(0.5))).toEqual({ x: 0, y: 0 })
+      expect(lonLatToTile(testRoot, 0, degToRad(0.9), degToRad(-0.9))).toEqual({ x: 0, y: 0 })
+    })
+  })
+
+  describe('level 1 (2x2 grid)', () => {
+    it('should return correct tile coordinates for each quadrant', () => {
+      // Bottom-left quadrant (x=0, y=0)
+      expect(lonLatToTile(testRoot, 1, degToRad(-0.5), degToRad(-0.5))).toEqual({ x: 0, y: 0 })
+      
+      // Bottom-right quadrant (x=1, y=0)  
+      expect(lonLatToTile(testRoot, 1, degToRad(0.5), degToRad(-0.5))).toEqual({ x: 1, y: 0 })
+      
+      // Top-left quadrant (x=0, y=1)
+      expect(lonLatToTile(testRoot, 1, degToRad(-0.5), degToRad(0.5))).toEqual({ x: 0, y: 1 })
+      
+      // Top-right quadrant (x=1, y=1)
+      expect(lonLatToTile(testRoot, 1, degToRad(0.5), degToRad(0.5))).toEqual({ x: 1, y: 1 })
+    })
+
+    it('should handle coordinates at tile boundaries correctly', () => {
+      // Point exactly at the center should go to bottom-left tile
+      expect(lonLatToTile(testRoot, 1, degToRad(0), degToRad(0))).toEqual({ x: 1, y: 1 })
+      
+      // Point at west boundary should go to left tiles
+      expect(lonLatToTile(testRoot, 1, degToRad(-1), degToRad(-0.5))).toEqual({ x: 0, y: 0 })
+      expect(lonLatToTile(testRoot, 1, degToRad(-1), degToRad(0.5))).toEqual({ x: 0, y: 1 })
+    })
+  })
+
+  describe('level 2 (4x4 grid)', () => {
+    it('should return correct tile coordinates for higher subdivision', () => {
+      // Test a point in the first tile (0,0)
+      expect(lonLatToTile(testRoot, 2, degToRad(-0.75), degToRad(-0.75))).toEqual({ x: 0, y: 0 })
+      
+      // Test a point in the last tile (3,3)
+      expect(lonLatToTile(testRoot, 2, degToRad(0.75), degToRad(0.75))).toEqual({ x: 3, y: 3 })
+      
+      // Test center point
+      expect(lonLatToTile(testRoot, 2, degToRad(0), degToRad(0))).toEqual({ x: 2, y: 2 })
+    })
+  })
+
+  describe('boundary conditions', () => {
+    it('should handle coordinates at exact region boundaries', () => {
+      // Points at the exact boundaries of the root region
+      expect(lonLatToTile(testRoot, 1, testRoot.west, testRoot.south)).toEqual({ x: 0, y: 0 })
+      expect(lonLatToTile(testRoot, 1, testRoot.east, testRoot.north)).toEqual({ x: 1, y: 1 })
+      
+      // Points very close to but within boundaries
+      const epsilon = 1e-10
+      expect(lonLatToTile(testRoot, 1, testRoot.west + epsilon, testRoot.south + epsilon)).toEqual({ x: 0, y: 0 })
+    })
+
+    it('should clamp to maximum tile indices for edge coordinates', () => {
+      // At level 2, max indices should be 3,3
+      expect(lonLatToTile(testRoot, 2, testRoot.east, testRoot.north)).toEqual({ x: 3, y: 3 })
+    })
+  })
+
+  describe('error conditions', () => {
+    it('should throw RangeError for coordinates outside west boundary', () => {
+      expect(() => {
+        lonLatToTile(testRoot, 1, degToRad(-1.1), degToRad(0))
+      }).toThrow(RangeError)
+      expect(() => {
+        lonLatToTile(testRoot, 1, degToRad(-1.1), degToRad(0))
+      }).toThrow('Position is outside the root bounding region')
+    })
+
+    it('should throw RangeError for coordinates outside east boundary', () => {
+      expect(() => {
+        lonLatToTile(testRoot, 1, degToRad(1.1), degToRad(0))
+      }).toThrow(RangeError)
+    })
+
+    it('should throw RangeError for coordinates outside south boundary', () => {
+      expect(() => {
+        lonLatToTile(testRoot, 1, degToRad(0), degToRad(-1.1))
+      }).toThrow(RangeError)
+    })
+
+    it('should throw RangeError for coordinates outside north boundary', () => {
+      expect(() => {
+        lonLatToTile(testRoot, 1, degToRad(0), degToRad(1.1))
+      }).toThrow(RangeError)
+    })
+  })
+
+  describe('real-world coordinate system', () => {
+    // Test with a more realistic bounding region (Switzerland area)
+    const swissRegion: BoundingRegion = {
+      west: degToRad(5.96),   // Western Switzerland
+      south: degToRad(45.82), // Southern Switzerland  
+      east: degToRad(10.49),  // Eastern Switzerland
+      north: degToRad(47.81), // Northern Switzerland
+      minH: 0,
+      maxH: 4000
+    }
+
+    it('should handle realistic geographic coordinates', () => {
+      // Test Bern coordinates (approximately 7.45°E, 46.95°N)
+      const bernLon = degToRad(7.45)
+      const bernLat = degToRad(46.95)
+      
+      const result = lonLatToTile(swissRegion, 3, bernLon, bernLat)
+      
+      // Verify the result is within expected bounds for level 3 (8x8 grid)
+      expect(result.x).toBeGreaterThanOrEqual(0)
+      expect(result.x).toBeLessThanOrEqual(7)
+      expect(result.y).toBeGreaterThanOrEqual(0)
+      expect(result.y).toBeLessThanOrEqual(7)
+      
+      // Verify it's roughly in the center of Switzerland (should be around middle tiles)
+      // Bern is roughly in the center-west of Switzerland, so expect x around 2-3 and y around 4-5
+      expect(result.x).toBeGreaterThanOrEqual(2)
+      expect(result.x).toBeLessThanOrEqual(4)
+      expect(result.y).toBeGreaterThanOrEqual(3)
+      expect(result.y).toBeLessThanOrEqual(6)
+    })
+
+    it('should handle Lausanne dataset coordinates', () => {
+      // Lausanne dataset bounds
+      const lausanneRegion: BoundingRegion = {
+        west: degToRad(6.5248166),   // Western Lausanne
+        south: degToRad(46.4976347), // Southern Lausanne
+        east: degToRad(6.6700634),   // Eastern Lausanne
+        north: degToRad(46.6156402), // Northern Lausanne
+        minH: 0,
+        maxH: 1000
+      }
+
+      // Test coordinates in central Lausanne (approximately 6.63°E, 46.52°N)
+      const lausanneLon = degToRad(6.63)
+      const lausanneLat = degToRad(46.52)
+      
+      const result = lonLatToTile(lausanneRegion, 4, lausanneLon, lausanneLat)
+      
+      // Verify the result is within expected bounds for level 4 (16x16 grid)
+      expect(result.x).toBeGreaterThanOrEqual(0)
+      expect(result.x).toBeLessThanOrEqual(15)
+      expect(result.y).toBeGreaterThanOrEqual(0)
+      expect(result.y).toBeLessThanOrEqual(15)
+      
+      // For a small region like Lausanne, the coordinates should be in the eastern part
+      // since 6.63 is closer to the eastern bound (6.67) than western (6.52)
+      expect(result.x).toBeGreaterThan(8) // Should be in the eastern half
+      expect(result.y).toBeGreaterThanOrEqual(0) // Should be in the valid range
+    })
+
+    it('should handle coordinates at Lausanne dataset boundaries', () => {
+      const lausanneRegion: BoundingRegion = {
+        west: degToRad(6.5248166),
+        south: degToRad(46.4976347),
+        east: degToRad(6.6700634),
+        north: degToRad(46.6156402),
+        minH: 0,
+        maxH: 1000
+      }
+
+      // Test boundary coordinates
+      expect(() => {
+        lonLatToTile(lausanneRegion, 2, lausanneRegion.west, lausanneRegion.south)
+      }).not.toThrow()
+
+      expect(() => {
+        lonLatToTile(lausanneRegion, 2, lausanneRegion.east, lausanneRegion.north)
+      }).not.toThrow()
+
+      // Test coordinates just outside the boundaries
+      expect(() => {
+        lonLatToTile(lausanneRegion, 2, degToRad(6.5), degToRad(46.5))
+      }).toThrow(RangeError)
+
+      expect(() => {
+        lonLatToTile(lausanneRegion, 2, degToRad(6.68), degToRad(46.62))
+      }).toThrow(RangeError)
+    })
+  })
+}) 

apps/api/src/utils/utils.ts

@@ -16,17 +16,96 @@ proj4.defs(
  * @param y LV95 y coordinate
  * @returns WGS84 coordinates
  */
-const LV95toWGS84 = (x: number, y: number) => {
+export function LV95toWGS84(x: number, y: number) {
   return proj4('LV95', 'WGS84', [x, y]);
-};
+}
 
 /**
  * Convert degrees to radians
  * @param deg Degrees
  * @returns Radians
  */
-const degToRad = (deg: number) => {
+export function degToRad(deg: number) {
   return deg * (Math.PI / 180);
-};
+}
 
-export { LV95toWGS84, degToRad };
+/** A geographic bounding region as used by 3D Tiles 1.1 (radians + metres). */
+export interface BoundingRegion {
+  west:  number;  // longitude,  radians
+  south: number;  // latitude,   radians
+  east:  number;  // longitude,  radians
+  north: number;  // latitude,   radians
+  minH:  number;  // metres
+  maxH:  number;  // metres
+}
+
+/**
+ * Compute the bounding region of a quadtree tile.
+ *
+ * @param root     Full-extent region for level 0 (usually the implicit-root tile).
+ * @param level    0-based quadtree level.
+ * @param x,y      Horizontal tile indices in that level (0 ≤ index < 2^level).
+ * @param splitH   If true, height is halved each level; otherwise height stays constant.
+ */
+export function tileToRegion(
+  root: BoundingRegion,
+  level: number,
+  x: number,
+  y: number,
+  splitH = false
+): BoundingRegion {
+  const div = 1 << level;                           // 2^level
+  const lonStep = (root.east  - root.west)  / div;  // Δλ per tile
+  const latStep = (root.north - root.south) / div;  // Δφ per tile
+
+  const west  = root.west  + lonStep * x;           // west → east is +λ :contentReference[oaicite:1]{index=1}
+  const east  = west + lonStep;
+  const south = root.south + latStep * y;           // south → north is +φ :contentReference[oaicite:2]{index=2}
+  const north = south + latStep;
+
+  let { minH, maxH } = root;
+  if (splitH && level > 0) {
+    const hStep = (root.maxH - root.minH) / div;    // follow same rule for z (height)
+    minH = root.minH + hStep * y;                   // use y as proxy for z-slice; adapt if you store z
+    maxH = minH + hStep;
+  }
+  return { west, south, east, north, minH, maxH };
+}
+
+/**
+ * Return the (x, y) tile coordinates that contain the given longitude/latitude.
+ *
+ * @param root   The bounding region of the implicit-root tile.
+ * @param level  Quadtree level (0 = root).
+ * @param lon    Longitude in **radians** (WGS 84, same units as the spec).
+ * @param lat    Latitude  in **radians**.
+ *
+ * @throws RangeError if the point lies outside the root region.
+ */
+export function lonLatToTile(
+  root: BoundingRegion,
+  level: number,
+  lon: number,
+  lat: number,
+): { x: number; y: number } {
+  if (lon < root.west || lon > root.east ||
+      lat < root.south || lat > root.north) {
+    throw new RangeError("Position is outside the root bounding region");
+  }
+
+  const div   = 1 << level;                       // = 2^level
+  const sizeX = (root.east  - root.west)  / div;  // Δλ per tile
+  const sizeY = (root.north - root.south) / div;  // Δφ per tile
+
+  // Compute zero-based indices (west→east, south→north) :contentReference[oaicite:0]{index=0}
+  const x = Math.min(
+    div - 1,
+    Math.floor((lon - root.west)  / sizeX),
+  );
+  const y = Math.min(
+    div - 1,
+    Math.floor((lat - root.south) / sizeY),
+  );
+
+  return { x, y };
+}

apps/api/vitest.config.ts

@@ -0,0 +1,10 @@
+import { defineConfig } from 'vitest/config'
+
+export default defineConfig({
+  test: {
+    globals: true,
+    environment: 'node',
+    include: ['src/**/*.{test,spec}.{js,mjs,cjs,ts,mts,cts}'],
+    exclude: ['**/node_modules/**', '**/dist/**'],
+  },
+}) 

apps/web/package.json

@@ -10,15 +10,20 @@
     "preview": "vite preview",
     "lint": "eslint . --ext .ts,.tsx",
     "lint:fix": "eslint . --ext .ts,.tsx --fix",
+    "test": "vitest",
+    "test:run": "vitest run",
     "format": "prettier --write \"**/*.{ts,tsx,js,jsx,json,md}\"",
     "format:check": "prettier --check \"**/*.{ts,tsx,js,jsx,json,md}\""
   },
   "devDependencies": {
+    "@types/jsdom": "^21.1.7",
     "@types/node": "^22.13.11",
     "@types/three": "^0.173.0",
+    "jsdom": "^26.1.0",
     "prettier": "^3.5.0",
     "typescript": "~5.7.2",
     "vite": "^6.1.0",
+    "vitest": "^3.2.4",
     "wrangler": "4"
   },
   "dependencies": {

apps/web/src/main.test.ts

@@ -0,0 +1,13 @@
+import { describe, it, expect } from 'vitest'
+
+describe('Main', () => {
+  it('should be able to run tests', () => {
+    expect(1 + 1).toBe(2)
+  })
+  
+  it('should have access to DOM', () => {
+    const div = document.createElement('div')
+    div.textContent = 'Hello World'
+    expect(div.textContent).toBe('Hello World')
+  })
+}) 

apps/web/vitest.config.ts

@@ -0,0 +1,10 @@
+import { defineConfig } from 'vitest/config'
+
+export default defineConfig({
+  test: {
+    globals: true,
+    environment: 'jsdom',
+    include: ['src/**/*.{test,spec}.{js,mjs,cjs,ts,mts,cts,jsx,tsx}'],
+    exclude: ['**/node_modules/**', '**/dist/**'],
+  },
+})