brepjs 12.2.12 → 12.4.0

package/dist/brepjs.cjs

@@ -45,35 +45,38 @@ var __callDispose = (stack, error, hasError) => {
   return next();
 };
 Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
-const shapeTypes = require("./shapeTypes-BQGbhdgi.cjs");
+const shapeTypes = require("./shapeTypes-7xEam9Ri.cjs");
 const errors = require("./errors-9fDehDNc.cjs");
 const vecOps = require("./vecOps-CjRL1jau.cjs");
-const Blueprint = require("./Blueprint-CX2oh-NE.cjs");
-const loft$2 = require("./loft-BDnb8toT.cjs");
-const operations = require("./operations-CLaaoj2N.cjs");
-const boolean2D = require("./boolean2D-G9edb4Pw.cjs");
+const Blueprint = require("./Blueprint-CoFJDAQd.cjs");
+const loft$2 = require("./loft-DR1UN5uN.cjs");
+const operations = require("./operations-D-gTZNtM.cjs");
+const boolean2D = require("./boolean2D-Dk-vLBdl.cjs");
 const _2d = require("./2d.cjs");
-const helpers = require("./helpers-Cu_7Qo9J.cjs");
+const helpers = require("./helpers-DNzVfe-Z.cjs");
 const io = require("./io.cjs");
-const drawFns = require("./drawFns-Br57GZWI.cjs");
+const drawFns = require("./drawFns-BEeoD1yO.cjs");
 const types = require("./types-CA_xrgDq.cjs");
 const vectors = require("./vectors-TlfO1hu2.cjs");
-const shapeFns = require("./shapeFns-ZbzAD8yC.cjs");
-const booleanFns = require("./booleanFns-DQj7i7qb.cjs");
-const topology = require("./topology-CPYjaISY.cjs");
-const curveFns = require("./curveFns-BN9bWCIl.cjs");
-const faceFns = require("./faceFns-Cfvj4nxx.cjs");
-const meshFns = require("./meshFns-xWim4bEU.cjs");
-const measurement = require("./measurement-ypLLNq5y.cjs");
-const surfaceBuilders = require("./surfaceBuilders-CXarnCh8.cjs");
+const shapeFns = require("./shapeFns-DHlLNHTn.cjs");
+const booleanFns = require("./booleanFns-BJjYqwJ5.cjs");
+const topology = require("./topology-BHnY7Szr.cjs");
+const curveFns = require("./curveFns-Ch87sD5O.cjs");
+const faceFns = require("./faceFns-BLTEPBKq.cjs");
+const meshFns = require("./meshFns-BU2l_yOm.cjs");
+const measurement = require("./measurement-DoYXRaKI.cjs");
+const surfaceBuilders = require("./surfaceBuilders-Be_ENWSA.cjs");
 const query = require("./query.cjs");
-const solidBuilders = require("./solidBuilders-CYEEZgiP.cjs");
+const solidBuilders = require("./solidBuilders-BzfRBizW.cjs");
 const result = require("./result.cjs");
-const cornerFinder = require("./cornerFinder-NbeO5KWC.cjs");
+const cornerFinder = require("./cornerFinder-BESZIitp.cjs");
 const worker = require("./worker.cjs");
 function supportsProjection(kernel) {
   return "projectShape" in kernel;
 }
