brepjs 20.12.6 → 20.12.8

package/dist/{importFns-KEPAgbjj.cjs → importFns-BiRpt227.cjs}

@@ -1,8 +1,12 @@
-const require_shapeTypes = require("./shapeTypes-Dc7j-MYg.cjs");
+const require_shapeTypes = require("./shapeTypes-DmThK_oa.cjs");
 const require_bug = require("./bug-CBcpIPuf.cjs");
 const require_errors = require("./errors-O_blYTWT.cjs");
+const require_topologyQueryFns = require("./topologyQueryFns-CXbCFaU2.cjs");
+const require_constants = require("./constants-oee0S_x6.cjs");
+const require_solidBuilders = require("./solidBuilders-DGskMugU.cjs");
+const require_meshFns = require("./meshFns-Djbb4PUC.cjs");
 const require_arrayAccess = require("./arrayAccess-DpJYARwv.cjs");
-const require_blueprint = require("./blueprint-D83DDDPb.cjs");
+const require_blueprint = require("./blueprint-DTDSztfd.cjs");
 // src/io/objExportFns.ts
 /** Read a vec3 from a typed array at the given vertex index. */
 function vec3At(arr, i) {
@@ -1248,13 +1252,17 @@ function importSVGPathD(pathD) {
 */
 function importSVG(svgString) {
 	try {
-		const dAttrRe = /\bd\s*=\s*(?:"([^"]*)"|'([^']*)')/;
+		const dAttrRe = /\sd\s*=\s*(?:"([^"]*)"|'([^']*)')/;
 		const blueprints = [];
 		const lower = svgString.toLowerCase();
 		let pos = 0;
 		while (pos < lower.length) {
-			const tagStart = lower.indexOf("<path ", pos);
+			const tagStart = lower.indexOf("<path", pos);
 			if (tagStart === -1) break;
+			if (!/\s/.test(lower.charAt(tagStart + 5))) {
+				pos = tagStart + 5;
+				continue;
+			}
 			const tagEnd = svgString.indexOf(">", tagStart);
 			if (tagEnd === -1) break;
 			const tag = svgString.slice(tagStart, tagEnd + 1);
@@ -1297,6 +1305,275 @@ function exportSTEPConfigured(parts, options) {
 		return require_errors.err(require_errors.ioError(require_errors.BrepErrorCode.STEP_EXPORT_CONFIGURED_FAILED, "Configured STEP export failed", e));
 	}
 }
+// src/io/meshNesting.ts
+/**
+* Cavities in sewn mesh bodies.
+*
+* A hollow mesh is an outer shell plus inward-facing inner shells, and sewing makes
+* each of them a closed body of its own. A cavity is a shell whose triangles face
+* inward (negative signed volume, read before solidifying reorients it) that lies
+* inside another body; it is cut from the innermost body around it. An outward-facing
+* shell inside another is a separate part and stays one. Containment comes from ray
+* casts against each body's tessellation, because no kernel here can classify a
+* point against a solid.
+*/
+var RAY_LENGTH = Math.hypot(.5389, .6213, .5689);
+var RAY = [
+	.5389 / RAY_LENGTH,
+	.6213 / RAY_LENGTH,
+	.5689 / RAY_LENGTH
+];
+/**
+* The parts to keep: `bodies` (each built from the same-index shell of `shells`)
+* with every cavity cut from the body around it and left out. Cut results are
+* pushed to `owned` for the caller to dispose; no input is disposed here.
+*
+* @throws When meshing or a cut fails, rather than leave a cavity filled.
+*/
+function carveCavities(bodies, shells, owned) {
+	const solids = bodies.flatMap((body, i) => require_shapeTypes.isSolid(body) ? [{
+		body,
+		shell: shells[i]
+	}] : []);
+	if (solids.length < 2) return [...bodies];
+	const voids = findVoids(solids);
+	const carved = /* @__PURE__ */ new Map();
+	for (const [body, inner] of voids) {
+		const result = cutVoids(body, inner);
+		owned.push(result);
+		carved.set(body, result);
+	}
+	const consumed = new Set([...carved.keys()].flatMap((body) => voids.get(body) ?? []));
+	return bodies.filter((body) => !consumed.has(body)).map((body) => carved.get(body) ?? body);
+}
+/** The cavities of each body that has any, keyed by that body. */
+function findVoids(solids) {
+	const kernel = require_shapeTypes.getKernel();
+	const boxes = solids.map(({ body }) => kernel.boundingBox(body.wrapped));
+	const meshes = /* @__PURE__ */ new Map();
+	const meshOf = (i) => {
+		let mesh = meshes.get(i);
+		if (mesh === void 0) {
+			mesh = meshShape(solids[i].body, boxes[i]);
+			meshes.set(i, mesh);
+		}
+		return mesh;
+	};
+	const containers = solids.map((_inner, j) => solids.map((_outer, i) => i).filter((i) => i !== j && boxInside(boxes[j], boxes[i]) && insideMesh(firstVertex(meshOf(j)), meshOf(i))));
+	const isVoid = containers.map((around, j) => {
+		const shell = solids[j]?.shell;
+		return around.length > 0 && shell !== void 0 && facesInward(shell, boxes[j]);
+	});
+	const voids = /* @__PURE__ */ new Map();
+	containers.forEach((around, j) => {
+		if (!isVoid[j]) return;
+		const bodiesAround = around.filter((i) => !isVoid[i]);
+		if (bodiesAround.length === 0) return;
+		const body = solids[bodiesAround.reduce((a, b) => (containers[b]?.length ?? 0) > (containers[a]?.length ?? 0) ? b : a)].body;
+		voids.set(body, [...voids.get(body) ?? [], solids[j].body]);
+	});
+	return voids;
+}
+/** Whether a closed shell's triangles face inward, by the sign of its enclosed volume. */
+function facesInward(shell, box) {
+	const mesh = meshShape(shell, box);
+	const t = mesh.triangles;
+	let volume = 0;
+	for (let i = 0; i + 2 < t.length; i += 3) {
+		const a = vertexAt(mesh, t[i]);
+		volume += dot(a, cross(vertexAt(mesh, t[i + 1]), vertexAt(mesh, t[i + 2])));
+	}
+	return volume < 0;
+}
+function cutVoids(body, voids) {
+	const kernel = require_shapeTypes.getKernel();
+	let current = body;
+	for (const inner of voids) try {
+		const next = require_shapeTypes.castResultShape(kernel.cut(current.wrapped, inner.wrapped));
+		if (current !== body) current[Symbol.dispose]();
+		current = next;
+	} catch (e) {
+		if (current !== body) current[Symbol.dispose]();
+		throw e;
+	}
+	return current;
+}
+function meshShape(shape, box) {
+	const diagonal = Math.hypot(...box.max.map((v, i) => v - (box.min[i] ?? 0)));
+	return require_shapeTypes.getKernel().mesh(shape.wrapped, {
+		tolerance: Math.max(diagonal * .001, 1e-6),
+		angularTolerance: .5,
+		skipNormals: true
+	});
+}
+function boxInside(inner, outer) {
+	return inner.min.every((v, i) => v >= (outer.min[i] ?? 0) && (inner.max[i] ?? 0) <= (outer.max[i] ?? 0));
+}
+function firstVertex(mesh) {
+	return [
+		mesh.vertices[0] ?? 0,
+		mesh.vertices[1] ?? 0,
+		mesh.vertices[2] ?? 0
+	];
+}
+function vertexAt(mesh, index) {
+	const i = (index ?? 0) * 3;
+	return [
+		mesh.vertices[i] ?? 0,
+		mesh.vertices[i + 1] ?? 0,
+		mesh.vertices[i + 2] ?? 0
+	];
+}
+/** Whether `p` is inside the closed mesh, by the parity of a ray's crossings. */
+function insideMesh(p, mesh) {
+	const t = mesh.triangles;
+	let crossings = 0;
+	for (let i = 0; i + 2 < t.length; i += 3) if (rayHits(p, vertexAt(mesh, t[i]), vertexAt(mesh, t[i + 1]), vertexAt(mesh, t[i + 2]))) crossings++;
+	return crossings % 2 === 1;
+}
+var sub = (a, b) => [
+	a[0] - b[0],
+	a[1] - b[1],
+	a[2] - b[2]
+];
+var dot = (a, b) => a[0] * b[0] + a[1] * b[1] + a[2] * b[2];
+var cross = (a, b) => [
+	a[1] * b[2] - a[2] * b[1],
+	a[2] * b[0] - a[0] * b[2],
+	a[0] * b[1] - a[1] * b[0]
+];
+/** Moller-Trumbore: does the ray from `p` along RAY cross triangle abc ahead of `p`? */
+function rayHits(p, a, b, c) {
+	const e1 = sub(b, a);
+	const e2 = sub(c, a);
+	const h = cross(RAY, e2);
+	const det = dot(e1, h);
+	if (det === 0) return false;
+	const s = sub(p, a);
+	const u = dot(s, h) / det;
+	if (u < 0 || u > 1) return false;
+	const q = cross(s, e1);
+	const v = dot(RAY, q) / det;
+	if (v < 0 || u + v > 1) return false;
+	return dot(e2, q) / det > 0;
+}
+// src/io/ioUtils.ts
+/**
+* Shared mesh-to-solid sewing utilities for mesh importers.
+*
+* Builds triangular B-Rep faces from vertex/index data and sews them into one
+* solid per closed body, keeping any open body as a shell.
+*/
+/**
+* Sew faces into one solid per closed body.
+*
+* A single body comes back on its own: a `Solid` when closed, a `Shell` when
+* open. Several bodies come back as a `Compound` holding a `Solid` per closed
+* body, a `Shell` per open one, and any face that joined no shell. An
+* inward-facing closed shell inside another body is a cavity, cut from that
+* body. The caller keeps ownership of `faces`.
+*
+* @throws When the kernel cannot sew the faces at all.
+*/
+function sewFacesIntoSolids(faces, tolerance) {
+	try {
+		var _usingCtx$2 = require_shapeTypes._usingCtx();
+		const kernel = require_shapeTypes.getKernel();
+		const solid = solidify(faces, tolerance);
+		if (solid !== null) return solid;
+		const sewn = require_shapeTypes.castResultShape(kernel.sew(faces, tolerance));
+		const shells = require_topologyQueryFns.getShells(sewn);
+		const hasLooseFaces = shells.reduce((n, shell) => n + require_topologyQueryFns.subShapeCount(shell, "face"), 0) !== require_topologyQueryFns.subShapeCount(sewn, "face");
+		if (shells.length === 0 || shells.length === 1 && !hasLooseFaces) return sewn;
+		_usingCtx$2.u(sewn);
+		const owned = [];
+		try {
+			const parts = carveCavities(shells.map((shell) => {
+				const body = solidifyShell(shell.wrapped, tolerance);
+				owned.push(body);
+				return body;
+			}), shells, owned);
+			if (hasLooseFaces) for (const face of facesOutsideShells(sewn, shells)) {
+				const copy = require_shapeTypes.castResultShape(kernel.copyShape(face.wrapped));
+				owned.push(copy);
+				parts.push(copy);
+			}
+			return require_solidBuilders.makeCompound(parts);
+		} finally {
+			for (const shape of owned) shape[Symbol.dispose]();
+		}
+	} catch (_) {
+		_usingCtx$2.e = _;
+	} finally {
+		_usingCtx$2.d();
+	}
+}
+function facesOutsideShells(sewn, shells) {
+	const kernel = require_shapeTypes.getKernel();
+	const inShells = /* @__PURE__ */ new Map();
+	for (const shell of shells) for (const face of require_topologyQueryFns.getFaces(shell)) {
+		const hash = kernel.hashCode(face.wrapped, require_constants.HASH_CODE_MAX);
+		const bucket = inShells.get(hash);
+		if (bucket) bucket.push(face.wrapped);
+		else inShells.set(hash, [face.wrapped]);
+	}
+	return require_topologyQueryFns.getFaces(sewn).filter((face) => {
+		return !inShells.get(kernel.hashCode(face.wrapped, require_constants.HASH_CODE_MAX))?.some((other) => kernel.isSame(face.wrapped, other));
+	});
+}
+/**
+* `sewAndSolidify` when it yields a single solid, else `null`. Kernels signal
+* "not one closed body" differently: occt-wasm's solid downcast throws (and
+* castResultShape releases the slot), while opencascade.js returns the sewn
+* shell or compound, so the result's type decides.
+*/
+function solidify(faces, tolerance) {
+	let shape;
+	try {
+		shape = require_shapeTypes.castResultShape(require_shapeTypes.getKernel().sewAndSolidify(faces, tolerance));
+	} catch {
+		return null;
+	}
+	if (require_shapeTypes.isSolid(shape)) return shape;
+	shape[Symbol.dispose]();
+	return null;
+}
+function solidifyShell(shell, tolerance) {
+	const kernel = require_shapeTypes.getKernel();
+	const faces = kernel.iterShapes(shell, "face");
+	try {
+		return solidify(faces, tolerance) ?? require_shapeTypes.castResultShape(kernel.copyShape(shell));
+	} finally {
+		for (const face of faces) kernel.dispose(face);
+	}
+}
+/**
+* Build triangular B-Rep faces from vertex data and sew them into solids.
+*
+* For each triple of vertex coordinates, calls `kernel.buildTriFace` to create
+* a planar triangular face, then sews them with {@link sewFacesIntoSolids}.
+*
+* @param triangles - Array of vertex triples, each triple being three [x,y,z] tuples.
+* @param errorCode - The error code to use in any returned errors.
+* @param tolerance - Sewing tolerance (default 1e-6).
+* @returns A `Result` wrapping the sewn shape, or an error.
+*/
+function sewMeshToSolid(triangles, errorCode, tolerance = 1e-6) {
+	const kernel = require_shapeTypes.getKernel();
+	const triFaces = [];
+	for (const [va, vb, vc] of triangles) {
+		const triFace = kernel.buildTriFace(va, vb, vc);
+		if (triFace !== null) triFaces.push(triFace);
+	}
+	if (triFaces.length === 0) return require_errors.err(require_errors.ioError(errorCode, "No valid triangular faces could be built"));
+	try {
+		return require_errors.ok(sewFacesIntoSolids(triFaces, tolerance));
+	} catch (e) {
+		return require_errors.err(require_errors.ioError(errorCode, "Failed to sew triangular faces", e));
+	} finally {
+		for (const triFace of triFaces) kernel.dispose(triFace);
+	}
+}
 // src/io/importFns.ts
 /**
 * Functional file import operations using branded shape types.
@@ -1333,16 +1610,25 @@ async function importSTEP(blob) {
 		return require_errors.err(require_errors.ioError("STEP_IMPORT_FAILED", "Failed to load STEP file", e));
 	}
 }
+var STL_SEW_TOLERANCE = 1e-6;
 /**
 * Import an STL file from a Blob.
 *
-* Reads the mesh, unifies same-domain faces with `ShapeUpgrade_UnifySameDomain`,
-* and wraps the result as a solid.
+* Reads the triangle mesh and sews its facets together. A closed mesh becomes a
+* `Solid` (one planar face per facet), so booleans and volume measurement work on
+* it directly. An open mesh has no interior, so it comes back as a sewn `Shell`.
+* A file with several bodies comes back as a `Compound` holding a `Solid` per
+* closed body and a `Shell` per open one.
 *
 * @param blob - A Blob or File containing STL data (binary or ASCII).
-* @returns A `Result` wrapping the imported solid, or an error if parsing fails.
+* @returns A `Result` wrapping the imported solid (a shell for an open mesh, a
+*   compound for several bodies), or an error if parsing fails.
 *
-* @remarks The temporary file on the WASM FS is cleaned up automatically.
+* @remarks Every triangle becomes its own B-Rep face, so import time grows with
+* the triangle count: on the default occt-wasm kernel, roughly 2.5 seconds per
+* 10,000 triangles (about 15 seconds for 50,000), and up to about twice that
+* when the file holds several bodies. The temporary file on the WASM FS is
+* cleaned up automatically.
 *
 * @example
 * ```ts
@@ -1351,10 +1637,21 @@ async function importSTEP(blob) {
 */
 async function importSTL(blob) {
 	try {
-		const data = await blob.arrayBuffer();
-		const shape = require_shapeTypes.getKernel().importSTL(data);
-		if (shape.IsNull()) return require_errors.err(require_errors.ioError("STL_IMPORT_FAILED", "Failed to create solid from STL mesh"));
-		return require_errors.ok(require_shapeTypes.castResultShape(shape));
+		try {
+			var _usingCtx$1 = require_shapeTypes._usingCtx();
+			const data = await blob.arrayBuffer();
+			const raw = require_shapeTypes.getKernel().importSTL(data);
+			if (raw.IsNull()) return require_errors.err(require_errors.ioError("STL_IMPORT_FAILED", "Failed to create solid from STL mesh"));
+			const shape = require_shapeTypes.castResultShape(raw);
+			if (require_shapeTypes.isSolid(shape)) return require_errors.ok(shape);
+			const facets = _usingCtx$1.u(shape);
+			const faces = require_topologyQueryFns.getFaces(facets).map((f) => f.wrapped);
+			return require_errors.ok(sewFacesIntoSolids(faces, STL_SEW_TOLERANCE));
+		} catch (_) {
+			_usingCtx$1.e = _;
+		} finally {
+			_usingCtx$1.d();
+		}
 	} catch (e) {
 		return require_errors.err(require_errors.ioError("STL_IMPORT_FAILED", "Failed to load STL file", e));
 	}
@@ -1365,7 +1662,9 @@ async function importSTL(blob) {
 * @param blob - A Blob or File containing IGES data (.iges / .igs).
 * @returns A `Result` wrapping the imported shape, or an error if parsing fails.
 *
-* @remarks The temporary file on the WASM FS is cleaned up automatically.
+* @remarks The temporary file on the WASM FS is cleaned up automatically. The
+* default occt-wasm kernel is built without an IGES translator, so there this
+* returns an `UNSUPPORTED_CAPABILITY` error; import STEP instead.
 *
 * @example
 * ```ts
@@ -1383,7 +1682,7 @@ async function importIGES(blob) {
 		}
 		return require_errors.ok(require_shapeTypes.castResultShape(shapes[0]));
 	} catch (e) {
-		return require_errors.err(require_errors.ioError("IGES_IMPORT_FAILED", "Failed to load IGES file", e));
+		return require_errors.err(require_meshFns.igesUnsupportedError("importIGES", e) ?? require_errors.ioError("IGES_IMPORT_FAILED", "Failed to load IGES file", e));
 	}
 }
 Object.defineProperty(exports, "blueprintToDXF", {
@@ -1458,3 +1757,9 @@ Object.defineProperty(exports, "importSVGPathD", {
 		return importSVGPathD;
 	}
 });
+Object.defineProperty(exports, "sewMeshToSolid", {
+	enumerable: true,
+	get: function() {
+		return sewMeshToSolid;
+	}
+});