brepjs 18.78.1 → 18.80.0

package/dist/operations/jointFns.d.ts

@@ -5,18 +5,33 @@ export interface JointAxis {
     readonly origin: Vec3;
     readonly direction: Vec3;
 }
-export type JointType = 'revolute' | 'prismatic';
+export type JointType = 'revolute' | 'prismatic' | 'cylindrical' | 'planar' | 'spherical';
+/**
+ * A single drivable degree of freedom. A `rotation` DOF turns about the joint's
+ * anchor point along `axis` (degrees); a `translation` DOF slides along `axis`
+ * (length units). `value` is always clamped to `[min, max]`.
+ */
+export interface JointDOF {
+    readonly kind: 'rotation' | 'translation';
+    readonly axis: Vec3;
+    readonly min: number;
+    readonly max: number;
+    readonly value: number;
+}
 export interface Joint {
     readonly type: JointType;
     /** Reference body (stays put); the child moves relative to it. */
     readonly parent: string;
     readonly child: string;
+    /** Primary axis; `origin` is the anchor every rotation DOF pivots about. */
     readonly axis: JointAxis;
-    /** Range bounds — degrees for revolute, length units for prismatic. */
+    /** Primary-DOF range bounds (mirror of `dofs[0]`). */
     readonly min: number;
     readonly max: number;
-    /** Current drivable parameter, always clamped to `[min, max]`. */
+    /** Primary-DOF value (mirror of `dofs[0]`), always clamped to `[min, max]`. */
     readonly value: number;
+    /** All drivable degrees of freedom, in composition order. */
+    readonly dofs: readonly JointDOF[];
 }
 /** A rigid transform: translation + quaternion rotation `[w, x, y, z]`. */
 export interface JointPose {
@@ -31,6 +46,36 @@ export interface JointOptions {
     /** Initial value, clamped to the range. Default: 0. */
     value?: number;
 }
+/** Per-DOF ranges for a cylindrical joint (rotation about + slide along one axis). */
+export interface CylindricalOptions {
+    /** Rotation DOF (degrees). Default range -180..180. */
+    rotation?: JointOptions;
+    /** Translation DOF (length). Default range 0..100. */
+    translation?: JointOptions;
+}
+/** Per-DOF ranges for a planar joint (two in-plane translations + a rotation). */
+export interface PlanarOptions {
+    /** Translation along the in-plane `uDirection`. Default range -100..100. */
+    u?: JointOptions;
+    /** Translation along `normal × u`. Default range -100..100. */
+    v?: JointOptions;
+    /** Rotation about the plane normal (degrees). Default range -180..180. */
+    rotation?: JointOptions;
+    /**
+     * In-plane reference direction for the `u` translation. Projected onto the
+     * plane and normalized; defaults to an arbitrary perpendicular of the normal.
+     */
+    uDirection?: Vec3;
+}
+/** Per-DOF ranges for a spherical joint (three rotations about a pivot). */
+export interface SphericalOptions {
+    /** Rotation about local X through the pivot (degrees). Default range -180..180. */
+    x?: JointOptions;
+    /** Rotation about local Y through the pivot (degrees). Default range -180..180. */
+    y?: JointOptions;
+    /** Rotation about local Z through the pivot (degrees). Default range -180..180. */
+    z?: JointOptions;
+}
 /** A revolute (hinge) joint — the child rotates about `axis` by `value` degrees. */
 export declare function revoluteJoint(parent: string, child: string, axis: JointAxis, opts?: JointOptions): Joint;
 /**
@@ -40,17 +85,45 @@ export declare function revoluteJoint(parent: string, child: string, axis: Joint
  * the axis line through `origin`.
  */
 export declare function prismaticJoint(parent: string, child: string, axis: JointAxis, opts?: JointOptions): Joint;
-/** Return a copy of `joint` with its drivable parameter set (clamped to range). */
+/**
+ * A cylindrical joint — the child both rotates about and slides along a single
+ * `axis` (2 DOF). DOF order: `[rotation, translation]`. The two motions share
+ * the axis, so they commute; rotation pivots about `axis.origin`.
+ */
+export declare function cylindricalJoint(parent: string, child: string, axis: JointAxis, opts?: CylindricalOptions): Joint;
+/**
+ * A planar joint — the child translates within a plane and rotates about its
+ * normal (3 DOF). `plane.direction` is the normal; `plane.origin` the rotation
+ * anchor. DOF order: `[u-translation, v-translation, rotation]`, where the
+ * translations are applied in the plane frame (independent of the rotation).
+ */
+export declare function planarJoint(parent: string, child: string, plane: JointAxis, opts?: PlanarOptions): Joint;
+/**
+ * A spherical (ball) joint — the child rotates freely about a pivot point
+ * (3 DOF). DOF order: `[x, y, z]` rotations about the local axes through
+ * `pivot`, composed as `Rx · Ry · Rz`.
+ */
+export declare function sphericalJoint(parent: string, child: string, pivot: Vec3, opts?: SphericalOptions): Joint;
+/**
+ * Return a copy of `joint` with per-DOF values set (each clamped to its range).
+ * Values are positional, matching `joint.dofs`; omitted entries keep their
+ * stored value. The primary mirror (`value`) is kept in sync with `dofs[0]`.
+ */
+export declare function setJointValues(joint: Joint, values: readonly number[]): Joint;
+/** Return a copy of `joint` with its primary DOF set (clamped to range). */
 export declare function setJointValue(joint: Joint, value: number): Joint;
 /**
- * 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.
+ * The child's local rigid transform (relative to the parent) for given DOF
+ * values. Defaults to each DOF's stored value. A single `number` overrides only
+ * the primary DOF (single-DOF ergonomics); an array overrides positionally,
+ * with omitted entries keeping their stored value. Each value is clamped to its
+ * DOF 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.
+ * DOFs are folded in array order via frame composition. For same-anchor
+ * rotations (e.g. spherical) this composes to a single rotation about the pivot;
+ * for a cylindrical axis the rotation and slide commute.
  */
-export declare function jointTransform(joint: Joint, value?: number): JointPose;
+export declare function jointTransform(joint: Joint, value?: number | readonly number[]): JointPose;
 /** Attach a joint to an assembly node. Returns a new node (immutable). */
 export declare function addJoint(assembly: AssemblyNode, joint: Joint): AssemblyNode;
 /**
@@ -63,10 +136,11 @@ export declare function addJoint(assembly: AssemblyNode, joint: Joint): Assembly
  * joints use `joint.value`. Resolution is topological (reuses the Phase-0
  * ordering), so chains of any depth compose. Returns a world pose for every node.
  */
-export declare function forwardKinematics(assembly: AssemblyNode, jointValues?: Readonly<Record<string, number>>): Map<string, JointPose>;
+export declare function forwardKinematics(assembly: AssemblyNode, jointValues?: Readonly<Record<string, number | readonly number[]>>): Map<string, JointPose>;
 /**
- * Open-chain mobility — the number of independent degrees of freedom. Each
- * revolute/prismatic joint contributes 1, so for a serial chain this equals the
- * joint count. (Closed-loop Grübler/Kutzbach analysis is future work.)
+ * Open-chain mobility — the number of independent degrees of freedom, summing
+ * each joint's DOF count (revolute/prismatic 1, cylindrical 2, planar/spherical
+ * 3). For a serial chain this equals the total DOF. (Closed-loop
+ * Grübler/Kutzbach analysis is future work.)
  */
 export declare function mechanismDOF(assembly: AssemblyNode): number;

package/dist/operations.cjs

@@ -1,7 +1,8 @@
 Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
-const require_threadFns = require("./threadFns-a_C2wGGt.cjs");
+const require_threadFns = require("./threadFns-B7a1EVpS.cjs");
 const require_loftFns = require("./loftFns-DiSsI2PM.cjs");
 exports.addChild = require_threadFns.addChild;
+exports.addJoint = require_threadFns.addJoint;
 exports.addStep = require_threadFns.addStep;
 exports.circularPattern = require_threadFns.circularPattern;
 exports.collectShapes = require_threadFns.collectShapes;
@@ -11,18 +12,28 @@ exports.createAssembly = require_threadFns.createAssembly;
 exports.createAssemblyNode = require_threadFns.createAssemblyNode;
 exports.createHistory = require_threadFns.createHistory;
 exports.createRegistry = require_threadFns.createRegistry;
+exports.cylindricalJoint = require_threadFns.cylindricalJoint;
 exports.exportAssemblySTEP = require_threadFns.exportAssemblySTEP;
 exports.findNode = require_threadFns.findNode;
 exports.findStep = require_threadFns.findStep;
+exports.forwardKinematics = require_threadFns.forwardKinematics;
 exports.getHistoryShape = require_threadFns.getShape;
 exports.gridPattern = require_threadFns.gridPattern;
+exports.jointTransform = require_threadFns.jointTransform;
 exports.linearPattern = require_threadFns.linearPattern;
+exports.mechanismDOF = require_threadFns.mechanismDOF;
 exports.modifyStep = require_threadFns.modifyStep;
+exports.planarJoint = require_threadFns.planarJoint;
+exports.prismaticJoint = require_threadFns.prismaticJoint;
 exports.registerOperation = require_threadFns.registerOperation;
 exports.registerShape = require_threadFns.registerShape;
 exports.removeChild = require_threadFns.removeChild;
 exports.replayFrom = require_threadFns.replayFrom;
 exports.replayHistory = require_threadFns.replayHistory;
+exports.revoluteJoint = require_threadFns.revoluteJoint;
+exports.setJointValue = require_threadFns.setJointValue;
+exports.setJointValues = require_threadFns.setJointValues;
+exports.sphericalJoint = require_threadFns.sphericalJoint;
 exports.stepCount = require_threadFns.stepCount;
 exports.stepsFrom = require_threadFns.stepsFrom;
 exports.supportExtrude = require_loftFns.supportExtrude;

package/dist/operations.d.ts

@@ -10,6 +10,7 @@ export { sweep, supportExtrude, complexExtrude, twistExtrude, type SweepOptions,
 export { thread, type ThreadOptions } from './operations/threadFns.js';
 export { linearPattern, circularPattern, gridPattern } from './operations/patternFns.js';
 export { createAssemblyNode, addChild, removeChild, updateNode, findNode, walkAssembly, countNodes, collectShapes, type AssemblyNode, type AssemblyNodeOptions, } from './operations/assemblyFns.js';
+export { revoluteJoint, prismaticJoint, cylindricalJoint, planarJoint, sphericalJoint, setJointValue, setJointValues, jointTransform, addJoint, forwardKinematics, mechanismDOF, type Joint, type JointDOF, type JointAxis, type JointType, type JointPose, type JointOptions, type CylindricalOptions, type PlanarOptions, type SphericalOptions, } from './operations/jointFns.js';
 export { exportAssemblySTEP, type ShapeOptions, type SupportedUnit, } from './operations/exporterFns.js';
 export { createHistory, addStep, undoLast, findStep, getShape as getHistoryShape, stepCount, stepsFrom, registerShape, createRegistry, registerOperation, replayHistory, replayFrom, modifyStep, type OperationStep, type ModelHistory, type OperationFn, type OperationRegistry as HistoryOperationRegistry, } from './operations/historyFns.js';
 export { type AssemblyExporter, createAssembly } from './operations/exporters.js';

package/dist/operations.js

@@ -1,3 +1,3 @@
-import { C as updateNode, D as linearPattern, E as gridPattern, O as exportAssemblySTEP, S as removeChild, T as circularPattern, _ as addChild, b as createAssemblyNode, c as modifyStep, d as replayFrom, f as replayHistory, g as undoLast, h as stepsFrom, i as createRegistry, k as createAssembly, l as registerOperation, m as stepCount, n as addStep, o as findStep, r as createHistory, s as getShape, t as thread, u as registerShape, v as collectShapes, w as walkAssembly, x as findNode, y as countNodes } from "./threadFns-DGEyXFGP.js";
+import { B as gridPattern, C as prismaticJoint, D as sphericalJoint, E as setJointValues, F as findNode, H as exportAssemblySTEP, I as removeChild, L as updateNode, M as collectShapes, N as countNodes, P as createAssemblyNode, R as walkAssembly, S as planarJoint, T as setJointValue, U as createAssembly, V as linearPattern, _ as addJoint, b as jointTransform, c as modifyStep, d as replayFrom, f as replayHistory, g as undoLast, h as stepsFrom, i as createRegistry, j as addChild, l as registerOperation, m as stepCount, n as addStep, o as findStep, r as createHistory, s as getShape, t as thread, u as registerShape, v as cylindricalJoint, w as revoluteJoint, x as mechanismDOF, y as forwardKinematics, z as circularPattern } from "./threadFns-Cra0yHSF.js";
 import { d as twistExtrude, l as supportExtrude, o as complexExtrude, u as sweep } from "./loftFns-CsHOwded.js";
-export { addChild, addStep, circularPattern, collectShapes, complexExtrude, countNodes, createAssembly, createAssemblyNode, createHistory, createRegistry, exportAssemblySTEP, findNode, findStep, getShape as getHistoryShape, gridPattern, linearPattern, modifyStep, registerOperation, registerShape, removeChild, replayFrom, replayHistory, stepCount, stepsFrom, supportExtrude, sweep, thread, twistExtrude, undoLast, updateNode, walkAssembly };
+export { addChild, addJoint, addStep, circularPattern, collectShapes, complexExtrude, countNodes, createAssembly, createAssemblyNode, createHistory, createRegistry, cylindricalJoint, exportAssemblySTEP, findNode, findStep, forwardKinematics, getShape as getHistoryShape, gridPattern, jointTransform, linearPattern, mechanismDOF, modifyStep, planarJoint, prismaticJoint, registerOperation, registerShape, removeChild, replayFrom, replayHistory, revoluteJoint, setJointValue, setJointValues, sphericalJoint, stepCount, stepsFrom, supportExtrude, sweep, thread, twistExtrude, undoLast, updateNode, walkAssembly };