brepjs 18.69.3 → 18.71.0

package/dist/brepjs.cjs

@@ -1,36 +1,36 @@
 Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
-const require_textBlueprints = require("./textBlueprints-TG6AH06v.cjs");
-const require_shapeTypes = require("./shapeTypes-BIlZar9m.cjs");
-const require_occtWasmAdapter = require("./occtWasmAdapter-BH7r2nTq.cjs");
+const require_textBlueprints = require("./textBlueprints-COG8m1aE.cjs");
+const require_shapeTypes = require("./shapeTypes-DRxArFIc.cjs");
+const require_occtWasmAdapter = require("./occtWasmAdapter-Crs07qIe.cjs");
 const require_vec3 = require("./vec3-CFwOI0ZI.cjs");
 const require_errors = require("./errors-CXJtc4I7.cjs");
-const require_topologyQueryFns = require("./topologyQueryFns-BuWZAQ_o.cjs");
+const require_topologyQueryFns = require("./topologyQueryFns-024l64sD.cjs");
 const require_constants = require("./constants-BOVyEYGH.cjs");
 const require_types = require("./types-KjA8tY4Y.cjs");
 const require_vecOps = require("./vecOps-CCnJt-yH.cjs");
 const require_planeOps = require("./planeOps-BA4HfgQu.cjs");
-const require_faceFns = require("./faceFns-FAZgMVCx.cjs");
-const require_shapeFns = require("./shapeFns-w1YoIn_p.cjs");
-const require_curveFns = require("./curveFns-CXytEfTr.cjs");
-const require_meshFns = require("./meshFns-lwgHYQ79.cjs");
+const require_faceFns = require("./faceFns-CcLFCtg4.cjs");
+const require_shapeFns = require("./shapeFns-CDHya-nt.cjs");
+const require_curveFns = require("./curveFns-uPVW6eo-.cjs");
+const require_meshFns = require("./meshFns-CEGnFm33.cjs");
 const require_arrayAccess = require("./arrayAccess-e4H9cBfh.cjs");
-const require_surfaceBuilders = require("./surfaceBuilders-CzHPZtd3.cjs");
-const require_booleanFns = require("./booleanFns-DvXg6a2Y.cjs");
-const require_primitiveFns = require("./primitiveFns-DZmgvzvk.cjs");
-const require_historyFns = require("./historyFns-mnmeZ0kB.cjs");
-const require_blueprintSketcher = require("./blueprintSketcher-BpOknLmX.cjs");
-const require_helpers = require("./helpers-D8ycrNeD.cjs");
-const require_drawFns = require("./drawFns-Bn4vzbUr.cjs");
-const require_solidBuilders = require("./solidBuilders-dNhToZgl.cjs");
-const require_measureFns = require("./measureFns-CT0XaSOt.cjs");
-const require_cornerFinder = require("./cornerFinder-ChltJ_ur.cjs");
-const require_boolean2D = require("./boolean2D-DZcOTOSA.cjs");
-const require_blueprintFns = require("./blueprintFns-BO44cqFY.cjs");
-const require_importFns = require("./importFns-4mi5Ih46.cjs");
-const require_extrudeFns = require("./extrudeFns-C0FsOXev.cjs");
-const require_cameraFns = require("./cameraFns-CsGSVYgb.cjs");
-const require_textMetrics = require("./textMetrics-Dag-YREs.cjs");
-const require_shapeRefFns = require("./shapeRefFns-B3myHs0D.cjs");
+const require_surfaceBuilders = require("./surfaceBuilders-D2PBBoja.cjs");
+const require_booleanFns = require("./booleanFns-Bp_wYEwG.cjs");
+const require_primitiveFns = require("./primitiveFns-CpkG8ZkI.cjs");
+const require_historyFns = require("./historyFns-BEB2Yjld.cjs");
+const require_blueprintSketcher = require("./blueprintSketcher-dZZ8e5ey.cjs");
+const require_helpers = require("./helpers-BmY5kO0w.cjs");
+const require_drawFns = require("./drawFns-eMU4H__w.cjs");
+const require_solidBuilders = require("./solidBuilders-ibLq_9EK.cjs");
+const require_measureFns = require("./measureFns-zGABZl6o.cjs");
+const require_cornerFinder = require("./cornerFinder-CQPXY8Aw.cjs");
+const require_boolean2D = require("./boolean2D-4E1kbwQx.cjs");
+const require_blueprintFns = require("./blueprintFns-DsuY7gCu.cjs");
+const require_importFns = require("./importFns-DA0Klh7_.cjs");
+const require_extrudeFns = require("./extrudeFns-CzQans6p.cjs");
+const require_cameraFns = require("./cameraFns-dRK1CnFi.cjs");
+const require_textMetrics = require("./textMetrics-CTSpUXtk.cjs");
+const require_shapeRefFns = require("./shapeRefFns-B1Tygk9V.cjs");
 const require_workerHandler = require("./workerHandler-CdlOTwJg.cjs");
 //#region src/topology/shapeBooleans.ts
 var BOPAlgo_GlueShift = 1;
