okgeometry-api 1.1.13 → 1.1.15

package/dist/wasm-bindings.js

@@ -1688,7 +1688,7 @@ export function version() {
 function __wbg_get_imports() {
     const import0 = {
         __proto__: null,
-        __wbg___okgeometry_boolean_should_cancel_9b2919fd8513410f: function () {
+        __wbg___okgeometry_boolean_should_cancel_18de25279e7a7d72: function () {
             const ret = globalThis.__okgeometry_boolean_should_cancel();
             return ret;
         },

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "okgeometry-api",
-  "version": "1.1.13",
+  "version": "1.1.15",
   "description": "Geometry engine API for AEC applications — NURBS, meshes, booleans, intersections. Powered by Rust/WASM.",
   "type": "module",
   "main": "dist/index.js",

package/src/Circle.ts

@@ -139,15 +139,25 @@ export class Circle {
    * @param caps - Whether to cap the ends (default true)
    * @returns Mesh representing the extruded cylinder
    */
-  extrude(direction: Vec3, segments = 16, caps = true): Mesh {
-    ensureInit();
-    const buf = wasm.extrude_circle(
-      this.center.x, this.center.y, this.center.z,
-      this.normal.x, this.normal.y, this.normal.z,
+  extrude(direction: Vec3, segments = 16, caps = true): Mesh {
+    ensureInit();
+    const buf = wasm.extrude_circle(
+      this.center.x, this.center.y, this.center.z,
+      this.normal.x, this.normal.y, this.normal.z,
       this.radius,
       direction.x, direction.y, direction.z,
       segments, caps
-    );
-    return Mesh.fromBuffer(buf);
-  }
-}
+    );
+    return Mesh.fromBuffer(buf);
+  }
+
+  /**
+   * Extrude this closed circle into a trusted solid suitable for booleans.
+   * @param direction - Extrusion direction and magnitude
+   * @param segments - Number of boundary samples used for tessellation (default 32)
+   * @returns Closed mesh solid ready for boolean operations
+   */
+  extrudeAsSolid(direction: Vec3, segments = 32): Mesh {
+    return Mesh.extrudeCurveAsSolid(this, direction, segments);
+  }
+}

package/src/Mesh.ts

@@ -1192,21 +1192,91 @@ export class Mesh {
    * Extrude a planar curve along a direction.
    * Open curves return an uncapped polysurface; closed curves are capped solids.
    */
-  static extrudePlanarCurve(points: Point[], normal: Vec3, height: number, closed: boolean): Mesh {
-    ensureInit();
-    const buf = wasm.mesh_extrude_planar_curve(
-      pointsToCoords(points),
-      normal.x, normal.y, normal.z,
+  static extrudePlanarCurve(points: Point[], normal: Vec3, height: number, closed: boolean): Mesh {
+    ensureInit();
+    const buf = wasm.mesh_extrude_planar_curve(
+      pointsToCoords(points),
+      normal.x, normal.y, normal.z,
       height,
       closed,
-    );
-    return Mesh.fromTrustedBuffer(buf);
-  }
-
-  /**
-   * Shift a closed cutter profile slightly opposite to travel direction and
-   * compensate height so the distal end remains at the user-intended depth.
-   */
+    );
+    return Mesh.fromTrustedBuffer(buf);
+  }
+
+  private static normalizeClosedCurvePoints(points: Point[], eps = 1e-10): Point[] {
+    const normalized: Point[] = [];
+    for (const point of points) {
+      if (normalized.length > 0 && normalized[normalized.length - 1].equals(point, eps)) continue;
+      normalized.push(point);
+    }
+    if (normalized.length > 1 && normalized[0].equals(normalized[normalized.length - 1], eps)) {
+      normalized.pop();
+    }
+    return normalized;
+  }
+
+  private static getClosedCurveLoopPoints(curve: SweepableCurve, segments: number): Point[] {
+    const closureEps = 1e-6;
+    const sampleCount = Number.isFinite(segments) ? Math.max(3, Math.floor(segments)) : 32;
+
+    if (curve instanceof Circle) {
+      return Mesh.normalizeClosedCurvePoints(curve.sample(sampleCount), closureEps);
+    }
+    if (curve instanceof Polygon || curve instanceof Polyline) {
+      if (!curve.isClosed(closureEps)) {
+        throw new Error("Mesh.extrudeCurveAsSolid() requires a closed polyline or polygon.");
+      }
+      return Mesh.normalizeClosedCurvePoints(curve.points, closureEps);
+    }
+    if (curve instanceof PolyCurve) {
+      if (!curve.isClosed(closureEps)) {
+        throw new Error("Mesh.extrudeCurveAsSolid() requires a closed polycurve.");
+      }
+      return Mesh.normalizeClosedCurvePoints(curve.sample(Math.max(2, sampleCount)), closureEps);
+    }
+    if (curve instanceof NurbsCurve) {
+      if (!curve.isClosed(closureEps)) {
+        throw new Error("Mesh.extrudeCurveAsSolid() requires a closed NURBS curve.");
+      }
+      return Mesh.normalizeClosedCurvePoints(curve.sample(sampleCount), closureEps);
+    }
+
+    throw new Error(
+      "Mesh.extrudeCurveAsSolid() requires a closed curve "
+      + "(Circle, closed Polyline/Polygon, closed PolyCurve, or closed NurbsCurve).",
+    );
+  }
+
+  /**
+   * Extrude a closed planar curve into a trusted closed solid suitable for booleans.
+   * Curved inputs are sampled first, so `segments` controls tessellation density
+   * for circles, polycurves, and NURBS curves.
+   */
+  static extrudeCurveAsSolid(curve: SweepableCurve, direction: Vec3, segments = 32): Mesh {
+    ensureInit();
+
+    const height = direction.length();
+    if (!Number.isFinite(height) || height < 1e-10) {
+      throw new Error("Mesh.extrudeCurveAsSolid() requires a non-zero extrusion direction.");
+    }
+
+    const points = Mesh.getClosedCurveLoopPoints(curve, segments);
+    if (points.length < 3) {
+      throw new Error("Mesh.extrudeCurveAsSolid() requires at least 3 unique boundary points.");
+    }
+
+    const normal = direction.scale(1 / height);
+    const mesh = Mesh.extrudePlanarCurve(points, normal, height, true);
+    if (mesh.vertexCount === 0) {
+      throw new Error("Mesh.extrudeCurveAsSolid() failed. Ensure the curve is planar and closed.");
+    }
+    return mesh;
+  }
+
+  /**
+   * Shift a closed cutter profile slightly opposite to travel direction and
+   * compensate height so the distal end remains at the user-intended depth.
+   */
   static prepareBooleanCutterCurve(
     points: Point[],
     closed: boolean,

package/src/NurbsCurve.ts

@@ -1,10 +1,11 @@
 import { ensureInit } from "./engine.js";
 import { Point } from "./Point.js";
-import { Vec3 } from "./Vec3.js";
-import { Plane } from "./Plane.js";
-import { Polyline } from "./Polyline.js";
-import type { Line } from "./Line.js";
-import type { Arc } from "./Arc.js";
+import { Vec3 } from "./Vec3.js";
+import { Plane } from "./Plane.js";
+import { Mesh } from "./Mesh.js";
+import { Polyline } from "./Polyline.js";
+import type { Line } from "./Line.js";
+import type { Arc } from "./Arc.js";
 import type { RotationAxis } from "./types.js";
 import { parseIntersectionPoints } from "./BufferCodec.js";
 import * as wasm from "./wasm-bindings.js";
@@ -50,15 +51,24 @@ export class NurbsCurve {
    * @param n - Number of points to generate
    * @returns Array of n points along the curve
    */
-  sample(n: number): Point[] {
-    ensureInit();
-    const buf = wasm.sample_nurbs_curve(this._data, n);
-    const pts: Point[] = [];
-    for (let i = 0; i < buf.length; i += 3) {
-      pts.push(new Point(buf[i], buf[i + 1], buf[i + 2]));
-    }
-    return pts;
-  }
+  sample(n: number): Point[] {
+    ensureInit();
+    const buf = wasm.sample_nurbs_curve(this._data, n);
+    const pts: Point[] = [];
+    for (let i = 0; i < buf.length; i += 3) {
+      pts.push(new Point(buf[i], buf[i + 1], buf[i + 2]));
+    }
+    return pts;
+  }
+
+  /**
+   * Check if this NURBS curve is closed.
+   * @param eps - Tolerance for comparing start and end points
+   * @returns True if the curve closes on itself
+   */
+  isClosed(eps = 1e-10): boolean {
+    return this.pointAt(0).equals(this.pointAt(1), eps);
+  }
 
   /**
    * Find intersection points with a plane.
@@ -153,15 +163,25 @@ export class NurbsCurve {
    * @param samples - Number of sample points (default 64)
    * @returns Offset polyline approximation
    */
-  offset(distance: number, normal?: Vec3, samples = 64): Polyline {
-    const pts = this.sample(samples);
-    const pl = new Polyline(pts);
-    return pl.offset(distance, normal);
-  }
-
-  /**
-   * Decode a NurbsCurve from WASM flat buffer.
-   * @param data - Buffer in format [degree, num_cp, xyz..., w..., k...]
+  offset(distance: number, normal?: Vec3, samples = 64): Polyline {
+    const pts = this.sample(samples);
+    const pl = new Polyline(pts);
+    return pl.offset(distance, normal);
+  }
+
+  /**
+   * Extrude this closed NURBS curve into a trusted solid suitable for booleans.
+   * @param direction - Extrusion direction and magnitude
+   * @param segments - Number of curve samples used for tessellation (default 64)
+   * @returns Closed mesh solid ready for boolean operations
+   */
+  extrudeAsSolid(direction: Vec3, segments = 64): Mesh {
+    return Mesh.extrudeCurveAsSolid(this, direction, segments);
+  }
+
+  /**
+   * Decode a NurbsCurve from WASM flat buffer.
+   * @param data - Buffer in format [degree, num_cp, xyz..., w..., k...]
    * @returns New NurbsCurve instance
    */
   static fromData(data: Float64Array | number[]): NurbsCurve {

package/src/PolyCurve.ts

@@ -1,14 +1,15 @@
 import { ensureInit } from "./engine.js";
 import { Point } from "./Point.js";
 import { Line } from "./Line.js";
-import { Arc } from "./Arc.js";
-import { Vec3 } from "./Vec3.js";
-import { NurbsCurve } from "./NurbsCurve.js";
-import type { Plane } from "./Plane.js";
-import type { CurveSegment, RotationAxis } from "./types.js";
-import { SegmentTypeCode } from "./types.js";
-import { pointsToCoords, coordsToPoints } from "./BufferCodec.js";
-import * as wasm from "./wasm-bindings.js";
+import { Arc } from "./Arc.js";
+import { Vec3 } from "./Vec3.js";
+import { Mesh } from "./Mesh.js";
+import { NurbsCurve } from "./NurbsCurve.js";
+import type { Plane } from "./Plane.js";
+import type { CurveSegment, RotationAxis } from "./types.js";
+import { SegmentTypeCode } from "./types.js";
+import { pointsToCoords } from "./BufferCodec.js";
+import * as wasm from "./wasm-bindings.js";
 
 /**
  * Composite curve made of sequential Line and Arc segments.
@@ -108,10 +109,10 @@ export class PolyCurve {
     return new PolyCurve(this.segments.map(s => s.translate(offset)));
   }
 
-  projectOntoPlane(plane: Plane, direction?: Vec3, arcSamples = 32): PolyCurve {
-    const proj = (p: Point) => direction ? plane.projectPointAlongDirection(p, direction) : plane.projectPoint(p);
-    const segs: CurveSegment[] = [];
-    for (const s of this.segments) {
+  projectOntoPlane(plane: Plane, direction?: Vec3, arcSamples = 32): PolyCurve {
+    const proj = (p: Point) => direction ? plane.projectPointAlongDirection(p, direction) : plane.projectPoint(p);
+    const segs: CurveSegment[] = [];
+    for (const s of this.segments) {
       if (s instanceof Line) {
         segs.push(new Line(proj(s.start), proj(s.end)));
       } else {
@@ -121,14 +122,45 @@ export class PolyCurve {
           segs.push(new Line(proj(pts[i]), proj(pts[i + 1])));
         }
       }
-    }
-    return new PolyCurve(segs);
-  }
-
-  /**
-   * Fillet corners of this PolyCurve with arcs of the given radius.
-   * Extracts the vertex points, calls WASM fillet_corners, returns a new PolyCurve.
-   */
+    }
+    return new PolyCurve(segs);
+  }
+
+  /**
+   * Extrude this polycurve along a direction vector.
+   * Curved segments are sampled to a polyline first, so `segments` controls
+   * the tessellation density used for arc segments before extrusion.
+   * @param direction - Extrusion direction and magnitude
+   * @param segments - Number of samples per arc segment (default 32)
+   * @param caps - Whether to cap closed profiles (default false)
+   * @returns Mesh representing the extruded surface
+   */
+  extrude(direction: Vec3, segments = 32, caps = false): Mesh {
+    ensureInit();
+    const arcSamples = Number.isFinite(segments) ? Math.max(2, Math.floor(segments)) : 32;
+    const buf = wasm.extrude_polyline(
+      pointsToCoords(this.sample(arcSamples)),
+      direction.x, direction.y, direction.z,
+      arcSamples, caps,
+    );
+    return Mesh.fromBuffer(buf);
+  }
+
+  /**
+   * Extrude this closed polycurve into a trusted solid suitable for booleans.
+   * Curved segments are sampled first, so `segments` controls tessellation density.
+   * @param direction - Extrusion direction and magnitude
+   * @param segments - Number of samples per curved segment (default 32)
+   * @returns Closed mesh solid ready for boolean operations
+   */
+  extrudeAsSolid(direction: Vec3, segments = 32): Mesh {
+    return Mesh.extrudeCurveAsSolid(this, direction, segments);
+  }
+
+  /**
+   * Fillet corners of this PolyCurve with arcs of the given radius.
+   * Extracts the vertex points, calls WASM fillet_corners, returns a new PolyCurve.
+   */
   fillet(radius: number, normal?: Vec3): PolyCurve {
     ensureInit();
     if (this.segments.length < 2) {

package/src/Polyline.ts

@@ -57,19 +57,28 @@ export class Polyline {
    * @param caps - Whether to cap the ends (default false)
    * @returns Mesh representing the extruded surface
    */
-  extrude(direction: Vec3, segments = 1, caps = false): Mesh {
-    ensureInit();
-    const buf = wasm.extrude_polyline(
-      this.toCoords(),
-      direction.x, direction.y, direction.z,
+  extrude(direction: Vec3, segments = 1, caps = false): Mesh {
+    ensureInit();
+    const buf = wasm.extrude_polyline(
+      this.toCoords(),
+      direction.x, direction.y, direction.z,
       segments, caps
-    );
-    return Mesh.fromBuffer(buf);
-  }
-
-  /**
-   * Translate this polyline by an offset vector.
-   * @param offset - Translation vector
+    );
+    return Mesh.fromBuffer(buf);
+  }
+
+  /**
+   * Extrude this closed polyline into a trusted solid suitable for booleans.
+   * @param direction - Extrusion direction and magnitude
+   * @returns Closed mesh solid ready for boolean operations
+   */
+  extrudeAsSolid(direction: Vec3): Mesh {
+    return Mesh.extrudeCurveAsSolid(this, direction);
+  }
+
+  /**
+   * Translate this polyline by an offset vector.
+   * @param offset - Translation vector
    * @returns New translated polyline
    */
   translate(offset: Vec3): Polyline {