brepjs 8.2.0 → 8.3.0

package/dist/query.cjs

@@ -1,11 +1,11 @@
 "use strict";
 Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
-const helpers = require("./helpers-Dje6wrKi.cjs");
-const cornerFinder = require("./cornerFinder-DuStF5jK.cjs");
+const helpers = require("./helpers-CP2KrBZl.cjs");
+const cornerFinder = require("./cornerFinder-BdKtobgb.cjs");
 const occtBoundary = require("./occtBoundary-BFAaUtA7.cjs");
 const shapeTypes = require("./shapeTypes-UqVCIO_T.cjs");
 const vecOps = require("./vecOps-CjRL1jau.cjs");
-const curveFns = require("./curveFns-ByeCqutv.cjs");
+const curveFns = require("./curveFns-B5EQsSwv.cjs");
 function edgeDirectionFilter(dir, angle) {
   const d = vecOps.vecNormalize(helpers.resolveDir(dir));
   return (edge) => {

package/dist/query.js

@@ -1,10 +1,10 @@
-import { c as createTypedFinder, o as distanceFromPointFilter, q as resolveDir } from "./helpers-BSQfs538.js";
-import { f, g } from "./helpers-BSQfs538.js";
-import { c } from "./cornerFinder-CPm2baSJ.js";
+import { c as createTypedFinder, o as distanceFromPointFilter, q as resolveDir } from "./helpers-r_e-u1JM.js";
+import { f, g } from "./helpers-r_e-u1JM.js";
+import { c } from "./cornerFinder-DvPiz-VR.js";
 import { g as getKernel } from "./occtBoundary-CoXB2xvx.js";
 import { p as gcWithScope } from "./shapeTypes-BU2LKv2S.js";
 import { j as vecNormalize, d as vecDot, D as DEG2RAD } from "./vecOps-ZDdZWbwT.js";
-import { F as getCurveType, w as curveLength } from "./curveFns-C5gSZ5EY.js";
+import { l as getCurveType, f as curveLength } from "./curveFns-CyHyk29c.js";
 function edgeDirectionFilter(dir, angle) {
   const d = vecNormalize(resolveDir(dir));
   return (edge) => {

package/dist/{curveFns-C5gSZ5EY.js → shapeFns-CWd_ASDV.js}

@@ -1,32 +1,8 @@
 import { g as getKernel, c as toOcVec, e as makeOcAx1, m as makeOcAx2, b as toOcPnt } from "./occtBoundary-CoXB2xvx.js";
-import { c as castShape, g as getShapeKind, p as gcWithScope, d as isEdge, m as isWire } from "./shapeTypes-BU2LKv2S.js";
+import { c as castShape, g as getShapeKind, p as gcWithScope } from "./shapeTypes-BU2LKv2S.js";
 import { D as DEG2RAD, H as HASH_CODE_MAX } from "./vecOps-ZDdZWbwT.js";
 import { i as iterTopo, d as downcast } from "./cast-D0OhP1nV.js";
-import { e as err, p as typeCastError, l as ok, u as unwrap } from "./errors-wGhcJMpB.js";
-let CURVE_TYPES_MAP = null;
-const getCurveTypesMap = (refresh) => {
-  if (CURVE_TYPES_MAP && !refresh) return CURVE_TYPES_MAP;
-  const oc = getKernel().oc;
-  const ga = oc.GeomAbs_CurveType;
-  CURVE_TYPES_MAP = /* @__PURE__ */ new Map([
-    [ga.GeomAbs_Line, "LINE"],
-    [ga.GeomAbs_Circle, "CIRCLE"],
-    [ga.GeomAbs_Ellipse, "ELLIPSE"],
-    [ga.GeomAbs_Hyperbola, "HYPERBOLA"],
-    [ga.GeomAbs_Parabola, "PARABOLA"],
-    [ga.GeomAbs_BezierCurve, "BEZIER_CURVE"],
-    [ga.GeomAbs_BSplineCurve, "BSPLINE_CURVE"],
-    [ga.GeomAbs_OffsetCurve, "OFFSET_CURVE"],
-    [ga.GeomAbs_OtherCurve, "OTHER_CURVE"]
-  ]);
-  return CURVE_TYPES_MAP;
-};
-const findCurveType = (type) => {
-  let shapeType = getCurveTypesMap().get(type);
-  if (!shapeType) shapeType = getCurveTypesMap(true).get(type);
-  if (!shapeType) return err(typeCastError("UNKNOWN_CURVE_TYPE", "Unknown curve type"));
-  return ok(shapeType);
-};
+import { u as unwrap } from "./errors-wGhcJMpB.js";
 function clone(shape) {
   return castShape(unwrap(downcast(shape.wrapped)));
 }
@@ -60,6 +36,7 @@ function translate(shape, v) {
   trsf.SetTranslation_1(vec);
   const transformer = new oc.BRepBuilderAPI_Transform_2(shape.wrapped, trsf, true);
   const result = castShape(transformer.Shape());
+  propagateOrigins(transformer, [shape], result);
   transformer.delete();
   trsf.delete();
   vec.delete();
@@ -72,6 +49,7 @@ function rotate(shape, angle, position = [0, 0, 0], direction = [0, 0, 1]) {
   trsf.SetRotation_1(ax1, angle * DEG2RAD);
   const transformer = new oc.BRepBuilderAPI_Transform_2(shape.wrapped, trsf, true);
   const result = castShape(transformer.Shape());
+  propagateOrigins(transformer, [shape], result);
   transformer.delete();
   trsf.delete();
   ax1.delete();
@@ -84,6 +62,7 @@ function mirror(shape, planeNormal = [0, 1, 0], planeOrigin = [0, 0, 0]) {
   trsf.SetMirror_3(ax2);
   const transformer = new oc.BRepBuilderAPI_Transform_2(shape.wrapped, trsf, true);
   const result = castShape(transformer.Shape());
+  propagateOrigins(transformer, [shape], result);
   transformer.delete();
   trsf.delete();
   ax2.delete();
@@ -96,6 +75,7 @@ function scale(shape, factor, center = [0, 0, 0]) {
   trsf.SetScale(pnt, factor);
   const transformer = new oc.BRepBuilderAPI_Transform_2(shape.wrapped, trsf, true);
   const result = castShape(transformer.Shape());
+  propagateOrigins(transformer, [shape], result);
   transformer.delete();
   trsf.delete();
   pnt.delete();
@@ -163,6 +143,7 @@ function applyMatrix(shape, matrix) {
     );
     const transformer2 = new oc.BRepBuilderAPI_Transform_2(shape.wrapped, trsf, true);
     const result2 = castShape(transformer2.Shape());
+    propagateOrigins(transformer2, [shape], result2);
     transformer2.delete();
     trsf.delete();
     return result2;
@@ -178,6 +159,7 @@ function applyMatrix(shape, matrix) {
   xyz.delete();
   const transformer = new oc.BRepBuilderAPI_GTransform_2(shape.wrapped, gtrsf, true);
   const result = castShape(transformer.Shape());
+  propagateOrigins(transformer, [shape], result);
   transformer.delete();
   gtrsf.delete();
   return result;
@@ -205,6 +187,7 @@ function transformCopy(shape, composed) {
   const oc = getKernel().oc;
   const transformer = new oc.BRepBuilderAPI_Transform_2(shape.wrapped, composed.trsf, true);
   const result = castShape(transformer.Shape());
+  propagateOrigins(transformer, [shape], result);
   transformer.delete();
   return result;
 }
@@ -244,6 +227,89 @@ function getWires(shape) {
   cache.wires = wires;
   return wires;
 }
+function setShapeOrigin(shape, origin) {
+  const cache = getOrCreateCache(shape);
+  const map = /* @__PURE__ */ new Map();
+  for (const f of getFaces(shape)) {
+    map.set(f.wrapped.HashCode(HASH_CODE_MAX), origin);
+  }
+  cache.faceOrigins = map;
+}
+function getFaceOrigins(shape) {
+  return topoCache.get(shape.wrapped)?.faceOrigins;
+}
+function iterOcList(list, callback) {
+  const oc = getKernel().oc;
+  const copy = new oc.TopTools_ListOfShape_3(list);
+  while (copy.Size() > 0) {
+    callback(copy.First_1());
+    copy.RemoveFirst();
+  }
+  copy.delete();
+}
+function propagateOrigins(op, inputs, result) {
+  const inputOrigins = [];
+  for (const input of inputs) {
+    const origins = getFaceOrigins(input);
+    if (!origins) continue;
+    for (const f of getFaces(input)) {
+      const hash = f.wrapped.HashCode(HASH_CODE_MAX);
+      const origin = origins.get(hash);
+      if (origin !== void 0) {
+        inputOrigins.push({ face: f.wrapped, origin });
+      }
+    }
+  }
+  if (inputOrigins.length === 0) return;
+  const resultMap = /* @__PURE__ */ new Map();
+  for (const { face, origin } of inputOrigins) {
+    if (op.IsDeleted?.(face)) continue;
+    const modifiedList = op.Modified(face);
+    if (modifiedList.Size() > 0) {
+      iterOcList(modifiedList, (modFace) => {
+        resultMap.set(modFace.HashCode(HASH_CODE_MAX), origin);
+      });
+    } else {
+      resultMap.set(face.HashCode(HASH_CODE_MAX), origin);
+    }
+    const generatedList = op.Generated(face);
+    if (generatedList.Size() > 0) {
+      iterOcList(generatedList, (genFace) => {
+        const hash = genFace.HashCode(HASH_CODE_MAX);
+        if (!resultMap.has(hash)) {
+          resultMap.set(hash, 0);
+        }
+      });
+    }
+  }
+  if (resultMap.size > 0) {
+    const cache = getOrCreateCache(result);
+    cache.faceOrigins = resultMap;
+  }
+}
+function propagateOriginsByHash(inputs, result) {
+  const lookup = /* @__PURE__ */ new Map();
+  for (const input of inputs) {
+    const origins = getFaceOrigins(input);
+    if (!origins) continue;
+    for (const [hash, origin] of origins) {
+      lookup.set(hash, origin);
+    }
+  }
+  if (lookup.size === 0) return;
+  const resultMap = /* @__PURE__ */ new Map();
+  for (const f of getFaces(result)) {
+    const hash = f.wrapped.HashCode(HASH_CODE_MAX);
+    const origin = lookup.get(hash);
+    if (origin !== void 0) {
+      resultMap.set(hash, origin);
+    }
+  }
+  if (resultMap.size > 0) {
+    const cache = getOrCreateCache(result);
+    cache.faceOrigins = resultMap;
+  }
+}
 function getVertices(shape) {
   return Array.from(iterTopo(shape.wrapped, "vertex")).map(
     (e) => castShape(unwrap(downcast(e)))
@@ -308,179 +374,34 @@ function vertexPosition(vertex) {
   pnt.delete();
   return result;
 }
-function getAdaptor(shape) {
-  const oc = getKernel().oc;
-  const st = shape.wrapped.ShapeType();
-  const e = oc.TopAbs_ShapeEnum;
-  if (st === e.TopAbs_WIRE) {
-    return new oc.BRepAdaptor_CompCurve_2(shape.wrapped, false);
-  }
-  return new oc.BRepAdaptor_Curve_2(shape.wrapped);
-}
-function mapParam(adaptor, t) {
-  const first = Number(adaptor.FirstParameter());
-  const last = Number(adaptor.LastParameter());
-  return first + (last - first) * t;
-}
-function getCurveType(shape) {
-  const r = gcWithScope();
-  const adaptor = r(getAdaptor(shape));
-  const technicalType = adaptor.GetType && adaptor.GetType();
-  return unwrap(findCurveType(technicalType));
-}
-function curveStartPoint(shape) {
-  const r = gcWithScope();
-  const adaptor = r(getAdaptor(shape));
-  const pnt = r(adaptor.Value(adaptor.FirstParameter()));
-  return [pnt.X(), pnt.Y(), pnt.Z()];
-}
-function curveEndPoint(shape) {
-  const r = gcWithScope();
-  const adaptor = r(getAdaptor(shape));
-  const pnt = r(adaptor.Value(adaptor.LastParameter()));
-  return [pnt.X(), pnt.Y(), pnt.Z()];
-}
-function curvePointAt(shape, position = 0.5) {
-  const r = gcWithScope();
-  const adaptor = r(getAdaptor(shape));
-  const pnt = r(adaptor.Value(mapParam(adaptor, position)));
-  return [pnt.X(), pnt.Y(), pnt.Z()];
-}
-function curveTangentAt(shape, position = 0.5) {
-  const oc = getKernel().oc;
-  const r = gcWithScope();
-  const adaptor = r(getAdaptor(shape));
-  const param = mapParam(adaptor, position);
-  const tmpPnt = r(new oc.gp_Pnt_1());
-  const tmpVec = r(new oc.gp_Vec_1());
-  adaptor.D1(param, tmpPnt, tmpVec);
-  return [tmpVec.X(), tmpVec.Y(), tmpVec.Z()];
-}
-function curveLength(shape) {
-  const oc = getKernel().oc;
-  const r = gcWithScope();
-  const props = r(new oc.GProp_GProps_1());
-  oc.BRepGProp.LinearProperties(shape.wrapped, props, true, false);
-  return props.Mass();
-}
-function curveIsClosed(shape) {
-  const r = gcWithScope();
-  const adaptor = r(getAdaptor(shape));
-  return adaptor.IsClosed();
-}
-function curveIsPeriodic(shape) {
-  const r = gcWithScope();
-  const adaptor = r(getAdaptor(shape));
-  return adaptor.IsPeriodic();
-}
-function curvePeriod(shape) {
-  const adaptor = getAdaptor(shape);
-  const result = adaptor.Period();
-  adaptor.delete();
-  return result;
-}
-function getOrientation(shape) {
-  const oc = getKernel().oc;
-  const orient = shape.wrapped.Orientation_1();
-  return orient === oc.TopAbs_Orientation.TopAbs_FORWARD ? "forward" : "backward";
-}
-function flipOrientation(shape) {
-  return castShape(shape.wrapped.Reversed());
-}
-function interpolateCurve(points, options = {}) {
-  if (points.length < 2) {
-    return err(typeCastError("INTERPOLATE_MIN_POINTS", "Interpolation requires at least 2 points"));
-  }
-  try {
-    const result = getKernel().interpolatePoints(points, options);
-    const cast = castShape(result);
-    if (!isEdge(cast)) {
-      return err(typeCastError("INTERPOLATE_NOT_EDGE", "Interpolation did not produce an edge"));
-    }
-    return ok(cast);
-  } catch (e) {
-    return err(
-      typeCastError(
-        "INTERPOLATE_FAILED",
-        `Interpolation failed: ${e instanceof Error ? e.message : String(e)}`
-      )
-    );
-  }
-}
-function approximateCurve(points, options = {}) {
-  if (points.length < 2) {
-    return err(typeCastError("APPROXIMATE_MIN_POINTS", "Approximation requires at least 2 points"));
-  }
-  try {
-    const result = getKernel().approximatePoints(points, options);
-    const cast = castShape(result);
-    if (!isEdge(cast)) {
-      return err(typeCastError("APPROXIMATE_NOT_EDGE", "Approximation did not produce an edge"));
-    }
-    return ok(cast);
-  } catch (e) {
-    return err(
-      typeCastError(
-        "APPROXIMATE_FAILED",
-        `Approximation failed: ${e instanceof Error ? e.message : String(e)}`
-      )
-    );
-  }
-}
-function offsetWire2D(wire, offset, kind = "arc") {
-  const oc = getKernel().oc;
-  const joinTypes = {
-    arc: oc.GeomAbs_JoinType.GeomAbs_Arc,
-    intersection: oc.GeomAbs_JoinType.GeomAbs_Intersection,
-    tangent: oc.GeomAbs_JoinType.GeomAbs_Tangent
-  };
-  const resultShape = getKernel().offsetWire2D(wire.wrapped, offset, joinTypes[kind]);
-  const wrapped = castShape(resultShape);
-  if (!isWire(wrapped)) {
-    wrapped[Symbol.dispose]();
-    return err(typeCastError("OFFSET_NOT_WIRE", "Offset did not produce a Wire"));
-  }
-  return ok(wrapped);
-}
 export {
-  composeTransforms as A,
-  curveIsPeriodic as B,
-  curvePeriod as C,
-  findCurveType as D,
-  flipOrientation as E,
-  getCurveType as F,
-  getOrientation as G,
-  interpolateCurve as H,
-  isEqualShape as I,
-  iterEdges as J,
-  iterFaces as K,
-  iterVertices as L,
-  iterWires as M,
-  offsetWire2D as N,
-  getEdges as a,
-  applyMatrix as b,
-  curveIsClosed as c,
-  clone as d,
-  describe as e,
-  isEmpty as f,
-  getHashCode as g,
-  simplify as h,
+  iterVertices as A,
+  iterWires as B,
+  setShapeOrigin as C,
+  propagateOriginsByHash as a,
+  getHashCode as b,
+  getEdges as c,
+  applyMatrix as d,
+  clone as e,
+  describe as f,
+  getFaceOrigins as g,
+  isEmpty as h,
   isSameShape as i,
-  toBREP as j,
-  transformCopy as k,
-  getBounds as l,
+  simplify as j,
+  toBREP as k,
+  transformCopy as l,
   mirror as m,
-  getFaces as n,
-  curveTangentAt as o,
-  curvePointAt as p,
-  curveEndPoint as q,
+  getBounds as n,
+  getFaces as o,
+  propagateOrigins as p,
+  getVertices as q,
   rotate as r,
   scale as s,
   translate as t,
-  curveStartPoint as u,
+  getWires as u,
   vertexPosition as v,
-  curveLength as w,
-  getVertices as x,
-  getWires as y,
-  approximateCurve as z
+  composeTransforms as w,
+  isEqualShape as x,
+  iterEdges as y,
+  iterFaces as z
 };