opengeometry 2.0.10 → 2.0.11

package/index.d.ts

@@ -97,6 +97,6 @@ export * from "./src/freeform/index.js";
  */
 export * from "./src/editor/index.js";
 /**
- * Kernel-backed modeling operations.
+ * Kernel-backed modeling operations (incl. analytic polyline offset → regions).
  */
 export * from "./src/operations/index.js";

package/index.js

@@ -209,16 +209,42 @@ function getStringFromWasm0(ptr, len) {
   ptr = ptr >>> 0;
   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}
+ */
+function extrudeBrepFace$1(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;
 function getFloat64ArrayMemory0() {
   if (cachedFloat64ArrayMemory0 === null || cachedFloat64ArrayMemory0.byteLength === 0) {
@@ -239,9 +265,63 @@ function passArrayJsValueToWasm0(array, malloc) {
   WASM_VECTOR_LEN = array.length;
   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}
+ */
+function offsetPolylineRegions$1(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}
+ */
+function offsetPolylineGroupRegions$1(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
@@ -327,40 +407,22 @@ function booleanSubtractionMany(lhs_brep_serialized, cutters_brep_serialized, op
 }
 
 /**
- * @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}
  */
-function extrudeBrepFace$1(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)));
+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' ? {
   register: () => {},
@@ -2818,7 +2880,7 @@ 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);
   }
   /**
@@ -2872,6 +2934,50 @@ 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.
+ */
+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: () => {}
@@ -3444,7 +3550,7 @@ 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);
   }
   /**
@@ -5435,7 +5541,7 @@ 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);
   }
 }
@@ -5862,6 +5968,7 @@ var OGKernel = /*#__PURE__*/Object.freeze({
     OGFreeformGeometry: OGFreeformGeometry,
     OGIfcExportResult: OGIfcExportResult,
     OGLine: OGLine,
+    OGOffsetRegionsResult: OGOffsetRegionsResult,
     OGPolygon: OGPolygon,
     OGPolyline: OGPolyline,
     OGRectangle: OGRectangle,
@@ -5872,13 +5979,16 @@ var OGKernel = /*#__PURE__*/Object.freeze({
     OGSweep: OGSweep,
     OGWedge: OGWedge,
     Vector3: Vector3,
+    batchUnion: batchUnion,
     booleanIntersection: booleanIntersection$1,
     booleanSubtraction: booleanSubtraction$1,
     booleanSubtractionMany: booleanSubtractionMany,
     booleanUnion: booleanUnion$1,
     default: __wbg_init,
     extrudeBrepFace: extrudeBrepFace$1,
-    initSync: initSync
+    initSync: initSync,
+    offsetPolylineGroupRegions: offsetPolylineGroupRegions$1,
+    offsetPolylineRegions: offsetPolylineRegions$1
 });
 
 function spotLabelElement() {
@@ -11145,6 +11255,44 @@ function createEditorModesExample(scene) {
     };
 }
 
+/**
+ * Offset a centreline by ±half-width into one or more filled REGIONS, via the
+ * deterministic analytic offset — miters / flat bevels at `miterLimit`, concave
+ * trims, and nonzero-winding resolution of reflex / closed loops. NO boolean union
+ * (so it is deterministic, unlike the 3D-mesh CSG path). A simple centreline returns
+ * one region; a self-crossing closed centreline (e.g. a figure-8) returns one per
+ * simple sub-loop. Returns an EMPTY array for a genuinely unbuildable input (does
+ * not throw, so it never looks like a kernel crash). Rings are CW-outer / CCW-holes.
+ *
+ * @param centrelineFlat centreline points as `[x,y,z, …]`.
+ * @param width full stroke width (offset ±width/2 on each side).
+ * @param miterLimit SVG stroke-miterlimit; corners sharper than this bevel. Default 4.
+ */
+function offsetPolylineRegions(centrelineFlat, width, closed, miterLimit = 4) {
+    const buildExport = offsetPolylineRegions$1;
+    if (typeof buildExport !== "function") {
+        throw new Error("offsetPolylineRegions is not available in the loaded wasm package. Rebuild opengeometry wasm bindings.");
+    }
+    const flat = centrelineFlat instanceof Float64Array ? centrelineFlat : new Float64Array(centrelineFlat);
+    const result = buildExport(flat, width, closed, miterLimit);
+    return JSON.parse(result.regionsSerialized);
+}
+/**
+ * Merge a GROUP of separate polylines (a crossing T / X / L overlap) into one clean
+ * region by nonzero-winding union of their mitered bands — the overlapping strokes
+ * merge into a single region with mitered/bevelled corners, no internal edges.
+ * Returns CW-outer / CCW-hole regions (one or more); empty if nothing is buildable.
+ * No CSG. Used to render/extrude an overlapping crossing as one joined mass.
+ */
+function offsetPolylineGroupRegions(polylines) {
+    const buildExport = offsetPolylineGroupRegions$1;
+    if (typeof buildExport !== "function") {
+        throw new Error("offsetPolylineGroupRegions is not available in the loaded wasm package. Rebuild opengeometry wasm bindings.");
+    }
+    const result = buildExport(JSON.stringify(polylines));
+    return JSON.parse(result.regionsSerialized);
+}
+
 /**
  * Shared runtime entrypoint used to initialize the OpenGeometry wasm module.
  */
@@ -11209,5 +11357,5 @@ class OpenGeometry {
 OpenGeometry.version = OPEN_GEOMETRY_THREE_VERSION;
 OpenGeometry.instance = null;
 
-export { Arc, BooleanError, BooleanResult, CoincidentFacesError, Cuboid, Curve, CutterExceedsHostError, Cylinder, FreeformEditor, FreeformGeometry, Line, NonManifoldOutputError, OGSceneManager, OpenGeometry, Opening, OverlappingCuttersError, Polygon, Polyline, Rectangle, Solid, Sphere, SpotLabel, Sweep, Vector3, Wedge, booleanIntersection, booleanSubtraction, booleanUnion, clonePlacement, createBooleanExample, createEditorModesExample, createFreeformEditor, createFreeformGeometry, createOffsetExample, createParametricEditCapabilities, createPrimitivesExample, createShapesExample, createSweepExample, createWallFromOffsetsExample, describeWallSubtractError, executeBooleanSubtractionMany, extrudeBrepFace, parseBooleanError, toObjectTransformation$1 as toObjectTransformation };
+export { Arc, BooleanError, BooleanResult, CoincidentFacesError, Cuboid, Curve, CutterExceedsHostError, Cylinder, FreeformEditor, FreeformGeometry, Line, NonManifoldOutputError, OGSceneManager, OpenGeometry, Opening, OverlappingCuttersError, Polygon, Polyline, Rectangle, Solid, Sphere, SpotLabel, Sweep, Vector3, Wedge, booleanIntersection, booleanSubtraction, booleanUnion, clonePlacement, createBooleanExample, createEditorModesExample, createFreeformEditor, createFreeformGeometry, createOffsetExample, createParametricEditCapabilities, createPrimitivesExample, createShapesExample, createSweepExample, createWallFromOffsetsExample, describeWallSubtractError, executeBooleanSubtractionMany, extrudeBrepFace, offsetPolylineGroupRegions, offsetPolylineRegions, parseBooleanError, toObjectTransformation$1 as toObjectTransformation };
 //# sourceMappingURL=index.js.map