brepjs 18.63.0 → 18.65.0

package/dist/{shapeTypes-9yfC5Z8_.js → shapeTypes-C-32Klnb.js}

@@ -10062,8 +10062,8 @@ function translationMatrix(x, y, z) {
 	m[14] = z;
 	return m;
 }
-function rotationMatrix(angleDeg, axis, center) {
-	const rad = angleDeg * Math.PI / 180;
+function rotationMatrix(angleRad, axis, center) {
+	const rad = angleRad;
 	const [ax, ay, az] = normalizeAxis(axis);
 	const c = Math.cos(rad);
 	const s = Math.sin(rad);
@@ -10293,6 +10293,171 @@ function multiplyMatrix(a, b) {
 	return out;
 }
 //#endregion
+//#region src/kernel/manifold/curveDesc.ts
+var TAU = 2 * Math.PI;
+var hypot3 = (a) => Math.hypot(a[0], a[1], a[2]);
+var sub3 = (a, b) => [
+	a[0] - b[0],
+	a[1] - b[1],
+	a[2] - b[2]
+];
+function lineLen(d) {
+	return hypot3(sub3(d.p2, d.p1));
+}
+function bezierAt$1(points, t) {
+	const tmp = points.map((p) => [
+		p[0],
+		p[1],
+		p[2]
+	]);
+	for (let k = 1; k < tmp.length; k++) for (let i = 0; i < tmp.length - k; i++) {
+		const a = tmp[i] ?? [
+			0,
+			0,
+			0
+		];
+		const b = tmp[i + 1] ?? [
+			0,
+			0,
+			0
+		];
+		tmp[i] = [
+			a[0] * (1 - t) + b[0] * t,
+			a[1] * (1 - t) + b[1] * t,
+			a[2] * (1 - t) + b[2] * t
+		];
+	}
+	return tmp[0] ?? [
+		0,
+		0,
+		0
+	];
+}
+function descType(d) {
+	if (d.k === "line") return "LINE";
+	if (d.k === "bezier") return "BEZIER";
+	if (d.k === "helix") return "BSPLINE";
+	return Math.abs(d.rx - d.ry) < 1e-9 * Math.max(1, d.rx) ? "CIRCLE" : "ELLIPSE";
+}
+/** Parameter bounds: line → [0, length]; conic → [a0, a1]; helix → [0, 2π·turns]; bezier → [0, 1]. */
+function descBounds(d) {
+	if (d.k === "line") return {
+		first: 0,
+		last: lineLen(d)
+	};
+	if (d.k === "conic") return {
+		first: d.a0,
+		last: d.a1
+	};
+	if (d.k === "helix") return {
+		first: 0,
+		last: TAU * d.turns
+	};
+	return {
+		first: 0,
+		last: 1
+	};
+}
+function descPointAt(d, param) {
+	if (d.k === "line") {
+		const t = param / (lineLen(d) || 1);
+		return [
+			d.p1[0] + (d.p2[0] - d.p1[0]) * t,
+			d.p1[1] + (d.p2[1] - d.p1[1]) * t,
+			d.p1[2] + (d.p2[2] - d.p1[2]) * t
+		];
+	}
+	if (d.k === "bezier") return bezierAt$1(d.points, param);
+	if (d.k === "helix") {
+		const ct = Math.cos(param);
+		const st = Math.sin(param);
+		const z = d.pitch * param / TAU;
+		return [
+			d.center[0] + d.radius * (ct * d.x[0] + st * d.y[0]) + z * d.axis[0],
+			d.center[1] + d.radius * (ct * d.x[1] + st * d.y[1]) + z * d.axis[1],
+			d.center[2] + d.radius * (ct * d.x[2] + st * d.y[2]) + z * d.axis[2]
+		];
+	}
+	const ct = Math.cos(param);
+	const st = Math.sin(param);
+	return [
+		d.center[0] + d.rx * ct * d.x[0] + d.ry * st * d.y[0],
+		d.center[1] + d.rx * ct * d.x[1] + d.ry * st * d.y[1],
+		d.center[2] + d.rx * ct * d.x[2] + d.ry * st * d.y[2]
+	];
+}
+function descTangent(d, param) {
+	let t;
+	if (d.k === "line") t = sub3(d.p2, d.p1);
+	else if (d.k === "bezier") {
+		const a = bezierAt$1(d.points, Math.max(0, param - 1e-4));
+		t = sub3(bezierAt$1(d.points, Math.min(1, param + 1e-4)), a);
+	} else if (d.k === "helix") {
+		const ct = Math.cos(param);
+		const st = Math.sin(param);
+		const k = d.pitch / TAU;
+		t = [
+			d.radius * (-st * d.x[0] + ct * d.y[0]) + k * d.axis[0],
+			d.radius * (-st * d.x[1] + ct * d.y[1]) + k * d.axis[1],
+			d.radius * (-st * d.x[2] + ct * d.y[2]) + k * d.axis[2]
+		];
+	} else {
+		const ct = Math.cos(param);
+		const st = Math.sin(param);
+		t = [
+			-d.rx * st * d.x[0] + d.ry * ct * d.y[0],
+			-d.rx * st * d.x[1] + d.ry * ct * d.y[1],
+			-d.rx * st * d.x[2] + d.ry * ct * d.y[2]
+		];
+	}
+	const l = hypot3(t) || 1;
+	return [
+		t[0] / l,
+		t[1] / l,
+		t[2] / l
+	];
+}
+/** Exact length where closed-form exists; Ramanujan for full ellipses; numeric otherwise. */
+function descLength(d) {
+	if (d.k === "line") return lineLen(d);
+	if (d.k === "helix") {
+		const c = TAU * d.radius;
+		return d.turns * Math.sqrt(c * c + d.pitch * d.pitch);
+	}
+	if (d.k === "conic") {
+		const span = Math.abs(d.a1 - d.a0);
+		if (Math.abs(d.rx - d.ry) < 1e-9 * Math.max(1, d.rx)) return d.rx * span;
+		if (Math.abs(span - TAU) < 1e-9) {
+			const a = d.rx;
+			const b = d.ry;
+			const h = (a - b) * (a - b) / ((a + b) * (a + b));
+			return Math.PI * (a + b) * (1 + 3 * h / (10 + Math.sqrt(4 - 3 * h)));
+		}
+		return numericLength((t) => descPointAt(d, t), d.a0, d.a1, 256);
+	}
+	return numericLength((t) => descPointAt(d, t), 0, 1, 128);
+}
+function descIsClosed(d) {
+	if (d.k === "conic") return Math.abs(Math.abs(d.a1 - d.a0) - TAU) < 1e-9;
+	return false;
+}
+function descIsPeriodic(d) {
+	return descIsClosed(d);
+}
+function descPeriod(d) {
+	return d.k === "conic" ? TAU : 0;
+}
+function numericLength(at, t0, t1, n) {
+	let len = 0;
+	let prev = at(t0);
+	for (let i = 1; i <= n; i++) {
+		const p = at(t0 + (t1 - t0) * i / n);
+		len += hypot3(sub3(p, prev));
+		prev = p;
+	}
+	return len;
+}
+//#endregion
 //#region src/kernel/manifold/approximations.ts
 function asShape$2(shape) {
 	return shape;
@@ -10694,10 +10859,22 @@ function rotationMinimizingFrames(path, seed) {
 }
 //#endregion
 //#region src/kernel/manifold/profileOps.ts
-/** Segments used to approximate a full circle; arcs scale by angle span. */
+/** Fallback full-circle segment count when the kernel exposes no quality fn. */
 var FULL_CIRCLE_SEGMENTS = 24;
 /** Bezier sampling segments per edge. */
 var BEZIER_SEGMENTS = 24;
+/**
+* Full-circle segment count, following the Manifold global quality setting
+* (`getCircularSegments`) when available so profile-curve fidelity scales with
+* the kernel's tessellation quality — fine for accuracy-sensitive callers,
+* coarse for fast preview — instead of a hardcoded constant. Set by
+* {@link makeProfileBuilders}.
+*/
+var circularSegmentsFor = null;
+function fullCircleSegments(radius) {
+	const n = circularSegmentsFor ? circularSegmentsFor(Math.max(Math.abs(radius), 1e-6)) : FULL_CIRCLE_SEGMENTS;
+	return Math.max(FULL_CIRCLE_SEGMENTS, n);
+}
 var ZERO3 = [
 	0,
 	0,
@@ -10711,8 +10888,8 @@ var PLACEHOLDER = {
 function at3(pts, i) {
 	return pts[i] ?? ZERO3;
 }
-function arcSegments(angleSpan) {
-	return Math.max(2, Math.ceil(Math.abs(angleSpan) / (2 * Math.PI) * FULL_CIRCLE_SEGMENTS));
+function arcSegments(angleSpan, radius = 1) {
+	return Math.max(2, Math.ceil(Math.abs(angleSpan) / (2 * Math.PI) * fullCircleSegments(radius)));
 }
 function pickPerp(n) {
 	return normalize3(cross(n, Math.abs(n[0]) < .9 ? [
@@ -10731,7 +10908,7 @@ function sampleArc(center, normal, radius, startAngle, endAngle, xDir) {
 	const x = xDir ? normalize3(xDir) : pickPerp(n);
 	const y = normalize3(cross(n, x));
 	const span = endAngle - startAngle;
-	const segs = arcSegments(span);
+	const segs = arcSegments(span, radius);
 	const pts = [];
 	for (let i = 0; i <= segs; i++) {
 		const a = startAngle + span * i / segs;
@@ -10867,9 +11044,54 @@ function sampleOcctEdge(occt, edge) {
 function discretizeOcctWire(occt, wire) {
 	return chainEdges(occt.iterShapes(wire, "edge").map((e) => sampleOcctEdge(occt, e)));
 }
-function makeProfileBuilders(_module) {
-	function edge(pts) {
-		return wrap(PLACEHOLDER, makeNode("profileEdge", { pts }, []));
+function makeProfileBuilders(module) {
+	const getSegs = module.getCircularSegments;
+	if (typeof getSegs === "function") circularSegmentsFor = (r) => getSegs(r);
+	function edge(pts, curve) {
+		return wrap(PLACEHOLDER, makeNode("profileEdge", curve ? {
+			pts,
+			curve
+		} : { pts }, []));
+	}
+	/** In-plane orthonormal frame (x, y) for a conic on a plane with the given normal. */
+	function conicFrame(normal, xDir) {
+		const n = normalize3(normal);
+		const x = xDir ? normalize3(xDir) : pickPerp(n);
+		return {
+			x,
+			y: normalize3(cross(n, x))
+		};
+	}
+	/** Analytic conic descriptor for the circle through three points (or null if collinear). */
+	function conicDescFrom3(p1, p2, p3) {
+		const v1 = sub(p2, p1);
+		const v2 = sub(p3, p1);
+		const n = cross(v1, v2);
+		if (length3(n) < 1e-12) return void 0;
+		const nn = normalize3(n);
+		const b = dot(v1, v1);
+		const c = dot(v2, v2);
+		const dd = dot(v1, v2);
+		const denom = 2 * (b * c - dd * dd);
+		if (Math.abs(denom) < 1e-18) return void 0;
+		const s = c * (b - dd) / denom;
+		const t = b * (c - dd) / denom;
+		const center = add(p1, add(scaleVec(v1, s), scaleVec(v2, t)));
+		const radius = length3(sub(p1, center));
+		const x = normalize3(sub(p1, center));
+		const y = normalize3(cross(nn, x));
+		let a1 = Math.atan2(dot(sub(p3, center), y), dot(sub(p3, center), x));
+		if (a1 < 0) a1 += 2 * Math.PI;
+		return {
+			k: "conic",
+			center,
+			x,
+			y,
+			rx: radius,
+			ry: radius,
+			a0: 0,
+			a1
+		};
 	}
 	function ringOrPts(shape) {
 		const ms = asManifoldShape(shape);
@@ -10957,8 +11179,9 @@ function makeProfileBuilders(_module) {
 		const x = xDir ? normalize3(xDir) : pickPerp(n);
 		const y = normalize3(cross(n, x));
 		const pts = [];
-		for (let i = 0; i <= FULL_CIRCLE_SEGMENTS; i++) {
-			const a = 2 * Math.PI * i / FULL_CIRCLE_SEGMENTS;
+		const segs = fullCircleSegments(Math.max(majorRadius, minorRadius));
+		for (let i = 0; i <= segs; i++) {
+			const a = 2 * Math.PI * i / segs;
 			pts.push(add(center, add(scaleVec(x, majorRadius * Math.cos(a)), scaleVec(y, minorRadius * Math.sin(a)))));
 		}
 		return pts;
@@ -10969,13 +11192,89 @@ function makeProfileBuilders(_module) {
 			y,
 			z
 		]]),
-		makeLineEdge: (p1, p2) => edge([p1, p2]),
-		makeCircleEdge: (center, normal, radius) => edge(sampleArc(center, normal, radius, 0, 2 * Math.PI)),
-		makeCircleArc: (center, normal, radius, startAngle, endAngle) => edge(sampleArc(center, normal, radius, startAngle, endAngle)),
-		makeArcEdge: (p1, p2, p3) => edge(circleFrom3(p1, p2, p3)),
-		makeEllipseEdge: (center, normal, majorRadius, minorRadius, xDir) => edge(ellipsePts(center, normal, majorRadius, minorRadius, xDir)),
-		makeBezierEdge: (points) => edge(sampleBezier(points)),
-		makeTangentArc: (startPoint, _startTangent, endPoint) => edge([startPoint, endPoint]),
+		makeLineEdge: (p1, p2) => edge([p1, p2], {
+			k: "line",
+			p1,
+			p2
+		}),
+		makeCircleEdge: (center, normal, radius) => {
+			const { x, y } = conicFrame(normal);
+			return edge(sampleArc(center, normal, radius, 0, 2 * Math.PI), {
+				k: "conic",
+				center,
+				x,
+				y,
+				rx: radius,
+				ry: radius,
+				a0: 0,
+				a1: 2 * Math.PI
+			});
+		},
+		makeCircleArc: (center, normal, radius, startAngle, endAngle) => {
+			const { x, y } = conicFrame(normal);
+			return edge(sampleArc(center, normal, radius, startAngle, endAngle), {
+				k: "conic",
+				center,
+				x,
+				y,
+				rx: radius,
+				ry: radius,
+				a0: startAngle,
+				a1: endAngle
+			});
+		},
+		makeArcEdge: (p1, p2, p3) => edge(circleFrom3(p1, p2, p3), conicDescFrom3(p1, p2, p3)),
+		makeEllipseEdge: (center, normal, majorRadius, minorRadius, xDir) => {
+			const { x, y } = conicFrame(normal, xDir);
+			return edge(ellipsePts(center, normal, majorRadius, minorRadius, xDir), {
+				k: "conic",
+				center,
+				x,
+				y,
+				rx: majorRadius,
+				ry: minorRadius,
+				a0: 0,
+				a1: 2 * Math.PI
+			});
+		},
+		makeBezierEdge: (points) => edge(sampleBezier(points), {
+			k: "bezier",
+			points: points.map((p) => [...p])
+		}),
+		makeTangentArc: (startPoint, _startTangent, endPoint) => edge([startPoint, endPoint], {
+			k: "line",
+			p1: startPoint,
+			p2: endPoint
+		}),
+		makeHelixWire: (pitch, height, radius, center = [
+			0,
+			0,
+			0
+		], direction = [
+			0,
+			0,
+			1
+		], leftHanded = false) => {
+			const axis = normalize3(direction);
+			const x = pickPerp(axis);
+			const y0 = normalize3(cross(axis, x));
+			const y = leftHanded ? scaleVec(y0, -1) : y0;
+			const turns = pitch !== 0 ? height / pitch : 0;
+			const desc = {
+				k: "helix",
+				center,
+				axis,
+				x,
+				y,
+				radius,
+				pitch,
+				turns
+			};
+			const segs = Math.max(8, Math.ceil(turns * FULL_CIRCLE_SEGMENTS));
+			const pts = [];
+			for (let i = 0; i <= segs; i++) pts.push(descPointAt(desc, 2 * Math.PI * turns * i / segs));
+			return edge(pts, desc);
+		},
 		makeWire: (edges) => wireFrom(edges),
 		makeWireFromMixed: (items) => wireFrom(items),
 		makeFace,
@@ -11021,7 +11320,7 @@ function makeBuilderOps(module) {
 		makeEllipseArc: () => notImplemented("makeEllipseArc"),
 		makeBezierEdge: (points) => profile.makeBezierEdge(points),
 		makeTangentArc: (startPoint, startTangent, endPoint) => profile.makeTangentArc(startPoint, startTangent, endPoint),
-		makeHelixWire: () => notImplemented("makeHelixWire"),
+		makeHelixWire: (pitch, height, radius, center, direction, leftHanded) => profile.makeHelixWire(pitch, height, radius, center, direction, leftHanded),
 		makeWireFromMixed: (items) => profile.makeWireFromMixed(items),
 		makeCompound: () => notImplemented("makeCompound"),
 		solidFromShell: () => notImplemented("solidFromShell"),
@@ -12613,6 +12912,8 @@ function makeMeasureOps(_module) {
 		length: (shape) => {
 			const e = shape;
 			if (e && e.__nativeEdge && typeof e.length === "number") return e.length;
+			const node = asManifoldShape(shape)?.node;
+			if (node?.op === "profileEdge" && node.params?.curve) return descLength(node.params.curve);
 			return notImplemented("length");
 		},
 		centerOfMass: (shape) => centerOfMass(shape),
@@ -13119,8 +13420,7 @@ function hashCode(shape, upperBound) {
 function isNull(shape) {
 	const s = asManifoldShape(shape);
 	if (!s) return true;
-	const solid = unwrap(s);
-	return !solid || typeof solid.isEmpty === "function" && solid.isEmpty();
+	return !unwrap(s);
 }
 function iterShapes(shape, type) {
 	const s = asManifoldShape(shape);
@@ -13777,18 +14077,56 @@ function viaOcct(shape, query) {
 	}
 	return query(occtShape, occt);
 }
+/** The analytic curve descriptor of a standalone profile edge, if it has one. */
+function descOf(shape) {
+	const ms = asManifoldShape(shape);
+	if (!ms) return void 0;
+	const node = ms.node;
+	return node.op === "profileEdge" ? node.params?.curve : void 0;
+}
 function makeGeometryOps(_module) {
 	return {
-		curveType: (shape) => isNativeEdge(shape) ? shape.curveType : viaOcct(shape, (s, occt) => occt.curveType(s)),
-		curveParameters: (shape) => isNativeEdge(shape) ? [0, shape.length] : viaOcct(shape, (s, occt) => occt.curveParameters(s)),
-		curvePointAtParam: (shape, param) => isNativeEdge(shape) ? edgePointAt(shape, param) : viaOcct(shape, (s, occt) => occt.curvePointAtParam(s, param)),
-		curveTangent: (shape, param) => isNativeEdge(shape) ? {
-			point: edgePointAt(shape, param),
-			tangent: edgeTangentAt(shape, param)
-		} : viaOcct(shape, (s, occt) => occt.curveTangent(s, param)),
-		curveIsClosed: (shape) => viaOcct(shape, (s, occt) => occt.curveIsClosed(s)),
-		curveIsPeriodic: (shape) => viaOcct(shape, (s, occt) => occt.curveIsPeriodic(s)),
-		curvePeriod: (shape) => viaOcct(shape, (s, occt) => occt.curvePeriod(s)),
+		curveType: (shape) => {
+			const d = descOf(shape);
+			if (d) return descType(d);
+			return isNativeEdge(shape) ? shape.curveType : viaOcct(shape, (s, occt) => occt.curveType(s));
+		},
+		curveParameters: (shape) => {
+			const d = descOf(shape);
+			if (d) {
+				const b = descBounds(d);
+				return [b.first, b.last];
+			}
+			return isNativeEdge(shape) ? [0, shape.length] : viaOcct(shape, (s, occt) => occt.curveParameters(s));
+		},
+		curvePointAtParam: (shape, param) => {
+			const d = descOf(shape);
+			if (d) return descPointAt(d, param);
+			return isNativeEdge(shape) ? edgePointAt(shape, param) : viaOcct(shape, (s, occt) => occt.curvePointAtParam(s, param));
+		},
+		curveTangent: (shape, param) => {
+			const d = descOf(shape);
+			if (d) return {
+				point: descPointAt(d, param),
+				tangent: descTangent(d, param)
+			};
+			return isNativeEdge(shape) ? {
+				point: edgePointAt(shape, param),
+				tangent: edgeTangentAt(shape, param)
+			} : viaOcct(shape, (s, occt) => occt.curveTangent(s, param));
+		},
+		curveIsClosed: (shape) => {
+			const d = descOf(shape);
+			return d ? descIsClosed(d) : viaOcct(shape, (s, occt) => occt.curveIsClosed(s));
+		},
+		curveIsPeriodic: (shape) => {
+			const d = descOf(shape);
+			return d ? descIsPeriodic(d) : viaOcct(shape, (s, occt) => occt.curveIsPeriodic(s));
+		},
+		curvePeriod: (shape) => {
+			const d = descOf(shape);
+			return d ? descPeriod(d) : viaOcct(shape, (s, occt) => occt.curvePeriod(s));
+		},
 		interpolatePoints: (points, options) => occtOrThrow("interpolatePoints").interpolatePoints(points, options),
 		approximatePoints: (points, options) => occtOrThrow("approximatePoints").approximatePoints(points, options),
 		curveDegreeElevate: (edge, elevateBy) => viaOcct(edge, (s, occt) => occt.curveDegreeElevate(s, elevateBy)),