@ifc-lite/wasm 2.8.1 → 2.9.1

package/package.json

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

package/pkg/ifc-lite.d.ts

@@ -554,10 +554,53 @@ export class SpacePlateHandle {
    * surviving room.
    */
   mergeFaces(edge: number): any;
+  /**
+   * The face outline offset to a wall boundary, as flat `[x0, y0, …]`: each
+   * edge is moved by its own wall's half-thickness — inward when `inset`
+   * (the net / inner face), outward otherwise (the gross / outer face).
+   * Shared room↔room edges are pinned when pushing outward. Falls back to the
+   * centreline outline when no offset applies — so it's always a sane ring.
+   * (For a `center` boundary just use `faceOutline`.)
+   */
+  netOutline(face: number, inset: boolean): Float64Array;
+  /**
+   * Remove a wall edge, choosing the right semantics from its two faces:
+   * two real rooms → union them; a bridge / spur / outer-only wall → delete
+   * it and auto-clean the orphaned inner lines and nodes it leaves; a real
+   * enclosing wall (room ↔ exterior) → rejected (`BordersExterior`). This is
+   * the "remove this wall and tidy up" affordance for the orphan cruft the
+   * non-destructive wall arrangement leaves behind. Returns the rooms it
+   * changed (empty if the edge bounded no room).
+   */
+  removeEdge(edge: number): any;
   /**
    * Flat outline `[x0, y0, x1, y1, …]` of a face (no repeated closing vertex).
    */
   faceOutline(face: number): Float64Array;
+  /**
+   * Face-based gap-room boundary as flat `[x0, y0, …]`: each edge pushed
+   * OUTWARD (into the wall) by `factor × the source wall's half-thickness`.
+   * `0` → net (the gap / inner faces); `1` → centre axis (½ thickness, the
+   * editable node line on the wall mid); `2` → gross outer face.
+   */
+  gapBoundary(face: number, factor: number): Float64Array;
+  /**
+   * Dissolve a degree-2 vertex, welding its two edges into one straight
+   * edge between the neighbours — the inverse of `splitEdge`, and the
+   * "delete this corner / node" affordance. Returns the rooms it changed.
+   * Rejects a wall junction (degree ≥ 3) or a weld that would duplicate an
+   * edge.
+   */
+  dissolveVertex(v: number): any;
+  /**
+   * FACE-BASED build: rooms are the gaps between wall footprint rectangles.
+   * `rectCoords` is flat `[x0, y0, x1, y1, x2, y2, x3, y3, …]` — 8 f64 per wall
+   * (its 4 plan-rectangle corners, CCW). A bounded arrangement face is a room
+   * only if its centroid is outside every rectangle (a gap, not a wall
+   * interior). The room outline IS the net (inner-face) area; `gapBoundary`
+   * gives the centre axis (½ thickness) and the gross outer face.
+   */
+  static fromWallRects(rect_coords: Float64Array, snap_tolerance: number, min_area: number): SpacePlateHandle;
   /**
    * The room on the far side of a half-edge (its twin's face), or
    * `undefined`. O(1) — the "who's across this wall" query.
@@ -582,9 +625,27 @@ export class SpacePlateHandle {
    *
    * `segCoords`: `[ax, ay, bx, by, …]` (length a multiple of 4).
    * `segSources`: one `i32` per segment, `-1` for none.
+   * `segHalfThickness`: one `f64` per segment — half the wall's thickness in
+   * metres, carried onto the derived edges for `netOutline`. Pass an empty
+   * array (or all zeros) when thickness is unknown (centreline only).
    * `snapTolerance` / `minArea`: pass `<= 0` to take the defaults.
    */
-  constructor(seg_coords: Float64Array, seg_sources: Int32Array, snap_tolerance: number, min_area: number);
+  constructor(seg_coords: Float64Array, seg_sources: Int32Array, seg_half_thickness: Float64Array, snap_tolerance: number, min_area: number);
+  /**
+   * Sweep the whole plate clean: remove dangling spur walls, isolated nodes,
+   * and redundant collinear nodes — the "clean up orphans" / eraser action.
+   * Area-neutral and idempotent. Returns how many topology elements were
+   * pruned (0 = the plate was already clean); the caller re-renders via
+   * `snapshot` like any other edit.
+   */
+  prune(): number;
+  /**
+   * Author a new room from a flat ring `[x0, y0, x1, y1, …]` (no repeated
+   * closing vertex). `source` `-1` marks a user-drawn room. Winding is
+   * normalised to CCW; returns the new room patch. The room is its own
+   * connected component — it does not merge into existing topology.
+   */
+  addFace(coords: Float64Array, source: number): any;
   /**
    * Face ids of every live room.
    */
@@ -916,15 +977,22 @@ export interface InitOutput {
   readonly profileentryjs_modelIndex: (a: number) => number;
   readonly profileentryjs_outerPoints: (a: number) => number;
   readonly profileentryjs_transform: (a: number) => number;
+  readonly spaceplatehandle_addFace: (a: number, b: number, c: number, d: number, e: number) => void;
   readonly spaceplatehandle_boundingElements: (a: number, b: number, c: number) => void;
+  readonly spaceplatehandle_dissolveVertex: (a: number, b: number, c: number) => void;
   readonly spaceplatehandle_dragVertex: (a: number, b: number, c: number, d: number, e: number) => void;
   readonly spaceplatehandle_duplicate: (a: number) => number;
   readonly spaceplatehandle_faceArea: (a: number, b: number) => number;
   readonly spaceplatehandle_faceOutline: (a: number, b: number, c: number) => void;
   readonly spaceplatehandle_findVertexNear: (a: number, b: number, c: number, d: number) => number;
+  readonly spaceplatehandle_fromWallRects: (a: number, b: number, c: number, d: number, e: number) => void;
+  readonly spaceplatehandle_gapBoundary: (a: number, b: number, c: number, d: number) => void;
   readonly spaceplatehandle_mergeFaces: (a: number, b: number, c: number) => void;
   readonly spaceplatehandle_neighborAcross: (a: number, b: number) => number;
-  readonly spaceplatehandle_new: (a: number, b: number, c: number, d: number, e: number, f: number, g: number) => void;
+  readonly spaceplatehandle_netOutline: (a: number, b: number, c: number, d: number) => void;
+  readonly spaceplatehandle_new: (a: number, b: number, c: number, d: number, e: number, f: number, g: number, h: number, i: number) => void;
+  readonly spaceplatehandle_prune: (a: number) => number;
+  readonly spaceplatehandle_removeEdge: (a: number, b: number, c: number) => void;
   readonly spaceplatehandle_roomCount: (a: number) => number;
   readonly spaceplatehandle_roomIds: (a: number, b: number) => void;
   readonly spaceplatehandle_setFaceHeight: (a: number, b: number, c: number, d: number, e: number) => void;

package/pkg/ifc-lite.js

@@ -1728,6 +1728,56 @@ export class SpacePlateHandle {
             wasm.__wbindgen_add_to_stack_pointer(16);
         }
     }
+    /**
+     * The face outline offset to a wall boundary, as flat `[x0, y0, …]`: each
+     * edge is moved by its own wall's half-thickness — inward when `inset`
+     * (the net / inner face), outward otherwise (the gross / outer face).
+     * Shared room↔room edges are pinned when pushing outward. Falls back to the
+     * centreline outline when no offset applies — so it's always a sane ring.
+     * (For a `center` boundary just use `faceOutline`.)
+     * @param {number} face
+     * @param {boolean} inset
+     * @returns {Float64Array}
+     */
+    netOutline(face, inset) {
+        try {
+            const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
+            wasm.spaceplatehandle_netOutline(retptr, this.__wbg_ptr, face, inset);
+            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);
+        }
+    }
+    /**
+     * Remove a wall edge, choosing the right semantics from its two faces:
+     * two real rooms → union them; a bridge / spur / outer-only wall → delete
+     * it and auto-clean the orphaned inner lines and nodes it leaves; a real
+     * enclosing wall (room ↔ exterior) → rejected (`BordersExterior`). This is
+     * the "remove this wall and tidy up" affordance for the orphan cruft the
+     * non-destructive wall arrangement leaves behind. Returns the rooms it
+     * changed (empty if the edge bounded no room).
+     * @param {number} edge
+     * @returns {any}
+     */
+    removeEdge(edge) {
+        try {
+            const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
+            wasm.spaceplatehandle_removeEdge(retptr, this.__wbg_ptr, edge);
+            var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
+            var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
+            var r2 = getDataViewMemory0().getInt32(retptr + 4 * 2, true);
+            if (r2) {
+                throw takeObject(r1);
+            }
+            return takeObject(r0);
+        } finally {
+            wasm.__wbindgen_add_to_stack_pointer(16);
+        }
+    }
     /**
      * Flat outline `[x0, y0, x1, y1, …]` of a face (no repeated closing vertex).
      * @param {number} face
@@ -1746,6 +1796,81 @@ export class SpacePlateHandle {
             wasm.__wbindgen_add_to_stack_pointer(16);
         }
     }
+    /**
+     * Face-based gap-room boundary as flat `[x0, y0, …]`: each edge pushed
+     * OUTWARD (into the wall) by `factor × the source wall's half-thickness`.
+     * `0` → net (the gap / inner faces); `1` → centre axis (½ thickness, the
+     * editable node line on the wall mid); `2` → gross outer face.
+     * @param {number} face
+     * @param {number} factor
+     * @returns {Float64Array}
+     */
+    gapBoundary(face, factor) {
+        try {
+            const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
+            wasm.spaceplatehandle_gapBoundary(retptr, this.__wbg_ptr, face, factor);
+            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);
+        }
+    }
+    /**
+     * Dissolve a degree-2 vertex, welding its two edges into one straight
+     * edge between the neighbours — the inverse of `splitEdge`, and the
+     * "delete this corner / node" affordance. Returns the rooms it changed.
+     * Rejects a wall junction (degree ≥ 3) or a weld that would duplicate an
+     * edge.
+     * @param {number} v
+     * @returns {any}
+     */
+    dissolveVertex(v) {
+        try {
+            const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
+            wasm.spaceplatehandle_dissolveVertex(retptr, this.__wbg_ptr, v);
+            var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
+            var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
+            var r2 = getDataViewMemory0().getInt32(retptr + 4 * 2, true);
+            if (r2) {
+                throw takeObject(r1);
+            }
+            return takeObject(r0);
+        } finally {
+            wasm.__wbindgen_add_to_stack_pointer(16);
+        }
+    }
+    /**
+     * FACE-BASED build: rooms are the gaps between wall footprint rectangles.
+     * `rectCoords` is flat `[x0, y0, x1, y1, x2, y2, x3, y3, …]` — 8 f64 per wall
+     * (its 4 plan-rectangle corners, CCW). A bounded arrangement face is a room
+     * only if its centroid is outside every rectangle (a gap, not a wall
+     * interior). The room outline IS the net (inner-face) area; `gapBoundary`
+     * gives the centre axis (½ thickness) and the gross outer face.
+     * @param {Float64Array} rect_coords
+     * @param {number} snap_tolerance
+     * @param {number} min_area
+     * @returns {SpacePlateHandle}
+     */
+    static fromWallRects(rect_coords, snap_tolerance, min_area) {
+        try {
+            const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
+            const ptr0 = passArrayF64ToWasm0(rect_coords, wasm.__wbindgen_export);
+            const len0 = WASM_VECTOR_LEN;
+            wasm.spaceplatehandle_fromWallRects(retptr, ptr0, len0, snap_tolerance, min_area);
+            var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
+            var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
+            var r2 = getDataViewMemory0().getInt32(retptr + 4 * 2, true);
+            if (r2) {
+                throw takeObject(r1);
+            }
+            return SpacePlateHandle.__wrap(r0);
+        } finally {
+            wasm.__wbindgen_add_to_stack_pointer(16);
+        }
+    }
     /**
      * The room on the far side of a half-edge (its twin's face), or
      * `undefined`. O(1) — the "who's across this wall" query.
@@ -1804,20 +1929,26 @@ export class SpacePlateHandle {
      *
      * `segCoords`: `[ax, ay, bx, by, …]` (length a multiple of 4).
      * `segSources`: one `i32` per segment, `-1` for none.
+     * `segHalfThickness`: one `f64` per segment — half the wall's thickness in
+     * metres, carried onto the derived edges for `netOutline`. Pass an empty
+     * array (or all zeros) when thickness is unknown (centreline only).
      * `snapTolerance` / `minArea`: pass `<= 0` to take the defaults.
      * @param {Float64Array} seg_coords
      * @param {Int32Array} seg_sources
+     * @param {Float64Array} seg_half_thickness
      * @param {number} snap_tolerance
      * @param {number} min_area
      */
