rbush-rs 1.0.2 → 1.0.4

package/package.json

@@ -1,19 +1,27 @@
 {
   "name": "rbush-rs",
-  "version": "1.0.2",
-  "description": "High-performance RBush port in WebAssembly (Rust)",
-  "main": "rbush.js",
-  "module": "rbush.js",
-  "type": "module", 
-  "files": [
-    "rbush.js",
-    "pkg/"
+  "type": "module",
+  "collaborators": [
+    "Preetham <ppmpreetham1@gmail.com>"
   ],
-  "scripts": {
-    "build": "wasm-pack build --target bundler",
-    "test": "node --experimental-vm-modules node_modules/jest/bin/jest.js"
+  "description": "High-performance RBush port in WebAssembly",
+  "version": "1.0.4",
+  "license": "MIT",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/ppmpreetham/rbush-rs"
   },
-  "devDependencies": {
-    "jest": "^30.2.0"
-  }
+  "files": [
+    "rbush_rs_bg.wasm",
+    "rbush_rs.js",
+    "rbush_rs_bg.js",
+    "rbush_rs.d.ts",
+    "rbush.js"
+  ],
+  "main": "rbush.js",
+  "types": "rbush_rs.d.ts",
+  "sideEffects": [
+    "./rbush_rs.js",
+    "./snippets/*"
+  ]
 }

package/rbush_rs.d.ts

@@ -0,0 +1,18 @@
+/* tslint:disable */
+/* eslint-disable */
+
+export class RBush {
+    free(): void;
+    [Symbol.dispose](): void;
+    all(): Array<any>;
+    clear(): void;
+    collides(bbox_js: any): boolean;
+    fromJSON(data: any): void;
+    insert(item: any): void;
+    load(data: Array<any>): void;
+    loadHybrid(fast_coords: Float64Array, items: Array<any>): void;
+    constructor(max_entries?: number | null);
+    remove(item: any): void;
+    search(bbox_js: any): Array<any>;
+    toJSON(): any;
+}

package/rbush_rs.js

@@ -0,0 +1,9 @@
+/* @ts-self-types="./rbush_rs.d.ts" */
+
+import * as wasm from "./rbush_rs_bg.wasm";
+import { __wbg_set_wasm } from "./rbush_rs_bg.js";
+__wbg_set_wasm(wasm);
+wasm.__wbindgen_start();
+export {
+    RBush
+} from "./rbush_rs_bg.js";

package/rbush_rs_bg.js

@@ -0,0 +1,245 @@
+export 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.prototype[Symbol.dispose] = RBush.prototype.free;
+export function __wbg___wbindgen_boolean_get_bbbb1c18aa2f5e25(arg0) {
+    const v = arg0;
+    const ret = typeof(v) === 'boolean' ? v : undefined;
+    return isLikeNone(ret) ? 0xFFFFFF : ret ? 1 : 0;
+}
+export function __wbg___wbindgen_is_null_ac34f5003991759a(arg0) {
+    const ret = arg0 === null;
+    return ret;
+}
+export function __wbg___wbindgen_is_undefined_9e4d92534c42d778(arg0) {
+    const ret = arg0 === undefined;
+    return ret;
+}
+export function __wbg___wbindgen_jsval_eq_11888390b0186270(arg0, arg1) {
+    const ret = arg0 === arg1;
+    return ret;
+}
+export function __wbg___wbindgen_number_get_8ff4255516ccad3e(arg0, arg1) {
+    const obj = arg1;
+    const ret = typeof(obj) === 'number' ? obj : undefined;
+    getDataViewMemory0().setFloat64(arg0 + 8 * 1, isLikeNone(ret) ? 0 : ret, true);
+    getDataViewMemory0().setInt32(arg0 + 4 * 0, !isLikeNone(ret), true);
+}
+export function __wbg___wbindgen_throw_be289d5034ed271b(arg0, arg1) {
+    throw new Error(getStringFromWasm0(arg0, arg1));
+}
+export function __wbg_get_9b94d73e6221f75c(arg0, arg1) {
+    const ret = arg0[arg1 >>> 0];
+    return ret;
+}
+export function __wbg_get_b3ed3ad4be2bc8ac() { return handleError(function (arg0, arg1) {
+    const ret = Reflect.get(arg0, arg1);
+    return ret;
+}, arguments); }
+export function __wbg_isArray_d314bb98fcf08331(arg0) {
+    const ret = Array.isArray(arg0);
+    return ret;
+}
+export function __wbg_length_35a7bace40f36eac(arg0) {
+    const ret = arg0.length;
+    return ret;
+}
+export function __wbg_new_361308b2356cecd0() {
+    const ret = new Object();
+    return ret;
+}
+export function __wbg_new_3eb36ae241fe6f44() {
+    const ret = new Array();
+    return ret;
+}
+export function __wbg_push_8ffdcb2063340ba5(arg0, arg1) {
+    const ret = arg0.push(arg1);
+    return ret;
+}
+export function __wbg_set_6cb8631f80447a67() { return handleError(function (arg0, arg1, arg2) {
+    const ret = Reflect.set(arg0, arg1, arg2);
+    return ret;
+}, arguments); }
+export function __wbindgen_cast_0000000000000001(arg0) {
+    // Cast intrinsic for `F64 -> Externref`.
+    const ret = arg0;
+    return ret;
+}
+export function __wbindgen_cast_0000000000000002(arg0, arg1) {
+    // Cast intrinsic for `Ref(String) -> Externref`.
+    const ret = getStringFromWasm0(arg0, arg1);
+    return ret;
+}
+export function __wbindgen_init_externref_table() {
+    const table = wasm.__wbindgen_externrefs;
+    const offset = table.grow(4);
+    table.set(0, undefined);
+    table.set(offset + 0, undefined);
+    table.set(offset + 1, null);
+    table.set(offset + 2, true);
+    table.set(offset + 3, false);
+}
+const RBushFinalization = (typeof FinalizationRegistry === 'undefined')
+    ? { register: () => {}, unregister: () => {} }
+    : new FinalizationRegistry(ptr => wasm.__wbg_rbush_free(ptr >>> 0, 1));
+
+function addToExternrefTable0(obj) {
+    const idx = wasm.__externref_table_alloc();
+    wasm.__wbindgen_externrefs.set(idx, obj);
+    return idx;
+}
+
+let cachedDataViewMemory0 = null;
+function getDataViewMemory0() {
+    if (cachedDataViewMemory0 === null || cachedDataViewMemory0.buffer.detached === true || (cachedDataViewMemory0.buffer.detached === undefined && cachedDataViewMemory0.buffer !== wasm.memory.buffer)) {
+        cachedDataViewMemory0 = new DataView(wasm.memory.buffer);
+    }
+    return cachedDataViewMemory0;
+}
+
+let cachedFloat64ArrayMemory0 = null;
+function getFloat64ArrayMemory0() {
+    if (cachedFloat64ArrayMemory0 === null || cachedFloat64ArrayMemory0.byteLength === 0) {
+        cachedFloat64ArrayMemory0 = new Float64Array(wasm.memory.buffer);
+    }
+    return cachedFloat64ArrayMemory0;
+}
+
+function getStringFromWasm0(ptr, len) {
+    ptr = ptr >>> 0;
+    return decodeText(ptr, len);
+}
+
+let cachedUint8ArrayMemory0 = null;
+function getUint8ArrayMemory0() {
+    if (cachedUint8ArrayMemory0 === null || cachedUint8ArrayMemory0.byteLength === 0) {
+        cachedUint8ArrayMemory0 = new Uint8Array(wasm.memory.buffer);
+    }
+    return cachedUint8ArrayMemory0;
+}
+
+function handleError(f, args) {
+    try {
+        return f.apply(this, args);
+    } catch (e) {
+        const idx = addToExternrefTable0(e);
+        wasm.__wbindgen_exn_store(idx);
+    }
+}
+
+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();
+const MAX_SAFARI_DECODE_BYTES = 2146435072;
+let numBytesDecoded = 0;
+function decodeText(ptr, len) {
+    numBytesDecoded += len;
+    if (numBytesDecoded >= MAX_SAFARI_DECODE_BYTES) {
+        cachedTextDecoder = new TextDecoder('utf-8', { ignoreBOM: true, fatal: true });
+        cachedTextDecoder.decode();
+        numBytesDecoded = len;
+    }
+    return cachedTextDecoder.decode(getUint8ArrayMemory0().subarray(ptr, ptr + len));
+}
+
+let WASM_VECTOR_LEN = 0;
+
+
+let wasm;
+export function __wbg_set_wasm(val) {
+    wasm = val;
+}