brepjs 20.13.5 → 20.13.6

package/dist/query.js

@@ -1,3 +1,3 @@
-import { n as edgeFinder, r as faceFinder, t as getSingleFace } from "./helpers-D3oo0Zfs.js";
-import { t as cornerFinder } from "./cornerFinder-ChkO3EOO.js";
+import { n as edgeFinder, r as faceFinder, t as getSingleFace } from "./helpers-DolHn2_s.js";
+import { t as cornerFinder } from "./cornerFinder-C7f43oKE.js";
 export { cornerFinder, edgeFinder, faceFinder, getSingleFace };

package/dist/{refResolveFns-BFws5K2t.cjs → refResolveFns-ROMmhWfH.cjs}

@@ -1,10 +1,10 @@
-const require_shapeTypes = require("./shapeTypes-BK53GmLC.cjs");
-const require_topologyQueryFns = require("./topologyQueryFns--p_-tywe.cjs");
-const require_faceFns = require("./faceFns-DfEUZlnf.cjs");
+const require_shapeTypes = require("./shapeTypes-DEe6gtTR.cjs");
+const require_topologyQueryFns = require("./topologyQueryFns-I_m8o-s7.cjs");
+const require_faceFns = require("./faceFns-dj_c8LVc.cjs");
 const require_faceRoleFns = require("./faceRoleFns-Db5bYj4Q.cjs");
