brepjs 8.3.0 → 8.7.4

package/dist/{booleanFns-BcQUqjUu.js → booleanFns-DdjtpcM6.js}

@@ -1,9 +1,10 @@
-import { g as getKernel } from "./occtBoundary-CoXB2xvx.js";
-import { p as gcWithScope, c as castShape, h as isShape3D } from "./shapeTypes-BU2LKv2S.js";
-import { l as ok, d as isErr, e as err, x as validationError, B as BrepErrorCode, p as typeCastError, o as occtError } from "./errors-wGhcJMpB.js";
-import { r as resolvePlane } from "./vectors-BhfKwL9J.js";
-import { n as vecScale, v as vecAdd } from "./vecOps-ZDdZWbwT.js";
-import { p as propagateOrigins, a as propagateOriginsByHash } from "./shapeFns-CWd_ASDV.js";
+import { g as getKernel } from "./occtBoundary-CWzWqBCm.js";
+import { n as gcWithScope, c as castShape, h as isShape3D } from "./shapeTypes-D0vfRxWb.js";
+import { l as ok, d as isErr, e as err, x as validationError, B as BrepErrorCode, p as typeCastError, o as occtError } from "./errors-Coh_5_19.js";
+import { r as resolvePlane } from "./vectors-CZV4ZrTz.js";
+import { H as HASH_CODE_MAX, n as vecScale, v as vecAdd } from "./vecOps-ZDdZWbwT.js";
+import { a as getFaces, p as propagateOrigins, b as propagateOriginsByHash, c as getWires, d as getEdges } from "./shapeFns-4ioRrhih.js";
+import { m as makeFace } from "./surfaceBuilders-B7Jxob8g.js";
 function applyGlue(op, optimisation) {
   const oc = getKernel().oc;
   if (optimisation === "commonFace") {
@@ -13,6 +14,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 : 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(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 getFaces(shape)) {
+    const hash = face.wrapped.HashCode(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 = getFaces(shape);
+  const faceByHash = /* @__PURE__ */ new Map();
+  for (const face of faces) {
+    faceByHash.set(face.wrapped.HashCode(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 getFaces(input)) {
+      const hash = face.wrapped.HashCode(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 = getKernel().oc;
+        const copy = new oc.TopTools_ListOfShape_3(modifiedList);
+        while (copy.Size() > 0) {
+          const modFace = copy.First_1();
+          const modHash = modFace.HashCode(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(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(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 getFaces(input)) {
+      const hash = face.wrapped.HashCode(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 = getKernel().oc;
+        const copy = new oc.TopTools_ListOfShape_3(modifiedList);
+        while (copy.Size() > 0) {
+          const modFace = copy.First_1();
+          const modHash = modFace.HashCode(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 err(validationError(BrepErrorCode.NULL_SHAPE_INPUT, `${label} is a null shape`));
@@ -71,6 +277,8 @@ function fuse(a, b, { optimisation = "none", simplify = false, signal } = {}) {
   );
   if (fuseResult.ok) {
     propagateOrigins(fuseOp, [a, b], fuseResult.value);
+    propagateFaceTags(fuseOp, [a, b], fuseResult.value);
+    propagateColors(fuseOp, [a, b], fuseResult.value);
   }
   return fuseResult;
 }
@@ -90,6 +298,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) {
     propagateOrigins(cutOp, [base, tool], cutResult.value);
+    propagateFaceTags(cutOp, [base, tool], cutResult.value);
+    propagateColors(cutOp, [base, tool], cutResult.value);
   }
   return cutResult;
 }
@@ -112,6 +322,8 @@ function intersect(a, b, { simplify = false, signal } = {}) {
   );
   if (intResult.ok) {
     propagateOrigins(intOp, [a, b], intResult.value);
+    propagateFaceTags(intOp, [a, b], intResult.value);
+    propagateColors(intOp, [a, b], intResult.value);
   }
   return intResult;
 }
@@ -187,6 +399,8 @@ function cutAll(base, tools, { optimisation = "none", simplify = false, signal }
   );
   if (cutAllResult.ok) {
     propagateOrigins(cutOp, [base, ...tools], cutAllResult.value);
+    propagateFaceTags(cutOp, [base, ...tools], cutAllResult.value);
+    propagateColors(cutOp, [base, ...tools], cutAllResult.value);
   }
   return cutAllResult;
 }
@@ -249,6 +463,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 = getWires(sectionResult.value);
+  if (wires.length === 0) {
+    const edges = getEdges(sectionResult.value);
+    if (edges.length === 0) {
+      return err(occtError("SECTION_FAILED", "sectionToFace: section produced no geometry"));
+    }
+    const oc = 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(castShape(wb.Wire()));
+      }
+      wb.delete();
+    }
+  }
+  if (wires.length === 0) {
+    return err(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 = 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 makeFace(outer, holes.length > 0 ? holes : void 0);
+}
 function split(shape, tools) {
   if (tools.length === 0) return ok(shape);
   if (shape.wrapped.IsNull()) {
@@ -290,13 +572,25 @@ function slice(shape, planes, options = {}) {
   return ok(results);
 }
 export {
-  slice as a,
-  split as b,
+  propagateColors as a,
+  sectionToFace as b,
   cut as c,
-  fuseAll as d,
-  cutAll as e,
+  slice as d,
+  split as e,
   fuse as f,
-  applyGlue as g,
+  fuseAll as g,
+  cutAll as h,
   intersect as i,
-  section as s
+  applyGlue as j,
+  colorFaces as k,
+  colorShape as l,
+  findFacesByTag as m,
+  getFaceColor as n,
+  getFaceTags as o,
+  propagateFaceTags as p,
+  getShapeColor as q,
+  getTagMetadata as r,
+  section as s,
+  setTagMetadata as t,
+  tagFaces as u
 };