brepjs 18.6.0 → 18.14.3

package/dist/cameraFns-1y1NyACI.cjs

@@ -0,0 +1,315 @@
+const require_shapeTypes = require("./shapeTypes-BTt_LLbk.cjs");
+const require_errors = require("./errors-Dv6pfNct.cjs");
+const require_topologyQueryFns = require("./topologyQueryFns-BU0qdNJP.cjs");
+const require_vecOps = require("./vecOps-D7xplSx8.cjs");
+//#region src/projection/projectionPlanes.ts
+/** Lookup table mapping each {@link ProjectionPlane} to its camera configuration. */
+var PROJECTION_PLANES = {
+	XY: {
+		dir: [
+			0,
+			0,
+			1
+		],
+		xAxis: [
+			1,
+			0,
+			0
+		]
+	},
+	XZ: {
+		dir: [
+			0,
+			-1,
+			0
+		],
+		xAxis: [
+			1,
+			0,
+			0
+		]
+	},
+	YZ: {
+		dir: [
+			1,
+			0,
+			0
+		],
+		xAxis: [
+			0,
+			1,
+			0
+		]
+	},
+	YX: {
+		dir: [
+			0,
+			0,
+			-1
+		],
+		xAxis: [
+			0,
+			1,
+			0
+		]
+	},
+	ZX: {
+		dir: [
+			0,
+			1,
+			0
+		],
+		xAxis: [
+			0,
+			0,
+			1
+		]
+	},
+	ZY: {
+		dir: [
+			-1,
+			0,
+			0
+		],
+		xAxis: [
+			0,
+			0,
+			1
+		]
+	},
+	front: {
+		dir: [
+			0,
+			-1,
+			0
+		],
+		xAxis: [
+			1,
+			0,
+			0
+		]
+	},
+	back: {
+		dir: [
+			0,
+			1,
+			0
+		],
+		xAxis: [
+			-1,
+			0,
+			0
+		]
+	},
+	right: {
+		dir: [
+			-1,
+			0,
+			0
+		],
+		xAxis: [
+			0,
+			-1,
+			0
+		]
+	},
+	left: {
+		dir: [
+			1,
+			0,
+			0
+		],
+		xAxis: [
+			0,
+			1,
+			0
+		]
+	},
+	bottom: {
+		dir: [
+			0,
+			0,
+			1
+		],
+		xAxis: [
+			1,
+			0,
+			0
+		]
+	},
+	top: {
+		dir: [
+			0,
+			0,
+			-1
+		],
+		xAxis: [
+			1,
+			0,
+			0
+		]
+	}
+};
+/** Type guard — check if a value is a valid {@link ProjectionPlane} name. */
+function isProjectionPlane(plane) {
+	return typeof plane === "string" && plane in PROJECTION_PLANES;
+}
+//#endregion
+//#region src/projection/makeProjectedEdges.ts
+var getEdgesFromOc = (shape) => {
+	if (shape.IsNull()) return [];
+	return require_topologyQueryFns.getEdges(require_shapeTypes.castShape(shape));
+};
+/**
+* Project a 3D shape onto a 2D plane using hidden-line removal (HLR).
+*
+* @param camera - Camera defining the projection plane.
+* @param withHiddenLines - If `true`, also returns hidden (occluded) edges.
+* @returns Separate arrays of visible and hidden projected edges.
+*/
+function makeProjectedEdges(shape, camera, withHiddenLines = true) {
+	const projected = require_shapeTypes.getKernel().projectEdges(shape.wrapped, [...camera.position], [...camera.direction], [...camera.xAxis]);
+	return {
+		visible: [
+			...getEdgesFromOc(projected.visible.sharp),
+			...getEdgesFromOc(projected.visible.smooth),
+			...getEdgesFromOc(projected.visible.outline)
+		],
+		hidden: withHiddenLines ? [
+			...getEdgesFromOc(projected.hidden.sharp),
+			...getEdgesFromOc(projected.hidden.smooth),
+			...getEdgesFromOc(projected.hidden.outline)
+		] : []
+	};
+}
+//#endregion
+//#region src/projection/cameraFns.ts
+/**
+* Create a camera from position, direction, and an optional X-axis.
+*
+* If `xAxis` is omitted, it is derived automatically from the direction.
+*
+* @param position - Camera position in world coordinates.
+* @param direction - View direction (camera looks along this vector).
+* @param xAxis - Optional horizontal axis; derived automatically if not provided.
+* @returns `Result<Camera>` -- an error if direction is zero-length.
+*/
+function createCamera(position = [
+	0,
+	0,
+	0
+], direction = [
+	0,
+	0,
+	1
+], xAxis) {
+	if (require_vecOps.vecLength(direction) < 1e-12) return require_errors.err(require_errors.validationError("CAMERA_ZERO_DIRECTION", "Camera direction cannot be a zero-length vector"));
+	let resolvedXAxis;
+	if (xAxis) resolvedXAxis = require_vecOps.vecNormalize(xAxis);
+	else {
+		let cross = require_vecOps.vecCross([
+			0,
+			0,
+			1
+		], direction);
+		if (require_vecOps.vecLength(cross) < 1e-12) cross = require_vecOps.vecCross([
+			0,
+			1,
+			0
+		], direction);
+		if (require_vecOps.vecLength(cross) < 1e-12) cross = require_vecOps.vecCross([
+			1,
+			0,
+			0
+		], direction);
+		resolvedXAxis = require_vecOps.vecNormalize(cross);
+	}
+	const yAxis = require_vecOps.vecNormalize(require_vecOps.vecCross(direction, resolvedXAxis));
+	return require_errors.ok({
+		position,
+		direction: require_vecOps.vecNormalize(direction),
+		xAxis: resolvedXAxis,
+		yAxis
+	});
+}
+/**
+* Create a new camera oriented to look at a target point from the current position.
+*
+* @param camera - Existing camera whose position is preserved.
+* @param target - World-space point to look at.
+* @returns `Result<Camera>` with updated direction and derived axes.
+*/
+function cameraLookAt(camera, target) {
+	const direction = require_vecOps.vecNormalize(require_vecOps.vecSub(camera.position, target));
+	return createCamera(camera.position, direction);
+}
+/**
+* Create a camera positioned at the origin, looking along a named projection plane.
+*
+* @param planeName - Named projection direction (e.g., `'front'`, `'top'`).
+* @returns `Result<Camera>` configured for that standard view.
+*/
+function cameraFromPlane(planeName) {
+	const config = PROJECTION_PLANES[planeName];
+	return createCamera([
+		0,
+		0,
+		0
+	], config.dir, config.xAxis);
+}
+/**
+* Project the edges of a 3D shape onto a 2D plane defined by a {@link Camera}.
+*
+* @param shape - The 3D shape to project.
+* @param camera - Camera defining the projection plane.
+* @param withHiddenLines - If true, compute hidden-line edges as well.
+* @returns Separate arrays of visible and hidden projected edges.
+*
+* @see {@link drawProjection} for the higher-level Drawing-based API.
+*/
+function projectEdges(shape, camera, withHiddenLines = true) {
+	return makeProjectedEdges(shape, camera, withHiddenLines);
+}
+//#endregion
+Object.defineProperty(exports, "PROJECTION_PLANES", {
+	enumerable: true,
+	get: function() {
+		return PROJECTION_PLANES;
+	}
+});
+Object.defineProperty(exports, "cameraFromPlane", {
+	enumerable: true,
+	get: function() {
+		return cameraFromPlane;
+	}
+});
+Object.defineProperty(exports, "cameraLookAt", {
+	enumerable: true,
+	get: function() {
+		return cameraLookAt;
+	}
+});
+Object.defineProperty(exports, "createCamera", {
+	enumerable: true,
+	get: function() {
+		return createCamera;
+	}
+});
+Object.defineProperty(exports, "isProjectionPlane", {
+	enumerable: true,
+	get: function() {
+		return isProjectionPlane;
+	}
+});
+Object.defineProperty(exports, "makeProjectedEdges", {
+	enumerable: true,
+	get: function() {
+		return makeProjectedEdges;
+	}
+});
+Object.defineProperty(exports, "projectEdges", {
+	enumerable: true,
+	get: function() {
+		return projectEdges;
+	}
+});