@@ -2132,13 +2132,94 @@ function roof(w, options) {
 	}
 }
 //#endregion
+//#region src/utils/quaternion.ts
+function dot$1(a, b) {
+	return a[0] * b[0] + a[1] * b[1] + a[2] * b[2];
+}
+function cross$1(a, b) {
+	return [
+		a[1] * b[2] - a[2] * b[1],
+		a[2] * b[0] - a[0] * b[2],
+		a[0] * b[1] - a[1] * b[0]
+	];
+}
+function normalize$1(a) {
+	const l = Math.hypot(a[0], a[1], a[2]) || 1;
+	return [
+		a[0] / l,
+		a[1] / l,
+		a[2] / l
+	];
+}
+/** A unit vector perpendicular to `v` (for the 180°/parallel degenerate cases). */
+function anyPerpendicular$1(v) {
+	return normalize$1(cross$1(v, Math.abs(v[0]) < .9 ? [
+		1,
+		0,
+		0
+	] : [
+		0,
+		1,
+		0
+	]));
+}
+/** Rotate vector `v` by quaternion `q`. */
+function quatRotate(q, v) {
+	const [w, x, y, z] = q;
+	const tx = 2 * (y * v[2] - z * v[1]);
+	const ty = 2 * (z * v[0] - x * v[2]);
+	const tz = 2 * (x * v[1] - y * v[0]);
+	return [
+		v[0] + w * tx + (y * tz - z * ty),
+		v[1] + w * ty + (z * tx - x * tz),
+		v[2] + w * tz + (x * ty - y * tx)
+	];
+}
+/** Quaternion for a rotation of `angle` radians about (unit-normalized) `axis`. */
+function quatFromAxisAngle(axis, angle) {
+	const h = angle / 2;
+	const s = Math.sin(h);
+	const u = normalize$1(axis);
+	return [
+		Math.cos(h),
+		u[0] * s,
+		u[1] * s,
+		u[2] * s
+	];
+}
+/** Shortest-arc quaternion rotating unit vector `from` onto unit vector `to`. */
+function quatFromTo(from, to) {
+	const a = normalize$1(from);
+	const b = normalize$1(to);
+	const d = dot$1(a, b);
+	if (d >= .999999999) return [
+		1,
+		0,
+		0,
+		0
+	];
+	if (d <= -.999999999) return quatFromAxisAngle(anyPerpendicular$1(a), Math.PI);
+	const c = cross$1(a, b);
+	const len = Math.hypot(1 + d, c[0], c[1], c[2]) || 1;
+	return [
+		(1 + d) / len,
+		c[0] / len,
+		c[1] / len,
+		c[2] / len
+	];
+}
+//#endregion
 //#region src/kernel/solverAdapter.ts
 /**
-* Standard degrees of freedom left unresolved by each unsupported constraint type.
-* coincident: 3 translational (plane normal alignment + contact)
-* concentric: 2 rotational (axis alignment) + 2 translational (axis centering) = 4
-* distance: 1 translational (offset along normal)
-* angle: 1 rotational
+* Constraint solver adapter — analytical solver for simple assembly mates.
+*/
+/**
+* Degrees of freedom each constraint leaves unresolved when it can't be applied
+* (entity-type mismatch or an unreachable reference). All four types now solve
+* for well-typed inputs; these counts only feed the diagnostic `dof` for the
+* unsupported cases.
+* coincident: 3 translational · concentric: 2 rotational + 2 translational = 4
+* distance: 1 translational · angle: 1 rotational
 */
 var UNSUPPORTED_DOF = {
 	coincident: 3,
@@ -2159,51 +2240,162 @@ function add$1(a, b) {
 		a[2] + b[2]
 	];
 }