-    constructor(seg_coords, seg_sources, snap_tolerance, min_area) {
+    constructor(seg_coords, seg_sources, seg_half_thickness, snap_tolerance, min_area) {
         try {
             const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
             const ptr0 = passArrayF64ToWasm0(seg_coords, wasm.__wbindgen_export);
             const len0 = WASM_VECTOR_LEN;
             const ptr1 = passArray32ToWasm0(seg_sources, wasm.__wbindgen_export);
             const len1 = WASM_VECTOR_LEN;
-            wasm.spaceplatehandle_new(retptr, ptr0, len0, ptr1, len1, snap_tolerance, min_area);
+            const ptr2 = passArrayF64ToWasm0(seg_half_thickness, wasm.__wbindgen_export);
+            const len2 = WASM_VECTOR_LEN;
+            wasm.spaceplatehandle_new(retptr, ptr0, len0, ptr1, len1, ptr2, len2, snap_tolerance, min_area);
             var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
             var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
             var r2 = getDataViewMemory0().getInt32(retptr + 4 * 2, true);
@@ -1831,6 +1962,44 @@ export class SpacePlateHandle {
             wasm.__wbindgen_add_to_stack_pointer(16);
         }
     }
+    /**
+     * Sweep the whole plate clean: remove dangling spur walls, isolated nodes,
+     * and redundant collinear nodes — the "clean up orphans" / eraser action.
+     * Area-neutral and idempotent. Returns how many topology elements were
+     * pruned (0 = the plate was already clean); the caller re-renders via
+     * `snapshot` like any other edit.
+     * @returns {number}
+     */
+    prune() {
+        const ret = wasm.spaceplatehandle_prune(this.__wbg_ptr);
+        return ret >>> 0;
+    }
+    /**
+     * Author a new room from a flat ring `[x0, y0, x1, y1, …]` (no repeated
+     * closing vertex). `source` `-1` marks a user-drawn room. Winding is
+     * normalised to CCW; returns the new room patch. The room is its own
+     * connected component — it does not merge into existing topology.
+     * @param {Float64Array} coords
+     * @param {number} source
+     * @returns {any}
+     */
+    addFace(coords, source) {
+        try {
+            const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
+            const ptr0 = passArrayF64ToWasm0(coords, wasm.__wbindgen_export);
+            const len0 = WASM_VECTOR_LEN;
+            wasm.spaceplatehandle_addFace(retptr, this.__wbg_ptr, ptr0, len0, source);
+            var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
+            var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
+            var r2 = getDataViewMemory0().getInt32(retptr + 4 * 2, true);
+            if (r2) {
+                throw takeObject(r1);
+            }
+            return takeObject(r0);
+        } finally {
+            wasm.__wbindgen_add_to_stack_pointer(16);
+        }
+    }
     /**
      * Face ids of every live room.
      * @returns {Uint32Array}
@@ -2784,6 +2953,10 @@ function __wbg_get_imports() {
         const ret = new Error();
         return addHeapObject(ret);
     };
+    imports.wbg.__wbg_new_df1173567d5ff028 = function(arg0, arg1) {
+        const ret = new Error(getStringFromWasm0(arg0, arg1));
+        return addHeapObject(ret);
+    };
     imports.wbg.__wbg_new_from_slice_41e2764a343e3cb1 = function(arg0, arg1) {
         const ret = new Float32Array(getArrayF32FromWasm0(arg0, arg1));
         return addHeapObject(ret);
@@ -2828,6 +3001,9 @@ function __wbg_get_imports() {
     imports.wbg.__wbg_set_index_42abe35f117e614e = function(arg0, arg1, arg2) {
         getObject(arg0)[arg1 >>> 0] = arg2 >>> 0;
     };
+    imports.wbg.__wbg_set_name_df69b75cb0b4de8a = function(arg0, arg1, arg2) {
+        getObject(arg0).name = getStringFromWasm0(arg1, arg2);
+    };
     imports.wbg.__wbg_stack_0ed75d68575b0f3c = function(arg0, arg1) {
         const ret = getObject(arg1).stack;
         const ptr1 = passStringToWasm0(ret, wasm.__wbindgen_export, wasm.__wbindgen_export2);