-const require_shapeFns = require("./shapeFns-C9P1KmqH.cjs");
-const require_measureFns = require("./measureFns-CmKNZ0gC.cjs");
-const require_adjacencyFns = require("./adjacencyFns-B1ZWTkxw.cjs");
+const require_shapeFns = require("./shapeFns-CljM3iMI.cjs");
+const require_measureFns = require("./measureFns-FrNeGmXh.cjs");
+const require_adjacencyFns = require("./adjacencyFns-BLtq-nUN.cjs");
 // src/topology/shapeRef/scoring.ts
 /**
 * Default face scorer combining surface type, normal alignment, centroid proximity,

package/dist/{refResolveFns-DZoPfglj.js → refResolveFns-Yy1n2BHJ.js}

@@ -1,10 +1,10 @@
-import { g as disposeTransientSubShape, o as castShapeWithKnownType, q as getKernel } from "./shapeTypes-Ckz9bpYW.js";
-import { c as getFaces, w as vertexPosition } from "./topologyQueryFns-SINsBrMe.js";
-import { i as faceGeomType, l as normalAt, r as faceCenter } from "./faceFns-Dz3eRgNR.js";
+import { g as disposeTransientSubShape, o as castShapeWithKnownType, q as getKernel } from "./shapeTypes-w2wyXEis.js";
+import { c as getFaces, w as vertexPosition } from "./topologyQueryFns-CTl4cWYD.js";
+import { i as faceGeomType, l as normalAt, r as faceCenter } from "./faceFns-BG1CBQUM.js";
 import { t as getFaceRoles } from "./faceRoleFns-BPxzQF-n.js";
-import { n as getHashCode } from "./shapeFns-CHsoXWeu.js";
-import { c as measureLength, r as measureArea } from "./measureFns-6mHYvqUc.js";
-import { a as facesOfVertex, c as verticesOfFace, i as facesOfEdge, o as sharedEdges, s as verticesOfEdge, t as adjacentFaceHashes } from "./adjacencyFns-XdjXKCXE.js";
+import { n as getHashCode } from "./shapeFns-BRRrZc1X.js";
+import { c as measureLength, r as measureArea } from "./measureFns-WGYWWnQ1.js";
+import { a as facesOfVertex, c as verticesOfFace, i as facesOfEdge, o as sharedEdges, s as verticesOfEdge, t as adjacentFaceHashes } from "./adjacencyFns-C1Hxy0tk.js";
 // src/topology/shapeRef/scoring.ts
 /**
 * Default face scorer combining surface type, normal alignment, centroid proximity,

package/dist/{shapeFns-CHsoXWeu.js → shapeFns-BRRrZc1X.js}

@@ -1,6 +1,6 @@
-import { q as getKernel } from "./shapeTypes-Ckz9bpYW.js";
+import { q as getKernel } from "./shapeTypes-w2wyXEis.js";
 import { t as BrepErrorCode } from "./errors-BTccWbtE.js";
-import { E as kernelCallRaw, T as kernelCall } from "./topologyQueryFns-SINsBrMe.js";
+import { E as kernelCallRaw, T as kernelCall } from "./topologyQueryFns-CTl4cWYD.js";
 import { n as HASH_CODE_MAX } from "./constants-iraOnb2p.js";
 // src/topology/shapeFns.ts
 /**

package/dist/{shapeFns-C9P1KmqH.cjs → shapeFns-CljM3iMI.cjs}

@@ -1,6 +1,6 @@
-const require_shapeTypes = require("./shapeTypes-BK53GmLC.cjs");
+const require_shapeTypes = require("./shapeTypes-DEe6gtTR.cjs");
 const require_errors = require("./errors-O_blYTWT.cjs");
-const require_topologyQueryFns = require("./topologyQueryFns--p_-tywe.cjs");
+const require_topologyQueryFns = require("./topologyQueryFns-I_m8o-s7.cjs");
 const require_constants = require("./constants-oee0S_x6.cjs");
 // src/topology/shapeFns.ts
 /**

package/dist/shapeRef.cjs

@@ -1,5 +1,5 @@
 Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
-const require_refResolveFns = require("./refResolveFns-BFws5K2t.cjs");
+const require_refResolveFns = require("./refResolveFns-ROMmhWfH.cjs");
 exports.assignRoles = require_refResolveFns.assignRoles;
 exports.captureHint = require_refResolveFns.captureHint;
 exports.createDerivedFaceRef = require_refResolveFns.createDerivedFaceRef;

package/dist/shapeRef.js

@@ -1 +1 @@
-export { h as assignRoles, g as captureHint, l as createDerivedFaceRef, p as createEdgeRef, _ as createRef, d as createVertexRef, b as defaultScorer, t as isDerivedFaceRef, n as isEdgeRef, r as isFaceRef, i as isLineageRef, a as isVertexRef, u as resolveDerivedFaceRef, m as resolveEdgeRef, o as resolveLineageRef, v as resolveRef, s as resolveRefIn, c as resolveRefParams, f as resolveVertexRef, y as updateRoles } from "./refResolveFns-DZoPfglj.js";
+export { h as assignRoles, g as captureHint, l as createDerivedFaceRef, p as createEdgeRef, _ as createRef, d as createVertexRef, b as defaultScorer, t as isDerivedFaceRef, n as isEdgeRef, r as isFaceRef, i as isLineageRef, a as isVertexRef, u as resolveDerivedFaceRef, m as resolveEdgeRef, o as resolveLineageRef, v as resolveRef, s as resolveRefIn, c as resolveRefParams, f as resolveVertexRef, y as updateRoles } from "./refResolveFns-Yy1n2BHJ.js";

package/dist/{shapeTypes-BK53GmLC.cjs → shapeTypes-DEe6gtTR.cjs}

@@ -1,4 +1,4 @@
-const require_occtWasmAdapter = require("./occtWasmAdapter-4YnvqZOW.cjs");
+const require_occtWasmAdapter = require("./occtWasmAdapter-B9ZXx36v.cjs");
 const require_bug = require("./bug-CBcpIPuf.cjs");
 // src/kernel/quality.ts
 /**
@@ -7278,21 +7278,85 @@ function makeBezierEdge(bk, points) {
 function makeTangentArc(bk, startPoint, startTangent, endPoint) {
 	return edgeHandle(bk.makeTangentArc3d(startPoint[0], startPoint[1], startPoint[2], startTangent[0], startTangent[1], startTangent[2], endPoint[0], endPoint[1], endPoint[2]));
 }
-function makeHelixWire(bk, pitch, height, radius, center, _direction, leftHanded) {
+/** The X axis occt's `gp_Ax3(P, V)` picks when given only a direction, so a helix starts where occt-wasm's does. */
+function occtDefaultXDir(a, b, c) {
+	const [aa, ba, ca] = [
+		Math.abs(a),
+		Math.abs(b),
+		Math.abs(c)
+	];
+	let x;
+	if (ba <= aa && ba <= ca) x = aa > ca ? [
+		-c,
+		0,
+		a
+	] : [
+		c,
+		0,
+		-a
+	];
+	else if (aa <= ba && aa <= ca) x = ba > ca ? [
+		0,
+		-c,
+		b
+	] : [
+		0,
+		c,
+		-b
+	];
+	else x = aa > ba ? [
+		-b,
+		a,
+		0
+	] : [
+		b,
+		-a,
+		0
+	];
+	const len = Math.hypot(x[0], x[1], x[2]);
+	return [
+		x[0] / len,
+		x[1] / len,
+		x[2] / len
+	];
+}
+function makeHelixWire(bk, pitch, height, radius, center, direction, leftHanded) {
 	const turns = height / pitch;
 	const nSamples = Math.max(4, Math.ceil(turns * 16));
-	const cx = center?.[0] ?? 0;
-	const cy = center?.[1] ?? 0;
-	const cz = center?.[2] ?? 0;
+	const [cx, cy, cz] = center ?? [
+		0,
+		0,
+		0
+	];
+	const [dx, dy, dz] = direction ?? [
+		0,
+		0,
+		1
+	];
+	const dLen = Math.hypot(dx, dy, dz);
+	const z = [
+		dx / dLen,
+		dy / dLen,
+		dz / dLen
+	];
+	const x = occtDefaultXDir(z[0], z[1], z[2]);
+	const y = [
+		z[1] * x[2] - z[2] * x[1],
+		z[2] * x[0] - z[0] * x[2],
+		z[0] * x[1] - z[1] * x[0]
+	];
 	const sign = leftHanded ? -1 : 1;
 	const points = [];
 	for (let i = 0; i <= nSamples; i++) {
 		const t = i / nSamples;
 		const angle = sign * 2 * Math.PI * turns * t;
+		const u = radius * Math.cos(angle);
+		const v = radius * Math.sin(angle);
+		const h = height * t;
 		points.push([
-			cx + radius * Math.cos(angle),
-			cy + radius * Math.sin(angle),
-			cz + height * t
+			cx + u * x[0] + v * y[0] + h * z[0],
+			cy + u * x[1] + v * y[1] + h * z[1],
+			cz + u * x[2] + v * y[2] + h * z[2]
 		]);
 	}
 	return makeWire(bk, [interpolatePoints(bk, points)]);
@@ -7934,45 +7998,80 @@ function fillet(bk, shape, edges, radius) {
 	const solidId = unwrapSolidOrThrow(shape, "fillet");
 	const edgeIds = edges.map((e) => unwrap$1(e, "edge"));
 	if (typeof radius === "number") return solidHandle(bk.fillet(solidId, edgeIds, radius));
-	const radii = /* @__PURE__ */ new Set();
-	for (const edge of edges) {
+	const laws = edges.map((edge, i) => {
 		const r = typeof radius === "function" ? radius(edge) : radius;
 		const [start, end] = Array.isArray(r) ? r : [r, r];
-		if (start !== end) throw varyingFilletUnsupported();
-		radii.add(start);
+		return {
+			edge: require_bug.wasmIndex(edgeIds, i),
+			start,
+			end
+		};
+	});
+	const [first] = laws;
+	if (!first) throw new Error("brepkit: fillet needs at least one edge");
+	if (laws.every((l) => l.start === first.start && l.end === first.start)) return solidHandle(bk.fillet(solidId, edgeIds, first.start));
+	return filletAlongLaws(bk, solidId, laws);
+}
+var lawProbes = /* @__PURE__ */ new WeakMap();
+/**
+* brepkit-wasm before 4.6.9 cuts a flat bevel along a radius law, and the peer
+* range still admits those builds. Rounding a 10 mm cube edge from 1 to 2 tells
+* them apart: a round removes 5.0 mm3 and a bevel 11.7. The probe runs once per
+* kernel, inside a checkpoint it restores and discards, so it leaves nothing behind.
+*/
+function roundsAlongLaws(bk) {
+	const known = lawProbes.get(bk);
+	if (known !== void 0) return known;
+	let rounds;
+	const mark = bk.checkpoint();
+	try {
+		const cube = bk.makeBox(10, 10, 10);
+		const edge = require_bug.wasmIndex(bk.getSolidEdges(cube), 0);
+		const spec = JSON.stringify([{
+			edge,
+			law: "linear",
+			start: 1,
+			end: 2
+		}]);
+		rounds = 1e3 - bk.volume(bk.filletVariable(cube, spec), DEFAULT_DEFLECTION) < 8;
+	} catch {
+		rounds = false;
+	} finally {
+		bk.restore(mark);
+		bk.discardCheckpoint(mark);
 	}
-	if (radii.size > 1) throw perEdgeUnsupported("fillet radii");
-	const [only] = radii;
-	if (only === void 0) throw new Error("brepkit: fillet needs at least one edge");
-	return solidHandle(bk.fillet(solidId, edgeIds, only));
+	lawProbes.set(bk, rounds);
+	return rounds;
 }
 /**
-* brepkit takes one value for every edge of a fillet or chamfer call, and a
-* second call on the first one's result cannot name the input's other edges:
-* a chamfer fails on them ("no manifold edges to chamfer"), and a fillet builds
-* the right body but leaves the input solid corrupt, so that filleting the
-* input's four vertical cube edges at 2 mm afterwards cuts a flat chamfer.
+* One filletVariable call for every edge, each along its own constant or
+* linear law, running from the edge's start vertex to its end.
 */
-function perEdgeUnsupported(what) {
-	return new require_occtWasmAdapter.UnsupportedKernelOperationError(`brepkit: different ${what} on different edges in one call is not supported`);
+function filletAlongLaws(bk, solidId, laws) {
+	if (!roundsAlongLaws(bk)) throw new require_occtWasmAdapter.UnsupportedKernelOperationError("brepkit: a fillet along a radius law needs brepkit-wasm 4.6.9 or newer");
+	const spec = laws.map(({ edge, start, end }) => ({
+		edge,
+		law: start === end ? "constant" : "linear",
+		start,
+		end
+	}));
+	return solidHandle(bk.filletVariable(solidId, JSON.stringify(spec)));
 }
 /**
-* brepkit-wasm's filletVariable does not build a rolling-ball blend: on the
-* 40 mm top edge of a 40 x 30 x 20 box, a radius running 2 to 5 removes 260 mm3
-* where the blend removes about 113, and even a constant law of 3 removes 180
-* (the flat chamfer) where fillet removes 77.26. A radius that varies along an
-* edge is refused rather than built that way.
+* brepkit takes one distance for every edge of a chamfer call, and a second
+* call on the first one's result cannot name the input's other edges: it fails
+* on them ("no manifold edges to chamfer").
 */
-function varyingFilletUnsupported() {
-	return new require_occtWasmAdapter.UnsupportedKernelOperationError("brepkit: a fillet radius that varies along an edge is not supported");
+function perEdgeUnsupported(what) {
+	return new require_occtWasmAdapter.UnsupportedKernelOperationError(`brepkit: different ${what} on different edges in one call is not supported`);
 }
 /** occt's hashCode upper bound, which the kernel-agnostic filletVariable spec hashes edges with. */
 var HASH_UPPER_BOUND = 2147483647;
 /**
 * A variable fillet spec on one edge: `{ edge: hashCode, radii: [{ param, radius }] }`
-* from variableFillet, or `{ edgeId, startRadius, endRadius }`. A constant radius is
-* an ordinary fillet; a radius that varies is unsupported (see
-* {@link varyingFilletUnsupported}).
+* from variableFillet, or `{ edgeId, startRadius, endRadius }`. Like occt-wasm, a
+* profile runs linearly from its first radius to its last, so one of more than two
+* points is unsupported rather than flattened to a line.
 */
 function filletVariable$1(bk, shape, spec) {
 	const solidId = unwrapSolidOrThrow(shape, "filletVariable");
@@ -7988,9 +8087,15 @@ function filletVariable$1(bk, shape, spec) {
 		radii = [parsed.startRadius, parsed.endRadius];
 	} else throw new require_occtWasmAdapter.UnsupportedKernelOperationError("brepkit: filletVariable: unrecognized spec");
 	if (edgeId === void 0) throw new Error("brepkit: filletVariable: the edge is not an edge of the shape");
-	const [first = 0] = radii;
-	if (radii.some((r) => r !== first)) throw varyingFilletUnsupported();
-	return solidHandle(bk.fillet(solidId, [edgeId], first));
+	if (radii.length > 2) throw new require_occtWasmAdapter.UnsupportedKernelOperationError("brepkit: filletVariable supports only a linear (<=2-point) radius profile");
+	const start = require_bug.wasmIndex(radii, 0);
+	const end = require_bug.wasmIndex(radii, radii.length - 1);
+	if (start === end) return solidHandle(bk.fillet(solidId, [edgeId], start));
+	return filletAlongLaws(bk, solidId, [{
+		edge: edgeId,
+		start,
+		end
+	}]);
 }
 /**
 * A symmetric chamfer for two equal distances, brepkit's two-distance chamfer
@@ -10967,12 +11072,65 @@ function trySmoothPipeShell(bk, faceId, spine) {
 		return;
 	}
 }
+/**
+* The curve a guided sweep runs along: one line, or one edge brepkit stores
+* as NURBS. brepkit gives no NURBS for a circle or an ellipse, and reading one
+* by its end points would sweep along the chord.
+*/
+function guideCurve(bk, shape, role) {
+	const edges = shape.type === "edge" ? [shape] : iterShapes$1(bk, shape, "edge");
+	const [edge] = edges;
+	if (edges.length !== 1 || !edge) throw new require_occtWasmAdapter.UnsupportedKernelOperationError(`brepkit: a guided sweep takes a single-edge ${role}, got ${edges.length} edges`);
+	const edgeId = unwrap$1(edge, "edge");
+	const curveType = bk.getEdgeCurveType(edgeId);
+	if (curveType !== "LINE" && bk.getEdgeNurbsData(edgeId) === null) throw new require_occtWasmAdapter.UnsupportedKernelOperationError(`brepkit: a guided sweep takes a line or NURBS ${role}, got ${curveType}`);
+	const data = extractNurbsFromEdge(bk, edge);
+	if (!data) throw new Error(`brepkit: guided sweep could not read the ${role}`);
+	return data;
+}
+/**
+* brepkit places a guided sweep's sections at twice the spine's control points
+* (at least 4) and rules flat between them, so a straight spine twists through
+* 4 segments whatever the guide does: a square turned 90° comes out 2.5% light.
+* Splitting a straight spine into twice as many collinear spans as the guide
+* has control points samples the twist more finely than the guide is drawn.
+*/
+function densifyStraightSpine(path, spans) {
+	if (path.degree !== 1 || path.controlPoints.length !== 6 || spans <= 1) return path;
+	const start = require_bug.vec3At(path.controlPoints, 0);
+	const end = require_bug.vec3At(path.controlPoints, 3);
+	const controlPoints = [];
+	const interior = [];
+	for (let i = 0; i <= spans; i++) {
+		const t = i / spans;
+		controlPoints.push(...start.map((s, k) => s + (require_bug.wasmIndex(end, k) - s) * t));
+		if (i > 0 && i < spans) interior.push(t);
+	}
+	return {
+		degree: 1,
+		knots: [
+			0,
+			0,
+			...interior,
+			1,
+			1
+		],
+		controlPoints,
+		weights: new Array(spans + 1).fill(1)
+	};
+}
+function guidedPipeShell(bk, faceId, spine, auxiliary) {
+	const aux = guideCurve(bk, auxiliary, "auxiliary spine");
+	const path = densifyStraightSpine(guideCurve(bk, spine, "spine"), 2 * (aux.controlPoints.length / 3));
+	return solidHandle(bk.guidedSweep(faceId, path.degree, path.knots, path.controlPoints, path.weights, aux.degree, aux.knots, aux.controlPoints, aux.weights));
+}
 function sweepPipeShell(bk, profile, spine, options) {
-	if (options?.["auxiliary"] !== void 0) throw new require_occtWasmAdapter.UnsupportedKernelOperationError("brepkit: sweepPipeShell has no auxiliary spine (twist or guided sweep)");
 	if (options?.["law"] !== void 0) throw new require_occtWasmAdapter.UnsupportedKernelOperationError("brepkit: sweepPipeShell has no scaling law");
 	const profileHandle = profile;
 	const faceId = profileHandle.type === "wire" ? bk.makeFaceFromWire(profileHandle.id) : unwrap$1(profile, "face");
 	const shellMode = !!(options && options["shellMode"]);
+	const auxiliary = options?.["auxiliary"];
+	if (auxiliary !== void 0) return wrapPipeShellResult(guidedPipeShell(bk, faceId, spine, auxiliary), profile, shellMode);
 	const transitionMode = options?.["transitionMode"];
 	const contactMode = transitionMode ? mapStringTransitionMode(transitionMode) : void 0;
 	if (contactMode) {