rbush-rs 1.0.5 → 1.0.6

package/README.md

@@ -1,47 +1,51 @@
 # rbush-rs
+
 A high-performance(>5x faster), 100% Rust port of [RBush](https://github.com/mourner/rbush) spatial index library, compiled to WebAssembly.
 
 `rbush-rs` is designed to be a near drop-in replacement for `rbush`, offering significant performance improvements for bulk loading and searching massive datasets.
 
 ```diff
-+ Import { RBush } from 'rbush-rs';
-- Import { RBush } from 'rbush';
++ Import RBush from 'rbush-rs';
+- Import RBush from 'rbush';
 ```
 
 ## Benchmark
 
 Tests performed on a dataset of 10,000 rectangles.
 
-| Operation | JS (rbush) | WASM (rbush-rs) | Speedup |
-| --- | --- | --- | --- |
-| **Bulk Load (Hybrid)** | 20.23 ms | **3.60 ms** | **~5.6x Faster** |
-| **Insert (1000 items)** | 36.58 ms | **4.04 ms** | **~9.1x Faster** |
-| **Remove (1000 items)** | 58.03 ms | **7.85 ms** | **~7.4x Faster** |
-| **Search** | 0.042 ms | **0.027 ms** | **~1.6x Faster** |
-| **Collides** | 0.003 ms | 0.003 ms | **1x Faster** |
-| **Clear** | 0.001 ms | 0.001 ms | **1x Faster** |
+| Operation               | JS (rbush) | WASM (rbush-rs) | Speedup          |
+| ----------------------- | ---------- | --------------- | ---------------- |
+| **Bulk Load (Hybrid)**  | 20.23 ms   | **3.60 ms**     | **~5.6x Faster** |
+| **Insert (1000 items)** | 36.58 ms   | **4.04 ms**     | **~9.1x Faster** |
+| **Remove (1000 items)** | 58.03 ms   | **7.85 ms**     | **~7.4x Faster** |
+| **Search**              | 0.042 ms   | **0.027 ms**    | **~1.6x Faster** |
+| **Collides**            | 0.003 ms   | 0.003 ms        | **1x Faster**    |
+| **Clear**               | 0.001 ms   | 0.001 ms        | **1x Faster**    |
 
-*\*Standard load is slower due to the overhead of reading JS objects into WASM. Use Hybrid Load for maximum performance.*
+_\*Standard load is slower due to the overhead of reading JS objects into WASM. Use Hybrid Load for maximum performance._
 
 ## Installation
+
 You can install `rbush-rs` via:
 
 ### npm
+
 ```bash
 npm install rbush-rs
 ```
 
 ### pnpm
+
 ```bash
 pnpm install rbush-rs
 ```
 
 ### yarn
+
 ```bash
 yarn add rbush-rs
 ```
 
-
 ## Usage
 
 ### The "Drop-in" Replacement
@@ -49,22 +53,21 @@ yarn add rbush-rs
 Use this mode if you want to switch libraries with minimal code changes. It accepts the same data format as the original `rbush`.
 
 ```javascript
-import { RBush } from 'rbush-rs';
+import { RBush } from "rbush-rs"
 
 // Initialize (max entries per node, default 9)
-const tree = new RBush(9);
+const tree = new RBush(9)
 
 // Load standard data (Array of objects with minX, minY, maxX, maxY)
 const items = [
-    { minX: 10, minY: 10, maxX: 20, maxY: 20, id: 'a' },
-    { minX: 50, minY: 50, maxX: 60, maxY: 60, id: 'b' }
-];
-tree.load(items);
+  { minX: 10, minY: 10, maxX: 20, maxY: 20, id: "a" },
+  { minX: 50, minY: 50, maxX: 60, maxY: 60, id: "b" },
+]
+tree.load(items)
 
 // Search
-const results = tree.search({ minX: 0, minY: 0, maxX: 30, maxY: 30 });
-console.log(results); // [{ minX: 10, ... }]
-
+const results = tree.search({ minX: 0, minY: 0, maxX: 30, maxY: 30 })
+console.log(results) // [{ minX: 10, ... }]
 ```
 
 ### The "Hybrid" Load (Recommended for MAX Speed)
@@ -84,7 +87,7 @@ const flatCoords = new Float64Array(count * 4);
 
 for(let i = 0; i < count; i++) {
     const item = { minX: Math.random() * 100, minY: Math.random() * 100, maxX: ..., maxY: ..., id: i };
-    
+
     // standard items array
     items.push(item);
 
@@ -112,8 +115,8 @@ All operations below work regardless of how you loaded the data (Standard or Hyb
 `rbush-rs` is highly optimized for dynamic updates, performing ~9x faster than JS.
 
 ```javascript
-const item = { minX: 20, minY: 20, maxX: 30, maxY: 30, id: 'c' };
-tree.insert(item);
+const item = { minX: 20, minY: 20, maxX: 30, maxY: 30, id: "c" }
+tree.insert(item)
 ```
 
 #### Removal
@@ -121,7 +124,7 @@ tree.insert(item);
 Removal is ~7x faster than JS. The item object passed must match the one in the tree (by reference equality).
 
 ```javascript
-tree.remove(item);
+tree.remove(item)
 ```
 
 #### Collision Detection
@@ -129,7 +132,7 @@ tree.remove(item);
 Checks if there are any items in the bounding box. Faster than `search` if you don't need the actual items.
 
 ```javascript
-const hasCollision = tree.collides({ minX: 10, minY: 10, maxX: 20, maxY: 20 });
+const hasCollision = tree.collides({ minX: 10, minY: 10, maxX: 20, maxY: 20 })
 // returns true or false
 ```
 
@@ -138,7 +141,7 @@ const hasCollision = tree.collides({ minX: 10, minY: 10, maxX: 20, maxY: 20 });
 Returns all items currently stored in the tree.
 
 ```javascript
-const allItems = tree.all();
+const allItems = tree.all()
 ```
 
 #### Clear Tree
@@ -146,17 +149,17 @@ const allItems = tree.all();
 Removes all items and resets the tree.
 
 ```javascript
-tree.clear();
+tree.clear()
 ```
 
 ## 🔧 API Reference
 
-* **`new RBush(maxEntries?: number)`**: Creates a new tree.
-* **`load(items: array)`**: Bulk loads standard JS objects.
-* **`loadHybrid(coords: Float64Array, items: array)`**: High-performance bulk load.
-* **`insert(item: object)`**: Inserts a single item.
-* **`remove(item: object)`**: Removes a specific item.
-* **`search(bbox: object)`**: Returns an array of items intersecting the bbox.
-* **`collides(bbox: object)`**: Returns `true` if any item intersects the bbox.
-* **`all()`**: Returns all items in the tree.
-* **`clear()`**: Removes all items.
+- **`new RBush(maxEntries?: number)`**: Creates a new tree.
+- **`load(items: array)`**: Bulk loads standard JS objects.
+- **`loadHybrid(coords: Float64Array, items: array)`**: High-performance bulk load.
+- **`insert(item: object)`**: Inserts a single item.
+- **`remove(item: object)`**: Removes a specific item.
+- **`search(bbox: object)`**: Returns an array of items intersecting the bbox.
+- **`collides(bbox: object)`**: Returns `true` if any item intersects the bbox.
+- **`all()`**: Returns all items in the tree.
+- **`clear()`**: Removes all items.

package/package.json

@@ -5,18 +5,19 @@
     "Preetham <ppmpreetham1@gmail.com>"
   ],
   "description": "High-performance RBush port in WebAssembly",
-  "version": "1.0.5",
+  "version": "1.0.6",
   "license": "MIT",
   "repository": {
     "type": "git",
     "url": "https://github.com/ppmpreetham/rbush-rs"
   },
-  "files": [
+ "files": [
     "rbush_rs_bg.wasm",
     "rbush_rs.js",
     "rbush_rs_bg.js",
     "rbush_rs.d.ts",
-    "rbush.js"
+    "rbush.js",
+    "rbush.umd.js"
   ],
   "main": "rbush.js",
   "types": "rbush_rs.d.ts",

package/rbush.umd.js

@@ -0,0 +1,240 @@
+(function (global, factory) {
+  typeof exports === 'object' && typeof module !== 'undefined' ? module.exports = factory() :
+  typeof define === 'function' && define.amd ? define(factory) :
+  (global = typeof globalThis !== 'undefined' ? globalThis : global || self, global.RBush = factory());
+})(this, (function () { 'use strict';
+
+  function _loadWasmModule (sync, filepath, src, imports) {
+    function _instantiateOrCompile(source, imports, stream) {
+      var instantiateFunc = stream ? WebAssembly.instantiateStreaming : WebAssembly.instantiate;
+      var compileFunc = stream ? WebAssembly.compileStreaming : WebAssembly.compile;
+
+      if (imports) {
+        return instantiateFunc(source, imports)
+      } else {
+        return compileFunc(source)
+      }
+    }
+  var isNode = typeof process !== 'undefined' && process.versions != null && process.versions.node != null;
+
+  if (isNode) {
+    
+  var fs = require("fs");
+  var path = require("path");
+
+  return new Promise((resolve, reject) => {
+    fs.readFile(path.resolve(__dirname, filepath), (error, buffer) => {
+      if (error != null) {
+        reject(error);
+      } else {
+        resolve(_instantiateOrCompile(buffer, imports, false));
+      }
+    });
+  });
+
+  } else {
+    
+  return _instantiateOrCompile(fetch(filepath), imports, true);
+
+  }
+  }
+
+  function rbush_rs_bg(imports){return _loadWasmModule(0, 'c5b00a3a15dd90c3.wasm', null, imports)}
+
+  var wasm$1 = /*#__PURE__*/Object.freeze({
+    __proto__: null,
+    default: rbush_rs_bg
+  });
+
+  let RBush$1 = class RBush {
+      __destroy_into_raw() {
+          const ptr = this.__wbg_ptr;
+          this.__wbg_ptr = 0;
+          RBushFinalization.unregister(this);
+          return ptr;
+      }
+      free() {
+          const ptr = this.__destroy_into_raw();
+          wasm.__wbg_rbush_free(ptr, 0);
+      }
+      /**
+       * @returns {Array<any>}
+       */
+      all() {
+          const ret = wasm.rbush_all(this.__wbg_ptr);
+          return ret;
+      }
+      clear() {
+          wasm.rbush_clear(this.__wbg_ptr);
+      }
+      /**
+       * @param {any} bbox_js
+       * @returns {boolean}
+       */
+      collides(bbox_js) {
+          const ret = wasm.rbush_collides(this.__wbg_ptr, bbox_js);
+          return ret !== 0;
+      }
+      /**
+       * @param {any} data
+       */
+      fromJSON(data) {
+          wasm.rbush_fromJSON(this.__wbg_ptr, data);
+      }
+      /**
+       * @param {any} item
+       */
+      insert(item) {
+          wasm.rbush_insert(this.__wbg_ptr, item);
+      }
+      /**
+       * @param {Array<any>} data
+       */
+      load(data) {
+          wasm.rbush_load(this.__wbg_ptr, data);
+      }
+      /**
+       * @param {Float64Array} fast_coords
+       * @param {Array<any>} items
+       */
+      loadHybrid(fast_coords, items) {
+          const ptr0 = passArrayF64ToWasm0(fast_coords, wasm.__wbindgen_malloc);
+          const len0 = WASM_VECTOR_LEN;
+          wasm.rbush_loadHybrid(this.__wbg_ptr, ptr0, len0, items);
+      }
+      /**
+       * @param {number | null} [max_entries]
+       */
+      constructor(max_entries) {
+          const ret = wasm.rbush_new(isLikeNone(max_entries) ? 0x100000001 : (max_entries) >>> 0);
+          this.__wbg_ptr = ret >>> 0;
+          RBushFinalization.register(this, this.__wbg_ptr, this);
+          return this;
+      }
+      /**
+       * @param {any} item
+       */
+      remove(item) {
+          wasm.rbush_remove(this.__wbg_ptr, item);
+      }
+      /**
+       * @param {any} bbox_js
+       * @returns {Array<any>}
+       */
+      search(bbox_js) {
+          const ret = wasm.rbush_search(this.__wbg_ptr, bbox_js);
+          return ret;
+      }
+      /**
+       * @returns {any}
+       */
+      toJSON() {
+          const ret = wasm.rbush_toJSON(this.__wbg_ptr);
+          return ret;
+      }
+  };
+  if (Symbol.dispose) RBush$1.prototype[Symbol.dispose] = RBush$1.prototype.free;
+  const RBushFinalization = (typeof FinalizationRegistry === 'undefined')
+      ? { register: () => {}, unregister: () => {} }
+      : new FinalizationRegistry(ptr => wasm.__wbg_rbush_free(ptr >>> 0, 1));
+
+  let cachedFloat64ArrayMemory0 = null;
+  function getFloat64ArrayMemory0() {
+      if (cachedFloat64ArrayMemory0 === null || cachedFloat64ArrayMemory0.byteLength === 0) {
+          cachedFloat64ArrayMemory0 = new Float64Array(wasm.memory.buffer);
+      }
+      return cachedFloat64ArrayMemory0;
+  }
+
+  function isLikeNone(x) {
+      return x === undefined || x === null;
+  }
+
+  function passArrayF64ToWasm0(arg, malloc) {
+      const ptr = malloc(arg.length * 8, 8) >>> 0;
+      getFloat64ArrayMemory0().set(arg, ptr / 8);
+      WASM_VECTOR_LEN = arg.length;
+      return ptr;
+  }
+
+  let cachedTextDecoder = new TextDecoder('utf-8', { ignoreBOM: true, fatal: true });
+  cachedTextDecoder.decode();
+
+  let WASM_VECTOR_LEN = 0;
+
+
+  let wasm;
+  function __wbg_set_wasm(val) {
+      wasm = val;
+  }
+
+  /* @ts-self-types="./rbush_rs.d.ts" */
+
+  __wbg_set_wasm(wasm$1);
+  undefined();
+
+  class RBush {
+    constructor(maxEntries = 9) {
+      this._tree = new RBush$1(maxEntries);
+    }
+
+    toBBox(item) {
+      return item
+    }
+
+    insert(item) {
+      const b = this.toBBox(item);
+      this._tree.insert({
+        ...item,
+        minX: b.minX,
+        minY: b.minY,
+        maxX: b.maxX,
+        maxY: b.maxY,
+      });
+      return this
+    }
+
+    load(data) {
+      const normalized = data.map((item) => {
+        const b = this.toBBox(item);
+        return { ...item, minX: b.minX, minY: b.minY, maxX: b.maxX, maxY: b.maxY }
+      });
+      this._tree.load(normalized);
+      return this
+    }
+
+    remove(item) {
+      const b = this.toBBox(item);
+      this._tree.remove({ ...item, minX: b.minX, minY: b.minY, maxX: b.maxX, maxY: b.maxY });
+      return this
+    }
+
+    search(bbox) {
+      return this._tree.search(bbox)
+    }
+    collides(bbox) {
+      return this._tree.collides(bbox)
+    }
+    all() {
+      return this._tree.all()
+    }
+    clear() {
+      this._tree.clear();
+      return this
+    }
+    toJSON() {
+      return this._tree.toJSON()
+    }
+    fromJSON(data) {
+      this._tree.fromJSON(data);
+      return this
+    }
+
+    destroy() {
+      this._tree.free();
+    }
+  }
+
+  return RBush;
+
+}));