brepjs 18.79.0 → 18.80.0

package/dist/brepjs.cjs

@@ -2286,10 +2286,122 @@ function solveAngle(ref, dep, angleRad) {
 		rotation: require_threadFns.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). */
+/**
+* Point-point coincident/distance: place the dependent point on the reference
+* point (`extra` = 0) or at `extra` along the original separation direction.
+* If the points already coincide the direction is arbitrary (+X).
+*/
+function solvePointPair(refOrigin, depOrigin, extra) {
+	const sep = sub(depOrigin, refOrigin);
+	const len = Math.hypot(sep[0], sep[1], sep[2]);
+	return {
+		position: sub(add$1(refOrigin, scale$2(len < 1e-9 ? [
+			1,
+			0,
+			0
+		] : scale$2(sep, 1 / len), extra)), depOrigin),
+		rotation: IDENTITY_ROTATION
+	};
+}
+/**
+* Move the dependent plane (normal `depNormal`, at the origin) so its signed
+* distance from the reference point equals `extra` (the mirror of `solvePlanePair`
+* for a point reference and a plane dependent).
+*/
+function solvePlaneToPoint(depNormal, refOrigin, depOrigin, extra) {
+	const n = normalize(depNormal);
+	return {
+		position: scale$2(n, dot(n, sub(refOrigin, depOrigin)) - extra),
+		rotation: IDENTITY_ROTATION
+	};
+}
+/**
+* Reference axis, dependent point: drop the point onto the axis line
+* (`extra` = 0) or place it at radial distance `extra` from the line, keeping
+* its along-axis position. A point already on the axis gets an arbitrary radial.
+*/
+function solveAxisToPoint(ref, depOrigin, extra) {
+	const d = normalize(ref.direction ?? [
+		0,
+		0,
+		1
+	]);
+	const foot = add$1(ref.origin, scale$2(d, dot(d, sub(depOrigin, ref.origin))));
+	if (extra === 0) return {
+		position: sub(foot, depOrigin),
+		rotation: IDENTITY_ROTATION
+	};
+	const radial = sub(depOrigin, foot);
+	const rlen = Math.hypot(radial[0], radial[1], radial[2]);
+	return {
+		position: sub(add$1(foot, scale$2(rlen < 1e-9 ? anyPerpendicular(d) : scale$2(radial, 1 / rlen), extra)), depOrigin),
+		rotation: IDENTITY_ROTATION
+	};
+}
+/**
+* Reference point, dependent axis: translate the axis line so it passes through
+* the point (`extra` = 0) or lies at perpendicular distance `extra` from it.
+* Translation is purely perpendicular to the axis, so the line's direction and
+* along-axis parameterization are preserved.
+*/
+function solvePointToAxis(refOrigin, dep, extra) {
+	const d = normalize(dep.direction ?? [
+		0,
+		0,
+		1
+	]);
+	const w = sub(dep.origin, refOrigin);
+	const perp = sub(w, scale$2(d, dot(d, w)));
+	const plen = Math.hypot(perp[0], perp[1], perp[2]);
+	if (extra === 0) return {
+		position: scale$2(perp, -1),
+		rotation: IDENTITY_ROTATION
+	};
+	return {
+		position: sub(scale$2(plen < 1e-9 ? anyPerpendicular(d) : scale$2(perp, 1 / plen), extra), perp),
+		rotation: IDENTITY_ROTATION
+	};
+}
+/**
+* Axis-axis distance: align the dependent axis parallel to the reference, then
+* offset it to perpendicular distance `extra` (parallel pin-and-spacer). With
+* `extra` = 0 the axes become collinear, matching `concentric`.
+*/
+function solveAxisAxisDistance(ref, dep, extra) {
+	const dRef = normalize(ref.direction ?? [
+		0,
+		0,
+		1
+	]);
+	const rotation = require_threadFns.quatFromTo(normalize(dep.direction ?? [
+		0,
+		0,
+		1
+	]), dRef);
+	const w = sub(require_threadFns.quatRotate(rotation, dep.origin), ref.origin);
+	const perp = sub(w, scale$2(dRef, dot(dRef, w)));
+	const plen = Math.hypot(perp[0], perp[1], perp[2]);
+	return {
+		position: sub(scale$2(plen < 1e-9 ? anyPerpendicular(dRef) : scale$2(perp, 1 / plen), extra), perp),
+		rotation
+	};
+}
+/**
+* Supported entity-type pairs for the translational mates (`coincident` /
+* `distance`), keyed `${entityA}-${entityB}`. Both orders are listed where the
+* solver handles them, so a user need not pre-order the entities.
+*/
+var TRANSLATIONAL_PAIRS = new Set([
+	"plane-plane",
+	"plane-point",
+	"point-plane",
+	"point-point",
+	"axis-axis",
+	"axis-point",
+	"point-axis"
+]);
+/** Entity types the orientation/axis mates require of (entityA, entityB). */
 var REQUIRED_ENTITIES = {
-	coincident: "plane",
-	distance: "plane",
 	angle: "plane",
 	concentric: "axis"
 };
