brepjs 18.113.0 → 18.114.0

package/dist/adjacencyFns-BYnyXXqt.js

@@ -0,0 +1,247 @@
+import { Z as getKernel, r as castShapeWithKnownType } from "./shapeTypes-Dpu6mD3m.js";
+import { l as getOrCreateCache } from "./topologyQueryFns-BeKaWpNm.js";
+import { n as HASH_CODE_MAX } from "./constants-ITRzCnCp.js";
+//#region src/topology/adjacencyFns.ts
+/**
+* Topology adjacency queries — find related sub-shapes within a parent shape.
+*
+* Uses cached topology extraction and an edge→faces adjacency map
+* (built once per parent shape and cached) to avoid redundant WASM calls.
+*/
+function wrapAll(shapes, type) {
+	return shapes.map((s) => castShapeWithKnownType(s, type));
+}
+/**
+* Iterate sub-shapes of `parentKernel` of the given `type`, deduplicate by
+* hash+isSame, and return branded handles of type `T`.
+*
+* Used by edgesOfFace, wiresOfFace, and verticesOfEdge — all of which need
+* the same deduplicated-children pattern on a raw KernelShape.
+*/
+function deduplicatedSubShapes(parentKernel, type) {
+	const kernel = getKernel();
+	const items = kernel.iterShapes(parentKernel, type);
+	const results = [];
+	const seen = /* @__PURE__ */ new Map();
+	for (const item of items) {
+		const hash = kernel.hashCode(item, HASH_CODE_MAX);
+		const bucket = seen.get(hash);
+		if (!bucket) {
+			seen.set(hash, [item]);
+			results.push(item);
+		} else if (!bucket.some((r) => kernel.isSame(r, item))) {
+			bucket.push(item);
+			results.push(item);
+		}
+	}
+	return wrapAll(results, type);
+}
+/**
+* Build or retrieve the cached edge→faces adjacency map for a parent shape.
+* Maps edge hash codes to edge-face pairs, storing the edge alongside each
+* face so facesOfEdge can verify via isSame without re-extracting face edges.
+*/
+function getEdgeToFacesMap(parent) {
+	const cache = getOrCreateCache(parent);
+	if (cache.edgeToFaces) return cache.edgeToFaces;
+	const kernel = getKernel();
+	const edgeToFaces = /* @__PURE__ */ new Map();
+	const allFaces = kernel.iterShapes(parent.wrapped, "face");
+	for (const f of allFaces) {
+		const edges = kernel.iterShapes(f, "edge");
+		for (const e of edges) {
+			const hash = kernel.hashCode(e, HASH_CODE_MAX);
+			let bucket = edgeToFaces.get(hash);
+			if (!bucket) {
+				bucket = [];
+				edgeToFaces.set(hash, bucket);
+			}
+			if (!bucket.some((entry) => kernel.isSame(entry.edge, e) && kernel.isSame(entry.face, f))) bucket.push({
+				edge: e,
+				face: f
+			});
+		}
+	}
+	cache.edgeToFaces = edgeToFaces;
+	return edgeToFaces;
+}
+/**
+* Build or retrieve the cached vertex→faces adjacency map for a parent shape —
+* the vertex analogue of {@link getEdgeToFacesMap}.
+*/
+function getVertexToFacesMap(parent) {
+	const cache = getOrCreateCache(parent);
+	if (cache.vertexToFaces) return cache.vertexToFaces;
+	const kernel = getKernel();
+	const vertexToFaces = /* @__PURE__ */ new Map();
+	for (const f of kernel.iterShapes(parent.wrapped, "face")) for (const v of kernel.iterShapes(f, "vertex")) {
+		const hash = kernel.hashCode(v, HASH_CODE_MAX);
+		let bucket = vertexToFaces.get(hash);
+		if (!bucket) {
+			bucket = [];
+			vertexToFaces.set(hash, bucket);
+		}
+		if (!bucket.some((entry) => kernel.isSame(entry.vertex, v) && kernel.isSame(entry.face, f))) bucket.push({
+			vertex: v,
+			face: f
+		});
+	}
+	cache.vertexToFaces = vertexToFaces;
+	return vertexToFaces;
+}
+/**
+* Get all faces adjacent to a given edge within a parent shape.
+*
+* An edge typically borders exactly two faces in a solid, or one face
+* if the edge is on a boundary.
+*
+* @param parent - The parent shape to search within.
+* @param edge - The edge whose adjacent faces to find.
+* @returns Array of unique faces containing the given edge.
+*/
+function facesOfEdge(parent, edge) {
+	const kernel = getKernel();
+	const edgeToFaces = getEdgeToFacesMap(parent);
+	const hash = kernel.hashCode(edge.wrapped, HASH_CODE_MAX);
+	const bucket = edgeToFaces.get(hash) ?? [];
+	const results = [];
+	const seen = /* @__PURE__ */ new Map();
+	for (const entry of bucket) {
+		if (!kernel.isSame(entry.edge, edge.wrapped)) continue;
+		const fHash = kernel.hashCode(entry.face, HASH_CODE_MAX);
+		const fBucket = seen.get(fHash);
+		if (!fBucket) {
+			seen.set(fHash, [entry.face]);
+			results.push(entry.face);
+		} else if (!fBucket.some((r) => kernel.isSame(r, entry.face))) {
+			fBucket.push(entry.face);
+			results.push(entry.face);
+		}
+	}
+	return wrapAll(results, "face");
+}
+/**
+* Get all faces meeting at a vertex (≥3 for a solid corner, fewer on a
+* boundary), via the cached vertex→faces map. The vertex equivalent of
+* {@link facesOfEdge}, with the same hash-bucket + isSame verification.
+*
+* @param parent - The parent shape to search within.
+* @param vertex - The vertex whose adjacent faces to find.
+*/
+function facesOfVertex(parent, vertex) {
+	const kernel = getKernel();
+	const vertexToFaces = getVertexToFacesMap(parent);
+	const hash = kernel.hashCode(vertex.wrapped, HASH_CODE_MAX);
+	const bucket = vertexToFaces.get(hash) ?? [];
+	const results = [];
+	const seen = /* @__PURE__ */ new Map();
+	for (const entry of bucket) {
+		if (!kernel.isSame(entry.vertex, vertex.wrapped)) continue;
+		const fHash = kernel.hashCode(entry.face, HASH_CODE_MAX);
+		const fBucket = seen.get(fHash);
+		if (!fBucket) {
+			seen.set(fHash, [entry.face]);
+			results.push(entry.face);
+		} else if (!fBucket.some((r) => kernel.isSame(r, entry.face))) {
+			fBucket.push(entry.face);
+			results.push(entry.face);
+		}
+	}
+	return wrapAll(results, "face");
+}
+/**
+* Get all edges bounding a face.
+*
+* @param face - The face whose edges to enumerate.
+* @returns Array of unique edges forming the face boundary.
+*/
+function edgesOfFace(face) {
+	return deduplicatedSubShapes(face.wrapped, "edge");
+}
+/**
+* Get all vertices of a face. The vertex equivalent of {@link edgesOfFace}.
+*
+* @param face - The face whose vertices to enumerate.
+*/
+function verticesOfFace(face) {
+	return deduplicatedSubShapes(face.wrapped, "vertex");
+}
+/**
+* Get all wires of a face (outer wire + inner hole wires).
+* All wires bounding a face are closed by definition.
+*
+* @param face - The face whose wires to enumerate.
+*/
+function wiresOfFace(face) {
+	return deduplicatedSubShapes(face.wrapped, "wire");
+}
+/**
+* Get the start and end vertices of an edge.
+*
+* @param edge - The edge whose vertices to retrieve.
+* @returns Array of 1-2 vertices (1 if degenerate/closed, 2 otherwise).
+*/
+function verticesOfEdge(edge) {
+	return deduplicatedSubShapes(edge.wrapped, "vertex");
+}
+/**
+* Get all faces that share at least one edge with the given face.
+*
+* The returned list does not include the input face itself.
+* Uses the cached edge→faces adjacency map for the parent shape.
+*
+* @param parent - The parent shape to search within.
+* @param face - The face whose neighbors to find.
+* @returns Array of unique adjacent faces (excluding the input face).
+*/
+function adjacentFaces(parent, face) {
+	const kernel = getKernel();
+	const edgeToFaces = getEdgeToFacesMap(parent);
+	const faceEdgeHandles = deduplicatedSubShapes(face.wrapped, "edge");
+	const neighborRaw = [];
+	const seen = /* @__PURE__ */ new Map();
+	for (const edgeHandle of faceEdgeHandles) {
+		const hash = kernel.hashCode(edgeHandle.wrapped, HASH_CODE_MAX);
+		const entries = edgeToFaces.get(hash) ?? [];
+		for (const entry of entries) {
+			if (kernel.isSame(entry.face, face.wrapped)) continue;
+			const fHash = kernel.hashCode(entry.face, HASH_CODE_MAX);
+			const bucket = seen.get(fHash);
+			if (!bucket) {
+				seen.set(fHash, [entry.face]);
+				neighborRaw.push(entry.face);
+			} else if (!bucket.some((r) => kernel.isSame(r, entry.face))) {
+				bucket.push(entry.face);
+				neighborRaw.push(entry.face);
+			}
+		}
+	}
+	return wrapAll(neighborRaw, "face");
+}
+/**
+* Get all edges shared between two faces.
+*
+* @param face1 - The first face.
+* @param face2 - The second face.
+* @returns Array of edges present in both faces (via isSame comparison).
+*/
+function sharedEdges(face1, face2) {
+	const kernel = getKernel();
+	const edges1 = kernel.iterShapes(face1.wrapped, "edge");
+	const edges2 = kernel.iterShapes(face2.wrapped, "edge");
+	const edge2Map = /* @__PURE__ */ new Map();
+	for (const e2 of edges2) {
+		const hash = kernel.hashCode(e2, HASH_CODE_MAX);
+		let bucket = edge2Map.get(hash);
+		if (!bucket) {
+			bucket = [];
+			edge2Map.set(hash, bucket);
+		}
+		bucket.push(e2);
+	}
+	const shared = [];
+	for (const e1 of edges1) if (edge2Map.get(kernel.hashCode(e1, 2147483647))?.some((e2) => kernel.isSame(e1, e2))) shared.push(e1);
+	return wrapAll(shared, "edge");
+}
+//#endregion
+export { sharedEdges as a, wiresOfFace as c, facesOfVertex as i, edgesOfFace as n, verticesOfEdge as o, facesOfEdge as r, verticesOfFace as s, adjacentFaces as t };

