typescript types are done; added support for wgsl loading and typescr…

…ipt parsing; lots more test coverage; space module cleaned up; rust cleaned up

config/wgsl-loader/bun.ts

@@ -0,0 +1,54 @@
+import type { BunPlugin } from 'bun';
+
+// TODO: Some shaders may #include inside an already #included file. This is not supported yet.
+
+const WgslPlugin: BunPlugin = {
+  name: 'WGSL loader',
+  /**
+   * @param build - bun setup tool to parse wgsl files
+   */
+  setup(build) {
+    build.onLoad({ filter: /\.wgsl$/ }, async (args) => {
+      const { path } = args;
+      // load the file:
+      const file = await Bun.file(path).text();
+      const basePath = path.split('/').slice(0, -1).join('/');
+      // for each line, if a line starts with #include, replace it with the contents of the file
+      const lines = file.split('\n');
+      const contents: string[] = [];
+      for (const line of lines) {
+        if (line.startsWith('#include')) {
+          let includePath = line.split(' ')[1];
+          includePath = includePath.slice(0, -1);
+          const includeFile = await Bun.file(`${basePath}/${includePath}`).text();
+          contents.push(includeFile);
+        } else {
+          contents.push(line);
+        }
+      }
+      const result = contents.join('\n');
+      return {
+        contents: `export default "${sanitizeStringForExport(result)}"`,
+        loader: 'js',
+      };
+    });
+  },
+};
+
+/**
+ * @param str - string to sanitize
+ * @returns sanitized string
+ */
+function sanitizeStringForExport(str: string): string {
+  // Remove single-line comments
+  str = str.replace(/\/\/.*$/gm, '');
+  // Remove multi-line comments
+  str = str.replace(/\/\*[\s\S]*?\*\//g, '');
+  // Replace line breaks with '\n'
+  str = str.replace(/\n/g, '\\n');
+  // Escape double quotes
+  str = str.replace(/"/g, '\\"');
+  return str;
+}
+
+export default WgslPlugin;

package.json

@@ -66,6 +66,7 @@
     "@types/bun": "^1.1.10",
     "@types/node": "^22.5.5",
     "@types/tmp": "^0.2.6",
+    "@webgpu/types": "^0.1.48",
     "eslint": "^9.11.1",
     "eslint-config-prettier": "^9.1.0",
     "eslint-plugin-jsdoc": "^50.3.0",

rust/geometry/src/s2/cellid.rs

@@ -650,17 +650,28 @@ impl S2CellId {
         let k_limit = 1. + 2.220_446_049_250_313e-16;
         let u = fmax(
             -k_limit,
-            fmin(k_limit, k_scale * (2. * (i as f64 - (K_MAX_SIZE as f64) / 2.) + 1.)),
+            fmin(
+                k_limit,
+                k_scale * (2. * (i as f64 - (K_MAX_SIZE as f64) / 2.) + 1.),
+            ),
         );
         let v = fmax(
             -k_limit,
-            fmin(k_limit, k_scale * (2. * (j as f64 - (K_MAX_SIZE as f64) / 2.) + 1.)),
+            fmin(
+                k_limit,
+                k_scale * (2. * (j as f64 - (K_MAX_SIZE as f64) / 2.) + 1.),
+            ),
         );
 
         // Find the leaf cell coordinates on the adjacent face, and convert
         // them to a cell id at the appropriate level.
         let (n_face, nu, nv) = xyz_to_face_uv(&face_uv_to_xyz(face, u, v));
-        S2CellId::from_face_ij(n_face, st_to_ij(0.5 * (nu + 1.)), st_to_ij(0.5 * (nv + 1.)), None)
+        S2CellId::from_face_ij(
+            n_face,
+            st_to_ij(0.5 * (nu + 1.)),
+            st_to_ij(0.5 * (nv + 1.)),
+            None,
+        )
     }
 
     /// Given an S2CellID, find it's nearest neighbors associated with it
@@ -707,6 +718,16 @@ impl S2CellId {
 
         neighbors
     }
+
+    /// Return the low 32 bits of the cell id
+    pub fn low_bits(&self) -> u32 {
+        self.id as u32
+    }
+
+    /// Return the high 32 bits of the cell id
+    pub fn high_bits(&self) -> u32 {
+        (self.id >> 32) as u32
+    }
 }
 impl From<u64> for S2CellId {
     fn from(value: u64) -> Self {

rust/geometry/src/s2/mod.rs

@@ -1,8 +1,13 @@
-mod cellid;
-mod convert;
-mod coords;
-mod coords_internal;
-mod point;
+/// S2 Cell ID
+pub mod cellid;
+/// S2 Conversion tools
+pub mod convert;
+/// S2 Coordinates
+pub mod coords;
+/// S2 Coordinates internal methods
+pub mod coords_internal;
+/// S2 Point
+pub mod point;
 
 pub use cellid::*;
 pub use coords::*;

rust/s2cell/src/lib.rs

@@ -11,6 +11,8 @@ use alloc::boxed::Box;
 use s2::cellid::S2CellId;
 // use lonlat::LonLat;
 
+use core::cmp::Ordering;
+
 #[cfg(target_arch = "wasm32")]
 use lol_alloc::{AssumeSingleThreaded, FreeListAllocator};
 
@@ -61,12 +63,10 @@ pub unsafe extern "C" fn high_bits(ptr: *const S2CellId) -> u32 {
 pub unsafe extern "C" fn compare_s2_cell_id(id1: *const S2CellId, id2: *const S2CellId) -> i32 {
     let id1 = &*id1;
     let id2 = &*id2;
-    if id1 < id2 {
-        -1
-    } else if id1 == id2 {
-        0
-    } else {
-        1
+    match id1.cmp(id2) {
+        Ordering::Less => -1,
+        Ordering::Equal => 0,
+        Ordering::Greater => 1,
     }
 }
 

src/index.ts

@@ -4,5 +4,7 @@ export * from './dataStructures';
 export * from './geometry';
 export * from './proj4';
 export * from './readers';
+export * from './space';
+export * from './tools';
 export * from './util';
-// export * from './writers';
+export * from './writers';

src/proj4/constants/derives.ts

@@ -3,8 +3,6 @@ import { EPSLN, RA4, RA6, SIXTH } from './values';
 
 import type { Ellipsoid } from './ellipsoid';
 
-import match from '../util/match';
-
 /** Describes an ellipsoid's eccentricity */
 export interface EccentricityParams {
   a?: number;
@@ -73,3 +71,13 @@ export function deriveSphere(obj: SphereParams): void {
     obj.b = obj.a;
   }
 }
+
+/**
+ * @param obj - the object to search
+ * @param key - the key to search with
+ * @returns - the value of the key
+ */
+function match<T>(obj: Record<string, T>, key?: string): T | undefined {
+  if (key === undefined) return;
+  if (obj[key] !== undefined) return obj[key];
+}

src/readers/geotiff/decoder.ts

@@ -43,7 +43,7 @@ async function imageDecoder(buffer: ArrayBufferLike): Promise<ArrayBufferLike> {
   const blob = new Blob([buffer as ArrayBuffer]); // e.g. { type: 'image/png' }
   const imageBitmap = await createImageBitmap(blob);
   // Create OffscreenCanvas and draw
-  const canvas: OffscreenCanvas = new OffscreenCanvas(imageBitmap.width, imageBitmap.height);
+  const canvas = new OffscreenCanvas(imageBitmap.width, imageBitmap.height);
   const ctx = canvas.getContext('2d');
   if (ctx === null) throw new Error('Could not get 2d context');
   ctx.drawImage(imageBitmap, 0, 0);

src/readers/geotiff/image.ts

@@ -486,7 +486,6 @@ export class GeoTIFFImage {
       case 3:
         switch (bitsPerSample) {
           case 16:
-            // @ts-expect-error - getFloat16 is polyfilled
             return DataView.prototype.getFloat16;
           case 32:
             return DataView.prototype.getFloat32;