+function sub(a, b) {
+	return [
+		a[0] - b[0],
+		a[1] - b[1],
+		a[2] - b[2]
+	];
+}
 function dot(a, b) {
 	return a[0] * b[0] + a[1] * b[1] + a[2] * b[2];
 }
+function cross(a, b) {
+	return [
+		a[1] * b[2] - a[2] * b[1],
+		a[2] * b[0] - a[0] * b[2],
+		a[0] * b[1] - a[1] * b[0]
+	];
+}
+function scale$2(a, s) {
+	return [
+		a[0] * s,
+		a[1] * s,
+		a[2] * s
+	];
+}
+function normalize(a) {
+	const l = Math.hypot(a[0], a[1], a[2]) || 1;
+	return [
+		a[0] / l,
+		a[1] / l,
+		a[2] / l
+	];
+}
+/** A unit vector perpendicular to `v` (for the parallel-normals degenerate case). */
+function anyPerpendicular(v) {
+	return normalize(cross(v, Math.abs(v[0]) < .9 ? [
+		1,
+		0,
+		0
+	] : [
+		0,
+		1,
+		0
+	]));
+}
+/** Apply a pose (rotate then translate) to an entity's origin and any directions. */
+function transformEntity(e, pose) {
+	const origin = add$1(quatRotate(pose.rotation, e.origin), pose.position);
+	return {
+		type: e.type,
+		origin,
+		...e.normal ? { normal: quatRotate(pose.rotation, e.normal) } : {},
+		...e.direction ? { direction: quatRotate(pose.rotation, e.direction) } : {}
+	};
+}
 /**
 * Position a dependent plane against an already-placed reference plane.
 *
-* The reference's solved translation is applied to its (local) entity origin
-* before measuring, so a chain composes down already-solved poses instead of
-* reading original geometry. The dependent is at the origin (a node is only
-* solved once, while unplaced), so the returned position is its absolute
-* translation. `extra` is the gap for a distance mate (0 for coincident).
-* Rotation stays identity — coincident/distance produce pure translations;
-* Phase 1 rotational constraints will extend this.
+* `ref` is the reference entity already in world space. The dependent is at the
+* origin (a node is only solved once, while unplaced), so the returned position
+* is its absolute translation along the reference normal. `extra` is the gap for
+* a distance mate (0 for coincident). Plane mates don't reorient the dependent.
 */
