@ifc-lite/wasm 9.3.0 → 10.1.0

package/package.json

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

package/pkg/ifc-lite.d.ts

@@ -221,6 +221,7 @@ export class ClashRunResult {
     readonly a: Uint32Array;
     readonly b: Uint32Array;
     readonly bounds: Float64Array;
+    readonly depthFloor: Float64Array;
     readonly distance: Float64Array;
     readonly distanceKind: Uint8Array;
     readonly points: Float64Array;
@@ -245,11 +246,15 @@ export class ClashSession {
     ingest(positions: Float32Array, pos_ranges: Uint32Array, indices: Uint32Array, idx_ranges: Uint32Array, aabbs: Float32Array): void;
     constructor();
     /**
-     * Run one rule. `group_a`/`group_b` are GLOBAL element indices; an empty
-     * `group_b` means a self-clash within `group_a`. `mode`: 0 = hard,
-     * 1 = clearance. Records carry GLOBAL element indices.
+     * Run one rule. `group_a`/`group_b` are GLOBAL element indices.
+     * OMIT `group_b` (pass `undefined`/`null`) for a self-clash within
+     * `group_a`; pass an array -- INCLUDING an empty one -- for a two-sided
+     * rule. An empty array is a B side that matched nothing and yields no
+     * clashes, which is why this is nullable rather than "empty means
+     * self" (#5354). `mode`: 0 = hard, 1 = clearance. Records carry GLOBAL
+     * element indices.
      */
-    runRule(group_a: Uint32Array, group_b: Uint32Array, mode: number, tolerance: number, clearance: number, report_touch: boolean): ClashRunResult;
+    runRule(group_a: Uint32Array, group_b: Uint32Array | null | undefined, mode: number, tolerance: number, clearance: number, report_touch: boolean): ClashRunResult;
 }
 
 /**
@@ -2326,6 +2331,7 @@ export interface InitOutput {
     readonly clashrunresult_a: (a: number, b: number) => void;
     readonly clashrunresult_b: (a: number, b: number) => void;
     readonly clashrunresult_bounds: (a: number, b: number) => void;
+    readonly clashrunresult_depthFloor: (a: number, b: number) => void;
     readonly clashrunresult_distance: (a: number, b: number) => void;
     readonly clashrunresult_distanceKind: (a: number, b: number) => void;
     readonly clashrunresult_points: (a: number, b: number) => void;

package/pkg/ifc-lite.js

@@ -223,6 +223,22 @@ export class ClashRunResult {
             wasm.__wbindgen_add_to_stack_pointer(16);
         }
     }
+    /**
+     * @returns {Float64Array}
+     */
+    get depthFloor() {
+        try {
+            const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
+            wasm.clashrunresult_depthFloor(retptr, this.__wbg_ptr);
+            var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
+            var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
+            var v1 = getArrayF64FromWasm0(r0, r1).slice();
+            wasm.__wbindgen_export4(r0, r1 * 8, 8);
+            return v1;
+        } finally {
+            wasm.__wbindgen_add_to_stack_pointer(16);
+        }
+    }
     /**
      * @returns {Float64Array}
      */
@@ -338,11 +354,15 @@ export class ClashSession {
         return this;
     }
     /**
-     * Run one rule. `group_a`/`group_b` are GLOBAL element indices; an empty
-     * `group_b` means a self-clash within `group_a`. `mode`: 0 = hard,
-     * 1 = clearance. Records carry GLOBAL element indices.
+     * Run one rule. `group_a`/`group_b` are GLOBAL element indices.
+     * OMIT `group_b` (pass `undefined`/`null`) for a self-clash within
+     * `group_a`; pass an array -- INCLUDING an empty one -- for a two-sided
+     * rule. An empty array is a B side that matched nothing and yields no
+     * clashes, which is why this is nullable rather than "empty means
+     * self" (#5354). `mode`: 0 = hard, 1 = clearance. Records carry GLOBAL
+     * element indices.
      * @param {Uint32Array} group_a
-     * @param {Uint32Array} group_b
+     * @param {Uint32Array | null | undefined} group_b
      * @param {number} mode
      * @param {number} tolerance
      * @param {number} clearance
@@ -352,8 +372,8 @@ export class ClashSession {
     runRule(group_a, group_b, mode, tolerance, clearance, report_touch) {
         const ptr0 = passArray32ToWasm0(group_a, wasm.__wbindgen_export);
         const len0 = WASM_VECTOR_LEN;
-        const ptr1 = passArray32ToWasm0(group_b, wasm.__wbindgen_export);
-        const len1 = WASM_VECTOR_LEN;
+        var ptr1 = isLikeNone(group_b) ? 0 : passArray32ToWasm0(group_b, wasm.__wbindgen_export);
+        var len1 = WASM_VECTOR_LEN;
         const ret = wasm.clashsession_runRule(this.__wbg_ptr, ptr0, len0, ptr1, len1, mode, tolerance, clearance, report_touch);
         return ClashRunResult.__wrap(ret);
     }