package/dist/cameraFns-CUzI5RKS.js

@@ -0,0 +1,274 @@
+import { X as getKernel, t as castShape } from "./shapeTypes-C--1jaT1.js";
+import { A as ok, b as err, d as validationError } from "./errors-0fYW_YnO.js";
+import { o as getEdges } from "./topologyQueryFns-Dhf85ZBK.js";
+import { c as vecLength, d as vecNormalize, g as vecSub, r as vecCross } from "./vecOps-DVROrqTV.js";
+//#region src/projection/projectionPlanes.ts
+/** Lookup table mapping each {@link ProjectionPlane} to its camera configuration. */
+var PROJECTION_PLANES = {
+	XY: {
+		dir: [
+			0,
+			0,
+			1
+		],
+		xAxis: [
+			1,
+			0,
+			0
+		]
+	},
+	XZ: {
+		dir: [
+			0,
+			-1,
+			0
+		],
+		xAxis: [
+			1,
+			0,
+			0
+		]
+	},
+	YZ: {
+		dir: [
+			1,
+			0,
+			0
+		],
+		xAxis: [
+			0,
+			1,
+			0
+		]
+	},
+	YX: {
+		dir: [
+			0,
+			0,
+			-1
+		],
+		xAxis: [
+			0,
+			1,
+			0
+		]
+	},
+	ZX: {
+		dir: [
+			0,
+			1,
+			0
+		],
+		xAxis: [
+			0,
+			0,
+			1
+		]
+	},
+	ZY: {
+		dir: [
+			-1,
+			0,
+			0
+		],
+		xAxis: [
+			0,
+			0,
+			1
+		]
+	},
+	front: {
+		dir: [
+			0,
+			-1,
+			0
+		],
+		xAxis: [
+			1,
+			0,
+			0
+		]
+	},
+	back: {
+		dir: [
+			0,
+			1,
+			0
+		],
+		xAxis: [
+			-1,
+			0,
+			0
+		]
+	},
+	right: {
+		dir: [
+			-1,
+			0,
+			0
+		],
+		xAxis: [
+			0,
+			-1,
+			0
+		]
+	},
+	left: {
+		dir: [
+			1,
+			0,
+			0
+		],
+		xAxis: [
+			0,
+			1,
+			0
+		]
+	},
+	bottom: {
+		dir: [
+			0,
+			0,
+			1
+		],
+		xAxis: [
+			1,
+			0,
+			0
+		]
+	},
+	top: {
+		dir: [
+			0,
+			0,
+			-1
+		],
+		xAxis: [
+			1,
+			0,
+			0
+		]
+	}
+};
+/** Type guard — check if a value is a valid {@link ProjectionPlane} name. */
+function isProjectionPlane(plane) {
+	return typeof plane === "string" && plane in PROJECTION_PLANES;
+}
+//#endregion
+//#region src/projection/makeProjectedEdges.ts
+var getEdgesFromOc = (shape) => {
+	if (shape.IsNull()) return [];
+	return getEdges(castShape(shape));
+};
+/**
+* Project a 3D shape onto a 2D plane using hidden-line removal (HLR).
+*
+* @param camera - Camera defining the projection plane.
+* @param withHiddenLines - If `true`, also returns hidden (occluded) edges.
+* @returns Separate arrays of visible and hidden projected edges.
+*/
+function makeProjectedEdges(shape, camera, withHiddenLines = true) {
+	const projected = getKernel().projectEdges(shape.wrapped, [...camera.position], [...camera.direction], [...camera.xAxis]);
+	return {
+		visible: [
+			...getEdgesFromOc(projected.visible.sharp),
+			...getEdgesFromOc(projected.visible.smooth),
+			...getEdgesFromOc(projected.visible.outline)
+		],
+		hidden: withHiddenLines ? [
+			...getEdgesFromOc(projected.hidden.sharp),
+			...getEdgesFromOc(projected.hidden.smooth),
+			...getEdgesFromOc(projected.hidden.outline)
+		] : []
+	};
+}
+//#endregion
+//#region src/projection/cameraFns.ts
+/**
+* Create a camera from position, direction, and an optional X-axis.
+*
+* If `xAxis` is omitted, it is derived automatically from the direction.
+*
+* @param position - Camera position in world coordinates.
+* @param direction - View direction (camera looks along this vector).
+* @param xAxis - Optional horizontal axis; derived automatically if not provided.
+* @returns `Result<Camera>` -- an error if direction is zero-length.
+*/
+function createCamera(position = [
+	0,
+	0,
+	0
+], direction = [
+	0,
+	0,
+	1
+], xAxis) {
+	if (vecLength(direction) < 1e-12) return err(validationError("CAMERA_ZERO_DIRECTION", "Camera direction cannot be a zero-length vector"));
+	let resolvedXAxis;
+	if (xAxis) resolvedXAxis = vecNormalize(xAxis);
+	else {
+		let cross = vecCross([
+			0,
+			0,
+			1
+		], direction);
+		if (vecLength(cross) < 1e-12) cross = vecCross([
+			0,
+			1,
+			0
+		], direction);
+		if (vecLength(cross) < 1e-12) cross = vecCross([
+			1,
+			0,
+			0
+		], direction);
+		resolvedXAxis = vecNormalize(cross);
+	}
+	const yAxis = vecNormalize(vecCross(direction, resolvedXAxis));
+	return ok({
+		position,
+		direction: vecNormalize(direction),
+		xAxis: resolvedXAxis,
+		yAxis
+	});
+}
+/**
+* Create a new camera oriented to look at a target point from the current position.
+*
+* @param camera - Existing camera whose position is preserved.
+* @param target - World-space point to look at.
+* @returns `Result<Camera>` with updated direction and derived axes.
+*/
+function cameraLookAt(camera, target) {
+	const direction = vecNormalize(vecSub(camera.position, target));
+	return createCamera(camera.position, direction);
+}
+/**
+* Create a camera positioned at the origin, looking along a named projection plane.
+*
+* @param planeName - Named projection direction (e.g., `'front'`, `'top'`).
+* @returns `Result<Camera>` configured for that standard view.
+*/
+function cameraFromPlane(planeName) {
+	const config = PROJECTION_PLANES[planeName];
+	return createCamera([
+		0,
+		0,
+		0
+	], config.dir, config.xAxis);
+}
+/**
+* Project the edges of a 3D shape onto a 2D plane defined by a {@link Camera}.
+*
+* @param shape - The 3D shape to project.
+* @param camera - Camera defining the projection plane.
+* @param withHiddenLines - If true, compute hidden-line edges as well.
+* @returns Separate arrays of visible and hidden projected edges.
+*
+* @see {@link drawProjection} for the higher-level Drawing-based API.
+*/
+function projectEdges(shape, camera, withHiddenLines = true) {
+	return makeProjectedEdges(shape, camera, withHiddenLines);
+}
+//#endregion
+export { makeProjectedEdges as a, projectEdges as i, cameraLookAt as n, PROJECTION_PLANES as o, createCamera as r, isProjectionPlane as s, cameraFromPlane as t };