-function solvePlanePair(ref, refPos, dep, extra) {
+function solvePlanePair(ref, dep, extra) {
 	const n = ref.normal ?? [
 		0,
 		0,
 		1
 	];
-	const refOrigin = add$1(ref.origin, refPos);
-	const offset = dot(n, [
-		refOrigin[0] - dep.origin[0],
-		refOrigin[1] - dep.origin[1],
-		refOrigin[2] - dep.origin[2]
-	]) + extra;
+	return {
+		position: scale$2(n, dot(n, sub(ref.origin, dep.origin)) + extra),
+		rotation: IDENTITY_ROTATION
+	};
+}
+/**
+* Concentric (axis-axis) mate: rotate the dependent so its axis is parallel to
+* the reference axis, then translate so the two axes are collinear (the
+* dependent's axis point is placed on the reference axis). `ref` is in world
+* space; the dependent is at the origin.
+*/
+function solveConcentric(ref, dep) {
+	const dRef = ref.direction ?? [
+		0,
+		0,
+		1
+	];
+	const rotation = quatFromTo(dep.direction ?? [
+		0,
+		0,
+		1
+	], dRef);
+	const rotatedOrigin = quatRotate(rotation, dep.origin);
+	return {
+		position: sub(ref.origin, rotatedOrigin),
+		rotation
+	};
+}
+/**
+* Angle mate: rotate the dependent so the angle between its (plane) normal and
+* the reference normal equals `angleRad`. Orientation-only — position is left at
+* the origin. `ref` is in world space; the dependent is at the origin.
+*/
+function solveAngle(ref, dep, angleRad) {
+	const nRef = normalize(ref.normal ?? [
+		0,
+		0,
+		1
+	]);
+	const nDep = normalize(dep.normal ?? [
+		0,
+		0,
+		1
+	]);
+	const phi = Math.acos(Math.max(-1, Math.min(1, dot(nDep, nRef))));
+	const c = cross(nDep, nRef);
 	return {
 		position: [
-			offset * n[0],
-			offset * n[1],
-			offset * n[2]
+			0,
+			0,
+			0
 		],
-		rotation: IDENTITY_ROTATION
+		rotation: quatFromAxisAngle(Math.hypot(c[0], c[1], c[2]) < 1e-9 ? anyPerpendicular(nDep) : c, phi - angleRad)
 	};
 }
+/** Entity types each positioning constraint requires of (entityA, entityB). */
+var REQUIRED_ENTITIES = {
+	coincident: "plane",
+	distance: "plane",
+	angle: "plane",
+	concentric: "axis"
+};
+var POSITIONING_TYPES = new Set([
+	"coincident",
+	"distance",
+	"angle",
+	"concentric"
+]);
+/** Dispatch a positioning mate to its solver. `ref` is already in world space. */
+function solveMate(c, ref, dep) {
+	switch (c.type) {
+		case "concentric": return solveConcentric(ref, dep);
+		case "angle": return solveAngle(ref, dep, (c.value ?? 0) * Math.PI / 180);
+		case "distance": return solvePlanePair(ref, dep, c.value ?? 0);
+		default: return solvePlanePair(ref, dep, 0);
+	}
+}
 /**
 * Solve assembly constraints analytically.
 *
-* Handles: fixed, coincident (plane-plane), distance (plane-plane). For a
-* positioning mate, entityA is the reference and entityB the dependent. Chain
-* roots (nodes never positioned by a mate) and explicit `fixed` nodes anchor at
-* the origin; constraints then resolve in topological order — each places its
-* dependent against the reference's solved pose, so multi-body chains compose.
-* Returns `converged: false` with unsupported details for concentric, angle,
-* non-plane pairs, and any constraint whose reference never resolves.
+* Handles: fixed, coincident/distance (plane-plane), concentric (axis-axis), and
+* angle (plane-plane orientation). For a positioning mate, entityA is the
+* reference and entityB the dependent. Chain roots (nodes never positioned by a
+* mate) and explicit `fixed` nodes anchor at the origin; constraints then resolve
+* in topological order — each places its dependent against the reference's solved
+* pose (rotation included), so multi-body chains compose. Returns
+* `converged: false` with details for entity-type mismatches and any constraint
+* whose reference never resolves.
 */
 function solveConstraints(nodes, constraints) {
 	const transforms = /* @__PURE__ */ new Map();
@@ -2216,17 +2408,17 @@ function solveConstraints(nodes, constraints) {
 		rotation: IDENTITY_ROTATION
 	});
 	const unsupported = [];
-	const positioning = constraints.filter((c) => (c.type === "coincident" || c.type === "distance") && c.entityA && c.entityB);
+	const positioning = constraints.filter((c) => POSITIONING_TYPES.has(c.type) && c.entityA && c.entityB);
 	const dependents = /* @__PURE__ */ new Set();
 	for (const c of positioning) if (c.entityB) dependents.add(c.entityB.node);
 	const placed = /* @__PURE__ */ new Set();
 	for (const node of nodes) if (!dependents.has(node)) placed.add(node);
 	for (const c of constraints) if (c.type === "fixed" && c.entityA) placed.add(c.entityA.node);
-	for (const c of constraints) if (c.type === "concentric" || c.type === "angle") unsupported.push(c.type);
 	const pending = [];
 	for (const c of positioning) {
 		if (!c.entityA || !c.entityB) continue;
-		if (c.entityA.entity.type !== "plane" || c.entityB.entity.type !== "plane") {
+		const required = REQUIRED_ENTITIES[c.type];
+		if (c.entityA.entity.type !== required || c.entityB.entity.type !== required) {
 			unsupported.push(`${c.type}(${c.entityA.entity.type}-${c.entityB.entity.type})`);
 			continue;
 		}
@@ -2252,8 +2444,8 @@ function solveConstraints(nodes, constraints) {
 				],
 				rotation: IDENTITY_ROTATION
 			};
-			const extra = c.type === "distance" ? c.value ?? 0 : 0;
-			transforms.set(dep.node, solvePlanePair(ref.entity, refPose.position, dep.entity, extra));
+			const refWorld = transformEntity(ref.entity, refPose);
+			transforms.set(dep.node, solveMate(c, refWorld, dep.entity));
 			placed.add(dep.node);
 		}
 	}
