brepjs 18.82.3 → 18.82.5

package/dist/{primitiveFns-CjL5bygY.js → solidBuilders-QUpJdbiK.js}

@@ -1,13 +1,13 @@
-import { Z as getKernel, c as createSolid, h as isShape3D, t as castShape, x as isClosedWire } from "./shapeTypes-D4Evnmz_.js";
+import { Z as getKernel, _ as isSolid, c as createSolid, g as isShell, h as isShape3D, i as createCompound, l as createVertex, t as castShape } from "./shapeTypes-D4Evnmz_.js";
 import { A as ok, R as unwrap, b as err, d as validationError, i as kernelError, l as typeCastError, t as BrepErrorCode, v as andThen, w as isErr } from "./errors-DNWJsfVU.js";
 import { f as getVertices, p as getWires, s as getEdges } from "./topologyQueryFns-5EeBz6_7.js";
-import { n as HASH_CODE_MAX, t as DEG2RAD } from "./constants-ITRzCnCp.js";
+import { n as HASH_CODE_MAX } from "./constants-ITRzCnCp.js";
 import { h as vecScale, t as vecAdd } from "./vecOps-SKPRvPH-.js";
 import { o as resolvePlane } from "./planeOps-DSjjtrjg.js";
-import { _ as propagateAllMetadata, g as collectInputFaceHashes, h as translate, v as propagateMetadataByHash } from "./shapeFns-B6UAiYAx.js";
+import { _ as cast, v as downcast } from "./faceFns-BO8IXhhf.js";
+import { _ as propagateAllMetadata, g as collectInputFaceHashes, v as propagateMetadataByHash } from "./shapeFns-B6UAiYAx.js";
 import { n as getAtOrThrow, t as firstOrThrow } from "./arrayAccess-DrUGPADn.js";
-import { _ as makeThreePointArc, a as makeNonPlanarFace, c as makeBSplineApproximation, d as makeCircle, f as makeEllipse, g as makeTangentArc, h as makeLine, i as makeNewFaceWithinFace, m as makeHelix, o as makePolygon, p as makeEllipseArc, r as makeFace, s as assembleWire, t as addHolesInFace, u as makeBezierCurve } from "./surfaceBuilders-CLMyFimy.js";
-import { a as makeOffset, c as makeTorus, i as makeEllipsoid, l as makeVertex, n as makeCone, o as makeSolid, r as makeCylinder, s as makeSphere, t as makeCompound, u as weldShellsAndFaces } from "./solidBuilders-CgPOdC3Q.js";
+import { r as makeFace } from "./surfaceBuilders-CLMyFimy.js";
 //#region src/topology/booleanFns.ts
 /**
 * Boolean and compound operations — functional replacements for _3DShape boolean methods.
@@ -455,297 +455,140 @@ function booleanPipelineFallback(base, steps, options) {
 	return ok(current);
 }
 //#endregion
-//#region src/topology/primitiveFns.ts
+//#region src/topology/shapeUtils.ts
 /**
-* Create a box with the given dimensions.
-*
-* @param width  - Size along X.
-* @param depth  - Size along Y.
-* @param height - Size along Z.
+* Shape assembly utilities — welding and sewing operations.
 */
