brepjs 18.69.2 → 18.70.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;
@@ -2134,11 +2134,12 @@ function roof(w, options) {
 //#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
+* 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,
@@ -2146,11 +2147,220 @@ var UNSUPPORTED_DOF = {
 	distance: 1,
 	angle: 1
 };
+var IDENTITY_ROTATION = [
+	1,
+	0,
+	0,
+	0
+];
+function add$1(a, b) {
+	return [
+		a[0] + b[0],
+		a[1] + b[1],
+		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 180° / parallel degenerate cases). */
+function anyPerpendicular(v) {
+	return normalize(cross(v, Math.abs(v[0]) < .9 ? [
+		1,
+		0,
+		0
+	] : [
+		0,
+		1,
+		0
+	]));
+}
+/** Rotate vector `v` by quaternion `q` = [w, x, y, z]. */
+function qRotate(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)
+	];
+}
+function qFromAxisAngle(axis, angle) {
+	const h = angle / 2;
+	const s = Math.sin(h);
+	const u = normalize(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 qFromTo(from, to) {
+	const a = normalize(from);
+	const b = normalize(to);
+	const d = dot(a, b);
+	if (d >= .999999999) return IDENTITY_ROTATION;
+	if (d <= -.999999999) return qFromAxisAngle(anyPerpendicular(a), Math.PI);
+	const c = cross(a, b);
+	const q = [
+		1 + d,
+		c[0],
+		c[1],
+		c[2]
+	];
+	const l = Math.hypot(q[0], q[1], q[2], q[3]) || 1;
+	return [
+		q[0] / l,
+		q[1] / l,
+		q[2] / l,
+		q[3] / l
+	];
+}
+/** Apply a pose (rotate then translate) to an entity's origin and any directions. */
+function transformEntity(e, pose) {
+	const origin = add$1(qRotate(pose.rotation, e.origin), pose.position);
+	return {
+		type: e.type,
+		origin,
+		...e.normal ? { normal: qRotate(pose.rotation, e.normal) } : {},
+		...e.direction ? { direction: qRotate(pose.rotation, e.direction) } : {}
+	};
+}
+/**
+* Position a dependent plane against an already-placed reference plane.
+*
+* `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, dep, extra) {
+	const n = ref.normal ?? [
+		0,
+		0,
+		1
+	];
+	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 = qFromTo(dep.direction ?? [
+		0,
+		0,
+		1
+	], dRef);
+	const rotatedOrigin = qRotate(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: [
+			0,
+			0,
+			0
+		],
+		rotation: qFromAxisAngle(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.
 *
-* Currently handles: fixed, coincident (plane-plane), distance (plane-plane).
-* Returns `converged: false` with unsupported constraint details for concentric and angle.
+* 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();
@@ -2160,69 +2370,51 @@ function solveConstraints(nodes, constraints) {
 			0,
 			0
 		],
-		rotation: [
-			1,
-			0,
-			0,
-			0
-		]
+		rotation: IDENTITY_ROTATION
 	});
 	const unsupported = [];
-	for (const c of constraints) if (c.type === "coincident" && c.entityA && c.entityB) {
-		const a = c.entityA;
-		const b = c.entityB;
-		if (a.entity.type === "plane" && b.entity.type === "plane") {
-			const aNormal = a.entity.normal ?? [
-				0,
-				0,
-				1
-			];
-			const aOrigin = a.entity.origin;
-			const bOrigin = b.entity.origin;
-			const dot = aNormal[0] * (aOrigin[0] - bOrigin[0]) + aNormal[1] * (aOrigin[1] - bOrigin[1]) + aNormal[2] * (aOrigin[2] - bOrigin[2]);
-			const pos = [
-				dot * aNormal[0],
-				dot * aNormal[1],
-				dot * aNormal[2]
-			];
-			transforms.set(b.node, {
-				position: pos,
-				rotation: [
-					1,
-					0,
-					0,
-					0
-				]
-			});
-		} else unsupported.push(`coincident(${a.entity.type}-${b.entity.type})`);
-	} else if (c.type === "distance" && c.entityA && c.entityB && c.value !== void 0) {
-		const a = c.entityA;
-		const b = c.entityB;
-		if (a.entity.type === "plane" && b.entity.type === "plane") {
-			const aNormal = a.entity.normal ?? [
-				0,
-				0,
-				1
-			];
-			const aOrigin = a.entity.origin;
-			const bOrigin = b.entity.origin;
-			const offset = aNormal[0] * (aOrigin[0] - bOrigin[0]) + aNormal[1] * (aOrigin[1] - bOrigin[1]) + aNormal[2] * (aOrigin[2] - bOrigin[2]) + c.value;
-			const pos = [
-				offset * aNormal[0],
-				offset * aNormal[1],
-				offset * aNormal[2]
-			];
-			transforms.set(b.node, {
-				position: pos,
-				rotation: [
-					1,
+	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);
+	const pending = [];
+	for (const c of positioning) {
+		if (!c.entityA || !c.entityB) continue;
+		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;
+		}
+		pending.push(c);
+	}
+	let progress = true;
+	while (progress && pending.length > 0) {
+		progress = false;
+		for (let i = pending.length - 1; i >= 0; i--) {
+			const c = pending[i];
+			if (!c?.entityA || !c.entityB) continue;
+			const ref = c.entityA;
+			const dep = c.entityB;
+			if (!placed.has(ref.node)) continue;
+			pending.splice(i, 1);
+			progress = true;
+			if (placed.has(dep.node)) continue;
+			const refPose = transforms.get(ref.node) ?? {
+				position: [
 					0,
 					0,
 					0
-				]
-			});
-		} else unsupported.push(`distance(${a.entity.type}-${b.entity.type})`);
-	} else if (c.type === "concentric" || c.type === "angle") unsupported.push(c.type);
+				],
+				rotation: IDENTITY_ROTATION
+			};
+			const refWorld = transformEntity(ref.entity, refPose);
+			transforms.set(dep.node, solveMate(c, refWorld, dep.entity));
+			placed.add(dep.node);
+		}
+	}
+	for (const c of pending) unsupported.push(`${c.type}(unanchored)`);
 	return {
 		transforms,
 		dof: unsupported.reduce((sum, type) => {
@@ -2235,11 +2427,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
@@ -6327,6 +6535,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;