brepjs 20.11.0 → 20.11.2

package/dist/brepjs.cjs

@@ -1,42 +1,42 @@
 Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
 const require_rolldown_runtime = require("./rolldown-runtime-BW-eSwOZ.cjs");
-const require_shapeTypes = require("./shapeTypes-CNQn1x5H.cjs");
-const require_occtWasmAdapter = require("./occtWasmAdapter-CsDULjij.cjs");
+const require_shapeTypes = require("./shapeTypes-HDVHzNk1.cjs");
+const require_occtWasmAdapter = require("./occtWasmAdapter-D1EXktNq.cjs");
 const require_bug = require("./bug-CBcpIPuf.cjs");
 const require_errors = require("./errors-B9r_Dzs1.cjs");
-const require_topologyQueryFns = require("./topologyQueryFns-BwhwOtxv.cjs");
-const require_validityTypes = require("./validityTypes-B_6gRPPO.cjs");
+const require_topologyQueryFns = require("./topologyQueryFns-BJ5U4AmO.cjs");
+const require_validityTypes = require("./validityTypes-C2l1ryPq.cjs");
 const require_constants = require("./constants-oee0S_x6.cjs");
 const require_types = require("./types-CjF9Rofr.cjs");
 const require_vecOps = require("./vecOps-CrGEPPQM.cjs");
 const require_planeOps = require("./planeOps-C7sRqzno.cjs");
-const require_faceFns = require("./faceFns-vVGf6osa.cjs");
-const require_originTrackingFns = require("./originTrackingFns-cEKFxtia.cjs");
-const require_solidBuilders = require("./solidBuilders-BN1p303l.cjs");
-const require_primitiveFns = require("./primitiveFns-BJ-ehvvd.cjs");
-const require_shapeFns = require("./shapeFns-CJrIL2CG.cjs");
-const require_curveFns = require("./curveFns-DUSOe8uJ.cjs");
-const require_meshFns = require("./meshFns-0W1-80zv.cjs");
+const require_faceFns = require("./faceFns-DolWAvAu.cjs");
+const require_originTrackingFns = require("./originTrackingFns-DRRVoZxG.cjs");
+const require_solidBuilders = require("./solidBuilders-BeanhIbq.cjs");
+const require_primitiveFns = require("./primitiveFns-BdSDbmhs.cjs");
+const require_shapeFns = require("./shapeFns-CREKqmcG.cjs");
+const require_curveFns = require("./curveFns-BBx04S8G.cjs");
+const require_meshFns = require("./meshFns-BhOC8SuD.cjs");
 const require_arrayAccess = require("./arrayAccess-DpJYARwv.cjs");
