brepjs 8.4.0 → 8.7.4

package/dist/{booleanFns-5dDG0jpA.cjs → booleanFns-NtKxkiXn.cjs}

@@ -1,10 +1,11 @@
 "use strict";
-const occtBoundary = require("./occtBoundary-CocN2VKx.cjs");
-const shapeTypes = require("./shapeTypes-BxVxLdiD.cjs");
-const errors = require("./errors-D13q2HCk.cjs");
-const vectors = require("./vectors-DVmHF4zt.cjs");
+const occtBoundary = require("./occtBoundary-DH2VO-rq.cjs");
+const shapeTypes = require("./shapeTypes-CMjrTv36.cjs");
+const errors = require("./errors-eRQu29oc.cjs");
+const vectors = require("./vectors-DwFeX0Ja.cjs");
 const vecOps = require("./vecOps-CjRL1jau.cjs");
-const shapeFns = require("./shapeFns-B0zSdO9c.cjs");
+const shapeFns = require("./shapeFns-3RYtsUVY.cjs");
+const surfaceBuilders = require("./surfaceBuilders-Xx9DRRxs.cjs");
 function applyGlue(op, optimisation) {
   const oc = occtBoundary.getKernel().oc;
   if (optimisation === "commonFace") {
@@ -14,6 +15,211 @@ function applyGlue(op, optimisation) {
     op.SetGlue(oc.BOPAlgo_GlueEnum.BOPAlgo_GlueFull);
   }
 }
+const shapeTagStore = /* @__PURE__ */ new WeakMap();
+const tagMetadataStore = /* @__PURE__ */ new WeakMap();
+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;
+}
+function tagFaces(shape, selector, tag) {
+  const faces = Array.isArray(selector) ? selector : shapeFns.getFaces(shape).filter(selector);
+  const tagMap = getTagMap(shape);
+  const existing = tagMap.get(tag) ?? /* @__PURE__ */ new Set();
+  for (const face of faces) {
+    existing.add(face.wrapped.HashCode(vecOps.HASH_CODE_MAX));
+  }
+  tagMap.set(tag, existing);
+  return shape;
+}
+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 shapeFns.getFaces(shape)) {
+    const hash = face.wrapped.HashCode(vecOps.HASH_CODE_MAX);
+    if (hashes.has(hash)) {
+      result.push(face);
+    }
+  }
+  return result;
+}
+function getFaceTags(shape) {
+  const result = /* @__PURE__ */ new Map();
+  const tagMap = shapeTagStore.get(shape.wrapped);
+  if (!tagMap) return result;
+  const faces = shapeFns.getFaces(shape);
+  const faceByHash = /* @__PURE__ */ new Map();
+  for (const face of faces) {
+    faceByHash.set(face.wrapped.HashCode(vecOps.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;
+}
+function setTagMetadata(shape, tag, metadata) {
+  const metaMap = getMetaMap(shape);
+  metaMap.set(tag, metadata);
+  return shape;
+}
+function getTagMetadata(shape, tag) {
+  return tagMetadataStore.get(shape.wrapped)?.get(tag);
+}
+function propagateFaceTags(op, 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 face of shapeFns.getFaces(input)) {
+      const hash = face.wrapped.HashCode(vecOps.HASH_CODE_MAX);
+      const tags = hashToTags.get(hash);
+      if (!tags) continue;
+      if (op.IsDeleted?.(face.wrapped)) continue;
+      const modifiedList = op.Modified(face.wrapped);
+      const modSize = modifiedList.Size?.() ?? 0;
+      if (modSize > 0) {
+        const oc = occtBoundary.getKernel().oc;
+        const copy = new oc.TopTools_ListOfShape_3(modifiedList);
+        while (copy.Size() > 0) {
+          const modFace = copy.First_1();
+          const modHash = modFace.HashCode(vecOps.HASH_CODE_MAX);
+          for (const tag of tags) {
+            const set = resultTagMap.get(tag) ?? /* @__PURE__ */ new Set();
+            set.add(modHash);
+            resultTagMap.set(tag, set);
+          }
+          copy.RemoveFirst();
+        }
+        copy.delete();
+      } else {
+        for (const tag of tags) {
+          const set = resultTagMap.get(tag) ?? /* @__PURE__ */ new Set();
+          set.add(hash);
+          resultTagMap.set(tag, set);
+        }
+      }
+    }
+    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);
+        }
+      }
+    }
+  }
+}
+const shapeColorStore = /* @__PURE__ */ new WeakMap();
+const faceColorStore = /* @__PURE__ */ new WeakMap();
+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);
+    }
+    const r = parseInt(hex.slice(0, 2), 16) / 255;
+    const g = parseInt(hex.slice(2, 4), 16) / 255;
+    const b = parseInt(hex.slice(4, 6), 16) / 255;
+    return [r, g, b, 1];
+  }
+  if (input.length === 3) {
+    return [input[0], input[1], input[2], 1];
+  }
+  return [input[0], input[1], input[2], input[3]];
+}
+function colorShape(shape, color) {
+  shapeColorStore.set(shape.wrapped, parseColor(color));
+  return shape;
+}
+function colorFaces(shape, faces, color) {
+  const parsed = parseColor(color);
+  const map = getFaceColorMap(shape);
+  for (const face of faces) {
+    map.set(face.wrapped.HashCode(vecOps.HASH_CODE_MAX), parsed);
+  }
+  return shape;
+}
+function getShapeColor(shape) {
+  return shapeColorStore.get(shape.wrapped);
+}
+function getFaceColor(shape, face) {
+  const map = faceColorStore.get(shape.wrapped);
+  if (!map) return void 0;
+  return map.get(face.wrapped.HashCode(vecOps.HASH_CODE_MAX));
+}
+function propagateColors(op, 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 face of shapeFns.getFaces(input)) {
+      const hash = face.wrapped.HashCode(vecOps.HASH_CODE_MAX);
+      const color = inputFaceMap.get(hash);
+      if (!color) continue;
+      if (op.IsDeleted?.(face.wrapped)) continue;
+      const modifiedList = op.Modified(face.wrapped);
+      const modSize = modifiedList.Size?.() ?? 0;
+      if (modSize > 0) {
+        const oc = occtBoundary.getKernel().oc;
+        const copy = new oc.TopTools_ListOfShape_3(modifiedList);
+        while (copy.Size() > 0) {
+          const modFace = copy.First_1();
+          const modHash = modFace.HashCode(vecOps.HASH_CODE_MAX);
+          resultFaceMap.set(modHash, color);
+          copy.RemoveFirst();
+        }
+        copy.delete();
+      } else {
+        resultFaceMap.set(hash, color);
+      }
+    }
+  }
+}
 function validateShape3D(shape, label) {
   if (shape.wrapped.IsNull()) {
     return errors.err(errors.validationError(errors.BrepErrorCode.NULL_SHAPE_INPUT, `${label} is a null shape`));
@@ -72,6 +278,8 @@ function fuse(a, b, { optimisation = "none", simplify = false, signal } = {}) {
   );
   if (fuseResult.ok) {
     shapeFns.propagateOrigins(fuseOp, [a, b], fuseResult.value);
+    propagateFaceTags(fuseOp, [a, b], fuseResult.value);
+    propagateColors(fuseOp, [a, b], fuseResult.value);
   }
   return fuseResult;
 }
@@ -91,6 +299,8 @@ function cut(base, tool, { optimisation = "none", simplify = false, signal } = {
   const cutResult = castToShape3D(cutOp.Shape(), "CUT_NOT_3D", "Cut did not produce a 3D shape");
   if (cutResult.ok) {
     shapeFns.propagateOrigins(cutOp, [base, tool], cutResult.value);
+    propagateFaceTags(cutOp, [base, tool], cutResult.value);
+    propagateColors(cutOp, [base, tool], cutResult.value);
   }
   return cutResult;
 }
@@ -113,6 +323,8 @@ function intersect(a, b, { simplify = false, signal } = {}) {
   );
   if (intResult.ok) {
     shapeFns.propagateOrigins(intOp, [a, b], intResult.value);
+    propagateFaceTags(intOp, [a, b], intResult.value);
+    propagateColors(intOp, [a, b], intResult.value);
   }
   return intResult;
 }
@@ -188,6 +400,8 @@ function cutAll(base, tools, { optimisation = "none", simplify = false, signal }
   );
   if (cutAllResult.ok) {
     shapeFns.propagateOrigins(cutOp, [base, ...tools], cutAllResult.value);
+    propagateFaceTags(cutOp, [base, ...tools], cutAllResult.value);
+    propagateColors(cutOp, [base, ...tools], cutAllResult.value);
   }
   return cutAllResult;
 }