package/dist/adjacencyFns-d8ZabkvX.cjs

@@ -0,0 +1,294 @@
+const require_shapeTypes = require("./shapeTypes-BTTwjHy5.cjs");
+const require_topologyQueryFns = require("./topologyQueryFns-CoXVHuN7.cjs");
+const require_constants = require("./constants-BOVyEYGH.cjs");
+//#region src/topology/adjacencyFns.ts
+/**
+* Topology adjacency queries — find related sub-shapes within a parent shape.
+*
+* Uses cached topology extraction and an edge→faces adjacency map
+* (built once per parent shape and cached) to avoid redundant WASM calls.
+*/
+function wrapAll(shapes, type) {
+	return shapes.map((s) => require_shapeTypes.castShapeWithKnownType(s, type));
+}
+/**
+* Iterate sub-shapes of `parentKernel` of the given `type`, deduplicate by
+* hash+isSame, and return branded handles of type `T`.
+*
+* Used by edgesOfFace, wiresOfFace, and verticesOfEdge — all of which need
+* the same deduplicated-children pattern on a raw KernelShape.
+*/
+function deduplicatedSubShapes(parentKernel, type) {
+	const kernel = require_shapeTypes.getKernel();
+	const items = kernel.iterShapes(parentKernel, type);
+	const results = [];
+	const seen = /* @__PURE__ */ new Map();
+	for (const item of items) {
+		const hash = kernel.hashCode(item, require_constants.HASH_CODE_MAX);
+		const bucket = seen.get(hash);
+		if (!bucket) {
+			seen.set(hash, [item]);
+			results.push(item);
+		} else if (!bucket.some((r) => kernel.isSame(r, item))) {
+			bucket.push(item);
+			results.push(item);
+		}
+	}
+	return wrapAll(results, type);
+}
+/**
+* Build or retrieve the cached edge→faces adjacency map for a parent shape.
+* Maps edge hash codes to edge-face pairs, storing the edge alongside each
+* face so facesOfEdge can verify via isSame without re-extracting face edges.
+*/
+function getEdgeToFacesMap(parent) {
+	const cache = require_topologyQueryFns.getOrCreateCache(parent);
+	if (cache.edgeToFaces) return cache.edgeToFaces;
+	const kernel = require_shapeTypes.getKernel();
+	const edgeToFaces = /* @__PURE__ */ new Map();
+	const allFaces = kernel.iterShapes(parent.wrapped, "face");
+	for (const f of allFaces) {
+		const edges = kernel.iterShapes(f, "edge");
+		for (const e of edges) {
+			const hash = kernel.hashCode(e, require_constants.HASH_CODE_MAX);
+			let bucket = edgeToFaces.get(hash);
+			if (!bucket) {
+				bucket = [];
+				edgeToFaces.set(hash, bucket);
+			}
+			if (!bucket.some((entry) => kernel.isSame(entry.edge, e) && kernel.isSame(entry.face, f))) bucket.push({
+				edge: e,
+				face: f
+			});
+		}
+	}
+	cache.edgeToFaces = edgeToFaces;
+	return edgeToFaces;
+}
+/**
+* Build or retrieve the cached vertex→faces adjacency map for a parent shape —
+* the vertex analogue of {@link getEdgeToFacesMap}.
+*/
+function getVertexToFacesMap(parent) {
+	const cache = require_topologyQueryFns.getOrCreateCache(parent);
+	if (cache.vertexToFaces) return cache.vertexToFaces;
+	const kernel = require_shapeTypes.getKernel();
+	const vertexToFaces = /* @__PURE__ */ new Map();
+	for (const f of kernel.iterShapes(parent.wrapped, "face")) for (const v of kernel.iterShapes(f, "vertex")) {
+		const hash = kernel.hashCode(v, require_constants.HASH_CODE_MAX);
+		let bucket = vertexToFaces.get(hash);
+		if (!bucket) {
+			bucket = [];
+			vertexToFaces.set(hash, bucket);
+		}
+		if (!bucket.some((entry) => kernel.isSame(entry.vertex, v) && kernel.isSame(entry.face, f))) bucket.push({
+			vertex: v,
+			face: f
+		});
+	}
+	cache.vertexToFaces = vertexToFaces;
+	return vertexToFaces;
+}
+/**
+* Get all faces adjacent to a given edge within a parent shape.
+*
+* An edge typically borders exactly two faces in a solid, or one face
+* if the edge is on a boundary.
+*
+* @param parent - The parent shape to search within.
+* @param edge - The edge whose adjacent faces to find.
+* @returns Array of unique faces containing the given edge.
+*/
+function facesOfEdge(parent, edge) {
+	const kernel = require_shapeTypes.getKernel();
+	const edgeToFaces = getEdgeToFacesMap(parent);
+	const hash = kernel.hashCode(edge.wrapped, require_constants.HASH_CODE_MAX);
+	const bucket = edgeToFaces.get(hash) ?? [];
+	const results = [];
+	const seen = /* @__PURE__ */ new Map();
+	for (const entry of bucket) {
+		if (!kernel.isSame(entry.edge, edge.wrapped)) continue;
+		const fHash = kernel.hashCode(entry.face, require_constants.HASH_CODE_MAX);
+		const fBucket = seen.get(fHash);
+		if (!fBucket) {
+			seen.set(fHash, [entry.face]);
+			results.push(entry.face);
+		} else if (!fBucket.some((r) => kernel.isSame(r, entry.face))) {
+			fBucket.push(entry.face);
+			results.push(entry.face);
+		}
+	}
+	return wrapAll(results, "face");
+}
+/**
+* Get all faces meeting at a vertex (≥3 for a solid corner, fewer on a
+* boundary), via the cached vertex→faces map. The vertex equivalent of
+* {@link facesOfEdge}, with the same hash-bucket + isSame verification.
+*
+* @param parent - The parent shape to search within.
+* @param vertex - The vertex whose adjacent faces to find.
+*/
+function facesOfVertex(parent, vertex) {
+	const kernel = require_shapeTypes.getKernel();
+	const vertexToFaces = getVertexToFacesMap(parent);
+	const hash = kernel.hashCode(vertex.wrapped, require_constants.HASH_CODE_MAX);
+	const bucket = vertexToFaces.get(hash) ?? [];
+	const results = [];
+	const seen = /* @__PURE__ */ new Map();
+	for (const entry of bucket) {
+		if (!kernel.isSame(entry.vertex, vertex.wrapped)) continue;
+		const fHash = kernel.hashCode(entry.face, require_constants.HASH_CODE_MAX);
+		const fBucket = seen.get(fHash);
+		if (!fBucket) {
+			seen.set(fHash, [entry.face]);
+			results.push(entry.face);
+		} else if (!fBucket.some((r) => kernel.isSame(r, entry.face))) {
+			fBucket.push(entry.face);
+			results.push(entry.face);
+		}
+	}
+	return wrapAll(results, "face");
+}
+/**
+* Get all edges bounding a face.
+*
+* @param face - The face whose edges to enumerate.
+* @returns Array of unique edges forming the face boundary.
+*/
+function edgesOfFace(face) {
+	return deduplicatedSubShapes(face.wrapped, "edge");
+}
+/**
+* Get all vertices of a face. The vertex equivalent of {@link edgesOfFace}.
+*
+* @param face - The face whose vertices to enumerate.
+*/
+function verticesOfFace(face) {
+	return deduplicatedSubShapes(face.wrapped, "vertex");
+}
+/**
+* Get all wires of a face (outer wire + inner hole wires).
+* All wires bounding a face are closed by definition.
+*
+* @param face - The face whose wires to enumerate.
+*/
+function wiresOfFace(face) {
+	return deduplicatedSubShapes(face.wrapped, "wire");
+}
+/**
+* Get the start and end vertices of an edge.
+*
+* @param edge - The edge whose vertices to retrieve.
+* @returns Array of 1-2 vertices (1 if degenerate/closed, 2 otherwise).
+*/
+function verticesOfEdge(edge) {
+	return deduplicatedSubShapes(edge.wrapped, "vertex");
+}
+/**
+* Get all faces that share at least one edge with the given face.
+*
+* The returned list does not include the input face itself.
+* Uses the cached edge→faces adjacency map for the parent shape.
+*
+* @param parent - The parent shape to search within.
+* @param face - The face whose neighbors to find.
+* @returns Array of unique adjacent faces (excluding the input face).
+*/
+function adjacentFaces(parent, face) {
+	const kernel = require_shapeTypes.getKernel();
+	const edgeToFaces = getEdgeToFacesMap(parent);
+	const faceEdgeHandles = deduplicatedSubShapes(face.wrapped, "edge");
+	const neighborRaw = [];
+	const seen = /* @__PURE__ */ new Map();
+	for (const edgeHandle of faceEdgeHandles) {
+		const hash = kernel.hashCode(edgeHandle.wrapped, require_constants.HASH_CODE_MAX);
+		const entries = edgeToFaces.get(hash) ?? [];
+		for (const entry of entries) {
+			if (kernel.isSame(entry.face, face.wrapped)) continue;
+			const fHash = kernel.hashCode(entry.face, require_constants.HASH_CODE_MAX);
+			const bucket = seen.get(fHash);
+			if (!bucket) {
+				seen.set(fHash, [entry.face]);
+				neighborRaw.push(entry.face);
+			} else if (!bucket.some((r) => kernel.isSame(r, entry.face))) {
+				bucket.push(entry.face);
+				neighborRaw.push(entry.face);
+			}
+		}
+	}
+	return wrapAll(neighborRaw, "face");
+}
+/**
+* Get all edges shared between two faces.
+*
+* @param face1 - The first face.
+* @param face2 - The second face.
+* @returns Array of edges present in both faces (via isSame comparison).
+*/
+function sharedEdges(face1, face2) {
+	const kernel = require_shapeTypes.getKernel();
+	const edges1 = kernel.iterShapes(face1.wrapped, "edge");
+	const edges2 = kernel.iterShapes(face2.wrapped, "edge");
+	const edge2Map = /* @__PURE__ */ new Map();
+	for (const e2 of edges2) {
+		const hash = kernel.hashCode(e2, require_constants.HASH_CODE_MAX);
+		let bucket = edge2Map.get(hash);
+		if (!bucket) {
+			bucket = [];
+			edge2Map.set(hash, bucket);
+		}
+		bucket.push(e2);
+	}
+	const shared = [];
+	for (const e1 of edges1) if (edge2Map.get(kernel.hashCode(e1, 2147483647))?.some((e2) => kernel.isSame(e1, e2))) shared.push(e1);
+	return wrapAll(shared, "edge");
+}
+//#endregion
+Object.defineProperty(exports, "adjacentFaces", {
+	enumerable: true,
+	get: function() {
+		return adjacentFaces;
+	}
+});
+Object.defineProperty(exports, "edgesOfFace", {
+	enumerable: true,
+	get: function() {
+		return edgesOfFace;
+	}
+});
+Object.defineProperty(exports, "facesOfEdge", {
+	enumerable: true,
+	get: function() {
+		return facesOfEdge;
+	}
+});
+Object.defineProperty(exports, "facesOfVertex", {
+	enumerable: true,
+	get: function() {
+		return facesOfVertex;
+	}
+});
+Object.defineProperty(exports, "sharedEdges", {
+	enumerable: true,
+	get: function() {
+		return sharedEdges;
+	}
+});
+Object.defineProperty(exports, "verticesOfEdge", {
+	enumerable: true,
+	get: function() {
+		return verticesOfEdge;
+	}
+});
+Object.defineProperty(exports, "verticesOfFace", {
+	enumerable: true,
+	get: function() {
+		return verticesOfFace;
+	}
+});
+Object.defineProperty(exports, "wiresOfFace", {
+	enumerable: true,
+	get: function() {
+		return wiresOfFace;
+	}
+});