okgeometry-api 1.26.1 → 1.27.0

package/src/PolyCurve.ts

@@ -1,6 +1,6 @@
-import { ensureInit } from "./engine.js";
-import { Point } from "./Point.js";
-import { Line } from "./Line.js";
+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 { Mesh } from "./Mesh.js";
@@ -14,7 +14,7 @@ import type {
 } from "./types.js";
 import { SegmentTypeCode } from "./types.js";
 import { pointsToCoords } from "./BufferCodec.js";
-import * as wasm from "./wasm-bindings.js";
+import { wasm } from "./wasm-active.js";
 
 function offsetJoinStyleCode(style: CurveOffsetJoinStyle | undefined): number {
   switch (style ?? "miter") {
@@ -31,113 +31,113 @@ function offsetJoinStyleCode(style: CurveOffsetJoinStyle | undefined): number {
  * Composite curve made of sequential Line and Arc segments.
  */
 export class PolyCurve {
-  public readonly segments: CurveSegment[];
-
-  constructor(segments: CurveSegment[]) {
-    this.segments = segments;
-  }
-
-  /** Create a PolyCurve by connecting points with line segments */
-  static byPoints(points: Point[]): PolyCurve {
-    if (points.length < 2) return new PolyCurve([]);
-    const segs: CurveSegment[] = [];
-    for (let i = 0; i < points.length - 1; i++) {
-      segs.push(new Line(points[i], points[i + 1]));
-    }
-    return new PolyCurve(segs);
-  }
-
-  get startPoint(): Point {
-    if (this.segments.length === 0) return Point.ORIGIN;
-    const s = this.segments[0];
-    return s instanceof Line ? s.start : s.pointAt(0);
-  }
-
-  get endPoint(): Point {
-    if (this.segments.length === 0) return Point.ORIGIN;
-    const s = this.segments[this.segments.length - 1];
-    return s instanceof Line ? s.end : s.pointAt(1);
-  }
-
-  /** Returns all constituent curves (Line and Arc segments) in order. */
-  get curves(): CurveSegment[] {
-    return this.segments;
-  }
-
-  /**
-   * Sample all segments into a flat array of points for rendering.
-   * Line segments produce 2 points; Arc segments are sampled with `arcSamples` points.
-   * Consecutive duplicate junction points are removed.
-   */
-  sample(arcSamples = 32): Point[] {
-    const pts: Point[] = [];
-    for (const seg of this.segments) {
-      let segPts: Point[];
-      if (seg instanceof Line) {
-        segPts = [seg.start, seg.end];
-      } else {
-        // Arc: sample into multiple points for smooth rendering
-        segPts = seg.sample(arcSamples);
-      }
-      for (const p of segPts) {
-        // Skip duplicate junction points
-        if (pts.length > 0 && pts[pts.length - 1].equals(p)) continue;
-        pts.push(p);
-      }
-    }
-    return pts;
-  }
-
-  /** Evaluate a point on the curve at normalized parameter t (0 = start, 1 = end). */
-  pointAt(t: number): Point {
-    if (this.segments.length === 0) return Point.ORIGIN;
-    if (t <= 0) return this.startPoint;
-    if (t >= 1) return this.endPoint;
-
-    const lengths = this.segments.map(s => s.length());
-    const total = lengths.reduce((a, b) => a + b, 0);
-    if (total === 0) return this.startPoint;
-
-    let target = t * total;
-    for (let i = 0; i < this.segments.length; i++) {
-      if (target <= lengths[i] || i === this.segments.length - 1) {
-        const localT = lengths[i] > 0 ? target / lengths[i] : 0;
-        return this.segments[i].pointAt(Math.min(localT, 1));
-      }
-      target -= lengths[i];
-    }
-    return this.endPoint;
-  }
-
-  isClosed(eps = 1e-10): boolean {
-    return this.startPoint.equals(this.endPoint, eps);
-  }
-
-  length(): number {
-    return this.segments.reduce((sum, s) => sum + s.length(), 0);
-  }
-
-  rotate(axis: RotationAxis, angle: number): PolyCurve {
-    return new PolyCurve(this.segments.map(s => s.rotate(axis, angle)));
-  }
-
-  translate(offset: Vec3): PolyCurve {
-    return new PolyCurve(this.segments.map(s => s.translate(offset)));
-  }
-
+  public readonly segments: CurveSegment[];
+
+  constructor(segments: CurveSegment[]) {
+    this.segments = segments;
+  }
+
+  /** Create a PolyCurve by connecting points with line segments */
+  static byPoints(points: Point[]): PolyCurve {
+    if (points.length < 2) return new PolyCurve([]);
+    const segs: CurveSegment[] = [];
+    for (let i = 0; i < points.length - 1; i++) {
+      segs.push(new Line(points[i], points[i + 1]));
+    }
+    return new PolyCurve(segs);
+  }
+
+  get startPoint(): Point {
+    if (this.segments.length === 0) return Point.ORIGIN;
+    const s = this.segments[0];
+    return s instanceof Line ? s.start : s.pointAt(0);
+  }
+
+  get endPoint(): Point {
+    if (this.segments.length === 0) return Point.ORIGIN;
+    const s = this.segments[this.segments.length - 1];
+    return s instanceof Line ? s.end : s.pointAt(1);
+  }
+
+  /** Returns all constituent curves (Line and Arc segments) in order. */
+  get curves(): CurveSegment[] {
+    return this.segments;
+  }
+
+  /**
+   * Sample all segments into a flat array of points for rendering.
+   * Line segments produce 2 points; Arc segments are sampled with `arcSamples` points.
+   * Consecutive duplicate junction points are removed.
+   */
+  sample(arcSamples = 32): Point[] {
+    const pts: Point[] = [];
+    for (const seg of this.segments) {
+      let segPts: Point[];
+      if (seg instanceof Line) {
+        segPts = [seg.start, seg.end];
+      } else {
+        // Arc: sample into multiple points for smooth rendering
+        segPts = seg.sample(arcSamples);
+      }
+      for (const p of segPts) {
+        // Skip duplicate junction points
+        if (pts.length > 0 && pts[pts.length - 1].equals(p)) continue;
+        pts.push(p);
+      }
+    }
+    return pts;
+  }
+
+  /** Evaluate a point on the curve at normalized parameter t (0 = start, 1 = end). */
+  pointAt(t: number): Point {
+    if (this.segments.length === 0) return Point.ORIGIN;
+    if (t <= 0) return this.startPoint;
+    if (t >= 1) return this.endPoint;
+
+    const lengths = this.segments.map(s => s.length());
+    const total = lengths.reduce((a, b) => a + b, 0);
+    if (total === 0) return this.startPoint;
+
+    let target = t * total;
+    for (let i = 0; i < this.segments.length; i++) {
+      if (target <= lengths[i] || i === this.segments.length - 1) {
+        const localT = lengths[i] > 0 ? target / lengths[i] : 0;
+        return this.segments[i].pointAt(Math.min(localT, 1));
+      }
+      target -= lengths[i];
+    }
+    return this.endPoint;
+  }
+
+  isClosed(eps = 1e-10): boolean {
+    return this.startPoint.equals(this.endPoint, eps);
+  }
+
+  length(): number {
+    return this.segments.reduce((sum, s) => sum + s.length(), 0);
+  }
+
+  rotate(axis: RotationAxis, angle: number): PolyCurve {
+    return new PolyCurve(this.segments.map(s => s.rotate(axis, angle)));
+  }
+
+  translate(offset: Vec3): 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) {
-      if (s instanceof Line) {
-        segs.push(new Line(proj(s.start), proj(s.end)));
-      } else {
-        // Arc projects to elliptical arc — approximate with line segments
-        const pts = s.sample(arcSamples);
-        for (let i = 0; i < pts.length - 1; i++) {
-          segs.push(new Line(proj(pts[i]), proj(pts[i + 1])));
-        }
-      }
+      if (s instanceof Line) {
+        segs.push(new Line(proj(s.start), proj(s.end)));
+      } else {
+        // Arc projects to elliptical arc — approximate with line segments
+        const pts = s.sample(arcSamples);
+        for (let i = 0; i < pts.length - 1; i++) {
+          segs.push(new Line(proj(pts[i]), proj(pts[i + 1])));
+        }
+      }
     }
     return new PolyCurve(segs);
   }
@@ -177,66 +177,66 @@ export class PolyCurve {
    * 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) {
-      throw new Error("PolyCurve.fillet() requires at least 2 segments");
-    }
-
-    // Extract all vertex points from segments
-    const pts: Point[] = [];
-    for (const seg of this.segments) {
-      if (seg instanceof Line) {
-        if (pts.length === 0) pts.push(seg.start);
-        pts.push(seg.end);
-      } else {
-        // Arc: use start and end points
-        if (pts.length === 0) pts.push(seg.pointAt(0));
-        pts.push(seg.pointAt(1));
-      }
-    }
-    if (pts.length < 3) {
-      throw new Error("PolyCurve.fillet() requires at least 3 vertices");
-    }
-
-    const coords = new Float64Array(pts.length * 3);
-    for (let i = 0; i < pts.length; i++) {
-      coords[i * 3] = pts[i].x;
-      coords[i * 3 + 1] = pts[i].y;
-      coords[i * 3 + 2] = pts[i].z;
-    }
-
-    const nx = normal?.x ?? 0, ny = normal?.y ?? 0, nz = normal?.z ?? 0;
-    const buf = wasm.fillet_polycurve(coords, radius, nx, ny, nz);
-    if (buf.length < 1) {
-      throw new Error("PolyCurve.fillet() failed - WASM returned empty result");
-    }
-    return PolyCurve.fromSegmentData(buf);
-  }
-
-  /** Decode a PolyCurve from WASM segment buffer [count, type, ...data, ...] */
+  fillet(radius: number, normal?: Vec3): PolyCurve {
+    ensureInit();
+    if (this.segments.length < 2) {
+      throw new Error("PolyCurve.fillet() requires at least 2 segments");
+    }
+
+    // Extract all vertex points from segments
+    const pts: Point[] = [];
+    for (const seg of this.segments) {
+      if (seg instanceof Line) {
+        if (pts.length === 0) pts.push(seg.start);
+        pts.push(seg.end);
+      } else {
+        // Arc: use start and end points
+        if (pts.length === 0) pts.push(seg.pointAt(0));
+        pts.push(seg.pointAt(1));
+      }
+    }
+    if (pts.length < 3) {
+      throw new Error("PolyCurve.fillet() requires at least 3 vertices");
+    }
+
+    const coords = new Float64Array(pts.length * 3);
+    for (let i = 0; i < pts.length; i++) {
+      coords[i * 3] = pts[i].x;
+      coords[i * 3 + 1] = pts[i].y;
+      coords[i * 3 + 2] = pts[i].z;
+    }
+
+    const nx = normal?.x ?? 0, ny = normal?.y ?? 0, nz = normal?.z ?? 0;
+    const buf = wasm.fillet_polycurve(coords, radius, nx, ny, nz);
+    if (buf.length < 1) {
+      throw new Error("PolyCurve.fillet() failed - WASM returned empty result");
+    }
+    return PolyCurve.fromSegmentData(buf);
+  }
+
+  /** Decode a PolyCurve from WASM segment buffer [count, type, ...data, ...] */
   static fromSegmentData(buf: Float64Array | number[]): PolyCurve {
     const count = buf[0];
     const segs: CurveSegment[] = [];
     let idx = 1;
-    for (let i = 0; i < count; i++) {
-      const type = buf[idx++];
-      if (type === SegmentTypeCode.Line) {
-        // Line: 6 floats
-        const s = new Point(buf[idx], buf[idx + 1], buf[idx + 2]);
-        const e = new Point(buf[idx + 3], buf[idx + 4], buf[idx + 5]);
-        segs.push(new Line(s, e));
-        idx += 6;
-      } else if (type === SegmentTypeCode.Arc) {
-        // Arc: 9 floats
-        const center = new Point(buf[idx], buf[idx + 1], buf[idx + 2]);
-        const normal = new Vec3(buf[idx + 3], buf[idx + 4], buf[idx + 5]);
-        const radius = buf[idx + 6];
-        const startAngle = buf[idx + 7];
-        const endAngle = buf[idx + 8];
-        segs.push(new Arc(center, radius, startAngle, endAngle, normal));
-        idx += 9;
-      }
+    for (let i = 0; i < count; i++) {
+      const type = buf[idx++];
+      if (type === SegmentTypeCode.Line) {
+        // Line: 6 floats
+        const s = new Point(buf[idx], buf[idx + 1], buf[idx + 2]);
+        const e = new Point(buf[idx + 3], buf[idx + 4], buf[idx + 5]);
+        segs.push(new Line(s, e));
+        idx += 6;
+      } else if (type === SegmentTypeCode.Arc) {
+        // Arc: 9 floats
+        const center = new Point(buf[idx], buf[idx + 1], buf[idx + 2]);
+        const normal = new Vec3(buf[idx + 3], buf[idx + 4], buf[idx + 5]);
+        const radius = buf[idx + 6];
+        const startAngle = buf[idx + 7];
+        const endAngle = buf[idx + 8];
+        segs.push(new Arc(center, radius, startAngle, endAngle, normal));
+        idx += 9;
+      }
     }
     return new PolyCurve(segs);
   }
@@ -263,45 +263,45 @@ export class PolyCurve {
 
     return curves;
   }
-
-  /**
-   * Chamfer corners of this PolyCurve by cutting each corner with a straight segment.
-   * Returns a new PolyCurve of line segments only.
-   */
-  chamfer(distance: number): PolyCurve {
-    ensureInit();
-    if (this.segments.length < 2) {
-      throw new Error("PolyCurve.chamfer() requires at least 2 segments");
-    }
-
-    const pts: Point[] = [];
-    for (const seg of this.segments) {
-      if (seg instanceof Line) {
-        if (pts.length === 0) pts.push(seg.start);
-        pts.push(seg.end);
-      } else {
-        if (pts.length === 0) pts.push(seg.pointAt(0));
-        pts.push(seg.pointAt(1));
-      }
-    }
-    if (pts.length < 3) {
-      throw new Error("PolyCurve.chamfer() requires at least 3 vertices");
-    }
-
-    const coords = new Float64Array(pts.length * 3);
-    for (let i = 0; i < pts.length; i++) {
-      coords[i * 3] = pts[i].x;
-      coords[i * 3 + 1] = pts[i].y;
-      coords[i * 3 + 2] = pts[i].z;
-    }
-
-    const buf = wasm.chamfer_polycurve(coords, distance);
-    if (buf.length < 1) {
-      throw new Error("PolyCurve.chamfer() failed - WASM returned empty result");
-    }
-    return PolyCurve.fromSegmentData(buf);
-  }
-
+
+  /**
+   * Chamfer corners of this PolyCurve by cutting each corner with a straight segment.
+   * Returns a new PolyCurve of line segments only.
+   */
+  chamfer(distance: number): PolyCurve {
+    ensureInit();
+    if (this.segments.length < 2) {
+      throw new Error("PolyCurve.chamfer() requires at least 2 segments");
+    }
+
+    const pts: Point[] = [];
+    for (const seg of this.segments) {
+      if (seg instanceof Line) {
+        if (pts.length === 0) pts.push(seg.start);
+        pts.push(seg.end);
+      } else {
+        if (pts.length === 0) pts.push(seg.pointAt(0));
+        pts.push(seg.pointAt(1));
+      }
+    }
+    if (pts.length < 3) {
+      throw new Error("PolyCurve.chamfer() requires at least 3 vertices");
+    }
+
+    const coords = new Float64Array(pts.length * 3);
+    for (let i = 0; i < pts.length; i++) {
+      coords[i * 3] = pts[i].x;
+      coords[i * 3 + 1] = pts[i].y;
+      coords[i * 3 + 2] = pts[i].z;
+    }
+
+    const buf = wasm.chamfer_polycurve(coords, distance);
+    if (buf.length < 1) {
+      throw new Error("PolyCurve.chamfer() failed - WASM returned empty result");
+    }
+    return PolyCurve.fromSegmentData(buf);
+  }
+
   /**
    * Offset this PolyCurve by a distance in the given plane.
    * Preserves exact line/arc segments where possible and applies the requested outside-corner join style.
@@ -383,7 +383,7 @@ export class PolyCurve {
    * Convert to an exact NURBS curve representation via WASM.
    * Lines become degree-1 NURBS, Arcs become degree-2 rational NURBS.
    * All segments are degree-elevated to a common degree and joined.
-   */
+   */
   toNurbs(): NurbsCurve {
     ensureInit();
     const buf = wasm.polycurve_to_nurbs(this.toSegmentData());