@@ -250,6 +464,74 @@ function section(shape, plane, { approximation = true, planeSize = 1e4 } = {}) {
     sectionFace.delete();
   }
 }
+function sectionToFace(shape, plane, options = {}) {
+  const sectionResult = section(shape, plane, options);
+  if (!sectionResult.ok) return sectionResult;
+  const wires = shapeFns.getWires(sectionResult.value);
+  if (wires.length === 0) {
+    const edges = shapeFns.getEdges(sectionResult.value);
+    if (edges.length === 0) {
+      return errors.err(errors.occtError("SECTION_FAILED", "sectionToFace: section produced no geometry"));
+    }
+    const oc = occtBoundary.getKernel().oc;
+    const remaining = [...edges];
+    while (remaining.length > 0) {
+      const first = remaining.shift();
+      if (!first) break;
+      const wireEdges = [first];
+      let added = true;
+      while (added && remaining.length > 0) {
+        added = false;
+        for (let i = 0; i < remaining.length; i++) {
+          const candidate = remaining[i];
+          if (!candidate) continue;
+          const probe = new oc.BRepBuilderAPI_MakeWire_1();
+          for (const e of wireEdges) {
+            probe.Add_1(e.wrapped);
+          }
+          probe.Add_1(candidate.wrapped);
+          const connects = probe.Error() === oc.BRepBuilderAPI_WireError.BRepBuilderAPI_WireDone;
+          probe.delete();
+          if (connects) {
+            wireEdges.push(candidate);
+            remaining.splice(i, 1);
+            added = true;
+            break;
+          }
+        }
+      }
+      const wb = new oc.BRepBuilderAPI_MakeWire_1();
+      for (const e of wireEdges) {
+        wb.Add_1(e.wrapped);
+      }
+      if (wb.IsDone()) {
+        wires.push(shapeTypes.castShape(wb.Wire()));
+      }
+      wb.delete();
+    }
+  }
+  if (wires.length === 0) {
+    return errors.err(errors.occtError("SECTION_FAILED", "sectionToFace: section produced no usable geometry"));
+  }
+  let outerIdx = 0;
+  let maxDiag = -1;
+  for (let i = 0; i < wires.length; i++) {
+    const w = wires[i];
+    if (!w) continue;
+    const bb = occtBoundary.getKernel().boundingBox(w.wrapped);
+    const dx = bb.max[0] - bb.min[0];
+    const dy = bb.max[1] - bb.min[1];
+    const dz = bb.max[2] - bb.min[2];
+    const diag = dx * dx + dy * dy + dz * dz;
+    if (diag > maxDiag) {
+      maxDiag = diag;
+      outerIdx = i;
+    }
+  }
+  const outer = wires[outerIdx];
+  const holes = wires.filter((_, i) => i !== outerIdx);
+  return surfaceBuilders.makeFace(outer, holes.length > 0 ? holes : void 0);
+}
 function split(shape, tools) {
   if (tools.length === 0) return errors.ok(shape);
   if (shape.wrapped.IsNull()) {
@@ -291,11 +573,23 @@ function slice(shape, planes, options = {}) {
   return errors.ok(results);
 }
 exports.applyGlue = applyGlue;
+exports.colorFaces = colorFaces;
+exports.colorShape = colorShape;
 exports.cut = cut;
 exports.cutAll = cutAll;
+exports.findFacesByTag = findFacesByTag;
 exports.fuse = fuse;
 exports.fuseAll = fuseAll;
+exports.getFaceColor = getFaceColor;
+exports.getFaceTags = getFaceTags;
+exports.getShapeColor = getShapeColor;
+exports.getTagMetadata = getTagMetadata;
 exports.intersect = intersect;
+exports.propagateColors = propagateColors;
+exports.propagateFaceTags = propagateFaceTags;
 exports.section = section;
+exports.sectionToFace = sectionToFace;
+exports.setTagMetadata = setTagMetadata;
 exports.slice = slice;
 exports.split = split;
+exports.tagFaces = tagFaces;