@@ -2270,11 +2462,27 @@ function solveConstraints(nodes, constraints) {
 //#endregion
 //#region src/operations/mateFns.ts
 function extractEntity(mate) {
-	if (mate.face) return {
-		type: "plane",
-		origin: require_faceFns.faceCenter(mate.face),
-		normal: require_faceFns.normalAt(mate.face)
-	};
+	if (mate.face) {
+		const axis = require_faceFns.faceAxis(mate.face);
+		if (axis) return {
+			type: "axis",
+			origin: axis.origin,
+			direction: axis.direction
+		};
+		return {
+			type: "plane",
+			origin: require_faceFns.faceCenter(mate.face),
+			normal: require_faceFns.normalAt(mate.face)
+		};
+	}
+	if (mate.edge) {
+		if (require_curveFns.getCurveType(mate.edge) === "LINE") return {
+			type: "axis",
+			origin: require_curveFns.curveStartPoint(mate.edge),
+			direction: require_curveFns.curveTangentAt(mate.edge)
+		};
+		return null;
+	}
 	if (mate.point) return {
 		type: "point",
 		origin: mate.point
@@ -2394,6 +2602,102 @@ function solveAssembly(assembly) {
 	}
 }
 //#endregion
+//#region src/operations/jointFns.ts
+var DEG2RAD$1 = Math.PI / 180;
+function clamp(value, min, max) {
+	return Math.min(max, Math.max(min, value));
+}
+function unit(v) {
+	const l = Math.hypot(v[0], v[1], v[2]) || 1;
+	return [
+		v[0] / l,
+		v[1] / l,
+		v[2] / l
+	];
+}
+function makeJoint(type, parent, child, axis, opts, defMin, defMax) {
+	const a = opts.min ?? defMin;
+	const b = opts.max ?? defMax;
+	const min = Math.min(a, b);
+	const max = Math.max(a, b);
+	return {
+		type,
+		parent,
+		child,
+		axis: {
+			origin: axis.origin,
+			direction: unit(axis.direction)
+		},
+		min,
+		max,
+		value: clamp(opts.value ?? 0, min, max)
+	};
+}
+/** A revolute (hinge) joint — the child rotates about `axis` by `value` degrees. */
+function revoluteJoint(parent, child, axis, opts = {}) {
+	return makeJoint("revolute", parent, child, axis, opts, -180, 180);
+}
+/**
+* A prismatic (slider) joint — the child translates along `axis` by `value`
+* units. Only `axis.direction` is used; `axis.origin` is ignored (a pure
+* translation has no anchor point), unlike a revolute joint which rotates about
+* the axis line through `origin`.
+*/
+function prismaticJoint(parent, child, axis, opts = {}) {
+	return makeJoint("prismatic", parent, child, axis, opts, 0, 100);
+}
+/** Return a copy of `joint` with its drivable parameter set (clamped to range). */
+function setJointValue(joint, value) {
+	return {
+		...joint,
+		value: clamp(value, joint.min, joint.max)
+	};
+}
+/**
+* The child's local rigid transform (relative to the parent) for a joint value.
+* Defaults to the joint's stored value; an explicit value is clamped to range.
+*
+* - **revolute**: rotation of `value` degrees about the axis line. Rotating
+*   about a line through `origin` is `p ↦ R·p + (origin − R·origin)`.
+* - **prismatic**: translation of `value` units along the axis direction.
+*/
+function jointTransform(joint, value = joint.value) {
+	const v = clamp(value, joint.min, joint.max);
+	const dir = unit(joint.axis.direction);
+	if (joint.type === "prismatic") return {
+		position: [
+			dir[0] * v,
+			dir[1] * v,
+			dir[2] * v
+		],
+		rotation: [
+			1,
+			0,
+			0,
+			0
+		]
+	};
+	const rotation = quatFromAxisAngle(dir, v * DEG2RAD$1);
+	const o = joint.axis.origin;
+	const ro = quatRotate(rotation, o);
+	return {
+		position: [
+			o[0] - ro[0],
+			o[1] - ro[1],
+			o[2] - ro[2]
+		],
+		rotation
+	};
+}
+/** Attach a joint to an assembly node. Returns a new node (immutable). */
+function addJoint(assembly, joint) {
+	const existing = assembly.joints ?? [];
+	return {
+		...assembly,
+		joints: [...existing, joint]
+	};
+}
+//#endregion
 //#region src/measurement/interferenceFns.ts
 /**
 * Interference detection between shapes.
@@ -6192,6 +6496,7 @@ exports.Sketcher = require_drawFns.Sketcher;
 exports.Sketches = require_textBlueprints.Sketches;
 exports.addChild = require_historyFns.addChild;
 exports.addHoles = require_primitiveFns.addHoles;
+exports.addJoint = addJoint;
 exports.addMate = addMate;
 exports.addStep = require_historyFns.addStep;
 exports.adjacentFaces = require_primitiveFns.adjacentFaces;
@@ -6362,6 +6667,7 @@ exports.exportThreeMF = require_importFns.exportThreeMF;
 exports.extrude = extrude;
 exports.extrudeAll = require_extrudeFns.extrudeAll;
 exports.face = require_primitiveFns.face;
+exports.faceAxis = require_faceFns.faceAxis;
 exports.faceCenter = require_faceFns.faceCenter;
 exports.faceFinder = require_helpers.faceFinder;
 exports.faceGeomType = require_faceFns.faceGeomType;
@@ -6508,6 +6814,7 @@ exports.iterSolids = require_topologyQueryFns.iterSolids;
 exports.iterTopo = require_faceFns.iterTopo;
 exports.iterVertices = require_topologyQueryFns.iterVertices;
 exports.iterWires = require_topologyQueryFns.iterWires;
+exports.jointTransform = jointTransform;
 exports.kernelCall = require_topologyQueryFns.kernelCall;
 exports.kernelCallRaw = require_topologyQueryFns.kernelCallRaw;
 exports.kernelCallScoped = require_topologyQueryFns.kernelCallScoped;
@@ -6602,6 +6909,7 @@ Object.defineProperty(exports, "primitives", {
 		return primitives_exports;
 	}
 });
+exports.prismaticJoint = prismaticJoint;
 exports.projectEdges = require_cameraFns.projectEdges;
 exports.projectPointOnFace = require_faceFns.projectPointOnFace;
 Object.defineProperty(exports, "query", {
@@ -6633,6 +6941,7 @@ exports.resolveDirection = require_types.resolveDirection;
 exports.resolvePlane = require_planeOps.resolvePlane;
 exports.resolveRef = require_shapeRefFns.resolveRef;
 exports.reverseCurve = require_blueprintFns.reverseCurve;
+exports.revoluteJoint = revoluteJoint;
 exports.revolve = revolve;
 exports.roof = roof;
 exports.rotate = rotate;
@@ -6661,6 +6970,7 @@ exports.sdfTorus = torus;
 exports.section = section;
 exports.sectionToFace = sectionToFace;
 exports.serializeHistory = require_historyFns.serializeHistory;
+exports.setJointValue = setJointValue;
 exports.setShapeOrigin = require_shapeFns.setShapeOrigin;
 exports.setTagMetadata = require_shapeFns.setTagMetadata;
 exports.sewShells = require_primitiveFns.sewShells;