@ifc-lite/wasm 2.2.0 → 2.3.0

package/package.json

@@ -5,7 +5,7 @@
     "IFC-Lite Contributors"
   ],
   "description": "WebAssembly bindings for IFC-Lite",
-  "version": "2.2.0",
+  "version": "2.3.0",
   "license": "MPL-2.0",
   "repository": {
     "type": "git",

package/pkg/ifc-lite.d.ts

@@ -228,6 +228,17 @@ export class IfcAPI {
    * fail fast.
    */
   clearPrePassCache(): void;
+  /**
+   * Enable or disable per-entity geometry fingerprinting in
+   * `processGeometryBatch`, used by the viewer's revision-diff feature.
+   *
+   * Pass a positive `tolerance` (metres) to enable — it is the quantization
+   * grid the hash snaps positions to (larger = more tolerant of float noise,
+   * smaller = catches finer edits; the `f32` precision floor of model-local
+   * coordinates means values below ~1 mm mostly hash noise). Pass `null`/
+   * `undefined` (or a non-positive value) to disable. Default: disabled.
+   */
+  setComputeGeometryHashes(tolerance?: number | null): void;
   /**
    * Create and initialize the IFC API
    */
@@ -350,6 +361,23 @@ export class MeshCollection {
    * Returns None if no rotation was detected
    */
   readonly buildingRotation: number | undefined;
+  /**
+   * Express ids for the per-entity geometry fingerprints, parallel to
+   * [`Self::geometry_hash_values`]. Empty unless geometry hashing was
+   * enabled via `IfcAPI.setComputeGeometryHashes`.
+   */
+  readonly geometryHashIds: Uint32Array;
+  /**
+   * Number of per-entity geometry fingerprints recorded.
+   */
+  readonly geometryHashCount: number;
+  /**
+   * Per-entity geometry fingerprints as a `BigUint64Array`, parallel to
+   * [`Self::geometry_hash_ids`]. `u64` is exposed (not hex strings) so JS
+   * can compare with `===` and key maps without allocation. Empty unless
+   * geometry hashing was enabled.
+   */
+  readonly geometryHashValues: BigUint64Array;
   /**
    * Get number of meshes
    */
@@ -720,10 +748,14 @@ export interface InitOutput {
   readonly ifcapi_scanEntitiesFastBytes: (a: number, b: number, c: number) => number;
   readonly ifcapi_scanGeometryEntitiesFast: (a: number, b: number, c: number) => number;
   readonly ifcapi_scanRelevantEntitiesFastBytes: (a: number, b: number, c: number) => number;
+  readonly ifcapi_setComputeGeometryHashes: (a: number, b: number, c: number) => void;
   readonly ifcapi_setEntityIndex: (a: number, b: number, c: number, d: number, e: number, f: number, g: number) => void;
   readonly ifcapi_setMergeLayers: (a: number, b: number) => void;
   readonly ifcapi_version: (a: number, b: number) => void;
   readonly meshcollection_buildingRotation: (a: number, b: number) => void;
+  readonly meshcollection_geometryHashCount: (a: number) => number;
+  readonly meshcollection_geometryHashIds: (a: number) => number;
+  readonly meshcollection_geometryHashValues: (a: number) => number;
   readonly meshcollection_get: (a: number, b: number) => number;
   readonly meshcollection_hasRtcOffset: (a: number) => number;
   readonly meshcollection_length: (a: number) => number;
@@ -824,9 +856,9 @@ export interface InitOutput {
   readonly symbolictext_worldY: (a: number) => number;
   readonly symbolictext_x: (a: number) => number;
   readonly symbolictext_y: (a: number) => number;
-  readonly __wasm_bindgen_func_elem_654: (a: number, b: number, c: number) => void;
-  readonly __wasm_bindgen_func_elem_653: (a: number, b: number) => void;
-  readonly __wasm_bindgen_func_elem_688: (a: number, b: number, c: number, d: number) => void;
+  readonly __wasm_bindgen_func_elem_666: (a: number, b: number, c: number) => void;
+  readonly __wasm_bindgen_func_elem_665: (a: number, b: number) => void;
+  readonly __wasm_bindgen_func_elem_700: (a: number, b: number, c: number, d: number) => void;
   readonly __wbindgen_export: (a: number) => void;
   readonly __wbindgen_export2: (a: number, b: number, c: number) => void;
   readonly __wbindgen_export3: (a: number, b: number) => number;

package/pkg/ifc-lite.js

@@ -40,11 +40,24 @@ function getArrayU32FromWasm0(ptr, len) {
     return getUint32ArrayMemory0().subarray(ptr / 4, ptr / 4 + len);
 }
 
+function getArrayU64FromWasm0(ptr, len) {
+    ptr = ptr >>> 0;
+    return getBigUint64ArrayMemory0().subarray(ptr / 8, ptr / 8 + len);
+}
+
 function getArrayU8FromWasm0(ptr, len) {
     ptr = ptr >>> 0;
     return getUint8ArrayMemory0().subarray(ptr / 1, ptr / 1 + len);
 }
 
+let cachedBigUint64ArrayMemory0 = null;
+function getBigUint64ArrayMemory0() {
+    if (cachedBigUint64ArrayMemory0 === null || cachedBigUint64ArrayMemory0.byteLength === 0) {
+        cachedBigUint64ArrayMemory0 = new BigUint64Array(wasm.memory.buffer);
+    }
+    return cachedBigUint64ArrayMemory0;
+}
+
 let cachedDataViewMemory0 = null;
 function getDataViewMemory0() {
     if (cachedDataViewMemory0 === null || cachedDataViewMemory0.buffer.detached === true || (cachedDataViewMemory0.buffer.detached === undefined && cachedDataViewMemory0.buffer !== wasm.memory.buffer)) {
@@ -232,12 +245,12 @@ if (!('encodeInto' in cachedTextEncoder)) {
 
 let WASM_VECTOR_LEN = 0;
 
-function __wasm_bindgen_func_elem_654(arg0, arg1, arg2) {
-    wasm.__wasm_bindgen_func_elem_654(arg0, arg1, addHeapObject(arg2));
+function __wasm_bindgen_func_elem_666(arg0, arg1, arg2) {
+    wasm.__wasm_bindgen_func_elem_666(arg0, arg1, addHeapObject(arg2));
 }
 
-function __wasm_bindgen_func_elem_688(arg0, arg1, arg2, arg3) {
-    wasm.__wasm_bindgen_func_elem_688(arg0, arg1, addHeapObject(arg2), addHeapObject(arg3));
+function __wasm_bindgen_func_elem_700(arg0, arg1, arg2, arg3) {
+    wasm.__wasm_bindgen_func_elem_700(arg0, arg1, addHeapObject(arg2), addHeapObject(arg3));
 }
 
 const ClashRunResultFinalization = (typeof FinalizationRegistry === 'undefined')
@@ -886,6 +899,20 @@ export class IfcAPI {
     clearPrePassCache() {
         wasm.ifcapi_clearPrePassCache(this.__wbg_ptr);
     }
+    /**
+     * Enable or disable per-entity geometry fingerprinting in
+     * `processGeometryBatch`, used by the viewer's revision-diff feature.
+     *
+     * Pass a positive `tolerance` (metres) to enable — it is the quantization
+     * grid the hash snaps positions to (larger = more tolerant of float noise,
+     * smaller = catches finer edits; the `f32` precision floor of model-local
+     * coordinates means values below ~1 mm mostly hash noise). Pass `null`/
+     * `undefined` (or a non-positive value) to disable. Default: disabled.
+     * @param {number | null} [tolerance]
+     */
+    setComputeGeometryHashes(tolerance) {
+        wasm.ifcapi_setComputeGeometryHashes(this.__wbg_ptr, !isLikeNone(tolerance), isLikeNone(tolerance) ? 0 : tolerance);
+    }
     /**
      * Create and initialize the IFC API
      */
@@ -1148,6 +1175,35 @@ export class MeshCollection {
             wasm.__wbindgen_add_to_stack_pointer(16);
         }
     }
+    /**
+     * Express ids for the per-entity geometry fingerprints, parallel to
+     * [`Self::geometry_hash_values`]. Empty unless geometry hashing was
+     * enabled via `IfcAPI.setComputeGeometryHashes`.
+     * @returns {Uint32Array}
+     */
+    get geometryHashIds() {
+        const ret = wasm.meshcollection_geometryHashIds(this.__wbg_ptr);
+        return takeObject(ret);
+    }
+    /**
+     * Number of per-entity geometry fingerprints recorded.
+     * @returns {number}
+     */
+    get geometryHashCount() {
+        const ret = wasm.meshcollection_geometryHashCount(this.__wbg_ptr);
+        return ret >>> 0;
+    }
+    /**
+     * Per-entity geometry fingerprints as a `BigUint64Array`, parallel to
+     * [`Self::geometry_hash_ids`]. `u64` is exposed (not hex strings) so JS
+     * can compare with `===` and key maps without allocation. Empty unless
+     * geometry hashing was enabled.
+     * @returns {BigUint64Array}
+     */
+    get geometryHashValues() {
+        const ret = wasm.meshcollection_geometryHashValues(this.__wbg_ptr);
+        return takeObject(ret);
+    }
     /**
      * Get mesh at index
      * @param {number} index
@@ -2379,7 +2435,7 @@ function __wbg_get_imports() {
                 const a = state0.a;
                 state0.a = 0;
                 try {
-                    return __wasm_bindgen_func_elem_688(a, state0.b, arg0, arg1);
+                    return __wasm_bindgen_func_elem_700(a, state0.b, arg0, arg1);
                 } finally {
                     state0.a = a;
                 }
@@ -2394,6 +2450,10 @@ function __wbg_get_imports() {
         const ret = new Float32Array(getArrayF32FromWasm0(arg0, arg1));
         return addHeapObject(ret);
     };
+    imports.wbg.__wbg_new_from_slice_883d10a76ca46292 = function(arg0, arg1) {
+        const ret = new BigUint64Array(getArrayU64FromWasm0(arg0, arg1));
+        return addHeapObject(ret);
+    };
     imports.wbg.__wbg_new_from_slice_db0691b69e9d3891 = function(arg0, arg1) {
         const ret = new Uint32Array(getArrayU32FromWasm0(arg0, arg1));
         return addHeapObject(ret);
@@ -2478,16 +2538,16 @@ function __wbg_get_imports() {
     imports.wbg.__wbg_warn_6e567d0d926ff881 = function(arg0) {
         console.warn(getObject(arg0));
     };
+    imports.wbg.__wbindgen_cast_0093e2d96a856a3b = function(arg0, arg1) {
+        // Cast intrinsic for `Closure(Closure { dtor_idx: 61, function: Function { arguments: [Externref], shim_idx: 62, ret: Unit, inner_ret: Some(Unit) }, mutable: true }) -> Externref`.
+        const ret = makeMutClosure(arg0, arg1, wasm.__wasm_bindgen_func_elem_665, __wasm_bindgen_func_elem_666);
+        return addHeapObject(ret);
+    };
     imports.wbg.__wbindgen_cast_2241b6af4c4b2941 = function(arg0, arg1) {
         // Cast intrinsic for `Ref(String) -> Externref`.
         const ret = getStringFromWasm0(arg0, arg1);
         return addHeapObject(ret);
     };
-    imports.wbg.__wbindgen_cast_257c51b8abf9285e = function(arg0, arg1) {
-        // Cast intrinsic for `Closure(Closure { dtor_idx: 57, function: Function { arguments: [Externref], shim_idx: 58, ret: Unit, inner_ret: Some(Unit) }, mutable: true }) -> Externref`.
-        const ret = makeMutClosure(arg0, arg1, wasm.__wasm_bindgen_func_elem_653, __wasm_bindgen_func_elem_654);
-        return addHeapObject(ret);
-    };
     imports.wbg.__wbindgen_cast_4625c577ab2ec9ee = function(arg0) {
         // Cast intrinsic for `U64 -> Externref`.
         const ret = BigInt.asUintN(64, arg0);
@@ -2512,6 +2572,7 @@ function __wbg_get_imports() {
 function __wbg_finalize_init(instance, module) {
     wasm = instance.exports;
     __wbg_init.__wbindgen_wasm_module = module;
+    cachedBigUint64ArrayMemory0 = null;
     cachedDataViewMemory0 = null;
     cachedFloat32ArrayMemory0 = null;
     cachedFloat64ArrayMemory0 = null;