@@ -2299,21 +2411,51 @@ var POSITIONING_TYPES = new Set([
 	"angle",
 	"concentric"
 ]);
+/** Whether a positioning mate's entity pair is solvable. */
+function isSupportedPair(type, a, b) {
+	const required = REQUIRED_ENTITIES[type];
+	if (required) return a === required && b === required;
+	return TRANSLATIONAL_PAIRS.has(`${a}-${b}`);
+}
+/**
+* Solve a `coincident` (extra = 0) or `distance` (extra = value) mate for any
+* supported entity-type pair. `ref` is already in world space; the dependent is
+* at the origin. Returns null only for an unsupported pair (filtered out
+* upstream by `isSupportedPair`).
+*/
+function solveTranslational(ref, dep, extra) {
+	switch (`${ref.type}-${dep.type}`) {
+		case "plane-plane":
+		case "plane-point": return solvePlanePair(ref, dep, extra);
+		case "point-plane": return solvePlaneToPoint(dep.normal ?? [
+			0,
+			0,
+			1
+		], ref.origin, dep.origin, extra);
+		case "point-point": return solvePointPair(ref.origin, dep.origin, extra);
+		case "axis-axis": return extra === 0 ? solveConcentric(ref, dep) : solveAxisAxisDistance(ref, dep, extra);
+		case "axis-point": return solveAxisToPoint(ref, dep.origin, extra);
+		case "point-axis": return solvePointToAxis(ref.origin, dep, extra);
+		default: return null;
+	}
+}
 /** 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);
+		case "distance": return solveTranslational(ref, dep, c.value ?? 0) ?? solvePlanePair(ref, dep, c.value ?? 0);
+		default: return solveTranslational(ref, dep, 0) ?? solvePlanePair(ref, dep, 0);
 	}
 }
 /**
 * Solve assembly constraints analytically.
 *
-* 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
+* Handles: fixed, concentric (axis-axis), angle (plane-plane orientation), and
+* coincident/distance for any supported entity-type pair (plane-plane,
+* plane-point, point-point, axis-axis, axis-point, and both point orders — see
+* `TRANSLATIONAL_PAIRS`). 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
@@ -2340,9 +2482,10 @@ function solveConstraints(nodes, constraints) {
 	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})`);
+		const a = c.entityA.entity.type;
+		const b = c.entityB.entity.type;
+		if (!isSupportedPair(c.type, a, b)) {
+			unsupported.push(`${c.type}(${a}-${b})`);
 			continue;
 		}
 		pending.push(c);

package/dist/brepjs.js

@@ -2297,10 +2297,122 @@ function solveAngle(ref, dep, angleRad) {
 		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). */