-const require_surfaceBuilders = require("./surfaceBuilders-C5lz2TNF.cjs");
-const require_healingFns = require("./healingFns-CW0olP8u.cjs");
-const require_threadFns = require("./threadFns-DO9SkBPb.cjs");
-const require_blueprintSketcher = require("./blueprintSketcher-7v6ufdam.cjs");
-const require_helpers = require("./helpers-BIpWypkW.cjs");
-const require_blueprint = require("./blueprint-YK9OBMxh.cjs");
-const require_drawFns = require("./drawFns-Cy7P1Q-L.cjs");
-const require_measureFns = require("./measureFns-BoNCUOKe.cjs");
-const require_cornerFinder = require("./cornerFinder-DVHtBOzM.cjs");
-const require_boolean2D = require("./boolean2D-B21GheGE.cjs");
-const require_blueprintFns = require("./blueprintFns-DDiWI0Ol.cjs");
-const require_importFns = require("./importFns-DI3Q8B0Q.cjs");
-const require_textBlueprints = require("./textBlueprints-jlqCGG4p.cjs");
-const require_loftFns = require("./loftFns-tGsV_hHY.cjs");
-const require_refResolveFns = require("./refResolveFns-DvDeMCVU.cjs");
-const require_adjacencyFns = require("./adjacencyFns-CS62XPcQ.cjs");
-const require_cameraFns = require("./cameraFns-HpsMe1iL.cjs");
-const require_textMetrics = require("./textMetrics-B2KxCoHk.cjs");
-const require_principalBoxFns = require("./principalBoxFns-B1j2sNAc.cjs");
+const require_surfaceBuilders = require("./surfaceBuilders-BdOO4OJU.cjs");
+const require_healingFns = require("./healingFns-BZRF9VAs.cjs");
+const require_threadFns = require("./threadFns-LGRpYJea.cjs");
+const require_blueprintSketcher = require("./blueprintSketcher-Cy1atQHR.cjs");
+const require_helpers = require("./helpers-BjVuQMLI.cjs");
+const require_blueprint = require("./blueprint-DxAD4jsT.cjs");
+const require_drawFns = require("./drawFns-COim8Ti4.cjs");
+const require_measureFns = require("./measureFns-eOGL04SI.cjs");
+const require_cornerFinder = require("./cornerFinder-CrceCNPv.cjs");
+const require_boolean2D = require("./boolean2D-DF0i9O9B.cjs");
+const require_blueprintFns = require("./blueprintFns-BxEYPNV5.cjs");
+const require_importFns = require("./importFns-Uz6iAurc.cjs");
+const require_textBlueprints = require("./textBlueprints-0pLR2X5a.cjs");
+const require_loftFns = require("./loftFns-nWtrZfoY.cjs");
+const require_refResolveFns = require("./refResolveFns--VMNo9vf.cjs");
+const require_adjacencyFns = require("./adjacencyFns-ChCZyiBA.cjs");
+const require_cameraFns = require("./cameraFns-nr0q89z5.cjs");
+const require_textMetrics = require("./textMetrics-BhIL6fpo.cjs");
+const require_principalBoxFns = require("./principalBoxFns-CY98NNKz.cjs");
 const require_workerPool = require("./workerPool-D5tiNXrI.cjs");
 // src/kernel/types.ts
 /** Check if the kernel supports hidden-line-removal projection. */
