brepjs 8.8.2 → 8.8.3

package/dist/curveFns-BhQECv8e.js

@@ -1,180 +0,0 @@
-import { g as getKernel } from "./occtBoundary-DvBywHyU.js";
-import { c as castShape, d as isEdge, m as isWire, n as gcWithScope } from "./shapeTypes-DnwCo942.js";
-import { e as err, p as typeCastError, l as ok, u as unwrap } from "./errors-DJ92ermb.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);
-};
-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,
-    chamfer: oc.GeomAbs_JoinType.GeomAbs_Intersection
-    // sharp/miter corners
-  };
-  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 {
-  curveEndPoint as a,
-  getCurveType as b,
-  curveTangentAt as c,
-  curveStartPoint as d,
-  curveIsClosed as e,
-  findCurveType as f,
-  getOrientation as g,
-  curvePointAt as h,
-  curveLength as i,
-  approximateCurve as j,
-  curveIsPeriodic as k,
-  curvePeriod as l,
-  flipOrientation as m,
-  interpolateCurve as n,
-  offsetWire2D as o
-};

package/dist/faceFns-3PDjBeW7.js

@@ -1,272 +0,0 @@
-import { g as getKernel, a as toVec3, d as toOcPnt } from "./occtBoundary-DvBywHyU.js";
-import { c as castShape, h as isShape3D$1, m as isWire$1, n as gcWithScope } from "./shapeTypes-DnwCo942.js";
-import { e as err, p as typeCastError, l as ok, a as andThen, u as unwrap } from "./errors-DJ92ermb.js";
-let _topoMap = null;
-const asTopo = (entity) => {
-  if (!_topoMap) {
-    const oc = getKernel().oc;
-    const ta = oc.TopAbs_ShapeEnum;
-    _topoMap = /* @__PURE__ */ new Map([
-      ["vertex", ta.TopAbs_VERTEX],
-      ["edge", ta.TopAbs_EDGE],
-      ["wire", ta.TopAbs_WIRE],
-      ["face", ta.TopAbs_FACE],
-      ["shell", ta.TopAbs_SHELL],
-      ["solid", ta.TopAbs_SOLID],
-      ["solidCompound", ta.TopAbs_COMPSOLID],
-      ["compound", ta.TopAbs_COMPOUND],
-      ["shape", ta.TopAbs_SHAPE]
-    ]);
-  }
-  return _topoMap.get(entity);
-};
-const iterTopo = function* iterTopo2(shape, topo) {
-  const topoToShapeType = {
-    vertex: "vertex",
-    edge: "edge",
-    wire: "wire",
-    face: "face",
-    shell: "shell",
-    solid: "solid",
-    solidCompound: "compsolid",
-    compound: "compound",
-    shape: "compound"
-    // fallback; 'shape' isn't used in iterShapes
-  };
-  const shapeType2 = topoToShapeType[topo];
-  if (shapeType2) {
-    const shapes = getKernel().iterShapes(shape, shapeType2);
-    for (const s of shapes) yield s;
-  }
-};
-const shapeType = (shape) => {
-  if (shape.IsNull()) return err(typeCastError("NULL_SHAPE", "This shape has no type, it is null"));
-  return ok(shape.ShapeType());
-};
-let _downcastMap = null;
-function getDowncastMap() {
-  if (!_downcastMap) {
-    const oc = getKernel().oc;
-    const ta = oc.TopAbs_ShapeEnum;
-    _downcastMap = /* @__PURE__ */ new Map([
-      [ta.TopAbs_VERTEX, oc.TopoDS.Vertex_1],
-      [ta.TopAbs_EDGE, oc.TopoDS.Edge_1],
-      [ta.TopAbs_WIRE, oc.TopoDS.Wire_1],
-      [ta.TopAbs_FACE, oc.TopoDS.Face_1],
-      [ta.TopAbs_SHELL, oc.TopoDS.Shell_1],
-      [ta.TopAbs_SOLID, oc.TopoDS.Solid_1],
-      [ta.TopAbs_COMPSOLID, oc.TopoDS.CompSolid_1],
-      [ta.TopAbs_COMPOUND, oc.TopoDS.Compound_1]
-    ]);
-  }
-  return _downcastMap;
-}
-function downcast(shape) {
-  return andThen(shapeType(shape), (myType) => {
-    const caster = getDowncastMap().get(myType);
-    if (!caster)
-      return err(typeCastError("NO_WRAPPER", "Could not find a wrapper for this shape type"));
-    return ok(caster(shape));
-  });
-}
-function cast(shape) {
-  if (shape.IsNull()) {
-    return err(typeCastError("NULL_SHAPE", "Cannot cast a null shape"));
-  }
-  return ok(castShape(shape));
-}
-function isShape3D(shape) {
-  return isShape3D$1(shape);
-}
-function isWire(shape) {
-  return isWire$1(shape);
-}
-function isCompSolid(shape) {
-  const st = shape.wrapped.ShapeType();
-  const oc = getKernel().oc;
-  return st === oc.TopAbs_ShapeEnum.TopAbs_COMPSOLID;
-}
-function fromBREP(data) {
-  const oc = getKernel().oc;
-  return cast(oc.BRepToolsWrapper.Read(data));
-}
-function getSurfaceType(face) {
-  const oc = getKernel().oc;
-  const r = gcWithScope();
-  const adaptor = r(new oc.BRepAdaptor_Surface_2(face.wrapped, false));
-  const ga = oc.GeomAbs_SurfaceType;
-  const CAST_MAP = /* @__PURE__ */ new Map([
-    [ga.GeomAbs_Plane, "PLANE"],
-    [ga.GeomAbs_Cylinder, "CYLINDRE"],
-    [ga.GeomAbs_Cone, "CONE"],
-    [ga.GeomAbs_Sphere, "SPHERE"],
-    [ga.GeomAbs_Torus, "TORUS"],
-    [ga.GeomAbs_BezierSurface, "BEZIER_SURFACE"],
-    [ga.GeomAbs_BSplineSurface, "BSPLINE_SURFACE"],
-    [ga.GeomAbs_SurfaceOfRevolution, "REVOLUTION_SURFACE"],
-    [ga.GeomAbs_SurfaceOfExtrusion, "EXTRUSION_SURFACE"],
-    [ga.GeomAbs_OffsetSurface, "OFFSET_SURFACE"],
-    [ga.GeomAbs_OtherSurface, "OTHER_SURFACE"]
-  ]);
-  const surfType = CAST_MAP.get(adaptor.GetType());
-  if (!surfType) {
-    return err(
-      typeCastError("UNKNOWN_SURFACE_TYPE", "Unrecognized surface type from OCCT adapter")
-    );
-  }
-  return ok(surfType);
-}
-function faceGeomType(face) {
-  return unwrap(getSurfaceType(face));
-}
-function faceOrientation(face) {
-  const oc = getKernel().oc;
-  const orient = face.wrapped.Orientation_1();
-  return orient === oc.TopAbs_Orientation.TopAbs_FORWARD ? "forward" : "backward";
-}
-function flipFaceOrientation(face) {
-  return castShape(face.wrapped.Reversed());
-}
-function uvBounds(face) {
-  const oc = getKernel().oc;
-  const uMin = { current: 0 };
-  const uMax = { current: 0 };
-  const vMin = { current: 0 };
-  const vMax = { current: 0 };
-  oc.BRepTools.UVBounds_1(face.wrapped, uMin, uMax, vMin, vMax);
-  return {
-    uMin: uMin.current,
-    uMax: uMax.current,
-    vMin: vMin.current,
-    vMax: vMax.current
-  };
-}
-function pointOnSurface(face, u, v) {
-  const oc = getKernel().oc;
-  const r = gcWithScope();
-  const bounds = uvBounds(face);
-  const adaptor = r(new oc.BRepAdaptor_Surface_2(face.wrapped, false));
-  const p = r(new oc.gp_Pnt_1());
-  const absU = u * (bounds.uMax - bounds.uMin) + bounds.uMin;
-  const absV = v * (bounds.vMax - bounds.vMin) + bounds.vMin;
-  adaptor.D0(absU, absV, p);
-  return [p.X(), p.Y(), p.Z()];
-}
-function uvCoordinates(face, point) {
-  const oc = getKernel().oc;
-  const r = gcWithScope();
-  const v = toVec3(point);
-  const surface = r(oc.BRep_Tool.Surface_2(face.wrapped));
-  const projected = r(
-    new oc.GeomAPI_ProjectPointOnSurf_2(
-      r(toOcPnt(v)),
-      surface,
-      oc.Extrema_ExtAlgo.Extrema_ExtAlgo_Grad
-    )
-  );
-  const uPtr = { current: 0 };
-  const vPtr = { current: 0 };
-  projected.LowerDistanceParameters(uPtr, vPtr);
-  return [uPtr.current, vPtr.current];
-}
-function projectPointOnFace(face, point) {
-  const oc = getKernel().oc;
-  const r = gcWithScope();
-  const v = toVec3(point);
-  try {
-    const surface = r(oc.BRep_Tool.Surface_2(face.wrapped));
-    const projected = r(
-      new oc.GeomAPI_ProjectPointOnSurf_2(
-        r(toOcPnt(v)),
-        surface,
-        oc.Extrema_ExtAlgo.Extrema_ExtAlgo_Grad
-      )
-    );
-    if (projected.NbPoints() === 0) {
-      return err(typeCastError("PROJECTION_FAILED", "No projection found on the face"));
-    }
-    const uPtr = { current: 0 };
-    const vPtr = { current: 0 };
-    projected.LowerDistanceParameters(uPtr, vPtr);
-    const nearestPnt = r(projected.NearestPoint());
-    const projectedPoint = [nearestPnt.X(), nearestPnt.Y(), nearestPnt.Z()];
-    return ok({
-      uv: [uPtr.current, vPtr.current],
-      point: projectedPoint,
-      distance: projected.LowerDistance()
-    });
-  } catch (e) {
-    return err(
-      typeCastError(
-        "PROJECTION_FAILED",
-        `Point projection failed: ${e instanceof Error ? e.message : String(e)}`
-      )
-    );
-  }
-}
-function normalAt(face, locationPoint) {
-  const oc = getKernel().oc;
-  const r = gcWithScope();
-  let u;
-  let v;
-  if (!locationPoint) {
-    const bounds = uvBounds(face);
-    u = 0.5 * (bounds.uMin + bounds.uMax);
-    v = 0.5 * (bounds.vMin + bounds.vMax);
-  } else {
-    [u, v] = uvCoordinates(face, locationPoint);
-  }
-  const p = r(new oc.gp_Pnt_1());
-  const vn = r(new oc.gp_Vec_1());
-  const props = r(new oc.BRepGProp_Face_2(face.wrapped, false));
-  props.Normal(u, v, p, vn);
-  return [vn.X(), vn.Y(), vn.Z()];
-}
-function faceCenter(face) {
-  const oc = getKernel().oc;
-  const r = gcWithScope();
-  const props = r(new oc.GProp_GProps_1());
-  oc.BRepGProp.SurfaceProperties_2(face.wrapped, props, 1e-7, true);
-  const center = r(props.CentreOfMass());
-  return [center.X(), center.Y(), center.Z()];
-}
-function classifyPointOnFace(face, point, tolerance = 1e-6) {
-  const [u, v] = uvCoordinates(face, point);
-  return getKernel().classifyPointOnFace(face.wrapped, u, v, tolerance);
-}
-function outerWire(face) {
-  const oc = getKernel().oc;
-  return castShape(oc.BRepTools.OuterWire(face.wrapped));
-}
-function innerWires(face) {
-  const outer = outerWire(face);
-  const allWires = Array.from(iterTopo(face.wrapped, "wire")).map(
-    (w) => castShape(unwrap(downcast(w)))
-  );
-  const result = allWires.filter((w) => !w.wrapped.IsSame(outer.wrapped));
-  return result;
-}
-export {
-  isShape3D as a,
-  isWire as b,
-  cast as c,
-  downcast as d,
-  faceCenter as e,
-  faceGeomType as f,
-  getSurfaceType as g,
-  uvCoordinates as h,
-  iterTopo as i,
-  fromBREP as j,
-  innerWires as k,
-  asTopo as l,
-  classifyPointOnFace as m,
-  normalAt as n,
-  outerWire as o,
-  pointOnSurface as p,
-  faceOrientation as q,
-  flipFaceOrientation as r,
-  isCompSolid as s,
-  projectPointOnFace as t,
-  uvBounds as u,
-  shapeType as v
-};