+/**
+* Point-point coincident/distance: place the dependent point on the reference
+* point (`extra` = 0) or at `extra` along the original separation direction.
+* If the points already coincide the direction is arbitrary (+X).
+*/
+function solvePointPair(refOrigin, depOrigin, extra) {
+	const sep = sub(depOrigin, refOrigin);
+	const len = Math.hypot(sep[0], sep[1], sep[2]);
+	return {
+		position: sub(add$1(refOrigin, scale$2(len < 1e-9 ? [
+			1,
+			0,
+			0
+		] : scale$2(sep, 1 / len), extra)), depOrigin),
+		rotation: IDENTITY_ROTATION
+	};
+}
+/**
+* Move the dependent plane (normal `depNormal`, at the origin) so its signed
+* distance from the reference point equals `extra` (the mirror of `solvePlanePair`
+* for a point reference and a plane dependent).
+*/
+function solvePlaneToPoint(depNormal, refOrigin, depOrigin, extra) {
+	const n = normalize(depNormal);
+	return {
+		position: scale$2(n, dot(n, sub(refOrigin, depOrigin)) - extra),
+		rotation: IDENTITY_ROTATION
+	};
+}
+/**
+* Reference axis, dependent point: drop the point onto the axis line
+* (`extra` = 0) or place it at radial distance `extra` from the line, keeping
+* its along-axis position. A point already on the axis gets an arbitrary radial.
+*/
+function solveAxisToPoint(ref, depOrigin, extra) {
+	const d = normalize(ref.direction ?? [
+		0,
+		0,
+		1
+	]);
+	const foot = add$1(ref.origin, scale$2(d, dot(d, sub(depOrigin, ref.origin))));
+	if (extra === 0) return {
+		position: sub(foot, depOrigin),
+		rotation: IDENTITY_ROTATION
+	};
+	const radial = sub(depOrigin, foot);
+	const rlen = Math.hypot(radial[0], radial[1], radial[2]);
+	return {
+		position: sub(add$1(foot, scale$2(rlen < 1e-9 ? anyPerpendicular(d) : scale$2(radial, 1 / rlen), extra)), depOrigin),
+		rotation: IDENTITY_ROTATION
+	};
+}
+/**
+* Reference point, dependent axis: translate the axis line so it passes through
+* the point (`extra` = 0) or lies at perpendicular distance `extra` from it.
+* Translation is purely perpendicular to the axis, so the line's direction and
+* along-axis parameterization are preserved.
+*/
+function solvePointToAxis(refOrigin, dep, extra) {
+	const d = normalize(dep.direction ?? [
+		0,
+		0,
+		1
+	]);
+	const w = sub(dep.origin, refOrigin);
+	const perp = sub(w, scale$2(d, dot(d, w)));
+	const plen = Math.hypot(perp[0], perp[1], perp[2]);
+	if (extra === 0) return {
+		position: scale$2(perp, -1),
+		rotation: IDENTITY_ROTATION
+	};
+	return {
+		position: sub(scale$2(plen < 1e-9 ? anyPerpendicular(d) : scale$2(perp, 1 / plen), extra), perp),
+		rotation: IDENTITY_ROTATION
+	};
+}
+/**
+* Axis-axis distance: align the dependent axis parallel to the reference, then
+* offset it to perpendicular distance `extra` (parallel pin-and-spacer). With
+* `extra` = 0 the axes become collinear, matching `concentric`.
+*/
+function solveAxisAxisDistance(ref, dep, extra) {
+	const dRef = normalize(ref.direction ?? [
+		0,
+		0,
+		1
+	]);
+	const rotation = quatFromTo(normalize(dep.direction ?? [
+		0,
+		0,
+		1
+	]), dRef);
+	const w = sub(quatRotate(rotation, dep.origin), ref.origin);
+	const perp = sub(w, scale$2(dRef, dot(dRef, w)));
+	const plen = Math.hypot(perp[0], perp[1], perp[2]);
+	return {
+		position: sub(scale$2(plen < 1e-9 ? anyPerpendicular(dRef) : scale$2(perp, 1 / plen), extra), perp),
+		rotation
+	};
+}
+/**
+* Supported entity-type pairs for the translational mates (`coincident` /
+* `distance`), keyed `${entityA}-${entityB}`. Both orders are listed where the
+* solver handles them, so a user need not pre-order the entities.
+*/
+var TRANSLATIONAL_PAIRS = new Set([
+	"plane-plane",
+	"plane-point",
+	"point-plane",
+	"point-point",
+	"axis-axis",
+	"axis-point",
+	"point-axis"
+]);
+/** Entity types the orientation/axis mates require of (entityA, entityB). */
 var REQUIRED_ENTITIES = {
-	coincident: "plane",
-	distance: "plane",
 	angle: "plane",
 	concentric: "axis"
 };
