okgeometry-api 0.5.0 → 0.5.2

package/src/mesh-boolean.worker.ts

@@ -0,0 +1,160 @@
+import { init, isInitialized } from "./engine.js";
+import { Mesh } from "./Mesh.js";
+import type {
+  MeshBooleanErrorPayload,
+  MeshBooleanWorkerErrorResponse,
+  MeshBooleanWorkerInbound,
+  MeshBooleanWorkerResponse,
+  MeshBooleanWorkerSuccessResponse,
+} from "./mesh-boolean.protocol.js";
+
+const workerScope = self as unknown as {
+  postMessage: (message: MeshBooleanWorkerResponse, transfer?: Transferable[]) => void;
+  addEventListener: (type: "message", listener: (event: MessageEvent<MeshBooleanWorkerInbound>) => void) => void;
+};
+const workerGlobal = globalThis as typeof globalThis & {
+  __okgeometryBooleanCancelFlag?: Int32Array | null;
+  __okgeometry_boolean_should_cancel?: () => boolean;
+};
+
+const cancelledJobs = new Set<number>();
+let initPromise: Promise<void> | null = null;
+
+function readCancelRequested(cancelView: Int32Array | undefined): boolean {
+  if (!cancelView) return false;
+  try {
+    return (Atomics.load(cancelView, 0) | 0) !== 0;
+  } catch {
+    return (cancelView[0] | 0) !== 0;
+  }
+}
+
+function isCancelled(jobId: number, cancelView: Int32Array | undefined): boolean {
+  return cancelledJobs.has(jobId) || readCancelRequested(cancelView);
+}
+
+workerGlobal.__okgeometry_boolean_should_cancel = () =>
+  readCancelRequested(workerGlobal.__okgeometryBooleanCancelFlag ?? undefined);
+
+function nowMs(): number {
+  if (typeof performance !== "undefined" && typeof performance.now === "function") {
+    return performance.now();
+  }
+  return Date.now();
+}
+
+function toErrorMessage(error: unknown): string {
+  if (error instanceof Error) return error.message;
+  if (typeof error === "string") return error;
+  return String(error);
+}
+
+function makeError(code: MeshBooleanErrorPayload["code"], message: string, details?: string): MeshBooleanErrorPayload {
+  return { code, message, details };
+}
+
+function postError(jobId: number, startedAt: number, payload: MeshBooleanErrorPayload): void {
+  const response: MeshBooleanWorkerErrorResponse = {
+    kind: "mesh-boolean-result",
+    jobId,
+    ok: false,
+    error: payload,
+    elapsedMs: Math.max(0, nowMs() - startedAt),
+  };
+  workerScope.postMessage(response);
+}
+
+function postSuccess(jobId: number, startedAt: number, buffer: ArrayBuffer): void {
+  const response: MeshBooleanWorkerSuccessResponse = {
+    kind: "mesh-boolean-result",
+    jobId,
+    ok: true,
+    buffer,
+    elapsedMs: Math.max(0, nowMs() - startedAt),
+  };
+  workerScope.postMessage(response, [buffer]);
+}
+
+async function ensureWorkerInit(): Promise<void> {
+  if (isInitialized()) return;
+  if (!initPromise) {
+    initPromise = init();
+  }
+  await initPromise;
+}
+
+workerScope.addEventListener("message", async (event: MessageEvent<MeshBooleanWorkerInbound>) => {
+  const message = event.data;
+  if (!message) return;
+
+  if (message.kind === "mesh-boolean-cancel") {
+    cancelledJobs.add(message.jobId);
+    return;
+  }
+
+  if (message.kind !== "mesh-boolean-request") return;
+  const startedAt = nowMs();
+  const jobId = message.jobId;
+  const cancelView = message.cancelBuffer ? new Int32Array(message.cancelBuffer) : undefined;
+
+  if (isCancelled(jobId, cancelView)) {
+    postError(jobId, startedAt, makeError("worker_aborted", `Boolean ${message.operation} aborted.`));
+    cancelledJobs.delete(jobId);
+    return;
+  }
+
+  try {
+    await ensureWorkerInit();
+
+    if (isCancelled(jobId, cancelView)) {
+      postError(jobId, startedAt, makeError("worker_aborted", `Boolean ${message.operation} aborted.`));
+      cancelledJobs.delete(jobId);
+      return;
+    }
+
+    workerGlobal.__okgeometryBooleanCancelFlag = cancelView ?? null;
+
+    const meshA = Mesh.fromBuffer(new Float64Array(message.bufferA));
+    const meshB = Mesh.fromBuffer(new Float64Array(message.bufferB));
+    const options = {
+      allowUnsafe: message.options.allowUnsafe ?? true,
+      limits: message.options.limits,
+      backend: message.options.backend,
+    };
+
+    let result: Mesh;
+    if (message.operation === "union") {
+      result = meshA.union(meshB, options);
+    } else if (message.operation === "subtraction") {
+      result = meshA.subtract(meshB, options);
+    } else {
+      result = meshA.intersect(meshB, options);
+    }
+
+    if (isCancelled(jobId, cancelView)) {
+      postError(jobId, startedAt, makeError("worker_aborted", `Boolean ${message.operation} aborted.`));
+      cancelledJobs.delete(jobId);
+      return;
+    }
+
+    const payload = new Float64Array(result.rawBuffer);
+    postSuccess(jobId, startedAt, payload.buffer);
+  } catch (error) {
+    const details = toErrorMessage(error);
+    const cancelled = isCancelled(jobId, cancelView) || details.toLowerCase().includes("cancel");
+    postError(
+      jobId,
+      startedAt,
+      makeError(
+        cancelled ? "worker_aborted" : "kernel_error",
+        cancelled ? `Boolean ${message.operation} aborted.` : `Boolean ${message.operation} failed.`,
+        cancelled ? undefined : details,
+      ),
+    );
+  } finally {
+    workerGlobal.__okgeometryBooleanCancelFlag = null;
+    cancelledJobs.delete(jobId);
+  }
+});
+
+export {};

