opengeometry 2.0.10 → 2.0.11

package/opengeometry/pkg/opengeometry.js

@@ -168,17 +168,42 @@ function getStringFromWasm0(ptr, len) {
     return cachedTextDecoder.decode(getUint8ArrayMemory0().subarray(ptr, ptr + len));
 }
 
-function _assertClass(instance, klass) {
-    if (!(instance instanceof klass)) {
-        throw new Error(`expected instance of ${klass.name}`);
-    }
-}
-
 function takeFromExternrefTable0(idx) {
     const value = wasm.__wbindgen_export_2.get(idx);
     wasm.__externref_table_dealloc(idx);
     return value;
 }
+/**
+ * @param {string} local_brep_serialized
+ * @param {number} height
+ * @returns {string}
+ */
+export function extrudeBrepFace(local_brep_serialized, height) {
+    let deferred3_0;
+    let deferred3_1;
+    try {
+        const ptr0 = passStringToWasm0(local_brep_serialized, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+        const len0 = WASM_VECTOR_LEN;
+        const ret = wasm.extrudeBrepFace(ptr0, len0, height);
+        var ptr2 = ret[0];
+        var len2 = ret[1];
+        if (ret[3]) {
+            ptr2 = 0; len2 = 0;
+            throw takeFromExternrefTable0(ret[2]);
+        }
+        deferred3_0 = ptr2;
+        deferred3_1 = len2;
+        return getStringFromWasm0(ptr2, len2);
+    } finally {
+        wasm.__wbindgen_free(deferred3_0, deferred3_1, 1);
+    }
+}
+
+function _assertClass(instance, klass) {
+    if (!(instance instanceof klass)) {
+        throw new Error(`expected instance of ${klass.name}`);
+    }
+}
 
 let cachedFloat64ArrayMemory0 = null;
 
@@ -204,9 +229,65 @@ function passArrayJsValueToWasm0(array, malloc) {
     return ptr;
 }
 
+function getArrayJsValueFromWasm0(ptr, len) {
+    ptr = ptr >>> 0;
+    const mem = getDataViewMemory0();
+    const result = [];
+    for (let i = ptr; i < ptr + 4 * len; i += 4) {
+        result.push(wasm.__wbindgen_export_2.get(mem.getUint32(i, true)));
+    }
+    wasm.__externref_drop_slice(ptr, len);
+    return result;
+}
+
 function isLikeNone(x) {
     return x === undefined || x === null;
 }
+
+function passArrayF64ToWasm0(arg, malloc) {
+    const ptr = malloc(arg.length * 8, 8) >>> 0;
+    getFloat64ArrayMemory0().set(arg, ptr / 8);
+    WASM_VECTOR_LEN = arg.length;
+    return ptr;
+}
+/**
+ * Wasm entry point: offset a centreline by `width` into stroked regions via the
+ * deterministic analytic offset. `centreline_flat` is `[x0,y0,z0, …]`. Returns
+ * CW-outer / CCW-hole regions, canonicalised; empty (does NOT throw) when degenerate.
+ * @param {Float64Array} centreline_flat
+ * @param {number} width
+ * @param {boolean} closed
+ * @param {number} miter_limit
+ * @returns {OGOffsetRegionsResult}
+ */
+export function offsetPolylineRegions(centreline_flat, width, closed, miter_limit) {
+    const ptr0 = passArrayF64ToWasm0(centreline_flat, wasm.__wbindgen_malloc);
+    const len0 = WASM_VECTOR_LEN;
+    const ret = wasm.offsetPolylineRegions(ptr0, len0, width, closed, miter_limit);
+    if (ret[2]) {
+        throw takeFromExternrefTable0(ret[1]);
+    }
+    return OGOffsetRegionsResult.__wrap(ret[0]);
+}
+
+/**
+ * Wasm entry point: merge a GROUP of separate polylines (a crossing T / X / L
+ * overlap) into one clean stroked region by nonzero-winding union of their mitered
+ * bands. `polylines_json` is `[{centreline:[x,y,z,…], width, closed}, …]`. Returns
+ * CW-outer / CCW-hole regions (one or more); empty when nothing is buildable.
+ * @param {string} polylines_json
+ * @returns {OGOffsetRegionsResult}
+ */
+export function offsetPolylineGroupRegions(polylines_json) {
+    const ptr0 = passStringToWasm0(polylines_json, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+    const len0 = WASM_VECTOR_LEN;
+    const ret = wasm.offsetPolylineGroupRegions(ptr0, len0);
+    if (ret[2]) {
+        throw takeFromExternrefTable0(ret[1]);
+    }
+    return OGOffsetRegionsResult.__wrap(ret[0]);
+}
+
 /**
  * Wasm entry point for union.
  * @param {string} lhs_brep_serialized
@@ -292,40 +373,22 @@ export function booleanSubtractionMany(lhs_brep_serialized, cutters_brep_seriali
 }
 
 /**
- * @param {string} local_brep_serialized
- * @param {number} height
- * @returns {string}
+ * Wasm entry point for array-backed batched union. Accepts a JSON array of
+ * serialized BReps and folds them with `batch_union` in one boundary crossing.
+ * @param {string} operands_brep_serialized
+ * @param {string | null} [options_json]
+ * @returns {OGBooleanResult}
  */
-export function extrudeBrepFace(local_brep_serialized, height) {
-    let deferred3_0;
-    let deferred3_1;
-    try {
-        const ptr0 = passStringToWasm0(local_brep_serialized, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
-        const len0 = WASM_VECTOR_LEN;
-        const ret = wasm.extrudeBrepFace(ptr0, len0, height);
-        var ptr2 = ret[0];
-        var len2 = ret[1];
-        if (ret[3]) {
-            ptr2 = 0; len2 = 0;
-            throw takeFromExternrefTable0(ret[2]);
-        }
-        deferred3_0 = ptr2;
-        deferred3_1 = len2;
-        return getStringFromWasm0(ptr2, len2);
-    } finally {
-        wasm.__wbindgen_free(deferred3_0, deferred3_1, 1);
-    }
-}
-
-function getArrayJsValueFromWasm0(ptr, len) {
-    ptr = ptr >>> 0;
-    const mem = getDataViewMemory0();
-    const result = [];
-    for (let i = ptr; i < ptr + 4 * len; i += 4) {
-        result.push(wasm.__wbindgen_export_2.get(mem.getUint32(i, true)));
+export function batchUnion(operands_brep_serialized, options_json) {
+    const ptr0 = passStringToWasm0(operands_brep_serialized, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+    const len0 = WASM_VECTOR_LEN;
+    var ptr1 = isLikeNone(options_json) ? 0 : passStringToWasm0(options_json, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+    var len1 = WASM_VECTOR_LEN;
+    const ret = wasm.batchUnion(ptr0, len0, ptr1, len1);
+    if (ret[2]) {
+        throw takeFromExternrefTable0(ret[1]);
     }
-    wasm.__externref_drop_slice(ptr, len);
-    return result;
+    return OGBooleanResult.__wrap(ret[0]);
 }
 
 const Matrix3Finalization = (typeof FinalizationRegistry === 'undefined')
@@ -2801,7 +2864,7 @@ export class OGLine {
      * @returns {Vector3}
      */
     get_anchor() {
-        const ret = wasm.ogcurve_get_anchor(this.__wbg_ptr);
+        const ret = wasm.ogline_get_anchor(this.__wbg_ptr);
         return Vector3.__wrap(ret);
     }
     /**
@@ -2856,6 +2919,53 @@ export class OGLine {
     }
 }
 
+const OGOffsetRegionsResultFinalization = (typeof FinalizationRegistry === 'undefined')
+    ? { register: () => {}, unregister: () => {} }
+    : new FinalizationRegistry(ptr => wasm.__wbg_ogoffsetregionsresult_free(ptr >>> 0, 1));
+/**
+ * Result payload for a polyline offset: a list of regions (each an outer ring +
+ * inner-void holes). Normally one region; a self-crossing closed centreline (e.g.
+ * a figure-8) yields one per simple sub-loop. The deterministic analytic offset —
+ * no extrude/solid. Used to build the plan polygons + extruded base solids in JS.
+ */
+export class OGOffsetRegionsResult {
+
+    static __wrap(ptr) {
+        ptr = ptr >>> 0;
+        const obj = Object.create(OGOffsetRegionsResult.prototype);
+        obj.__wbg_ptr = ptr;
+        OGOffsetRegionsResultFinalization.register(obj, obj.__wbg_ptr, obj);
+        return obj;
+    }
+
+    __destroy_into_raw() {
+        const ptr = this.__wbg_ptr;
+        this.__wbg_ptr = 0;
+        OGOffsetRegionsResultFinalization.unregister(this);
+        return ptr;
+    }
+
+    free() {
+        const ptr = this.__destroy_into_raw();
+        wasm.__wbg_ogoffsetregionsresult_free(ptr, 0);
+    }
+    /**
+     * @returns {string}
+     */
+    get regionsSerialized() {
+        let deferred1_0;
+        let deferred1_1;
+        try {
+            const ret = wasm.ogoffsetregionsresult_regionsSerialized(this.__wbg_ptr);
+            deferred1_0 = ret[0];
+            deferred1_1 = ret[1];
+            return getStringFromWasm0(ret[0], ret[1]);
+        } finally {
+            wasm.__wbindgen_free(deferred1_0, deferred1_1, 1);
+        }
+    }
+}
+
 const OGPolygonFinalization = (typeof FinalizationRegistry === 'undefined')
     ? { register: () => {}, unregister: () => {} }
     : new FinalizationRegistry(ptr => wasm.__wbg_ogpolygon_free(ptr >>> 0, 1));
@@ -3434,7 +3544,7 @@ export class OGPolyline {
      * @returns {Vector3}
      */
     get_anchor() {
-        const ret = wasm.ogcurve_get_anchor(this.__wbg_ptr);
+        const ret = wasm.ogpolyline_get_anchor(this.__wbg_ptr);
         return Vector3.__wrap(ret);
     }
     /**
@@ -5440,7 +5550,7 @@ export class OGWedge {
      * @returns {Vector3}
      */
     get_anchor() {
-        const ret = wasm.ogwedge_get_anchor(this.__wbg_ptr);
+        const ret = wasm.ogarc_get_anchor(this.__wbg_ptr);
         return Vector3.__wrap(ret);
     }
 }