brepjs 18.69.2 → 18.69.3

package/dist/brepjs.cjs

@@ -2146,11 +2146,64 @@ 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 dot(a, b) {
+	return a[0] * b[0] + a[1] * b[1] + a[2] * b[2];
+}
+/**
+* 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.
+*/
+function solvePlanePair(ref, refPos, 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: [
+			offset * n[0],
+			offset * n[1],
+			offset * n[2]
+		],
+		rotation: IDENTITY_ROTATION
+	};
+}
 /**
 * 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 (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.
 */
 function solveConstraints(nodes, constraints) {
 	const transforms = /* @__PURE__ */ new Map();
@@ -2160,69 +2213,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) => (c.type === "coincident" || c.type === "distance") && 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") {
+			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 extra = c.type === "distance" ? c.value ?? 0 : 0;
+			transforms.set(dep.node, solvePlanePair(ref.entity, refPose.position, dep.entity, extra));
+			placed.add(dep.node);
+		}
+	}
+	for (const c of pending) unsupported.push(`${c.type}(unanchored)`);
 	return {
 		transforms,
 		dof: unsupported.reduce((sum, type) => {

package/dist/brepjs.js

@@ -2157,11 +2157,64 @@ 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 dot(a, b) {
+	return a[0] * b[0] + a[1] * b[1] + a[2] * b[2];
+}
+/**
+* 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.
+*/
+function solvePlanePair(ref, refPos, 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: [
+			offset * n[0],
+			offset * n[1],
+			offset * n[2]
+		],
+		rotation: IDENTITY_ROTATION
+	};
+}
 /**
 * 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 (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.
 */
 function solveConstraints(nodes, constraints) {
 	const transforms = /* @__PURE__ */ new Map();
@@ -2171,69 +2224,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) => (c.type === "coincident" || c.type === "distance") && 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") {
+			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 extra = c.type === "distance" ? c.value ?? 0 : 0;
+			transforms.set(dep.node, solvePlanePair(ref.entity, refPose.position, dep.entity, extra));
+			placed.add(dep.node);
+		}
+	}
+	for (const c of pending) unsupported.push(`${c.type}(unanchored)`);
 	return {
 		transforms,
 		dof: unsupported.reduce((sum, type) => {

package/dist/kernel/solverAdapter.d.ts

@@ -34,8 +34,13 @@ export interface SolverResult {
 /**
  * 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 (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.
  */
 export declare function solveConstraints(nodes: string[], constraints: SolverConstraint[]): SolverResult;
 export {};

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "brepjs",
-  "version": "18.69.2",
+  "version": "18.69.3",
   "description": "Web CAD library with pluggable geometry kernel",
   "keywords": [
     "cad",