@@ -2310,21 +2422,51 @@ var POSITIONING_TYPES = new Set([
 	"angle",
 	"concentric"
 ]);
+/** Whether a positioning mate's entity pair is solvable. */
+function isSupportedPair(type, a, b) {
+	const required = REQUIRED_ENTITIES[type];
+	if (required) return a === required && b === required;
+	return TRANSLATIONAL_PAIRS.has(`${a}-${b}`);
+}
+/**
+* Solve a `coincident` (extra = 0) or `distance` (extra = value) mate for any
+* supported entity-type pair. `ref` is already in world space; the dependent is
+* at the origin. Returns null only for an unsupported pair (filtered out
+* upstream by `isSupportedPair`).
+*/
+function solveTranslational(ref, dep, extra) {
+	switch (`${ref.type}-${dep.type}`) {
+		case "plane-plane":
+		case "plane-point": return solvePlanePair(ref, dep, extra);
+		case "point-plane": return solvePlaneToPoint(dep.normal ?? [
+			0,
+			0,
+			1
+		], ref.origin, dep.origin, extra);
+		case "point-point": return solvePointPair(ref.origin, dep.origin, extra);
+		case "axis-axis": return extra === 0 ? solveConcentric(ref, dep) : solveAxisAxisDistance(ref, dep, extra);
+		case "axis-point": return solveAxisToPoint(ref, dep.origin, extra);
+		case "point-axis": return solvePointToAxis(ref.origin, dep, extra);
+		default: return null;
+	}
+}
 /** 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);
+		case "distance": return solveTranslational(ref, dep, c.value ?? 0) ?? solvePlanePair(ref, dep, c.value ?? 0);
+		default: return solveTranslational(ref, dep, 0) ?? solvePlanePair(ref, dep, 0);
 	}
 }
 /**
 * Solve assembly constraints analytically.
 *
-* 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
+* Handles: fixed, concentric (axis-axis), angle (plane-plane orientation), and
+* coincident/distance for any supported entity-type pair (plane-plane,
+* plane-point, point-point, axis-axis, axis-point, and both point orders — see
+* `TRANSLATIONAL_PAIRS`). 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
@@ -2351,9 +2493,10 @@ function solveConstraints(nodes, constraints) {
 	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})`);
+		const a = c.entityA.entity.type;
+		const b = c.entityB.entity.type;
+		if (!isSupportedPair(c.type, a, b)) {
+			unsupported.push(`${c.type}(${a}-${b})`);
 			continue;
 		}
 		pending.push(c);

package/dist/kernel/solverAdapter.d.ts

@@ -34,9 +34,11 @@ export interface SolverResult {
 /**
  * Solve assembly constraints analytically.
  *
- * 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
+ * Handles: fixed, concentric (axis-axis), angle (plane-plane orientation), and
+ * coincident/distance for any supported entity-type pair (plane-plane,
+ * plane-point, point-point, axis-axis, axis-point, and both point orders — see
+ * `TRANSLATIONAL_PAIRS`). 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

package/package.json

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