@@ -6181,7 +6181,7 @@ function sub(a, b) {
 function dot(a, b) {
 	return a[0] * b[0] + a[1] * b[1] + a[2] * b[2];
 }
-function cross(a, b) {
+function cross$1(a, b) {
 	return [
 		a[1] * b[2] - a[2] * b[1],
 		a[2] * b[0] - a[0] * b[2],
@@ -6205,7 +6205,7 @@ function normalize(a) {
 }
 /** A unit vector perpendicular to `v` (for the parallel-normals degenerate case). */
 function anyPerpendicular(v) {
-	return normalize(cross(v, Math.abs(v[0]) < .9 ? [
+	return normalize(cross$1(v, Math.abs(v[0]) < .9 ? [
 		1,
 		0,
 		0
@@ -6285,7 +6285,7 @@ function solveAngle(ref, dep, angleRad) {
 		1
 	]);
 	const phi = Math.acos(Math.max(-1, Math.min(1, dot(nDep, nRef))));
-	const c = cross(nDep, nRef);
+	const c = cross$1(nDep, nRef);
 	const axis = Math.hypot(c[0], c[1], c[2]) < 1e-9 ? anyPerpendicular(nDep) : c;
 	return {
 		position: [
@@ -6792,63 +6792,378 @@ function parseEntities(text) {
 			current = {
 				type: value,
 				layer: "0",
-				data: /* @__PURE__ */ new Map()
+				data: /* @__PURE__ */ new Map(),
+				pairs: []
 			};
 			continue;
 		}
 		if (current) {
+			current.pairs.push([code, value]);
 			if (code === 8) current.layer = value;
 			else current.data.set(code, value);
 		}
 	}
 	return entities;
 }
-function getNum(data, code, fallback = 0) {
-	const v = data.get(code);
-	if (v === void 0) return fallback;
-	const n = parseFloat(v);
+function num(value, fallback = 0) {
+	if (value === void 0) return fallback;
+	const n = parseFloat(value);
 	return isNaN(n) ? fallback : n;
 }
-function entityToEdge(entity) {
-	const { type, data } = entity;
-	const kernel = require_shapeTypes.getKernel();
-	if (type === "LINE") return kernel.makeLineEdge([
-		getNum(data, 10),
-		getNum(data, 20),
-		getNum(data, 30)
-	], [
-		getNum(data, 11),
-		getNum(data, 21),
-		getNum(data, 31)
+function getNum(data, code, fallback = 0) {
+	return num(data.get(code), fallback);
+}
+/** LWPOLYLINE vertices: each 10 starts one and its 20 and 42 follow; 38 is the elevation. */
+function lwVertices(entity) {
+	const z = getNum(entity.data, 38);
+	const out = [];
+	for (const [code, value] of entity.pairs) {
+		const last = out[out.length - 1];
+		if (code === 10) out.push({
+			point: [
+				num(value),
+				0,
+				z
+			],
+			bulge: 0
+		});
+		else if (code === 20 && last) last.point[1] = num(value);
+		else if (code === 42 && last) last.bulge = num(value);
+	}
+	return out;
+}
+/**
+* The DXF R12 polyline: a POLYLINE header, its VERTEX entities, then SEQEND. They arrive as
+* separate entities, so the header gathers the vertices that follow it.
+*/
+function gatherPolylines(entities) {
+	const out = [];
+	for (let i = 0; i < entities.length; i++) {
+		const e = entities[i];
+		if (e === void 0) continue;
+		if (e.type !== "POLYLINE") {
+			if (e.type !== "VERTEX" && e.type !== "SEQEND") out.push(e);
+			continue;
+		}
+		const vertices = [];
+		let j = i + 1;
+		for (; j < entities.length && entities[j]?.type === "VERTEX"; j++) {
+			const v = entities[j];
+			if (v === void 0) continue;
+			vertices.push([10, v.data.get(10) ?? "0"], [20, v.data.get(20) ?? "0"], [30, v.data.get(30) ?? "0"], [42, v.data.get(42) ?? "0"]);
+		}
+		if (entities[j]?.type === "SEQEND") j++;
+		const own = e.pairs.filter(([code]) => code !== 10 && code !== 20 && code !== 30);
+		out.push({
+			...e,
+			pairs: [...own, ...vertices]
+		});
+		i = j - 1;
+	}
+	return out;
+}
+function polyVertices(entity) {
+	if (entity.type === "LWPOLYLINE") return lwVertices(entity);
+	const out = [];
+	const p = entity.pairs;
+	for (let k = 0; k < p.length; k++) {
+		if (p[k]?.[0] !== 10) continue;
+		out.push({
+			point: [
+				num(p[k]?.[1]),
+				num(p[k + 1]?.[1]),
+				num(p[k + 2]?.[1])
+			],
+			bulge: num(p[k + 3]?.[1])
+		});
+	}
+	return out;
+}
+var JOIN_TOL = 1e-7;
+var TURN = 2 * Math.PI;
+function cross(a, b) {
+	return [
+		a[1] * b[2] - a[2] * b[1],
+		a[2] * b[0] - a[0] * b[2],
+		a[0] * b[1] - a[1] * b[0]
+	];
+}
+function unit(v) {
+	const l = Math.hypot(v[0], v[1], v[2]) || 1;
+	return [
+		v[0] / l,
+		v[1] / l,
+		v[2] / l
+	];
+}
+/**
+* The entity's object coordinate system, from its extrusion direction (210/220/230), by DXF's
+* arbitrary axis algorithm. Planar entities (circles, arcs, 2D polylines) store their points in
+* it; the default extrusion +Z makes it the world frame.
+*/
+function ocsOf(data) {
+	const normal = unit([
+		getNum(data, 210),
+		getNum(data, 220),
+		getNum(data, 230, 1)
 	]);
-	if (type === "CIRCLE") return kernel.makeCircleEdge([
-		getNum(data, 10),
-		getNum(data, 20),
-		getNum(data, 30)
-	], [
+	if (normal[0] === 0 && normal[1] === 0 && normal[2] > 0) return {
+		normal: [
+			0,
+			0,
+			1
+		],
+		identity: true,
+		toWorld: (p) => p
+	};
+	const ax = unit(cross(Math.abs(normal[0]) < 1 / 64 && Math.abs(normal[1]) < 1 / 64 ? [
+		0,
+		1,
+		0
+	] : [
 		0,
 		0,
 		1
-	], getNum(data, 40));
-	if (type === "ARC") {
-		const startAngle = getNum(data, 50) * Math.PI / 180;
-		const endAngle = getNum(data, 51) * Math.PI / 180;
-		return kernel.makeCircleArc([
-			getNum(data, 10),
-			getNum(data, 20),
-			getNum(data, 30)
-		], [
+	], normal));
+	const ay = unit(cross(normal, ax));
+	return {
+		normal,
+		identity: false,
+		toWorld: ([x, y, z]) => [
+			ax[0] * x + ay[0] * y + normal[0] * z,
+			ax[1] * x + ay[1] * y + normal[1] * z,
+			ax[2] * x + ay[2] * y + normal[2] * z
+		]
+	};
+}
+function apart(a, b) {
+	return Math.hypot(a[0] - b[0], a[1] - b[1], a[2] - b[2]) > JOIN_TOL;
+}
+function linePiece(a, b) {
+	return {
+		start: a,
+		end: b,
+		build: () => require_shapeTypes.getKernel().makeLineEdge(a, b)
+	};
+}
+/**
+* An ARC entity about OCS center `c`, counterclockwise from angle `from` through `sweep` (0, 2π].
+* In the default OCS, which is most files, it's built from its center and angles, which stays
+* exact for a shallow arc. In a rotated OCS, whose in-plane axes the kernel doesn't share, it goes
+* through three points on it, or is a line when its sagitta is under the tolerance.
+*/
+function arcPiece(c, r, from, sweep, ocs) {
+	const on = (t) => ocs.toWorld([
+		c[0] + r * Math.cos(t),
+		c[1] + r * Math.sin(t),
+		c[2]
+	]);
+	const start = on(from);
+	const end = on(from + sweep);
+	if (ocs.identity) return {
+		start,
+		end,
+		build: () => require_shapeTypes.getKernel().makeCircleArc(c, [
+			0,
+			0,
+			1
+		], r, from, from + sweep)
+	};
+	if (r * (1 - Math.cos(sweep / 2)) <= JOIN_TOL) return linePiece(start, end);
+	const mid = on(from + sweep / 2);
+	return {
+		start,
+		end,
+		build: () => require_shapeTypes.getKernel().makeArcEdge(start, mid, end)
+	};
+}
+/**
+* A polyline segment in its OCS: straight, or the arc a bulge describes. A bulge is tan(θ/4) of
+* the arc's included angle, counterclockwise when positive, so the arc's midpoint lies the sagitta
+* (bulge × half the chord) off the chord's midpoint, to its right for a positive bulge. The arc
+* goes through the supplied vertices exactly, so it meets its neighbours; one whose sagitta is
+* under the tolerance is a line to the kernel and is built as one.
+*/
+function segment(a, b, bulge, ocs) {
+	const dx = b[0] - a[0];
+	const dy = b[1] - a[1];
+	const d = Math.hypot(dx, dy);
+	const s = bulge * d / 2;
+	if (Math.abs(s) <= JOIN_TOL) return linePiece(ocs.toWorld(a), ocs.toWorld(b));
+	const mid = [
+		(a[0] + b[0]) / 2 + dy / d * s,
+		(a[1] + b[1]) / 2 - dx / d * s,
+		a[2]
+	];
+	const [wa, wm, wb] = [
+		ocs.toWorld(a),
+		ocs.toWorld(mid),
+		ocs.toWorld(b)
+	];
+	return {
+		start: wa,
+		end: wb,
+		build: () => require_shapeTypes.getKernel().makeArcEdge(wa, wm, wb)
+	};
+}
+var CLOSED = 1;
+var POLYLINE_3D = 8;
+var MESH_FORMS = 80;
+function polylinePieces(entity) {
+	const flags = getNum(entity.data, 70);
+	if (entity.type === "POLYLINE" && (flags & MESH_FORMS) !== 0) return [];
+	const is3d = entity.type === "POLYLINE" && (flags & POLYLINE_3D) !== 0;
+	const ocs = is3d ? {
+		normal: [
 			0,
 			0,
 			1
-		], getNum(data, 40), startAngle, endAngle);
+		],
+		identity: true,
+		toWorld: (p) => p
+	} : ocsOf(entity.data);
+	const elevation = entity.type === "POLYLINE" && !is3d ? getNum(entity.data, 30) : void 0;
+	const vertices = polyVertices(entity).map((v) => elevation === void 0 ? v : {
+		...v,
+		point: [
+			v.point[0],
+			v.point[1],
+			elevation
+		]
+	});
+	const closed = (flags & CLOSED) === CLOSED;
+	const pieces = [];
+	const count = closed ? vertices.length : vertices.length - 1;
+	for (let k = 0; k < count; k++) {
+		const a = vertices[k];
+		const b = vertices[(k + 1) % vertices.length];
+		if (!a || !b || !apart(a.point, b.point)) continue;
+		pieces.push(segment(a.point, b.point, is3d ? 0 : a.bulge, ocs));
+	}
+	return pieces;
+}
+function entityToPieces(entity) {
+	const { type, data } = entity;
+	if (type === "LINE") {
+		const start = [
+			getNum(data, 10),
+			getNum(data, 20),
+			getNum(data, 30)
+		];
+		const end = [
+			getNum(data, 11),
+			getNum(data, 21),
+			getNum(data, 31)
+		];
+		return apart(start, end) ? [linePiece(start, end)] : [];
 	}
+	if (type === "CIRCLE" || type === "ARC") {
+		const ocs = ocsOf(data);
+		const c = [
+			getNum(data, 10),
+			getNum(data, 20),
+			getNum(data, 30)
+		];
+		const r = getNum(data, 40);
+		if (!(r > 0) || !Number.isFinite(r)) return [];
+		if (type === "CIRCLE") {
+			const center = ocs.toWorld(c);
+			const at = ocs.toWorld([
+				c[0] + r,
+				c[1],
+				c[2]
+			]);
+			return [{
+				start: at,
+				end: at,
+				build: () => require_shapeTypes.getKernel().makeCircleEdge(center, ocs.normal, r)
+			}];
+		}
+		const from = getNum(data, 50) * Math.PI / 180;
+		const to = getNum(data, 51) * Math.PI / 180;
+		if (!Number.isFinite(from) || !Number.isFinite(to)) return [];
+		let sweep = (to - from) % TURN;
+		if (sweep <= 0) sweep += TURN;
+		return [arcPiece(c, r, from % TURN, sweep, ocs)];
+	}
+	if (type === "LWPOLYLINE" || type === "POLYLINE") return polylinePieces(entity);
+	return [];
+}
+/** Gives endpoints within JOIN_TOL of each other one id, by a grid of JOIN_TOL cells. */
+function pointIds() {
+	const cells = /* @__PURE__ */ new Map();
+	let next = 0;
+	return (p) => {
+		const c = p.map((v) => Math.floor(v / JOIN_TOL));
+		for (let dx = -1; dx <= 1; dx++) for (let dy = -1; dy <= 1; dy++) for (let dz = -1; dz <= 1; dz++) {
+			const hit = cells.get(`${(c[0] ?? 0) + dx},${(c[1] ?? 0) + dy},${(c[2] ?? 0) + dz}`)?.find((e) => !apart(e.p, p));
+			if (hit) return hit.id;
+		}
+		const key = c.join(",");
+		const id = next++;
+		const cell = cells.get(key);
+		if (cell) cell.push({
+			p,
+			id
+		});
+		else cells.set(key, [{
+			p,
+			id
+		}]);
+		return id;
+	};
+}
+/** The pieces in connected chains, each in walking order, so every chain makes one wire. */
+function chainPieces(pieces) {
+	const idOf = pointIds();
+	const ends = pieces.map((p) => [idOf(p.start), idOf(p.end)]);
+	const at = /* @__PURE__ */ new Map();
+	ends.forEach(([s, e], i) => {
+		for (const id of s === e ? [s] : [s, e]) {
+			const list = at.get(id);
+			if (list) list.push(i);
+			else at.set(id, [i]);
+		}
+	});
+	const used = /* @__PURE__ */ new Set();
+	const cursor = /* @__PURE__ */ new Map();
+	const step = (tip) => {
+		const list = at.get(tip) ?? [];
+		let c = cursor.get(tip) ?? 0;
+		while (c < list.length && used.has(list[c] ?? -1)) c++;
+		cursor.set(tip, c + 1);
+		const i = list[c];
+		if (i === void 0) return void 0;
+		used.add(i);
+		const [s, e] = ends[i] ?? [tip, tip];
+		return {
+			i,
+			tip: s === tip ? e : s
+		};
+	};
+	const chains = [];
+	pieces.forEach((first, i) => {
+		if (used.has(i)) return;
+		used.add(i);
+		const chain = [first];
+		const [s, e] = ends[i] ?? [0, 0];
+		for (const [dir, from] of [[1, e], [-1, s]]) for (let hop = step(from); hop; hop = step(hop.tip)) {
+			const piece = pieces[hop.i];
+			if (!piece) continue;
+			if (dir === 1) chain.push(piece);
+			else chain.unshift(piece);
+		}
+		chains.push(chain);
+	});
+	return chains;
 }
 /**
 * Import a DXF file from a Blob, returning kernel wires.
 *
-* Parses ASCII DXF LINE, CIRCLE, and ARC entities.
-* Edges are assembled into wires using `BRepBuilderAPI_MakeWire`.
+* Parses ASCII DXF LINE, CIRCLE, ARC, LWPOLYLINE and R12 POLYLINE entities, polyline bulges
+* included, in world coordinates (planar entities are mapped out of their object coordinate
+* system). Polygon and polyface meshes are skipped. Edges that meet end to end become one wire,
+* so disconnected outlines come back as separate wires.
 *
 * @param blob - A Blob containing ASCII DXF data.
 * @param options - Optional import settings (layer filter).
@@ -6861,22 +7176,28 @@ async function importDXF(blob, options) {
 	} catch (cause) {
 		return require_errors.err(require_errors.ioError(require_errors.BrepErrorCode.DXF_IMPORT_FAILED, "Failed to read DXF blob", cause));
 	}
-	const allEntities = parseEntities(text);
-	const entities = options?.layer !== void 0 ? allEntities.filter((e) => e.layer === options.layer) : allEntities;
-	if (entities.length === 0) return require_errors.ok([]);
+	const allEntities = gatherPolylines(parseEntities(text));
+	const pieces = (options?.layer !== void 0 ? allEntities.filter((e) => e.layer === options.layer) : allEntities).flatMap(entityToPieces);
+	if (pieces.length === 0) return require_errors.ok([]);
+	const kernel = require_shapeTypes.getKernel();
 	const edges = [];
+	const wires = [];
 	try {
-		for (const entity of entities) {
-			const edge = entityToEdge(entity);
-			if (edge !== void 0) edges.push(edge);
+		for (const chain of chainPieces(pieces)) {
+			const chainEdges = [];
+			for (const p of chain) {
+				const edge = p.build();
+				edges.push(edge);
+				chainEdges.push(edge);
+			}
+			wires.push(require_shapeTypes.createWire(kernel.makeWire(chainEdges)));
 		}
-		if (edges.length === 0) return require_errors.ok([]);
-		const wire = require_shapeTypes.getKernel().makeWire(edges);
-		return require_errors.ok([require_shapeTypes.createWire(wire)]);
+		return require_errors.ok(wires);
 	} catch (cause) {
+		for (const w of wires) w[Symbol.dispose]();
 		return require_errors.err(require_errors.ioError(require_errors.BrepErrorCode.DXF_IMPORT_FAILED, "Failed to convert DXF entities to geometry", cause));
 	} finally {
-		for (const edge of edges) edge.delete();
+		for (const edge of edges) kernel.dispose(edge);
 	}
 }
 // src/io/ioUtils.ts