@ifc-lite/wasm 2.2.0 → 2.4.0

package/package.json

@@ -5,7 +5,7 @@
     "IFC-Lite Contributors"
   ],
   "description": "WebAssembly bindings for IFC-Lite",
-  "version": "2.2.0",
+  "version": "2.4.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
    */
@@ -383,6 +411,12 @@ export class MeshDataJs {
    */
   readonly shadingColor: Float32Array | undefined;
   readonly textureWidth: number;
+  /**
+   * Geometry provenance for the viewer's Model/Types switch (#957 follow-up):
+   * 0 = occurrence, 1 = orphan type geometry (no occurrence), 2 = instanced
+   * type geometry (hidden in Model mode, shown in Types mode).
+   */
+  readonly geometryClass: number;
   readonly textureHeight: number;
   /**
    * Get triangle count
@@ -423,6 +457,30 @@ export class MeshDataJs {
   readonly positions: Float32Array;
 }
 
+export class MeshOutlineJs {
+  private constructor();
+  free(): void;
+  [Symbol.dispose](): void;
+  /**
+   * Ring `i` as a flat `[u0, v0, u1, v1, …]` array, or `undefined` if out of
+   * range. The ring is closed implicitly (connect the last point to the
+   * first).
+   */
+  contour(index: number): Float32Array | undefined;
+  /**
+   * Number of boundary rings (outer + holes).
+   */
+  readonly contourCount: number;
+  /**
+   * Element extent (max) along the cut axis, world units.
+   */
+  readonly axisMax: number;
+  /**
+   * Element extent (min) along the cut axis, world units.
+   */
+  readonly axisMin: number;
+}
+
 export class ProfileCollection {
   private constructor();
   free(): void;
@@ -651,6 +709,25 @@ export function get_memory(): any;
  */
 export function init(): void;
 
+/**
+ * Compute the winding-robust 2D footprint outline of a triangle mesh.
+ *
+ * `positions` is flat XYZ; `indices` is flat triangle indices. `axis` is
+ * 0/1/2 = x/y/z (the cut axis, WebGL Y-up). Returns `undefined` when the mesh
+ * has no triangles or projects to nothing.
+ *
+ * ```javascript
+ * const outline = meshOutline2d(positions, indices, 1, false); // axis 1 = y
+ * if (outline) {
+ *   for (let i = 0; i < outline.contourCount; i++) {
+ *     const ring = outline.contour(i); // Float32Array of [u0, v0, u1, v1, ...]
+ *   }
+ *   outline.free();
+ * }
+ * ```
+ */
+export function meshOutline2d(positions: Float32Array, indices: Uint32Array, axis: number, flipped: boolean): MeshOutlineJs | undefined;
+
 /**
  * Get the version of IFC-Lite.
  *
@@ -677,6 +754,7 @@ export interface InitOutput {
   readonly __wbg_ifcapi_free: (a: number, b: number) => void;
   readonly __wbg_meshcollection_free: (a: number, b: number) => void;
   readonly __wbg_meshdatajs_free: (a: number, b: number) => void;
+  readonly __wbg_meshoutlinejs_free: (a: number, b: number) => void;
   readonly __wbg_profilecollection_free: (a: number, b: number) => void;
   readonly __wbg_profileentryjs_free: (a: number, b: number) => void;
   readonly __wbg_symboliccircle_free: (a: number, b: number) => void;
@@ -720,10 +798,15 @@ 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 meshOutline2d: (a: number, b: number, c: number, d: number, e: number, f: number) => number;
   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;
@@ -735,6 +818,7 @@ export interface InitOutput {
   readonly meshcollection_totalVertices: (a: number) => number;
   readonly meshdatajs_color: (a: number, b: number) => void;
   readonly meshdatajs_expressId: (a: number) => number;
+  readonly meshdatajs_geometryClass: (a: number) => number;
   readonly meshdatajs_hasTexture: (a: number) => number;
   readonly meshdatajs_ifcType: (a: number, b: number) => void;
   readonly meshdatajs_indices: (a: number) => number;
@@ -749,6 +833,10 @@ export interface InitOutput {
   readonly meshdatajs_triangleCount: (a: number) => number;
   readonly meshdatajs_uvs: (a: number) => number;
   readonly meshdatajs_vertexCount: (a: number) => number;
+  readonly meshoutlinejs_axisMax: (a: number) => number;
+  readonly meshoutlinejs_axisMin: (a: number) => number;
+  readonly meshoutlinejs_contour: (a: number, b: number) => number;
+  readonly meshoutlinejs_contourCount: (a: number) => number;
   readonly profilecollection_get: (a: number, b: number) => number;
   readonly profilecollection_length: (a: number) => number;
   readonly profileentryjs_expressId: (a: number) => number;
@@ -824,9 +912,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_675: (a: number, b: number, c: number) => void;
+  readonly __wasm_bindgen_func_elem_674: (a: number, b: number) => void;
+  readonly __wasm_bindgen_func_elem_709: (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_675(arg0, arg1, arg2) {
+    wasm.__wasm_bindgen_func_elem_675(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_709(arg0, arg1, arg2, arg3) {
+    wasm.__wasm_bindgen_func_elem_709(arg0, arg1, addHeapObject(arg2), addHeapObject(arg3));
 }
 
 const ClashRunResultFinalization = (typeof FinalizationRegistry === 'undefined')
@@ -268,6 +281,10 @@ const MeshDataJsFinalization = (typeof FinalizationRegistry === 'undefined')
     ? { register: () => {}, unregister: () => {} }
     : new FinalizationRegistry(ptr => wasm.__wbg_meshdatajs_free(ptr >>> 0, 1));
 
+const MeshOutlineJsFinalization = (typeof FinalizationRegistry === 'undefined')
+    ? { register: () => {}, unregister: () => {} }
+    : new FinalizationRegistry(ptr => wasm.__wbg_meshoutlinejs_free(ptr >>> 0, 1));
+
 const ProfileCollectionFinalization = (typeof FinalizationRegistry === 'undefined')
     ? { register: () => {}, unregister: () => {} }
     : new FinalizationRegistry(ptr => wasm.__wbg_profilecollection_free(ptr >>> 0, 1));
@@ -886,6 +903,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 +1179,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
@@ -1250,6 +1310,16 @@ export class MeshDataJs {
         const ret = wasm.meshdatajs_textureWidth(this.__wbg_ptr);
         return ret >>> 0;
     }
+    /**
+     * Geometry provenance for the viewer's Model/Types switch (#957 follow-up):
+     * 0 = occurrence, 1 = orphan type geometry (no occurrence), 2 = instanced
+     * type geometry (hidden in Model mode, shown in Types mode).
+     * @returns {number}
+     */
+    get geometryClass() {
+        const ret = wasm.meshdatajs_geometryClass(this.__wbg_ptr);
+        return ret;
+    }
     /**
      * @returns {number}
      */
@@ -1354,6 +1424,70 @@ export class MeshDataJs {
 }
 if (Symbol.dispose) MeshDataJs.prototype[Symbol.dispose] = MeshDataJs.prototype.free;
 
+/**
+ * A mesh's projected footprint outline.
+ *
+ * Contours are closed rings in drawing 2D space (same basis as `projectTo2D`
+ * in `@ifc-lite/drawing-2d`), WITHOUT a duplicated closing vertex.
+ * `axisMin`/`axisMax` are the element's extent along the cut axis (world
+ * units, not flip-adjusted) for band classification on the TS side.
+ */
+export class MeshOutlineJs {
+    static __wrap(ptr) {
+        ptr = ptr >>> 0;
+        const obj = Object.create(MeshOutlineJs.prototype);
+        obj.__wbg_ptr = ptr;
+        MeshOutlineJsFinalization.register(obj, obj.__wbg_ptr, obj);
+        return obj;
+    }
+    __destroy_into_raw() {
+        const ptr = this.__wbg_ptr;
+        this.__wbg_ptr = 0;
+        MeshOutlineJsFinalization.unregister(this);
+        return ptr;
+    }
+    free() {
+        const ptr = this.__destroy_into_raw();
+        wasm.__wbg_meshoutlinejs_free(ptr, 0);
+    }
+    /**
+     * Number of boundary rings (outer + holes).
+     * @returns {number}
+     */
+    get contourCount() {
+        const ret = wasm.meshoutlinejs_contourCount(this.__wbg_ptr);
+        return ret >>> 0;
+    }
+    /**
+     * Ring `i` as a flat `[u0, v0, u1, v1, …]` array, or `undefined` if out of
+     * range. The ring is closed implicitly (connect the last point to the
+     * first).
+     * @param {number} index
+     * @returns {Float32Array | undefined}
+     */
+    contour(index) {
+        const ret = wasm.meshoutlinejs_contour(this.__wbg_ptr, index);
+        return takeObject(ret);
+    }
+    /**
+     * Element extent (max) along the cut axis, world units.
+     * @returns {number}
+     */
+    get axisMax() {
+        const ret = wasm.meshoutlinejs_axisMax(this.__wbg_ptr);
+        return ret;
+    }
+    /**
+     * Element extent (min) along the cut axis, world units.
+     * @returns {number}
+     */
+    get axisMin() {
+        const ret = wasm.meshoutlinejs_axisMin(this.__wbg_ptr);
+        return ret;
+    }
+}
+if (Symbol.dispose) MeshOutlineJs.prototype[Symbol.dispose] = MeshOutlineJs.prototype.free;
+
 /**
  * A collection of extracted profiles.
  */
@@ -2250,6 +2384,37 @@ export function init() {
     wasm.init();
 }
 
+/**
+ * Compute the winding-robust 2D footprint outline of a triangle mesh.
+ *
+ * `positions` is flat XYZ; `indices` is flat triangle indices. `axis` is
+ * 0/1/2 = x/y/z (the cut axis, WebGL Y-up). Returns `undefined` when the mesh
+ * has no triangles or projects to nothing.
+ *
+ * ```javascript
+ * const outline = meshOutline2d(positions, indices, 1, false); // axis 1 = y
+ * if (outline) {
+ *   for (let i = 0; i < outline.contourCount; i++) {
+ *     const ring = outline.contour(i); // Float32Array of [u0, v0, u1, v1, ...]
+ *   }
+ *   outline.free();
+ * }
+ * ```
+ * @param {Float32Array} positions
+ * @param {Uint32Array} indices
+ * @param {number} axis
+ * @param {boolean} flipped
+ * @returns {MeshOutlineJs | undefined}
+ */
+export function meshOutline2d(positions, indices, axis, flipped) {
+    const ptr0 = passArrayF32ToWasm0(positions, wasm.__wbindgen_export3);
+    const len0 = WASM_VECTOR_LEN;
+    const ptr1 = passArray32ToWasm0(indices, wasm.__wbindgen_export3);
+    const len1 = WASM_VECTOR_LEN;
+    const ret = wasm.meshOutline2d(ptr0, len0, ptr1, len1, axis, flipped);
+    return ret === 0 ? undefined : MeshOutlineJs.__wrap(ret);
+}
+
 /**
  * Get the version of IFC-Lite.
  *
@@ -2379,7 +2544,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_709(a, state0.b, arg0, arg1);
                 } finally {
                     state0.a = a;
                 }
@@ -2394,6 +2559,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 +2647,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_674, __wasm_bindgen_func_elem_675);
+        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 +2681,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;