brepjs 20.0.1 → 20.1.0

package/dist/{occtWasmAdapter-CIc9I87_.js → occtWasmAdapter-BYziKlFk.js}

@@ -1327,6 +1327,37 @@ function rotateZToDirection(k, shapeId, dir) {
 	const angle = Math.acos(Math.max(-1, Math.min(1, nz)));
 	return k.rotate(shapeId, 0, 0, 0, ax / axLen, ay / axLen, 0, angle);
 }
+/** Read an evolution result into a shape id and maps, releasing the Embind object. */
+function parseEvolution(evo) {
+	try {
+		const modifiedRaw = readVecInt(evo.modified);
+		const generatedRaw = readVecInt(evo.generated);
+		const deletedRaw = readVecInt(evo.deleted);
+		const parseMap = (raw) => {
+			const map = /* @__PURE__ */ new Map();
+			let i = 0;
+			while (i + 1 < raw.length) {
+				const inputHash = raw[i] ?? 0;
+				const count = raw[i + 1] ?? 0;
+				i += 2;
+				const outputs = [];
+				for (let j = 0; j < count && i < raw.length; j++, i++) outputs.push(raw[i] ?? 0);
+				map.set(inputHash, outputs);
+			}
+			return map;
+		};
+		return {
+			id: evo.resultId,
+			evolution: {
+				modified: parseMap(modifiedRaw),
+				generated: parseMap(generatedRaw),
+				deleted: new Set(deletedRaw)
+			}
+		};
+	} finally {
+		evo.delete();
+	}
+}
 //#endregion
 //#region src/kernel/occtWasm/adapterShims.ts
 function wrapKernelExceptions(kernel, mod) {
@@ -1382,6 +1413,89 @@ function buildOcShim(module, k) {
 }
 //#endregion
 //#region src/kernel/occtWasm/booleanOps.ts
+var BOOLEAN_OP_CODE = {
+	fuse: 0,
+	cut: 1,
+	common: 2
+};
+/** Same angular tolerance the opencascade.js adapter hands SimplifyResult. */
+var SIMPLIFY_ANGULAR_TOLERANCE = .001;
+/** Whether this occt-wasm build has the general `booleanOp`. */
+function hasBooleanOp(k) {
+	return typeof k.booleanOp === "function";
+}
+/** Whether `options` asks for anything only `booleanOp` can honor. */
+function needsBooleanOptions(options) {
+	if (!options) return false;
+	return options.optimisation !== void 0 && options.optimisation !== "none" || (options.fuzzyValue ?? 0) > 0 || options.simplify === true;
+}
+function glueCode(optimisation) {
+	if (optimisation === "commonFace") return 1;
+	if (optimisation === "sameFace") return 2;
+	return 0;
+}
+/**
+* Run `booleanOp` on raw shape ids, collecting face history when hashes are
+* given. The caller owns the returned id.
+*/
+function runBooleanOp(k, Module, kind, argIds, toolIds, options = {}, inputFaceHashes = [], hashUpperBound = 0) {
+	if (!k.booleanOp) throw new Error("occt-wasm: booleanOp is not available in this build");
+	let args;
+	let tools;
+	let hashes;
+	try {
+		args = makeVecU32(Module, argIds);
+		tools = makeVecU32(Module, toolIds);
+		hashes = makeVecInt(Module, inputFaceHashes);
+		return parseEvolution(k.booleanOp(BOOLEAN_OP_CODE[kind], args, tools, glueCode(options.optimisation), options.fuzzyValue ?? 0, options.simplify === true ? SIMPLIFY_ANGULAR_TOLERANCE : 0, hashes, hashUpperBound));
+	} finally {
+		args?.delete();
+		tools?.delete();
+		hashes?.delete();
+	}
+}
+/**
+* Call `fn` with a tool's solids as separate ids, or with the tool alone when
+* it holds at most one solid, and report whether it was split. Solids are
+* handed to an n-way boolean as separate tools, which OCCT allows to overlap,
+* where one compound of overlapping solids is invalid input.
+*/
+function withToolIds(k, tool, fn) {
+	return withSolidIds(k, [tool], fn);
+}
+/**
+* {@link withToolIds} over several shapes: each multi-solid shape contributes
+* its solids, every other shape its own id, in order. `split` reports whether
+* any shape was expanded.
+*/
+function withSolidIds(k, shapes, fn) {
+	const ids = [];
+	const extracted = [];
+	try {
+		for (const shape of shapes) pushSolidIds(k, unwrap(shape), ids, extracted);
+		return fn(ids, ids.length > shapes.length);
+	} finally {
+		for (const id of extracted) k.release(id);
+	}
+}
+/**
+* Append `id`'s solids to `ids`, or `id` itself when it holds at most one.
+* Every solid copy the query allocated goes on `extracted` for release.
+*/
+function pushSolidIds(k, id, ids, extracted) {
+	const solids = k.getSubShapes(id, "solid");
+	try {
+		const n = solids.size();
+		for (let i = 0; i < n; i++) {
+			const solidId = solids.get(i);
+			if (solidId !== id) extracted.push(solidId);
+			if (n > 1) ids.push(solidId);
+		}
+		if (n <= 1) ids.push(id);
+	} finally {
+		solids.delete();
+	}
+}
 /**
 * Normalize a boolean tool to a single fused solid when it is a compound of
 * multiple solids (e.g. engraved text — one solid per glyph). occt-wasm's
@@ -1414,29 +1528,33 @@ function resolveBooleanTool(k, tool) {
 		solids.delete();
 	}
 }
-function fuse(k, shape, tool, _options) {
+function fuse(k, Module, shape, tool, options) {
+	if (hasBooleanOp(k) && needsBooleanOptions(options)) return wrapResult(k, runBooleanOp(k, Module, "fuse", [unwrap(shape)], [unwrap(tool)], options).id);
 	return wrapResult(k, k.fuse(unwrap(shape), unwrap(tool)));
 }
-function cut(k, shape, tool, _options) {
-	const resolved = resolveBooleanTool(k, tool);
-	try {
-		return wrapResult(k, k.cut(unwrap(shape), resolved.id));
-	} finally {
-		resolved.dispose();
+function subtractOrCommon(k, Module, kind, shape, tool, options) {
+	if (hasBooleanOp(k)) {
+		const id = withToolIds(k, tool, (toolIds, split) => split || needsBooleanOptions(options) ? runBooleanOp(k, Module, kind, [unwrap(shape)], toolIds, options).id : null);
+		if (id !== null) return wrapResult(k, id);
 	}
-}
-function intersect(k, shape, tool, _options) {
 	const resolved = resolveBooleanTool(k, tool);
 	try {
-		return wrapResult(k, k.intersect(unwrap(shape), resolved.id));
+		return wrapResult(k, kind === "cut" ? k.cut(unwrap(shape), resolved.id) : k.intersect(unwrap(shape), resolved.id));
 	} finally {
 		resolved.dispose();
 	}
 }
+function cut(k, Module, shape, tool, options) {
+	return subtractOrCommon(k, Module, "cut", shape, tool, options);
+}
+function intersect(k, Module, shape, tool, options) {
+	return subtractOrCommon(k, Module, "common", shape, tool, options);
+}
 function section(k, shape, plane, _approximation) {
 	return wrapResult(k, k.section(unwrap(shape), unwrap(plane)));
 }
-function fuseAll(k, Module, shapes, _options) {
+function fuseAll(k, Module, shapes, options) {
+	if (shapes.length > 1 && hasBooleanOp(k) && needsBooleanOptions(options)) return withSolidIds(k, shapes, ([first, ...rest]) => wrapResult(k, runBooleanOp(k, Module, "fuse", first === void 0 ? [] : [first], rest, options).id));
 	const vec = makeVecU32(Module, shapes.map(unwrap));
 	try {
 		return wrapResult(k, k.fuseAll(vec));
@@ -1444,7 +1562,8 @@ function fuseAll(k, Module, shapes, _options) {
 		vec.delete();
 	}
 }
-function cutAll(k, Module, shape, tools, _options) {
+function cutAll(k, Module, shape, tools, options) {
+	if (tools.length > 0 && hasBooleanOp(k) && needsBooleanOptions(options)) return withSolidIds(k, [shape], (argIds) => withSolidIds(k, tools, (toolIds) => wrapResult(k, runBooleanOp(k, Module, "cut", argIds, toolIds, options).id)));
 	const vec = makeVecU32(Module, tools.map(unwrap));
 	try {
 		return wrapResult(k, k.cutAll(unwrap(shape), vec));
@@ -4518,36 +4637,6 @@ function fixWireOnFace(k, wire, face, tolerance) {
 * Parse an EvolutionData result from the WASM kernel into a ShapeEvolution.
 * The C++ facade returns flat vectors of [inputHash, count, out1, out2, ..., inputHash, count, ...].
 */
-function parseEvolution(evo) {
-	try {
-		const modifiedRaw = readVecInt(evo.modified);
-		const generatedRaw = readVecInt(evo.generated);
-		const deletedRaw = readVecInt(evo.deleted);
-		const parseMap = (raw) => {
-			const map = /* @__PURE__ */ new Map();
-			let i = 0;
-			while (i + 1 < raw.length) {
-				const inputHash = raw[i] ?? 0;
-				const count = raw[i + 1] ?? 0;
-				i += 2;
-				const outputs = [];
-				for (let j = 0; j < count && i < raw.length; j++, i++) outputs.push(raw[i] ?? 0);
-				map.set(inputHash, outputs);
-			}
-			return map;
-		};
-		return {
-			id: evo.resultId,
-			evolution: {
-				modified: parseMap(modifiedRaw),
-				generated: parseMap(generatedRaw),
-				deleted: new Set(deletedRaw)
-			}
-		};
-	} finally {
-		evo.delete();
-	}
-}
 function translateWithHistory(k, Module, shape, x, y, z, inputFaceHashes, hashUpperBound) {
 	const hashVec = makeVecInt(Module, inputFaceHashes);
 	try {
@@ -4619,62 +4708,104 @@ function generalTransformWithHistory(generalTransformFn, shape, linear, translat
 		}
 	};
 }
-function fuseWithHistory(k, Module, shape, tool, inputFaceHashes, hashUpperBound, _options) {
+var NO_DIAGNOSTICS = {
+	hasErrors: false,
+	hasWarnings: false,
+	messages: []
+};
+function viaBooleanOp(k, Module, kind, argIds, toolIds, inputFaceHashes, hashUpperBound, options) {
+	const { id, evolution } = runBooleanOp(k, Module, kind, argIds, toolIds, options, inputFaceHashes, hashUpperBound);
+	return {
+		shape: wrapResult(k, id),
+		evolution,
+		diagnostics: NO_DIAGNOSTICS
+	};
+}
+function fuseWithHistory(k, Module, shape, tool, inputFaceHashes, hashUpperBound, options) {
+	if (hasBooleanOp(k) && needsBooleanOptions(options)) return viaBooleanOp(k, Module, "fuse", [unwrap(shape)], [unwrap(tool)], inputFaceHashes, hashUpperBound, options);
 	const hashVec = makeVecInt(Module, inputFaceHashes);
 	try {
 		const { id, evolution } = parseEvolution(k.fuseWithHistory(unwrap(shape), unwrap(tool), hashVec, hashUpperBound));
 		return {
 			shape: wrapResult(k, id),
 			evolution,
-			diagnostics: {
-				hasErrors: false,
-				hasWarnings: false,
-				messages: []
-			}
+			diagnostics: NO_DIAGNOSTICS
 		};
 	} finally {
 		hashVec.delete();
 	}
 }
-function cutWithHistory(k, Module, shape, tool, inputFaceHashes, hashUpperBound, _options) {
+function subtractOrCommonWithHistory(k, Module, kind, shape, tool, inputFaceHashes, hashUpperBound, options) {
+	if (hasBooleanOp(k)) {
+		const result = withToolIds(k, tool, (toolIds, split) => split || needsBooleanOptions(options) ? viaBooleanOp(k, Module, kind, [unwrap(shape)], toolIds, inputFaceHashes, hashUpperBound, options) : null);
+		if (result) return result;
+	}
 	const hashVec = makeVecInt(Module, inputFaceHashes);
 	let resolved;
 	try {
 		resolved = resolveBooleanTool(k, tool);
-		const { id, evolution } = parseEvolution(k.cutWithHistory(unwrap(shape), resolved.id, hashVec, hashUpperBound));
+		const { id, evolution } = parseEvolution(kind === "cut" ? k.cutWithHistory(unwrap(shape), resolved.id, hashVec, hashUpperBound) : k.intersectWithHistory(unwrap(shape), resolved.id, hashVec, hashUpperBound));
 		return {
 			shape: wrapResult(k, id),
 			evolution,
-			diagnostics: {
-				hasErrors: false,
-				hasWarnings: false,
-				messages: []
-			}
+			diagnostics: NO_DIAGNOSTICS
 		};
 	} finally {
 		hashVec.delete();
 		resolved?.dispose();
 	}
 }
-function intersectWithHistory(k, Module, shape, tool, inputFaceHashes, hashUpperBound, _options) {
-	const hashVec = makeVecInt(Module, inputFaceHashes);
-	let resolved;
-	try {
-		resolved = resolveBooleanTool(k, tool);
-		const { id, evolution } = parseEvolution(k.intersectWithHistory(unwrap(shape), resolved.id, hashVec, hashUpperBound));
-		return {
-			shape: wrapResult(k, id),
-			evolution,
-			diagnostics: {
-				hasErrors: false,
-				hasWarnings: false,
-				messages: []
-			}
-		};
-	} finally {
-		hashVec.delete();
-		resolved?.dispose();
+function cutWithHistory(k, Module, shape, tool, inputFaceHashes, hashUpperBound, options) {
+	return subtractOrCommonWithHistory(k, Module, "cut", shape, tool, inputFaceHashes, hashUpperBound, options);
+}
+function intersectWithHistory(k, Module, shape, tool, inputFaceHashes, hashUpperBound, options) {
+	return subtractOrCommonWithHistory(k, Module, "common", shape, tool, inputFaceHashes, hashUpperBound, options);
+}
+/**
+* History for a result that is its input re-stored: `fuseAll` of one solid and
+* `cutAll` with no tools keep the same TShape, so every face keeps its hash.
+*/
+function identityEvolution(inputFaceHashes) {
+	const modified = /* @__PURE__ */ new Map();
+	for (const h of inputFaceHashes) modified.set(h, [h]);
+	return {
+		modified,
+		generated: /* @__PURE__ */ new Map(),
+		deleted: /* @__PURE__ */ new Set()
+	};
+}
+/** N-way fuse with face history over every input. Needs `booleanOp`. */
+function fuseAllWithHistory(k, Module, shapes, inputFaceHashes, hashUpperBound, options) {
+	return withSolidIds(k, shapes, (ids) => {
+		const [first, ...rest] = ids;
+		if (first !== void 0 && rest.length > 0) return viaBooleanOp(k, Module, "fuse", [first], rest, inputFaceHashes, hashUpperBound, options);
+		const vec = makeVecU32(Module, ids);
+		try {
+			return {
+				shape: wrapResult(k, k.fuseAll(vec)),
+				evolution: identityEvolution(inputFaceHashes),
+				diagnostics: NO_DIAGNOSTICS
+			};
+		} finally {
+			vec.delete();
+		}
+	});
+}
+/** N-way cut with face history over the base and every tool. Needs `booleanOp`. */
+function cutAllWithHistory(k, Module, shape, tools, inputFaceHashes, hashUpperBound, options) {
+	if (tools.length === 0) {
+		const vec = makeVecU32(Module, []);
+		try {
+			return {
+				shape: wrapResult(k, k.cutAll(unwrap(shape), vec)),
+				evolution: identityEvolution(inputFaceHashes),
+				diagnostics: NO_DIAGNOSTICS
+			};
+		} finally {
+			vec.delete();
+		}
 	}
+	return withSolidIds(k, [shape], (argIds) => withSolidIds(k, tools, (toolIds) => viaBooleanOp(k, Module, "cut", argIds, toolIds, inputFaceHashes, hashUpperBound, options)));
 }
 function filletWithHistory(k, Module, shape, edges, radius, inputFaceHashes, hashUpperBound) {
 	const r = resolveUniformRadius(edges, radius);
@@ -4835,11 +4966,19 @@ var OcctWasmAdapter = class OcctWasmAdapter {
 	Module;
 	k;
 	owner;
+	/** Present when this occt-wasm build has `booleanOp`. */
+	fuseAllWithHistory;
+	/** Present when this occt-wasm build has `booleanOp`. */
+	cutAllWithHistory;
 	constructor(module, kernel, owner) {
 		this.Module = module;
 		this.k = wrapKernelExceptions(kernel, module);
 		this.oc = buildOcShim(module, this.k);
 		this.owner = owner;
+		if (hasBooleanOp(this.k)) {
+			this.fuseAllWithHistory = (shapes, inputFaceHashes, hashUpperBound, options) => fuseAllWithHistory(this.k, this.Module, shapes, inputFaceHashes, hashUpperBound, options);
+			this.cutAllWithHistory = (shape, tools, inputFaceHashes, hashUpperBound, options) => cutAllWithHistory(this.k, this.Module, shape, tools, inputFaceHashes, hashUpperBound, options);
+		}
 	}
 	/**
 	* Build an adapter from occt-wasm's `OcctKernel` wrapper, retaining it for the
@@ -4911,13 +5050,13 @@ var OcctWasmAdapter = class OcctWasmAdapter {
 		return makeRectangle(this.k, width, height);
 	}
 	fuse(shape, tool, options) {
-		return fuse(this.k, shape, tool, options);
+		return fuse(this.k, this.Module, shape, tool, options);
 	}
 	cut(shape, tool, options) {
-		return cut(this.k, shape, tool, options);
+		return cut(this.k, this.Module, shape, tool, options);
 	}
 	intersect(shape, tool, options) {
-		return intersect(this.k, shape, tool, options);
+		return intersect(this.k, this.Module, shape, tool, options);
 	}
 	section(shape, plane, approximation) {
 		return section(this.k, shape, plane, approximation);