okgeometry-api 1.2.0 → 1.2.1

package/src/Polyline.ts

@@ -1,13 +1,13 @@
 import { ensureInit } from "./engine.js";
 import { Point } from "./Point.js";
 import { Vec3 } from "./Vec3.js";
-import { Mesh } from "./Mesh.js";
-import { Line } from "./Line.js";
-import { PolyCurve } from "./PolyCurve.js";
-import type { Plane } from "./Plane.js";
-import type { RotationAxis } from "./types.js";
-import { pointsToCoords, coordsToPoints } from "./BufferCodec.js";
-import * as wasm from "./wasm-bindings.js";
+import { Mesh } from "./Mesh.js";
+import { Line } from "./Line.js";
+import { PolyCurve } from "./PolyCurve.js";
+import type { Plane } from "./Plane.js";
+import type { CurveOffsetOptions, RotationAxis } from "./types.js";
+import { pointsToCoords } from "./BufferCodec.js";
+import * as wasm from "./wasm-bindings.js";
 
 /**
  * Open or closed polyline defined by a sequence of points.
@@ -95,23 +95,73 @@ export class Polyline {
     return new Polyline(this.points.map(p => p.rotate(axis, angle)));
   }
 
-  /**
-   * Offset this polyline perpendicular to its segments.
-   * @param distance - Offset distance
-   * @param normal - Reference normal for determining offset direction
-   * @returns New offset polyline
-   */
-  offset(distance: number, normal?: Vec3): Polyline {
-    ensureInit();
-    const nx = normal?.x ?? 0, ny = normal?.y ?? 0, nz = normal?.z ?? 0;
-    const result = wasm.offset_polyline_curve(this.toCoords(), distance, nx, ny, nz);
-    return new Polyline(coordsToPoints(result));
-  }
-
-  /**
-   * Project this polyline onto a plane.
-   * @param plane - Target plane
-   * @param direction - Optional projection direction (default: perpendicular to plane)
+  /**
+   * Offset this polyline perpendicular to its segments.
+   * @param distance - Offset distance
+   * @param normal - Reference normal for determining offset direction
+   * @param arcSamples - Number of samples per arc join in the returned polyline(s)
+   * @param options - Offset options such as join style
+   * @returns New offset polyline
+   */
+  offset(
+    distance: number,
+    normal?: Vec3,
+    arcSamples = 32,
+    options: CurveOffsetOptions = {},
+  ): Polyline {
+    const results = this.offsetAll(distance, normal, arcSamples, options);
+    if (results.length === 1) return results[0];
+    if (results.length === 0) {
+      throw new Error("Polyline.offset() collapsed and produced no valid result polylines");
+    }
+    throw new Error(
+      `Polyline.offset() produced ${results.length} result polylines. Use Polyline.offsetAll() instead.`,
+    );
+  }
+
+  /**
+   * Offset this polyline and return every sampled result polyline.
+   * @param distance - Offset distance
+   * @param normal - Reference normal for determining offset direction
+   * @param arcSamples - Number of samples per exact arc segment in the returned polylines
+   * @param options - Offset options such as join style
+   * @returns Every valid offset polyline
+   */
+  offsetAll(
+    distance: number,
+    normal?: Vec3,
+    arcSamples = 32,
+    options: CurveOffsetOptions = {},
+  ): Polyline[] {
+    const exact = this.toPolyCurve().offsetAll(distance, normal, options);
+    const samples = Number.isFinite(arcSamples) ? Math.max(3, Math.floor(arcSamples)) : 32;
+    return exact.map(curve => new Polyline(curve.sample(samples)));
+  }
+
+  /**
+   * Thicken this open polyline into a closed PolyCurve suitable for extrusion.
+   * When `bothSides` is false, the source polyline forms one side of the result.
+   * When true, the thickness is added on each side of the source polyline.
+   */
+  thicken(
+    distance: number,
+    bothSides = false,
+    normal?: Vec3,
+    options: CurveOffsetOptions = {},
+  ): PolyCurve {
+    if (this.points.length < 2) {
+      throw new Error("Polyline.thicken() requires at least 2 points");
+    }
+    if (this.isClosed()) {
+      throw new Error("Polyline.thicken() requires an open polyline");
+    }
+    return this.toPolyCurve().thicken(distance, bothSides, normal, options);
+  }
+
+  /**
+   * Project this polyline onto a plane.
+   * @param plane - Target plane
+   * @param direction - Optional projection direction (default: perpendicular to plane)
    * @returns New projected polyline
    */
   projectOntoPlane(plane: Plane, direction?: Vec3): Polyline {

package/src/Surface.ts

@@ -0,0 +1,18 @@
+import type { Point } from "./Point.js";
+import type { Vec3 } from "./Vec3.js";
+
+/**
+ * Common parametric surface contract shared by NURBS surfaces and mesh-face surfaces.
+ */
+export interface Surface {
+  /**
+   * Evaluate a point on the surface at normalized parameters.
+   * Returns `Point(NaN, NaN, NaN)` when the query falls outside the valid surface patch.
+   */
+  evaluate(u: number, v: number): Point;
+
+  /**
+   * Evaluate the unit normal on the surface at normalized parameters.
+   */
+  normal(u: number, v: number): Vec3;
+}

package/src/index.ts

@@ -7,6 +7,8 @@ export type {
   LoftableCurve,
   RotationAxis,
   CurveSegment,
+  CurveOffsetJoinStyle,
+  CurveOffsetOptions,
 } from "./types.js";
 export { CurveTypeCode, SegmentTypeCode } from "./types.js";
 export {
@@ -31,6 +33,8 @@ export { Polygon } from "./Polygon.js";
 export { PolyCurve } from "./PolyCurve.js";
 export { NurbsCurve } from "./NurbsCurve.js";
 export { NurbsSurface } from "./NurbsSurface.js";
+export { MeshSurface } from "./MeshSurface.js";
+export type { Surface } from "./Surface.js";
 
 // Mesh and operations
 export { Mesh, MeshBooleanExecutionError } from "./Mesh.js";
@@ -50,6 +54,7 @@ export type {
   MeshPlaneSplitResult,
   MeshPlaneSplitOptions,
   MeshCurveSplitOptions,
+  MeshPlanarFace,
   MeshDebugBounds,
   MeshDebugRayHit,
   MeshDebugSummary,

package/src/types.ts

@@ -47,6 +47,21 @@ export type RotationAxis = Vec3 | Line;
  */
 export type CurveSegment = Line | Arc;
 
+/**
+ * Join style used when offsetting polycurves and sampled curve types.
+ * - `miter`: extend adjacent offset segments until they intersect
+ * - `round`: connect outside corners with an arc
+ * - `bevel`: connect outside corners with a straight bridge segment
+ */
+export type CurveOffsetJoinStyle = "miter" | "round" | "bevel";
+
+/**
+ * Optional settings for curve offset operations.
+ */
+export interface CurveOffsetOptions {
+  joinStyle?: CurveOffsetJoinStyle;
+}
+
 // ── WASM Buffer Encoding Constants ─────────────────────────────────
 
 /**