+function supportsConstraintSketch(kernel) {
+  return "sketchNew" in kernel && "sketchDof" in kernel;
+}
 function evaluateCurve2d(c, t) {
   switch (c.__bk2d) {
     case "line":
@@ -706,6 +709,9 @@ function dist3(x1, y1, z1, x2, y2, z2) {
   const dx = x1 - x2, dy = y1 - y2, dz = z1 - z2;
   return Math.sqrt(dx * dx + dy * dy + dz * dz);
 }
+function copyWasmBytes(bytes) {
+  return bytes.buffer.slice(bytes.byteOffset, bytes.byteOffset + bytes.byteLength);
+}
 function translationMatrix(x, y, z) {
   return [
     1,
@@ -2037,7 +2043,7 @@ class BrepkitAdapter {
     const deflection = options.tolerance || DEFAULT_DEFLECTION;
     let result2;
     if (bkHandle.type === "solid") {
-      result2 = this.meshSolid(h, deflection);
+      result2 = this.meshSolid(h, deflection, !!options.includeUVs);
     } else if (bkHandle.type === "face") {
       result2 = this.meshSingleFace(h, deflection, 0);
     } else {
@@ -2988,8 +2994,10 @@ class BrepkitAdapter {
     const id = this.bk.addHolesToFace(unwrap(face, "face"), wireIds);
     return faceHandle(id);
   }
-  // TODO: Expose bk.removeHolesFromFace() — inverse of addHolesInFace.
-  // Useful for defeaturing workflows. See brepkitWasmTypes.ts.
+  removeHolesFromFace(face) {
+    const id = this.bk.removeHolesFromFace(unwrap(face, "face"));
+    return faceHandle(id);
+  }
   makeFaceOnSurface(_surface, wire) {
     return this.makeFace(wire, true);
   }
@@ -3250,9 +3258,25 @@ class BrepkitAdapter {
   // ═══════════════════════════════════════════════════════════════════════
   // Dispose
   // ═══════════════════════════════════════════════════════════════════════
-  // TODO: Expose bk.checkpoint() / bk.restore() / bk.discardCheckpoint() for
-  // transactional arena management. Could back a future undo/redo or speculative
-  // operation API (try operation → restore on failure). See brepkitWasmTypes.ts.
+  /**
+   * Create an arena checkpoint. Returns checkpoint index.
+   * Use {@link restoreCheckpoint} to roll back or {@link discardCheckpoint} to keep.
+   */
+  checkpoint() {
+    return this.bk.checkpoint();
+  }
+  /** Get the current number of active checkpoints. */
+  checkpointCount() {
+    return this.bk.checkpointCount();
+  }
+  /** Restore arena to a checkpoint, freeing all handles created after it. */
+  restoreCheckpoint(cp) {
+    this.bk.restore(cp);
+  }
+  /** Discard a checkpoint without restoring (keep all handles). */
+  discardCheckpoint(cp) {
+    this.bk.discardCheckpoint(cp);
+  }
   dispose(_handle) {
   }
   // ═══════════════════════════════════════════════════════════════════════
@@ -3879,22 +3903,62 @@ class BrepkitAdapter {
   }
   extractCurve2dFromEdge(edge, face) {
     const eid = unwrap(edge, "edge");
-    unwrap(face, "face");
+    const fid = unwrap(face, "face");
     const params = this.bk.getEdgeCurveParameters(eid);
     const tMin = params[0] ?? 0;
     const tMax = params[1] ?? 1;
-    const N = 40;
-    const uvPoints = [];
-    for (let i = 0; i <= N; i++) {
-      const t = tMin + (tMax - tMin) * i / N;
+    const BASE_N = 20;
+    const MAX_N = 80;
+    const REFINE_THRESHOLD = 0.05;
+    const tValues = [];
+    for (let i = 0; i <= BASE_N; i++) {
+      tValues.push(tMin + (tMax - tMin) * i / BASE_N);
+    }
+    const evaluateUV = (t) => {
       const pt = this.bk.evaluateEdgeCurve(eid, t);
-      uvPoints.push([pt[0], pt[1]]);
+      const uv = this.bk.projectPointOnSurface(fid, pt[0], pt[1], pt[2]);
+      return [uv[0], uv[1]];
+    };
+    const uvSamples = tValues.map((t) => ({
+      t,
+      uv: evaluateUV(t)
+    }));
+    let refinements = 0;
+    while (uvSamples.length < MAX_N) {
+      const insertions = [];
+      for (let i = 0; i < uvSamples.length - 1; i++) {
+        const a = uvSamples[i];
+        const b = uvSamples[i + 1];
+        const tMid = (a.t + b.t) / 2;
+        const uvMid = evaluateUV(tMid);
+        const interpU = (a.uv[0] + b.uv[0]) / 2;
+        const interpV = (a.uv[1] + b.uv[1]) / 2;
+        const deviation = Math.sqrt((uvMid[0] - interpU) ** 2 + (uvMid[1] - interpV) ** 2);
+        if (deviation > REFINE_THRESHOLD) {
+          insertions.push({ index: i + 1, t: tMid, uv: uvMid });
+        }
+      }
+      if (insertions.length === 0) break;
+      let budget = MAX_N - uvSamples.length;
+      for (let j = insertions.length - 1; j >= 0 && budget > 0; j--) {
+        const ins = insertions[j];
+        uvSamples.splice(ins.index, 0, { t: ins.t, uv: ins.uv });
+        budget--;
+      }
+      refinements++;
+      if (refinements > 3) break;
     }
+    const uvPoints = uvSamples.map((s) => s.uv);
     if (uvPoints.length >= 2) {
       return this.makeBSpline2d(uvPoints);
     }
     const verts = this.bk.getEdgeVertices(eid);
-    return makeLine2d(verts[0], verts[1], verts[3], verts[4]);
+    if (verts.length >= 6) {
+      const uv1 = this.bk.projectPointOnSurface(fid, verts[0], verts[1], verts[2]);
+      const uv2 = this.bk.projectPointOnSurface(fid, verts[3], verts[4], verts[5]);
+      return makeLine2d(uv1[0], uv1[1], uv2[0], uv2[1]);
+    }
+    throw new Error(`brepkit: extractCurve2dFromEdge: degenerate edge (${verts.length} coords)`);
   }
   buildCurves3d(_wire) {
   }
@@ -4011,9 +4075,9 @@ class BrepkitAdapter {
     return result2;
   }
   /** Tessellate a solid with per-face groups for brepjs mesh format. */
-  meshSolid(solidId, deflection) {
+  meshSolid(solidId, deflection, includeUVs) {
     try {
-      return this.meshSolidGrouped(solidId, deflection);
+      return this.meshSolidGrouped(solidId, deflection, includeUVs);
     } catch (e) {
       console.warn(
         `brepkit: tessellateSolidGrouped failed (solidId=${solidId}), falling back to per-face:`,
@@ -4025,8 +4089,11 @@ class BrepkitAdapter {
   /**
    * Batch tessellation via `tessellateSolidGrouped` — single WASM call for
    * all faces. Falls back to `meshSolidPerFace` on error.
+   *
+   * When `includeUVs` is true, makes an additional `tessellateSolidUV` call
+   * to populate real surface parametrization coordinates.
    */
-  meshSolidGrouped(solidId, deflection) {
+  meshSolidGrouped(solidId, deflection, includeUVs) {
     const json = this.bk.tessellateSolidGrouped(solidId, deflection);
     const data = JSON.parse(json);
     const faceIds = toArray(this.bk.getSolidFaces(solidId));
@@ -4047,12 +4114,26 @@ class BrepkitAdapter {
         faceHash: faceIds[i] ?? 0
       });
     }
+    let uvs = new Float32Array(0);
+    if (includeUVs) {
+      const expectedUvLen = data.positions.length / 3 * 2;
+      try {
+        const uvJson = this.bk.tessellateSolidUV(solidId, deflection);
+        const uvData = JSON.parse(uvJson);
+        if (uvData.uvs.length === expectedUvLen) {
+          uvs = new Float32Array(uvData.uvs);
+        } else {
+          uvs = new Float32Array(expectedUvLen);
+        }
+      } catch {
+        uvs = new Float32Array(expectedUvLen);
+      }
+    }
     return {
       vertices: new Float32Array(data.positions),
       normals: new Float32Array(data.normals),
       triangles: new Uint32Array(data.indices),
-      // TODO: Use bk.tessellateSolidUV() for real surface parametrization
-      uvs: new Float32Array(0),
+      uvs,
       faceGroups
     };
   }
@@ -4336,6 +4417,231 @@ class BrepkitAdapter {
     }
     return { point: [0, 0, 0], normal };
   }
+  // ═══════════════════════════════════════════════════════════════════════
+  // Constraint sketch solver (brepkit-only capability)
+  // ═══════════════════════════════════════════════════════════════════════
+  /** Create a new constraint sketch. Returns an opaque sketch handle. */
+  sketchNew() {
+    return this.bk.sketchNew();
+  }
+  /** Add a point to a constraint sketch. Returns the point index. */
+  sketchAddPoint(sketch, x, y, fixed) {
+    return this.bk.sketchAddPoint(sketch, x, y, fixed);
+  }
+  /** Add a constraint to a sketch (JSON-encoded constraint descriptor). */
+  sketchAddConstraint(sketch, constraintJson) {
+    this.bk.sketchAddConstraint(sketch, constraintJson);
+  }
+  /**
+   * Solve sketch constraints. Returns a JSON result with solved point positions.
+   * @param maxIterations — solver iteration limit (e.g. 100)
+   * @param tolerance — convergence tolerance (e.g. 1e-10)
+   */
+  sketchSolve(sketch, maxIterations, tolerance) {
+    return this.bk.sketchSolve(sketch, maxIterations, tolerance);
+  }
+  /** Get degrees of freedom remaining in a solved or partially-constrained sketch. */
+  sketchDof(sketch) {
+    return this.bk.sketchDof(sketch);
+  }
+  // ═══════════════════════════════════════════════════════════════════════
+  // Extended I/O formats
+  // ═══════════════════════════════════════════════════════════════════════
+  export3MF(shape2, tolerance) {
+    const solidId = unwrapSolidOrThrow(shape2, "export3MF");
+    return copyWasmBytes(this.bk.export3mf(solidId, tolerance));
+  }
+  exportGLB(shape2, tolerance) {
+    const solidId = unwrapSolidOrThrow(shape2, "exportGLB");
+    return copyWasmBytes(this.bk.exportGlb(solidId, tolerance));
+  }
+  exportOBJ(shape2, tolerance) {
+    const solidId = unwrapSolidOrThrow(shape2, "exportOBJ");
+    return copyWasmBytes(this.bk.exportObj(solidId, tolerance));
+  }
+  exportPLY(shape2, tolerance) {
+    const solidId = unwrapSolidOrThrow(shape2, "exportPLY");
+    return copyWasmBytes(this.bk.exportPly(solidId, tolerance));
+  }
+  import3MF(data) {
+    const result2 = toArray(this.bk.import3mf(new Uint8Array(data)));
+    return result2.map((id) => solidHandle(id));
+  }
+  importOBJ(data) {
+    const result2 = this.bk.importObj(new Uint8Array(data));
+    return solidHandle(result2);
+  }
+  importGLB(data) {
+    const result2 = this.bk.importGlb(new Uint8Array(data));
+    return solidHandle(result2);
+  }
+  // ═══════════════════════════════════════════════════════════════════════
+  // Advanced modeling
+  // ═══════════════════════════════════════════════════════════════════════
+  filletVariable(shape2, spec) {
+    const solidId = unwrapSolidOrThrow(shape2, "filletVariable");
+    return solidHandle(this.bk.filletVariable(solidId, spec));
+  }
+  helicalSweep(profile, axisOrigin, axisDirection, radius, pitch, turns) {
+    const profileId = unwrap(profile, "face");
+    return solidHandle(
+      this.bk.helicalSweep(
+        profileId,
+        axisOrigin[0],
+        axisOrigin[1],
+        axisOrigin[2],
+        axisDirection[0],
+        axisDirection[1],
+        axisDirection[2],
+        radius,
+        pitch,
+        turns
+      )
+    );
+  }
+  sweepWithOptions(profile, pathEdge, contactMode, scaleValues, segments) {
+    const profileId = unwrap(profile, "face");
+    const pathId = unwrap(pathEdge, "edge");
+    return solidHandle(
+      this.bk.sweepWithOptions(profileId, pathId, contactMode, scaleValues, segments)
+    );
+  }
+  draft(shape2, faces, pullDirection, neutralPlane, angleDeg) {
+    const solidId = unwrapSolidOrThrow(shape2, "draft");
+    const faceIds = faces.map((f) => unwrap(f, "face"));
+    return solidHandle(
+      this.bk.draft(
+        solidId,
+        faceIds,
+        pullDirection[0],
+        pullDirection[1],
+        pullDirection[2],
+        neutralPlane[0],
+        neutralPlane[1],
+        neutralPlane[2],
+        angleDeg
+      )
+    );
+  }
+  defeature(shape2, faces) {
+    const solidId = unwrapSolidOrThrow(shape2, "defeature");
+    const faceIds = faces.map((f) => unwrap(f, "face"));
+    return solidHandle(this.bk.defeature(solidId, faceIds));
+  }
+  // ═══════════════════════════════════════════════════════════════════════
+  // Feature detection
+  // ═══════════════════════════════════════════════════════════════════════
+  detectSmallFeatures(shape2, areaThreshold, tolerance) {
+    const solidId = unwrapSolidOrThrow(shape2, "detectSmallFeatures");
+    return Array.from(this.bk.detectSmallFeatures(solidId, areaThreshold, tolerance)).map(
+      (id) => faceHandle(id)
+    );
+  }
+  recognizeFeatures(shape2, tolerance) {
+    const solidId = unwrapSolidOrThrow(shape2, "recognizeFeatures");
+    return this.bk.recognizeFeatures(solidId, tolerance);
+  }
+  // ═══════════════════════════════════════════════════════════════════════
+  // Mesh boolean
+  // ═══════════════════════════════════════════════════════════════════════
+  meshBoolean(positionsA, indicesA, positionsB, indicesB, op, tolerance) {
+    const mesh2 = this.bk.meshBoolean(positionsA, indicesA, positionsB, indicesB, op, tolerance);
+    return {
+      vertices: new Float32Array(mesh2.positions),
+      normals: new Float32Array(mesh2.normals),
+      triangles: new Uint32Array(mesh2.indices),
+      uvs: new Float32Array(0),
+      faceGroups: [{ start: 0, count: mesh2.indices.length, faceHash: 0 }]
+    };
+  }
+  // ═══════════════════════════════════════════════════════════════════════
+  // Topology queries
+  // ═══════════════════════════════════════════════════════════════════════
+  edgeToFaceMap(shape2) {
+    const solidId = unwrapSolidOrThrow(shape2, "edgeToFaceMap");
+    return this.bk.edgeToFaceMap(solidId);
+  }
+  sharedEdges(faceA, faceB) {
+    const aId = unwrap(faceA, "face");
+    const bId = unwrap(faceB, "face");
+    return Array.from(this.bk.sharedEdges(aId, bId)).map((id) => edgeHandle(id));
+  }
+  adjacentFaces(shape2, face) {
+    const solidId = unwrapSolidOrThrow(shape2, "adjacentFaces");
+    const faceId = unwrap(face, "face");
+    return Array.from(this.bk.adjacentFaces(solidId, faceId)).map((id) => faceHandle(id));
+  }
+  // ═══════════════════════════════════════════════════════════════════════
+  // NURBS curve operations
+  // ═══════════════════════════════════════════════════════════════════════
+  curveDegreeElevate(edge, elevateBy) {
+    const edgeId = unwrap(edge, "edge");
+    return edgeHandle(this.bk.curveDegreeElevate(edgeId, elevateBy));
+  }
+  curveKnotInsert(edge, knot, times) {
+    const edgeId = unwrap(edge, "edge");
+    return edgeHandle(this.bk.curveKnotInsert(edgeId, knot, times));
+  }
+  curveKnotRemove(edge, knot, tolerance) {
+    const edgeId = unwrap(edge, "edge");
+    return edgeHandle(this.bk.curveKnotRemove(edgeId, knot, tolerance));
+  }
+  curveSplit(edge, param) {
+    const edgeId = unwrap(edge, "edge");
+    const result2 = this.bk.curveSplit(edgeId, param);
+    return [edgeHandle(result2[0]), edgeHandle(result2[1])];
+  }
+  approximateSurfaceLspia(coords, rows, cols, degreeU, degreeV, numCpsU, numCpsV, tolerance, maxIterations) {
+    return faceHandle(
+      this.bk.approximateSurfaceLspia(
+        coords,
+        rows,
+        cols,
+        degreeU,
+        degreeV,
+        numCpsU,
+        numCpsV,
+        tolerance,
+        maxIterations
+      )
+    );
+  }
+  untrimFace(face, samplesPerCurve, interiorSamples) {
+    const faceId = unwrap(face, "face");
+    return faceHandle(this.bk.untrimFace(faceId, samplesPerCurve, interiorSamples));
+  }
+  // ═══════════════════════════════════════════════════════════════════════
+  // Validation / Repair
+  // ═══════════════════════════════════════════════════════════════════════
+  mergeCoincidentVertices(shape2, tolerance) {
+    const solidId = unwrapSolidOrThrow(shape2, "mergeCoincidentVertices");
+    return this.bk.mergeCoincidentVertices(solidId, tolerance);
+  }
+  removeDegenerateEdges(shape2, tolerance) {
+    const solidId = unwrapSolidOrThrow(shape2, "removeDegenerateEdges");
+    return this.bk.removeDegenerateEdges(solidId, tolerance);
+  }
+  fixFaceOrientations(shape2) {
+    const solidId = unwrapSolidOrThrow(shape2, "fixFaceOrientations");
+    return this.bk.fixFaceOrientations(solidId);
+  }
+  // ═══════════════════════════════════════════════════════════════════════
+  // Classification
+  // ═══════════════════════════════════════════════════════════════════════
+  classifyPointRobust(shape2, point, tolerance) {
+    const solidId = unwrapSolidOrThrow(shape2, "classifyPointRobust");
+    return this.bk.classifyPointRobust(solidId, point[0], point[1], point[2], tolerance);
+  }
+  classifyPointWinding(shape2, point, tolerance) {
+    const solidId = unwrapSolidOrThrow(shape2, "classifyPointWinding");
+    return this.bk.classifyPointWinding(solidId, point[0], point[1], point[2], tolerance);
+  }
+  // ═══════════════════════════════════════════════════════════════════════
+  // Batch execution
+  // ═══════════════════════════════════════════════════════════════════════
+  executeBatch(json) {
+    return this.bk.executeBatch(json);
+  }
 }
 function multiplyMatrices(a, b) {
   const result2 = new Array(16).fill(0);
@@ -7222,6 +7528,7 @@ exports.normalAt = faceFns.normalAt;
 exports.outerWire = faceFns.outerWire;
 exports.pointOnSurface = faceFns.pointOnSurface;
 exports.projectPointOnFace = faceFns.projectPointOnFace;
+exports.removeHolesFromFace = faceFns.removeHolesFromFace;
 exports.shapeType = faceFns.shapeType;
 exports.uvBounds = faceFns.uvBounds;
 exports.uvCoordinates = faceFns.uvCoordinates;
@@ -7322,6 +7629,7 @@ exports.simplify = simplify;
 exports.slice = slice;
 exports.solveAssembly = solveAssembly;
 exports.split = split;
+exports.supportsConstraintSketch = supportsConstraintSketch;
 exports.supportsProjection = supportsProjection;
 exports.surfaceFromGrid = surfaceFromGrid;
 exports.surfaceFromImage = surfaceFromImage;