brepjs 18.119.2 → 18.119.3

package/dist/{solidBuilders-I8_V8qqU.js → solidBuilders-DTgqQC3W.js}

@@ -1,13 +1,315 @@
-import { C as isSolid, R as getShapeKind, S as isShell, d as createSolid, f as createVertex, h as disposeResultShape, i as castShape, it as getKernel, m as disposeDowncastSource, n as castResultShape, nt as _usingCtx, s as createCompound, x as isShape3D } from "./shapeTypes-CnKFSfDT.js";
-import { I as unwrap, O as ok, S as isErr, d as validationError, g as andThen, i as kernelError, l as typeCastError, t as BrepErrorCode, v as err } from "./errors-B3CDG537.js";
-import { f as getVertices, p as getWires, s as getEdges } from "./topologyQueryFns-DNqT88yx.js";
+import { C as isSolid, E as getShapeKind, K as getKernel, S as isShell, W as _usingCtx, d as createSolid, f as createVertex, h as disposeResultShape, i as castShape, m as disposeDowncastSource, n as castResultShape, s as createCompound, x as isShape3D } from "./shapeTypes-t49f64Dx.js";
+import { E as ok, P as unwrap, b as isErr, d as validationError, g as err, i as kernelError, l as typeCastError, m as andThen, t as BrepErrorCode } from "./errors-MHLiNE-C.js";
+import { S as subShapeHashes, c as getFaces, f as getVertices, p as getWires, s as getEdges } from "./topologyQueryFns-BkQ6Q7gN.js";
 import { n as HASH_CODE_MAX } from "./constants-ITRzCnCp.js";
 import { a as vecDot, g as vecSub, h as vecScale, t as vecAdd } from "./vecOps-SKPRvPH-.js";
-import { o as resolvePlane } from "./planeOps-Cp6GQ23-.js";
-import { _ as cast, y as downcast } from "./faceFns-CB6uzvOg.js";
-import { _ as collectInputFaceHashes, b as propagateMetadataByHash, y as propagateAllMetadata } from "./shapeFns-BrHFNLMA.js";
+import { o as resolvePlane } from "./planeOps-CQahLrCx.js";
+import { _ as cast, y as downcast } from "./faceFns-DJj9Nb6T.js";
+import { n as propagateOriginsByHash, r as propagateOriginsFromEvolution, t as getFaceOrigins } from "./originTrackingFns-DZmdiQ-O.js";
 import { n as getAtOrThrow, t as firstOrThrow } from "./arrayAccess-DrUGPADn.js";