package/src/types.ts

@@ -0,0 +1,84 @@
+/**
+ * Shared type definitions for OkGeometry API.
+ * This module consolidates types used across multiple files.
+ * @module types
+ */
+
+import type { Line } from "./Line.js";
+import type { Circle } from "./Circle.js";
+import type { Arc } from "./Arc.js";
+import type { Polyline } from "./Polyline.js";
+import type { Polygon } from "./Polygon.js";
+import type { NurbsCurve } from "./NurbsCurve.js";
+import type { PolyCurve } from "./PolyCurve.js";
+import type { Vec3 } from "./Vec3.js";
+
+// ── Curve Type Unions ──────────────────────────────────────────────
+
+/**
+ * Any curve type that sweep/loft operations can accept.
+ * All these types support pointAt(), sample(), and length() methods.
+ */
+export type SweepableCurve =
+  | Line
+  | Circle
+  | Arc
+  | Polyline
+  | Polygon
+  | NurbsCurve
+  | PolyCurve;
+
+/**
+ * Alias for SweepableCurve - any curve type that loft operations can accept.
+ * Provided for semantic clarity in loft-specific contexts.
+ */
+export type LoftableCurve = SweepableCurve;
+
+/**
+ * Rotation axis specification.
+ * - Vec3: Rotation around axis through origin
+ * - Line: Rotation around arbitrary axis in space
+ */
+export type RotationAxis = Vec3 | Line;
+
+/**
+ * Curve segment types used in PolyCurve.
+ * A PolyCurve is composed of sequential Line and Arc segments.
+ */
+export type CurveSegment = Line | Arc;
+
+// ── WASM Buffer Encoding Constants ─────────────────────────────────
+
+/**
+ * Curve type codes for WASM buffer encoding.
+ * Used by Mesh.encodeCurve() for sweep_curves WASM function.
+ *
+ * Buffer formats:
+ * - Line (0): [0, sx,sy,sz, ex,ey,ez] - 7 floats
+ * - Circle (1): [1, cx,cy,cz, nx,ny,nz, r, ux?,uy?,uz?] - 8 or 11 floats
+ * - Arc (2): [2, cx,cy,cz, nx,ny,nz, r, startAngle, endAngle] - 10 floats
+ * - Polyline (3): [3, count, x1,y1,z1, ...] - 2 + count*3 floats
+ * - NurbsCurve (4): [4, degree, count, xyz..., weights..., knots...]
+ * - PolyCurve (5): [5, numSegs, segType, segData..., ...]
+ */
+export const enum CurveTypeCode {
+  Line = 0,
+  Circle = 1,
+  Arc = 2,
+  Polyline = 3,
+  NurbsCurve = 4,
+  PolyCurve = 5,
+}
+
+/**
+ * Segment type codes for PolyCurve WASM encoding.
+ * Used when encoding/decoding PolyCurve segments.
+ *
+ * Buffer formats:
+ * - Line (0): [sx,sy,sz, ex,ey,ez] - 6 floats
+ * - Arc (1): [cx,cy,cz, nx,ny,nz, r, startAngle, endAngle] - 9 floats
+ */
+export const enum SegmentTypeCode {
+  Line = 0,
+  Arc = 1,
+}