package/dist/core/constants.d.ts

@@ -4,4 +4,3 @@ export declare const HASH_CODE_MAX = 2147483647;
 export declare const DEG2RAD: number;
 /** Multiply radians by this constant to convert to degrees. */
 export declare const RAD2DEG: number;
-//# sourceMappingURL=constants.d.ts.map

package/dist/core/curve2dHandle.d.ts

@@ -24,4 +24,3 @@ export interface Curve2DHandle extends Disposable {
  */
 export declare function createCurve2DHandle(rawHandle: KernelType): Curve2DHandle;
 export {};
-//# sourceMappingURL=curve2dHandle.d.ts.map

package/dist/core/dimensionTypes.d.ts

@@ -49,4 +49,3 @@ export type RequireDimension<D extends Dimension, Expected extends Dimension, T,
  * Resolves to the shared dimension if equal, or a readable error if not.
  */
 export type SameDimension<A extends Dimension, B extends Dimension, Op extends string = 'operation'> = A extends B ? A : DimensionError<Op, A, B>;
-//# sourceMappingURL=dimensionTypes.d.ts.map

package/dist/core/disposal.d.ts

@@ -87,4 +87,3 @@ export declare function withScopeResultAsync<T, E = BrepError>(fn: (scope: Dispo
  * ```
  */
 export declare function isLive(handle: ShapeHandle | KernelHandle<Deletable>): boolean;
-//# sourceMappingURL=disposal.d.ts.map

package/dist/core/errors.d.ts

@@ -178,4 +178,3 @@ export { translateKernelError, getSuggestionForCode } from './kernelErrorTransla
  * @param context - Optional caller context for the error message (e.g. function name).
  */
 export declare function safeIndex<T>(arr: readonly T[], index: number, context?: string): T;
-//# sourceMappingURL=errors.d.ts.map

package/dist/core/kernelBoundary.d.ts

@@ -25,4 +25,3 @@ export declare function makeKernelAx2(origin: Vec3, zDir: Vec3, xDir?: Vec3): Ke
 /** Create a kernel 3D axis-3 from origin, z direction, and optional x direction. Caller must delete. */
 export declare function makeKernelAx3(origin: Vec3, zDir: Vec3, xDir?: Vec3): KernelType;
 export {};
-//# sourceMappingURL=kernelBoundary.d.ts.map

package/dist/core/kernelCall.d.ts

@@ -39,4 +39,3 @@ export declare function kernelCallRaw<T>(fn: () => T, code: string, message: str
  * ```
  */
 export declare function kernelCallScoped(fn: (scope: DisposalScope) => KernelShape, code: string, message: string, kind?: BrepErrorKind): Result<AnyShape>;
-//# sourceMappingURL=kernelCall.d.ts.map

package/dist/core/kernelErrorTranslation.d.ts

@@ -14,4 +14,3 @@ export declare function getSuggestionForCode(code: string): string | undefined;
  * @returns User-friendly error message with actionable guidance
  */
 export declare function translateKernelError(kernelMessage: string): string;
-//# sourceMappingURL=kernelErrorTranslation.d.ts.map

package/dist/core/planeOps.d.ts

@@ -53,4 +53,3 @@ export declare function translatePlane(plane: Plane, offset: Vec3): Plane;
  * @param axis - World-space axis to rotate around.
  */
 export declare function pivotPlane(plane: Plane, angleDeg: number, axis?: Vec3): Plane;
-//# sourceMappingURL=planeOps.d.ts.map

package/dist/core/planeTypes.d.ts

@@ -15,4 +15,3 @@ export interface Plane {
 export type PlaneName = 'XY' | 'YZ' | 'ZX' | 'XZ' | 'YX' | 'ZY' | 'front' | 'back' | 'left' | 'right' | 'top' | 'bottom';
 /** Accept either an explicit {@link Plane} object or a {@link PlaneName} string. */
 export type PlaneInput = Plane | PlaneName;
-//# sourceMappingURL=planeTypes.d.ts.map

package/dist/core/result.d.ts

@@ -78,4 +78,3 @@ export interface ResultPipeline<T, E> {
  * ```
  */
 export declare function pipeline<T, E = BrepError>(input: T | Result<T, E>): ResultPipeline<T, E>;
-//# sourceMappingURL=result.d.ts.map

package/dist/core/shapeTypeCache.d.ts

@@ -11,4 +11,3 @@ export declare function hasCachedType(shape: KernelShape): boolean;
  * This is the primary hot-path function — replaces direct `kernel.shapeType()` calls.
  */
 export declare function getOrQueryType(kernel: KernelAdapter, shape: KernelShape): ShapeType;
-//# sourceMappingURL=shapeTypeCache.d.ts.map

package/dist/core/shapeTypes.d.ts

@@ -124,4 +124,3 @@ export declare function castShape3D(ocShape: KernelShape): AnyShape;
  * Used internally by topology extractors for bulk sub-shape iteration.
  */
 export declare function castShapeWithKnownType<D extends Dimension = '3D'>(ocShape: KernelShape, knownType: ShapeType, dim?: D): AnyShape<D>;
-//# sourceMappingURL=shapeTypes.d.ts.map

package/dist/core/typeDiscriminants.d.ts

@@ -13,4 +13,3 @@ export declare const findCurveType: (type: number | {
 }) => Result<CurveType>;
 /** Query the kernel for the topological type of a shape. */
 export declare function getShapeKind(shape: AnyShape<Dimension>): ShapeKind;
-//# sourceMappingURL=typeDiscriminants.d.ts.map

package/dist/core/types.d.ts

@@ -48,4 +48,3 @@ export interface MatrixTransform {
 /** Input accepted by `applyMatrix`: either a raw 4x4 array or a structured object. */
 export type MatrixInput = Matrix4x4 | MatrixTransform;
 export {};
-//# sourceMappingURL=types.d.ts.map

package/dist/core/validityTypes.d.ts

@@ -129,4 +129,3 @@ export declare function planarFace<D extends Dimension>(face: Face<D>): Result<P
 /** Prove that a wire is planar, returning a branded `PlanarWire` on success. */
 export declare function planarWire<D extends Dimension>(wire: Wire<D>): Result<PlanarWire<D>, string>;
 export {};
-//# sourceMappingURL=validityTypes.d.ts.map

package/dist/core/vecOps.d.ts

@@ -45,4 +45,3 @@ export declare function vecProjectToPlane(v: Vec3, planeOrigin: Vec3, planeNorma
 export declare function vecRotate(v: Vec3, axis: Vec3, angleRad: number): Vec3;
 /** Format a Vec3 as a human-readable string rounded to 3 decimal places. */
 export declare function vecRepr(v: Vec3): string;
-//# sourceMappingURL=vecOps.d.ts.map