-function box(width, depth, height, options) {
-	const solid = createSolid(getKernel().makeBox(width, depth, height));
-	const center = options?.at ?? (options?.centered ? [
-		0,
-		0,
-		0
-	] : void 0);
-	if (center) return translate(solid, [
-		center[0] - width / 2,
-		center[1] - depth / 2,
-		center[2] - height / 2
-	]);
-	return solid;
+/** Sew faces/shells into a single shape using the kernel's sewing algorithm. */
+function weldShapes(facesOrShells) {
+	return unwrap(cast(unwrap(downcast(getKernel().sew(facesOrShells.map((s) => s.wrapped))))));
 }
 /**
-* Create a cylinder with the given radius and height.
+* Welds faces and shells into a single shell.
+*
+* @param facesOrShells - An array of faces and shells to be welded.
+* @param ignoreType - If true, the function will not check if the result is a shell.
+* @returns A shell that contains all the faces and shells.
 */
-function cylinder(radius, height, options) {
-	const at = options?.at ?? [
-		0,
-		0,
-		0
-	];
-	const axis = options?.axis ?? [
-		0,
-		0,
-		1
-	];
-	let solid = makeCylinder(radius, height, at, axis);
-	if (options?.centered) {
-		const halfShift = [
-			-axis[0] * height * .5,
-			-axis[1] * height * .5,
-			-axis[2] * height * .5
-		];
-		solid = translate(solid, halfShift);
-	}
-	return solid;
+function weldShellsAndFaces(facesOrShells, ignoreType = false) {
+	const shell = weldShapes(facesOrShells);
+	if (!ignoreType && !isShell(shell)) return err(typeCastError("WELD_NOT_SHELL", "Could not make a shell from faces and shells"));
+	return ok(shell);
 }
+//#endregion
+//#region src/topology/solidBuilders.ts
 /**
-* Create a sphere with the given radius.
+* Solid and primitive construction helpers — boxes, cylinders, spheres, cones,
+* tori, ellipsoids, vertices, compounds, and offsets.
 */
-function sphere(radius, options) {
-	let solid = makeSphere(radius);
-	if (options?.at) solid = translate(solid, options.at);
-	return solid;
-}
 /**
-* Create a cone (or frustum) with the given radii and height.
+* Creates a cylinder with the given radius and height.
 *
-* @param bottomRadius - Radius at the base.
-* @param topRadius    - Radius at the top (0 for a full cone).
-* @param height       - Height of the cone.
+* @category Solids
 */
-function cone(bottomRadius, topRadius, height, options) {
-	const at = options?.at ?? [
-		0,
-		0,
-		0
-	];
-	const axis = options?.axis ?? [
-		0,
-		0,
-		1
-	];
-	let solid = makeCone(bottomRadius, topRadius, height, at, axis);
-	if (options?.centered) {
-		const halfShift = [
-			-axis[0] * height * .5,
-			-axis[1] * height * .5,
-			-axis[2] * height * .5
-		];
-		solid = translate(solid, halfShift);
-	}
-	return solid;
+function makeCylinder(radius, height, location = [
+	0,
+	0,
+	0
+], direction = [
+	0,
+	0,
+	1
+]) {
+	return createSolid(getKernel().makeCylinder(radius, height, [...location], [...direction]));
 }
 /**
-* Create a torus with the given major and minor radii.
-*/
-function torus(majorRadius, minorRadius, options) {
-	return makeTorus(majorRadius, minorRadius, options?.at ?? [
-		0,
-		0,
-		0
-	], options?.axis ?? [
-		0,
-		0,
-		1
-	]);
-}
-/**
-* Create an ellipsoid with the given axis half-lengths.
+* Creates a sphere with the given radius.
 *
-* @param rx - Half-length along X.
-* @param ry - Half-length along Y.
-* @param rz - Half-length along Z.
+* @category Solids
 */
-function ellipsoid(rx, ry, rz, options) {
-	let solid = makeEllipsoid(rx, ry, rz);
-	if (options?.at) solid = translate(solid, options.at);
-	return solid;
-}
-/** Create a straight edge between two 3D points. */
-function line(from, to) {
-	return makeLine(from, to);
-}
-/** Create a circular edge with the given radius. */
-function circle(radius, options) {
-	const axisDir = options?.axis ?? [
-		0,
-		0,
-		1
-	];
-	return makeCircle(radius, options?.at ?? [
-		0,
-		0,
-		0
-	], axisDir);
+function makeSphere(radius) {
+	return createSolid(getKernel().makeSphere(radius));
 }
 /**
-* Create an elliptical edge.
+* Creates a cone (or frustum) with the given radii and height.
 *
-* @returns An error if `minorRadius` exceeds `majorRadius`.
+* @category Solids
 */
-function ellipse(majorRadius, minorRadius, options) {
-	const axisDir = options?.axis ?? [
-		0,
-		0,
-		1
-	];
-	return makeEllipse(majorRadius, minorRadius, options?.at ?? [
-		0,
-		0,
-		0
-	], axisDir, options?.xDir);
+function makeCone(radius1, radius2, height, location = [
+	0,
+	0,
+	0
+], direction = [
+	0,
+	0,
+	1
+]) {
+	return createSolid(getKernel().makeCone(radius1, radius2, height, [...location], [...direction]));
 }
 /**
-* Create a helical wire.
+* Creates a torus with the given major and minor radii.
 *
-* @param pitch  - Vertical distance per full turn.
-* @param height - Total height.
-* @param radius - Helix radius.
+* @category Solids
 */
-function helix(pitch, height, radius, options) {
-	return makeHelix(pitch, height, radius, options?.at ?? [
-		0,
-		0,
-		0
-	], options?.axis ?? [
-		0,
-		0,
-		1
-	], options?.lefthand ?? false);
-}
-/** Create a circular arc edge passing through three points. */
-function threePointArc(p1, p2, p3) {
-	return makeThreePointArc(p1, p2, p3);
+function makeTorus(majorRadius, minorRadius, location = [
+	0,
+	0,
+	0
+], direction = [
+	0,
+	0,
+	1
+]) {
+	return createSolid(getKernel().makeTorus(majorRadius, minorRadius, [...location], [...direction]));
 }
 /**
-* Create an elliptical arc edge between two angles.
+* Creates an ellipsoid with the given axis lengths.
 *
-* All angles are in **degrees** (unlike the legacy `makeEllipseArc` which used radians).
+* The algorithm creates a unit BSpline sphere surface, transforms its
+* control-point poles with an affinity matrix to match the requested
+* axis half-lengths, then sews the result into a solid.
 *
-* @param startAngle - Start angle in degrees.
-* @param endAngle   - End angle in degrees.
+* @category Solids
 */
-function ellipseArc(majorRadius, minorRadius, startAngle, endAngle, options) {
-	const axisDir = options?.axis ?? [
-		0,
-		0,
-		1
-	];
-	return makeEllipseArc(majorRadius, minorRadius, startAngle * DEG2RAD, endAngle * DEG2RAD, options?.at ?? [
-		0,
-		0,
-		0
-	], axisDir, options?.xDir);
+function makeEllipsoid(aLength, bLength, cLength) {
+	return createSolid(getKernel().makeEllipsoid(aLength, bLength, cLength));
 }
-/**
-* Create a B-spline edge that approximates a set of 3D points.
-*
-* @returns An error if the approximation algorithm fails.
-*/
-function bsplineApprox(points, config) {
-	return makeBSplineApproximation(points, config);
+/** Create a vertex at a 3D point. */
+function makeVertex(point) {
+	return createVertex(getKernel().makeVertex(point[0], point[1], point[2]));
 }
 /**
-* Create a Bezier curve edge from control points.
+* Create an offset shape from a face.
 *
-* @param points - Two or more control points.
-*/
-function bezier(points) {
-	return makeBezierCurve(points);
-}
-/**
-* Create a circular arc edge tangent to a direction at the start point.
-*/
-function tangentArc(startPoint, startTgt, endPoint) {
-	return makeTangentArc(startPoint, startTgt, endPoint);
+* @param offset - Signed offset distance (positive = outward).
+* @param tolerance - Geometric tolerance for the offset algorithm.
+* @returns An error if the result is not a valid 3D shape.
+*/
+function makeOffset(face, offset, tolerance = 1e-6) {
+	return andThen(downcast(getKernel().offset(face.wrapped, offset, tolerance)), (downcasted) => andThen(cast(downcasted), (newShape) => {
+		if (!isShape3D(newShape)) return err(typeCastError("OFFSET_NOT_3D", "Could not offset to a 3d shape"));
+		return ok(newShape);
+	}));
 }
 /**
-* Assemble edges and/or wires into a single connected wire.
+* Build a compound from multiple shapes.
+*
+* @param shapeArray - Shapes to group into a single compound.
+* @returns A new Compound containing all input shapes.
 */
-function wire(listOfEdges) {
-	return assembleWire(listOfEdges);
+function makeCompound(shapeArray) {
+	return createCompound(getKernel().makeCompound(shapeArray.map((s) => s.wrapped)));
 }
 /**
-* Assemble edges into a wire and verify it forms a closed loop.
+* Welds faces and shells into a single shell and then makes a solid.
 *
-* Combines {@link wire} + the `closedWire` smart constructor in a single step.
-* Returns an error if the edges cannot be assembled or the wire is not closed.
+* @param facesOrShells - An array of faces and shells to be welded.
+* @returns A solid that contains all the faces and shells.
 *
-* @example
-* ```ts
-* const cw = unwrap(wireLoop([e1, e2, e3, e4]));
-* const f = unwrap(face(cw)); // ClosedWire accepted directly
-* ```
+* @category Solids
 */
-function wireLoop(listOfEdges) {
-	return andThen(assembleWire(listOfEdges), (w) => {
-		if (isClosedWire(w)) return ok(w);
-		return err(validationError("WIRE_NOT_CLOSED", "Assembled wire is not closed: start and end points do not coincide"));
+function makeSolid(facesOrShells) {
+	const shell = weldShapes(facesOrShells);
+	return andThen(cast(getKernel().solidFromShell(shell.wrapped)), (solid) => {
+		if (!isSolid(solid)) return err(typeCastError("SOLID_BUILD_FAILED", "Could not make a solid of faces and shells"));
+		return ok(solid);
 	});
 }
-/**
-* Create a planar face from a closed wire, optionally with holes.
-* The resulting face is always oriented (consistent normal direction).
-*/
-function face(w, holes) {
-	return makeFace(w, holes);
-}
-/**
-* Create a non-planar face from a wire using surface filling.
-* The resulting face is always oriented.
-*/
-function filledFace(w) {
-	return makeNonPlanarFace(w);
-}
-/**
-* Create a face bounded by a wire on an existing face's surface.
-* The resulting face inherits orientation from the origin face.
-*/
-function subFace(originFace, w) {
-	return makeNewFaceWithinFace(originFace, w);
-}
-/**
-* Create a polygonal face from three or more coplanar points.
-* The resulting face is always oriented.
-*/
-function polygon(points) {
-	return makePolygon(points);
-}
-/** Create a vertex at a 3D point. */
-function vertex(point) {
-	return makeVertex(point);
-}
-/**
-* Build a compound from multiple shapes.
-*/
-function compound(shapeArray) {
-	return makeCompound(shapeArray);
-}
-/**
-* Weld faces and shells into a single solid.
-* The resulting solid is always validated.
-*/
-function solid(facesOrShells) {
-	return makeSolid(facesOrShells);
-}
-/**
-* Create an offset shape from a face.
-*/
-function offsetFace(f, distance, tolerance) {
-	return makeOffset(f, distance, tolerance);
-}
-/**
-* Weld faces and shells into a single shell.
-*/
-function sewShells(facesOrShells, ignoreType) {
-	return weldShellsAndFaces(facesOrShells, ignoreType);
-}
-function addHoles(f, holes) {
-	return addHolesInFace(f, holes);
-}
 //#endregion
-export { cutAll as A, threePointArc as C, wireLoop as D, wire as E, sectionToFace as F, slice as I, split as L, fuseAll as M, intersect as N, booleanPipeline as O, section as P, tangentArc as S, vertex as T, polygon as _, circle as a, sphere as b, cylinder as c, ellipsoid as d, face as f, offsetFace as g, line as h, bsplineApprox as i, fuse as j, cut as k, ellipse as l, helix as m, bezier as n, compound as o, filledFace as p, box as r, cone as s, addHoles as t, ellipseArc as u, sewShells as v, torus as w, subFace as x, solid as y };
+export { section as _, makeOffset as a, split as b, makeTorus as c, booleanPipeline as d, cut as f, intersect as g, fuseAll as h, makeEllipsoid as i, makeVertex as l, fuse as m, makeCone as n, makeSolid as o, cutAll as p, makeCylinder as r, makeSphere as s, makeCompound as t, weldShellsAndFaces as u, sectionToFace as v, slice as y };