@ifc-lite/wasm 1.15.0 → 1.16.1

package/package.json

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

package/pkg/ifc-lite.d.ts

@@ -434,6 +434,29 @@ export class IfcAPI {
    * ```
    */
   parseZeroCopy(content: string): ZeroCopyMesh;
+  /**
+   * Extract raw profile polygons from all building elements with `IfcExtrudedAreaSolid`
+   * representations.
+   *
+   * Returns a [`ProfileCollection`] whose entries each carry:
+   * - A 2D polygon (outer + holes) in local profile space (metres)
+   * - A 4 × 4 column-major transform in WebGL Y-up world space
+   * - Extrusion direction (world space) and depth (metres)
+   *
+   * Use [`ProfileProjector`] (TypeScript) to convert these into `DrawingLine[]`
+   * for clean projection without tessellation artifacts.
+   *
+   * ```javascript
+   * const api = new IfcAPI();
+   * const profiles = api.extractProfiles(ifcContent, 0);
+   * console.log('Profiles:', profiles.length);
+   * for (let i = 0; i < profiles.length; i++) {
+   *   const p = profiles.get(i);
+   *   console.log(p.ifcType, 'depth:', p.extrusionDepth);
+   * }
+   * ```
+   */
+  extractProfiles(content: string, model_index: number): ProfileCollection;
   /**
    * Debug: Test processing entity #953 (FacetedBrep wall)
    */
@@ -692,6 +715,63 @@ export class MeshDataJs {
   readonly positions: Float32Array;
 }
 
+export class ProfileCollection {
+  private constructor();
+  free(): void;
+  [Symbol.dispose](): void;
+  /**
+   * Get profile at `index`.  Returns `undefined` for out-of-bounds index.
+   */
+  get(index: number): ProfileEntryJs | undefined;
+  /**
+   * Number of profiles.
+   */
+  readonly length: number;
+}
+
+export class ProfileEntryJs {
+  private constructor();
+  free(): void;
+  [Symbol.dispose](): void;
+  /**
+   * Express ID of the building element.
+   */
+  readonly expressId: number;
+  /**
+   * Number of points per hole.
+   */
+  readonly holeCounts: Uint32Array;
+  /**
+   * All hole points concatenated: `[x0, y0, x1, y1, …]` (metres).
+   */
+  readonly holePoints: Float32Array;
+  /**
+   * Model index for multi-model federation.
+   */
+  readonly modelIndex: number;
+  /**
+   * Outer boundary: flat `[x0, y0, x1, y1, …]` in local profile space (metres).
+   */
+  readonly outerPoints: Float32Array;
+  /**
+   * Extrusion direction `[dx, dy, dz]` in WebGL Y-up world space (unit vector).
+   */
+  readonly extrusionDir: Float32Array;
+  /**
+   * Extrusion depth (metres).
+   */
+  readonly extrusionDepth: number;
+  /**
+   * IFC type name (e.g., `"IfcWall"`).
+   */
+  readonly ifcType: string;
+  /**
+   * 4 × 4 column-major transform in WebGL Y-up world space.
+   * `M * [x, y, 0, 1]ᵀ` gives the world position.
+   */
+  readonly transform: Float32Array;
+}
+
 export class RtcOffsetJs {
   private constructor();
   free(): void;
@@ -904,6 +984,8 @@ export interface InitOutput {
   readonly __wbg_meshcollection_free: (a: number, b: number) => void;
   readonly __wbg_meshcollectionwithrtc_free: (a: number, b: number) => void;
   readonly __wbg_meshdatajs_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_rtcoffsetjs_free: (a: number, b: number) => void;
   readonly __wbg_set_georeferencejs_eastings: (a: number, b: number) => void;
   readonly __wbg_set_georeferencejs_northings: (a: number, b: number) => void;
@@ -967,6 +1049,7 @@ export interface InitOutput {
   readonly ifcapi_buildPrePassOnce: (a: number, b: number, c: number) => number;
   readonly ifcapi_debugProcessEntity953: (a: number, b: number, c: number, d: number) => void;
   readonly ifcapi_debugProcessFirstWall: (a: number, b: number, c: number, d: number) => void;
+  readonly ifcapi_extractProfiles: (a: number, b: number, c: number, d: number) => number;
   readonly ifcapi_getGeoReference: (a: number, b: number, c: number) => number;
   readonly ifcapi_getMemory: (a: number) => number;
   readonly ifcapi_is_ready: (a: number) => number;
@@ -1019,6 +1102,16 @@ export interface InitOutput {
   readonly meshdatajs_positions: (a: number) => number;
   readonly meshdatajs_triangleCount: (a: number) => number;
   readonly meshdatajs_vertexCount: (a: number) => number;
+  readonly profilecollection_get: (a: number, b: number) => number;
+  readonly profilecollection_length: (a: number) => number;
+  readonly profileentryjs_extrusionDepth: (a: number) => number;
+  readonly profileentryjs_extrusionDir: (a: number) => number;
+  readonly profileentryjs_holeCounts: (a: number) => number;
+  readonly profileentryjs_holePoints: (a: number) => number;
+  readonly profileentryjs_ifcType: (a: number, b: number) => void;
+  readonly profileentryjs_modelIndex: (a: number) => number;
+  readonly profileentryjs_outerPoints: (a: number) => number;
+  readonly profileentryjs_transform: (a: number) => number;
   readonly rtcoffsetjs_isSignificant: (a: number) => number;
   readonly rtcoffsetjs_toWorld: (a: number, b: number, c: number, d: number, e: number) => void;
   readonly symboliccircle_centerX: (a: number) => number;
@@ -1081,11 +1174,12 @@ export interface InitOutput {
   readonly gpuinstancedgeometryref_geometryId: (a: number) => bigint;
   readonly instancedgeometry_geometryId: (a: number) => bigint;
   readonly meshcollection_rtcOffsetX: (a: number) => number;
+  readonly profileentryjs_expressId: (a: number) => number;
   readonly symboliccircle_expressId: (a: number) => number;
   readonly __wbg_gpuinstancedgeometryref_free: (a: number, b: number) => void;
-  readonly __wasm_bindgen_func_elem_1092: (a: number, b: number, c: number) => void;
-  readonly __wasm_bindgen_func_elem_1091: (a: number, b: number) => void;
-  readonly __wasm_bindgen_func_elem_1132: (a: number, b: number, c: number, d: number) => void;
+  readonly __wasm_bindgen_func_elem_1131: (a: number, b: number, c: number) => void;
+  readonly __wasm_bindgen_func_elem_1130: (a: number, b: number) => void;
+  readonly __wasm_bindgen_func_elem_1173: (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

@@ -212,12 +212,12 @@ if (!('encodeInto' in cachedTextEncoder)) {
 
 let WASM_VECTOR_LEN = 0;
 
-function __wasm_bindgen_func_elem_1092(arg0, arg1, arg2) {
-    wasm.__wasm_bindgen_func_elem_1092(arg0, arg1, addHeapObject(arg2));
+function __wasm_bindgen_func_elem_1131(arg0, arg1, arg2) {
+    wasm.__wasm_bindgen_func_elem_1131(arg0, arg1, addHeapObject(arg2));
 }
 
-function __wasm_bindgen_func_elem_1132(arg0, arg1, arg2, arg3) {
-    wasm.__wasm_bindgen_func_elem_1132(arg0, arg1, addHeapObject(arg2), addHeapObject(arg3));
+function __wasm_bindgen_func_elem_1173(arg0, arg1, arg2, arg3) {
+    wasm.__wasm_bindgen_func_elem_1173(arg0, arg1, addHeapObject(arg2), addHeapObject(arg3));
 }
 
 const GeoReferenceJsFinalization = (typeof FinalizationRegistry === 'undefined')
@@ -272,6 +272,14 @@ const MeshDataJsFinalization = (typeof FinalizationRegistry === 'undefined')
     ? { register: () => {}, unregister: () => {} }
     : new FinalizationRegistry(ptr => wasm.__wbg_meshdatajs_free(ptr >>> 0, 1));
 
+const ProfileCollectionFinalization = (typeof FinalizationRegistry === 'undefined')
+    ? { register: () => {}, unregister: () => {} }
+    : new FinalizationRegistry(ptr => wasm.__wbg_profilecollection_free(ptr >>> 0, 1));
+
+const ProfileEntryJsFinalization = (typeof FinalizationRegistry === 'undefined')
+    ? { register: () => {}, unregister: () => {} }
+    : new FinalizationRegistry(ptr => wasm.__wbg_profileentryjs_free(ptr >>> 0, 1));
+
 const RtcOffsetJsFinalization = (typeof FinalizationRegistry === 'undefined')
     ? { register: () => {}, unregister: () => {} }
     : new FinalizationRegistry(ptr => wasm.__wbg_rtcoffsetjs_free(ptr >>> 0, 1));
@@ -1428,6 +1436,37 @@ export class IfcAPI {
         const ret = wasm.ifcapi_parseZeroCopy(this.__wbg_ptr, ptr0, len0);
         return ZeroCopyMesh.__wrap(ret);
     }
+    /**
+     * Extract raw profile polygons from all building elements with `IfcExtrudedAreaSolid`
+     * representations.
+     *
+     * Returns a [`ProfileCollection`] whose entries each carry:
+     * - A 2D polygon (outer + holes) in local profile space (metres)
+     * - A 4 × 4 column-major transform in WebGL Y-up world space
+     * - Extrusion direction (world space) and depth (metres)
+     *
+     * Use [`ProfileProjector`] (TypeScript) to convert these into `DrawingLine[]`
+     * for clean projection without tessellation artifacts.
+     *
+     * ```javascript
+     * const api = new IfcAPI();
+     * const profiles = api.extractProfiles(ifcContent, 0);
+     * console.log('Profiles:', profiles.length);
+     * for (let i = 0; i < profiles.length; i++) {
+     *   const p = profiles.get(i);
+     *   console.log(p.ifcType, 'depth:', p.extrusionDepth);
+     * }
+     * ```
+     * @param {string} content
+     * @param {number} model_index
+     * @returns {ProfileCollection}
+     */
+    extractProfiles(content, model_index) {
+        const ptr0 = passStringToWasm0(content, wasm.__wbindgen_export3, wasm.__wbindgen_export4);
+        const len0 = WASM_VECTOR_LEN;
+        const ret = wasm.ifcapi_extractProfiles(this.__wbg_ptr, ptr0, len0, model_index);
+        return ProfileCollection.__wrap(ret);
+    }
     /**
      * Debug: Test processing entity #953 (FacetedBrep wall)
      * @param {string} content
@@ -2138,6 +2177,159 @@ export class MeshDataJs {
 }
 if (Symbol.dispose) MeshDataJs.prototype[Symbol.dispose] = MeshDataJs.prototype.free;
 
+/**
+ * A collection of extracted profiles.
+ */
+export class ProfileCollection {
+    static __wrap(ptr) {
+        ptr = ptr >>> 0;
+        const obj = Object.create(ProfileCollection.prototype);
+        obj.__wbg_ptr = ptr;
+        ProfileCollectionFinalization.register(obj, obj.__wbg_ptr, obj);
+        return obj;
+    }
+    __destroy_into_raw() {
+        const ptr = this.__wbg_ptr;
+        this.__wbg_ptr = 0;
+        ProfileCollectionFinalization.unregister(this);
+        return ptr;
+    }
+    free() {
+        const ptr = this.__destroy_into_raw();
+        wasm.__wbg_profilecollection_free(ptr, 0);
+    }
+    /**
+     * Get profile at `index`.  Returns `undefined` for out-of-bounds index.
+     * @param {number} index
+     * @returns {ProfileEntryJs | undefined}
+     */
+    get(index) {
+        const ret = wasm.profilecollection_get(this.__wbg_ptr, index);
+        return ret === 0 ? undefined : ProfileEntryJs.__wrap(ret);
+    }
+    /**
+     * Number of profiles.
+     * @returns {number}
+     */
+    get length() {
+        const ret = wasm.profilecollection_length(this.__wbg_ptr);
+        return ret >>> 0;
+    }
+}
+if (Symbol.dispose) ProfileCollection.prototype[Symbol.dispose] = ProfileCollection.prototype.free;
+
+/**
+ * A single profile entry – raw 2D polygon + world transform.
+ *
+ * Profile points are in **local 2D profile space** (metres).
+ * Apply `transform` to `[x, y, 0, 1]` to get WebGL Y-up world coordinates.
+ */
+export class ProfileEntryJs {
+    static __wrap(ptr) {
+        ptr = ptr >>> 0;
+        const obj = Object.create(ProfileEntryJs.prototype);
+        obj.__wbg_ptr = ptr;
+        ProfileEntryJsFinalization.register(obj, obj.__wbg_ptr, obj);
+        return obj;
+    }
+    __destroy_into_raw() {
+        const ptr = this.__wbg_ptr;
+        this.__wbg_ptr = 0;
+        ProfileEntryJsFinalization.unregister(this);
+        return ptr;
+    }
+    free() {
+        const ptr = this.__destroy_into_raw();
+        wasm.__wbg_profileentryjs_free(ptr, 0);
+    }
+    /**
+     * Express ID of the building element.
+     * @returns {number}
+     */
+    get expressId() {
+        const ret = wasm.meshdatajs_expressId(this.__wbg_ptr);
+        return ret >>> 0;
+    }
+    /**
+     * Number of points per hole.
+     * @returns {Uint32Array}
+     */
+    get holeCounts() {
+        const ret = wasm.profileentryjs_holeCounts(this.__wbg_ptr);
+        return takeObject(ret);
+    }
+    /**
+     * All hole points concatenated: `[x0, y0, x1, y1, …]` (metres).
+     * @returns {Float32Array}
+     */
+    get holePoints() {
+        const ret = wasm.profileentryjs_holePoints(this.__wbg_ptr);
+        return takeObject(ret);
+    }
+    /**
+     * Model index for multi-model federation.
+     * @returns {number}
+     */
+    get modelIndex() {
+        const ret = wasm.profileentryjs_modelIndex(this.__wbg_ptr);
+        return ret >>> 0;
+    }
+    /**
+     * Outer boundary: flat `[x0, y0, x1, y1, …]` in local profile space (metres).
+     * @returns {Float32Array}
+     */
+    get outerPoints() {
+        const ret = wasm.profileentryjs_outerPoints(this.__wbg_ptr);
+        return takeObject(ret);
+    }
+    /**
+     * Extrusion direction `[dx, dy, dz]` in WebGL Y-up world space (unit vector).
+     * @returns {Float32Array}
+     */
+    get extrusionDir() {
+        const ret = wasm.profileentryjs_extrusionDir(this.__wbg_ptr);
+        return takeObject(ret);
+    }
+    /**
+     * Extrusion depth (metres).
+     * @returns {number}
+     */
+    get extrusionDepth() {
+        const ret = wasm.profileentryjs_extrusionDepth(this.__wbg_ptr);
+        return ret;
+    }
+    /**
+     * IFC type name (e.g., `"IfcWall"`).
+     * @returns {string}
+     */
+    get ifcType() {
+        let deferred1_0;
+        let deferred1_1;
+        try {
+            const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
+            wasm.profileentryjs_ifcType(retptr, this.__wbg_ptr);
+            var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
+            var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
+            deferred1_0 = r0;
+            deferred1_1 = r1;
+            return getStringFromWasm0(r0, r1);
+        } finally {
+            wasm.__wbindgen_add_to_stack_pointer(16);
+            wasm.__wbindgen_export2(deferred1_0, deferred1_1, 1);
+        }
+    }
+    /**
+     * 4 × 4 column-major transform in WebGL Y-up world space.
+     * `M * [x, y, 0, 1]ᵀ` gives the world position.
+     * @returns {Float32Array}
+     */
+    get transform() {
+        const ret = wasm.profileentryjs_transform(this.__wbg_ptr);
+        return takeObject(ret);
+    }
+}
+if (Symbol.dispose) ProfileEntryJs.prototype[Symbol.dispose] = ProfileEntryJs.prototype.free;
+
 /**
  * RTC offset information exposed to JavaScript
  */
@@ -2857,7 +3049,7 @@ function __wbg_get_imports() {
                 const a = state0.a;
                 state0.a = 0;
                 try {
-                    return __wasm_bindgen_func_elem_1132(a, state0.b, arg0, arg1);
+                    return __wasm_bindgen_func_elem_1173(a, state0.b, arg0, arg1);
                 } finally {
                     state0.a = a;
                 }
@@ -2971,7 +3163,7 @@ function __wbg_get_imports() {
     };
     imports.wbg.__wbindgen_cast_8410bcb836a2825d = function(arg0, arg1) {
         // Cast intrinsic for `Closure(Closure { dtor_idx: 145, function: Function { arguments: [Externref], shim_idx: 146, ret: Unit, inner_ret: Some(Unit) }, mutable: true }) -> Externref`.
-        const ret = makeMutClosure(arg0, arg1, wasm.__wasm_bindgen_func_elem_1091, __wasm_bindgen_func_elem_1092);
+        const ret = makeMutClosure(arg0, arg1, wasm.__wasm_bindgen_func_elem_1130, __wasm_bindgen_func_elem_1131);
         return addHeapObject(ret);
     };
     imports.wbg.__wbindgen_cast_d6cd19b81560fd6e = function(arg0) {