-import { r as makeFace } from "./surfaceBuilders-BNR7yMQO.js";
+import { r as makeFace } from "./surfaceBuilders-BryY-i0F.js";
+//#region src/topology/metadata/faceTagFns.ts
+var shapeTagStore = /* @__PURE__ */ new WeakMap();
+var tagMetadataStore = /* @__PURE__ */ new WeakMap();
+/** O(1) check whether a shape has any face tags attached. */
+function hasFaceTags(shape) {
+	return shapeTagStore.has(shape.wrapped);
+}
+function getTagMap(shape) {
+	let map = shapeTagStore.get(shape.wrapped);
+	if (!map) {
+		map = /* @__PURE__ */ new Map();
+		shapeTagStore.set(shape.wrapped, map);
+	}
+	return map;
+}
+function getMetaMap(shape) {
+	let map = tagMetadataStore.get(shape.wrapped);
+	if (!map) {
+		map = /* @__PURE__ */ new Map();
+		tagMetadataStore.set(shape.wrapped, map);
+	}
+	return map;
+}
+/**
+* Tag selected faces with a string name.
+*
+* @param shape - The shape containing the faces.
+* @param selector - Array of faces, or a predicate function.
+* @param tag - The tag name to assign.
+* @returns The same shape (tags are stored externally).
+*/
+function tagFaces(shape, selector, tag) {
+	const faces = Array.isArray(selector) ? selector : getFaces(shape).filter(selector);
+	const tagMap = getTagMap(shape);
+	const existing = tagMap.get(tag) ?? /* @__PURE__ */ new Set();
+	for (const face of faces) existing.add(getKernel().hashCode(face.wrapped, HASH_CODE_MAX));
+	tagMap.set(tag, existing);
+	return shape;
+}
+/**
+* Find all faces on a shape that have the given tag.
+*
+* Checks both direct tags and propagated origins (for faces that
+* survived boolean/modifier operations).
+*/
+function findFacesByTag(shape, tag) {
+	const tagMap = shapeTagStore.get(shape.wrapped);
+	if (!tagMap) return [];
+	const hashes = tagMap.get(tag);
+	if (!hashes || hashes.size === 0) return [];
+	const result = [];
+	for (const face of getFaces(shape)) {
+		const hash = getKernel().hashCode(face.wrapped, HASH_CODE_MAX);
+		if (hashes.has(hash)) result.push(face);
+	}
+	return result;
+}
+/**
+* Get all tags and their associated faces on a shape.
+*/
+function getFaceTags(shape) {
+	const result = /* @__PURE__ */ new Map();
+	const tagMap = shapeTagStore.get(shape.wrapped);
+	if (!tagMap) return result;
+	const faces = getFaces(shape);
+	const faceByHash = /* @__PURE__ */ new Map();
+	for (const face of faces) faceByHash.set(getKernel().hashCode(face.wrapped, HASH_CODE_MAX), face);
+	for (const [tag, hashes] of tagMap) {
+		const taggedFaces = [];
+		for (const hash of hashes) {
+			const face = faceByHash.get(hash);
+			if (face) taggedFaces.push(face);
+		}
+		if (taggedFaces.length > 0) result.set(tag, taggedFaces);
+	}
+	return result;
+}
+/**
+* Store arbitrary metadata for a tag on a shape.
+*/
+function setTagMetadata(shape, tag, metadata) {
+	getMetaMap(shape).set(tag, metadata);
+	return shape;
+}
+/**
+* Retrieve metadata for a tag on a shape.
+*/
+function getTagMetadata(shape, tag) {
+	return tagMetadataStore.get(shape.wrapped)?.get(tag);
+}
+function addTagToResult(resultTagMap, tag, hash) {
+	const set = resultTagMap.get(tag) ?? /* @__PURE__ */ new Set();
+	set.add(hash);
+	resultTagMap.set(tag, set);
+}
+/**
+* Propagate face tags from input shapes to a result shape using a
+* kernel-provided ShapeEvolution record (no direct kernel op access needed).
+*/
+function propagateFaceTagsFromEvolution(evolution, inputs, result) {
+	const resultTagMap = getTagMap(result);
+	for (const input of inputs) {
+		const inputTagMap = shapeTagStore.get(input.wrapped);
+		if (!inputTagMap) continue;
+		const hashToTags = /* @__PURE__ */ new Map();
+		for (const [tag, hashes] of inputTagMap) for (const hash of hashes) {
+			const tags = hashToTags.get(hash) ?? [];
+			tags.push(tag);
+			hashToTags.set(hash, tags);
+		}
+		for (const [hash, tags] of hashToTags) {
+			if (evolution.deleted.has(hash)) continue;
+			const modifiedHashes = evolution.modified.get(hash);
+			const targetHashes = modifiedHashes && modifiedHashes.length > 0 ? modifiedHashes : [hash];
+			for (const targetHash of targetHashes) for (const tag of tags) addTagToResult(resultTagMap, tag, targetHash);
+		}
+		const inputMetaMap = tagMetadataStore.get(input.wrapped);
+		if (inputMetaMap) {
+			const resultMetaMap = getMetaMap(result);
+			for (const [tag, meta] of inputMetaMap) if (!resultMetaMap.has(tag)) resultMetaMap.set(tag, meta);
+		}
+	}
+}
+//#endregion
+//#region src/topology/metadata/colorFns.ts
+var shapeColorStore = /* @__PURE__ */ new WeakMap();
+var faceColorStore = /* @__PURE__ */ new WeakMap();
+/** O(1) check whether a shape has any color metadata (shape or face level). */
+function hasColorMetadata(shape) {
+	return shapeColorStore.has(shape.wrapped) || faceColorStore.has(shape.wrapped);
+}
+function getFaceColorMap(shape) {
+	let map = faceColorStore.get(shape.wrapped);
+	if (!map) {
+		map = /* @__PURE__ */ new Map();
+		faceColorStore.set(shape.wrapped, map);
+	}
+	return map;
+}
+function parseColor(input) {
+	if (typeof input === "string") {
+		let hex = input.startsWith("#") ? input.slice(1) : input;
+		if (hex.length === 3) hex = hex.charAt(0) + hex.charAt(0) + hex.charAt(1) + hex.charAt(1) + hex.charAt(2) + hex.charAt(2);
+		return [
+			parseInt(hex.slice(0, 2), 16) / 255,
+			parseInt(hex.slice(2, 4), 16) / 255,
+			parseInt(hex.slice(4, 6), 16) / 255,
+			1
+		];
+	}
+	if (input.length === 3) return [
+		input[0],
+		input[1],
+		input[2],
+		1
+	];
+	return [
+		input[0],
+		input[1],
+		input[2],
+		input[3]
+	];
+}
+/**
+* Set a whole-shape color (stored externally via WeakMap).
+* Returns the same shape reference.
+*/
+function colorShape(shape, color) {
+	shapeColorStore.set(shape.wrapped, parseColor(color));
+	return shape;
+}
+/**
+* Set per-face colors on a shape.
+* Returns the same shape reference.
+*/
+function colorFaces(shape, faces, color) {
+	const parsed = parseColor(color);
+	const map = getFaceColorMap(shape);
+	for (const face of faces) map.set(getKernel().hashCode(face.wrapped, HASH_CODE_MAX), parsed);
+	return shape;
+}
+/**
+* Get the whole-shape color, or undefined if none set.
+*/
+function getShapeColor(shape) {
+	return shapeColorStore.get(shape.wrapped);
+}
+/**
+* Get the color of a specific face, or undefined if none set.
+*/
+function getFaceColor(shape, face) {
+	const map = faceColorStore.get(shape.wrapped);
+	if (!map) return void 0;
+	return map.get(getKernel().hashCode(face.wrapped, HASH_CODE_MAX));
+}
+/**
+* Propagate colors from input shapes to a result shape using a
+* kernel-provided ShapeEvolution record (no direct kernel op access needed).
+*/
+function propagateColorsFromEvolution(evolution, inputs, result) {
+	for (const input of inputs) {
+		const c = shapeColorStore.get(input.wrapped);
+		if (c) {
+			shapeColorStore.set(result.wrapped, c);
+			break;
+		}
+	}
+	const resultFaceMap = getFaceColorMap(result);
+	for (const input of inputs) {
+		const inputFaceMap = faceColorStore.get(input.wrapped);
+		if (!inputFaceMap || inputFaceMap.size === 0) continue;
+		for (const [hash, color] of inputFaceMap) {
+			if (evolution.deleted.has(hash)) continue;
+			const modifiedHashes = evolution.modified.get(hash);
+			if (modifiedHashes && modifiedHashes.length > 0) for (const modHash of modifiedHashes) resultFaceMap.set(modHash, color);
+			else resultFaceMap.set(hash, color);
+		}
+	}
+}
+//#endregion
+//#region src/topology/metadata/metadataPropagation.ts
+/**
+* Collect ALL face hashes from input shapes for WithHistory kernel methods.
+*
+* Fast-path: returns empty array when no inputs have any metadata (origins,
+* tags, or colors), avoiding expensive WASM topology exploration.
+*/
+/**
+* O(1) check: does a shape carry any propagatable metadata (face origins,
+* tags, or colors)? Lets callers skip both expensive face iteration and
+* metadata-preserving slow paths when there's nothing to preserve.
+*/
+function hasAnyMetadata(shape) {
+	return getFaceOrigins(shape) !== void 0 || hasFaceTags(shape) || hasColorMetadata(shape);
+}
+function collectInputFaceHashes(inputs) {
+	if (!inputs.some(hasAnyMetadata)) return [];
+	const hashes = [];
+	for (const input of inputs) hashes.push(...subShapeHashes(input, "face"));
+	return hashes;
+}
+/**
+* Propagate all metadata (origins, tags, colors) from inputs to result
+* using a kernel-provided ShapeEvolution record.
+*
+* This is the standard pipeline for any operation that returns
+* `{ shape, evolution }` from a WithHistory kernel method.
+*/
+function propagateAllMetadata(evolution, inputs, result) {
+	propagateOriginsFromEvolution(evolution, inputs, result);
+	propagateFaceTagsFromEvolution(evolution, inputs, result);
+	propagateColorsFromEvolution(evolution, inputs, result);
+}
+/**
+* Fallback metadata propagation when no ShapeEvolution is available.
+*
+* Matches result faces to input faces by hash code (and geometric fallback).
+* Used by operations that don't support WithHistory (e.g., native fuseAll).
+*
+* **Limitation:** Only propagates face origins. Face tags and face colors
+* require a ShapeEvolution record to map input→output face hashes, so they
+* are lost through this path. Batch booleans (`fuseAll`, `cutAll`) therefore
+* have weaker metadata guarantees than pairwise booleans (`fuse`, `cut`).
+*/
+function propagateMetadataByHash(inputs, result) {
+	propagateOriginsByHash(inputs, result);
+}
+/**
+* Propagate all metadata through a *rigid relocation* (a `locate` re-tag).
+*
+* A relocated shape shares the source's TShape, so its faces correspond 1:1 to
+* the source faces in iteration order — but carry new, location-dependent
+* hashes, so the hash-keyed metadata must be re-keyed rather than left as-is.
+* This synthesizes a 1:1 `modified` evolution (source face hash → moved face
+* hash) and runs the standard propagation pipeline, so origins, tags, and
+* colors all survive a move at `locate` cost (O(faces)), not a full copy.
+*
+* Callers should gate on {@link hasAnyMetadata} first: with no metadata this
+* does pointless face iteration. The face counts always match for a rigid
+* relocation; the length guard is purely defensive.
+*/
+function propagateMetadataThroughRelocation(source, moved) {
+	const kernel = getKernel();
+	const srcFaces = [...kernel.iterShapes(source.wrapped, "face")];
+	const movedFaces = [...kernel.iterShapes(moved.wrapped, "face")];
+	if (srcFaces.length !== movedFaces.length) return;
+	const modified = /* @__PURE__ */ new Map();
+	for (let i = 0; i < srcFaces.length; i++) {
+		const sf = srcFaces[i];
+		const mf = movedFaces[i];
+		if (sf === void 0 || mf === void 0) continue;
+		modified.set(kernel.hashCode(sf, HASH_CODE_MAX), [kernel.hashCode(mf, HASH_CODE_MAX)]);
+	}
+	for (const f of srcFaces) kernel.dispose(f);
+	for (const f of movedFaces) kernel.dispose(f);
+	propagateAllMetadata({
+		modified,
+		generated: /* @__PURE__ */ new Map(),
+		deleted: /* @__PURE__ */ new Set()
+	}, [source], moved);
+}
+//#endregion
 //#region src/topology/booleanFns.ts
 /**
 * Boolean and compound operations — functional replacements for _3DShape boolean methods.
@@ -654,4 +956,4 @@ function makeSolid(facesOrShells) {
 	}
 }
 //#endregion
-export { section as _, makeOffset as a, split as b, makeTorus as c, booleanPipeline as d, cut as f, intersect as g, fuseAll as h, makeEllipsoid as i, makeVertex as l, fuse as m, makeCone as n, makeSolid as o, cutAll as p, makeCylinder as r, makeSphere as s, makeCompound as t, weldShellsAndFaces as u, sectionToFace as v, slice as y };
+export { findFacesByTag as A, propagateAllMetadata as C, colorShape as D, colorFaces as E, getTagMetadata as M, setTagMetadata as N, getFaceColor as O, tagFaces as P, hasAnyMetadata as S, propagateMetadataThroughRelocation as T, section as _, makeOffset as a, split as b, makeTorus as c, booleanPipeline as d, cut as f, intersect as g, fuseAll as h, makeEllipsoid as i, getFaceTags as j, getShapeColor as k, makeVertex as l, fuse as m, makeCone as n, makeSolid as o, cutAll as p, makeCylinder as r, makeSphere as s, makeCompound as t, weldShellsAndFaces as u, sectionToFace as v, propagateMetadataByHash as w, collectInputFaceHashes as x, slice as y };