fluidcad 0.0.2

package/lib/dist/oc/edge-query.js

@@ -0,0 +1,235 @@
+import { getOC } from "./init.js";
+import { Convert } from "./convert.js";
+import { Point } from "../math/point.js";
+import { Vector3d } from "../math/vector3d.js";
+export class EdgeQuery {
+    // Wrapper methods (public API for external callers)
+    static isCircleEdge(edge, diameter) {
+        return EdgeQuery.isCircleEdgeRaw(edge.getShape(), diameter);
+    }
+    static isArcEdge(edge, radius) {
+        return EdgeQuery.isArcEdgeRaw(edge.getShape(), radius);
+    }
+    static isLineEdge(edge) {
+        return EdgeQuery.isLineEdgeRaw(edge.getShape());
+    }
+    static isEdgeOnPlane(edge, plane) {
+        const [gpPln, dispose] = Convert.toGpPln(plane);
+        const result = EdgeQuery.isEdgeOnPlaneRaw(edge.getShape(), gpPln);
+        dispose();
+        return result;
+    }
+    static isEdgeParallelToPlane(edge, planeNormal) {
+        const [gpVec, dispose] = Convert.toGpVec(planeNormal);
+        const result = EdgeQuery.isEdgeParallelToPlaneRaw(edge.getShape(), gpVec);
+        dispose();
+        return result;
+    }
+    static isEdgeAlignedWithNormal(edge, planeNormal) {
+        const [gpVec, dispose] = Convert.toGpVec(planeNormal);
+        const result = EdgeQuery.isEdgeAlignedWithNormalRaw(edge.getShape(), gpVec);
+        dispose();
+        return result;
+    }
+    static isEdgeClosedCurve(edge) {
+        return EdgeQuery.isEdgeClosedCurveRaw(edge.getShape());
+    }
+    static getEdgeCurveType(edge) {
+        return EdgeQuery.getEdgeCurveTypeRaw(edge.getShape());
+    }
+    static getEdgeCurveParams(edge) {
+        return EdgeQuery.getEdgeCurveParamsRaw(edge.getShape());
+    }
+    static sampleEdgeCurvePoint(edge, param) {
+        return EdgeQuery.sampleEdgeCurvePointRaw(edge.getShape(), param);
+    }
+    static getCircleDataFromEdge(edge) {
+        return EdgeQuery.getCircleDataFromEdgeRaw(edge.getShape());
+    }
+    // Raw methods (for oc-internal and common/ use)
+    static isCircleEdgeRaw(edge, diameter) {
+        const oc = getOC();
+        const ocEdge = oc.TopoDS.Edge(edge);
+        const curveAdaptor = new oc.BRepAdaptor_Curve(ocEdge);
+        const curveType = curveAdaptor.GetType();
+        if (curveType !== oc.GeomAbs_CurveType.GeomAbs_Circle) {
+            curveAdaptor.delete();
+            return false;
+        }
+        if (!curveAdaptor.IsClosed()) {
+            curveAdaptor.delete();
+            return false;
+        }
+        if (diameter === undefined) {
+            curveAdaptor.delete();
+            return true;
+        }
+        const circle = curveAdaptor.Circle();
+        const r = circle.Radius();
+        circle.delete();
+        curveAdaptor.delete();
+        return Math.abs(r - diameter / 2) <= oc.Precision.Confusion();
+    }
+    static isArcEdgeRaw(edge, radius) {
+        const oc = getOC();
+        const ocEdge = oc.TopoDS.Edge(edge);
+        const curveAdaptor = new oc.BRepAdaptor_Curve(ocEdge);
+        const curveType = curveAdaptor.GetType();
+        if (curveType !== oc.GeomAbs_CurveType.GeomAbs_Circle) {
+            curveAdaptor.delete();
+            return false;
+        }
+        if (curveAdaptor.IsClosed()) {
+            curveAdaptor.delete();
+            return false;
+        }
+        if (radius === undefined) {
+            curveAdaptor.delete();
+            return true;
+        }
+        const circle = curveAdaptor.Circle();
+        const r = circle.Radius();
+        circle.delete();
+        curveAdaptor.delete();
+        return Math.abs(r - radius) <= oc.Precision.Confusion();
+    }
+    static isLineEdgeRaw(edge) {
+        const oc = getOC();
+        const ocEdge = oc.TopoDS.Edge(edge);
+        const curveAdaptor = new oc.BRepAdaptor_Curve(ocEdge);
+        const curveType = curveAdaptor.GetType();
+        curveAdaptor.delete();
+        return curveType === oc.GeomAbs_CurveType.GeomAbs_Line;
+    }
+    static isEdgeOnPlaneRaw(edge, plane) {
+        const oc = getOC();
+        const ocEdge = oc.TopoDS.Edge(edge);
+        const curveAdaptor = new oc.BRepAdaptor_Curve(ocEdge);
+        const uMin = curveAdaptor.FirstParameter();
+        const uMax = curveAdaptor.LastParameter();
+        const uMid = (uMin + uMax) / 2.0;
+        const parameters = [uMin, uMid, uMax];
+        let allOnPlane = true;
+        for (const u of parameters) {
+            const point = curveAdaptor.Value(u);
+            const distance = plane.Distance(point);
+            if (Math.abs(distance) > oc.Precision.Confusion()) {
+                allOnPlane = false;
+                point.delete();
+                break;
+            }
+            point.delete();
+        }
+        curveAdaptor.delete();
+        return allOnPlane;
+    }
+    static isEdgeParallelToPlaneRaw(edge, planeNormal) {
+        const oc = getOC();
+        const ocEdge = oc.TopoDS.Edge(edge);
+        const adaptor = new oc.BRepAdaptor_Curve(ocEdge);
+        const curve = adaptor.Curve().Curve()?.get();
+        if (!curve) {
+            adaptor.delete();
+            return false;
+        }
+        const firstParam = curve.FirstParameter();
+        const lastParam = curve.LastParameter();
+        const midParam = (firstParam + lastParam) / 2;
+        const tangent = new oc.gp_Vec();
+        const tempPnt = new oc.gp_Pnt();
+        curve.D1(midParam, tempPnt, tangent);
+        const dotProduct = Math.abs(tangent.Dot(planeNormal));
+        const tolerance = 1e-6;
+        const result = dotProduct < tolerance;
+        tangent.delete();
+        tempPnt.delete();
+        adaptor.delete();
+        return result;
+    }
+    static isEdgeAlignedWithNormalRaw(edge, planeNormal) {
+        const oc = getOC();
+        const ocEdge = oc.TopoDS.Edge(edge);
+        const curveAdaptor = new oc.BRepAdaptor_Curve(ocEdge);
+        const uMin = curveAdaptor.FirstParameter();
+        const uMax = curveAdaptor.LastParameter();
+        const startPoint = curveAdaptor.Value(uMin);
+        const endPoint = curveAdaptor.Value(uMax);
+        const edgeVector = new oc.gp_Vec(startPoint, endPoint);
+        if (edgeVector.Magnitude() < oc.Precision.Confusion()) {
+            edgeVector.delete();
+            startPoint.delete();
+            endPoint.delete();
+            curveAdaptor.delete();
+            return false;
+        }
+        edgeVector.Normalize();
+        const planeNormalDir = new oc.gp_Dir(planeNormal.X(), planeNormal.Y(), planeNormal.Z());
+        const edgeDir = new oc.gp_Dir(edgeVector.X(), edgeVector.Y(), edgeVector.Z());
+        const reversedNormal = planeNormalDir.Reversed();
+        const equals = edgeDir.IsEqual(planeNormalDir, oc.Precision.Angular())
+            || edgeDir.IsEqual(reversedNormal, oc.Precision.Angular());
+        edgeVector.delete();
+        startPoint.delete();
+        endPoint.delete();
+        planeNormalDir.delete();
+        edgeDir.delete();
+        reversedNormal.delete();
+        curveAdaptor.delete();
+        return equals;
+    }
+    static isEdgeClosedCurveRaw(edge) {
+        const oc = getOC();
+        const curve = new oc.BRepAdaptor_Curve(edge);
+        const result = curve.IsClosed();
+        curve.delete();
+        return result;
+    }
+    static getEdgeCurveTypeRaw(edge) {
+        const oc = getOC();
+        const curve = new oc.BRepAdaptor_Curve(edge);
+        const curveType = curve.GetType();
+        curve.delete();
+        if (curveType === oc.GeomAbs_CurveType.GeomAbs_Line)
+            return "line";
+        if (curveType === oc.GeomAbs_CurveType.GeomAbs_Circle)
+            return "circle";
+        return "other";
+    }
+    static getEdgeCurveParamsRaw(edge) {
+        const oc = getOC();
+        const curve = new oc.BRepAdaptor_Curve(edge);
+        const first = curve.FirstParameter();
+        const last = curve.LastParameter();
+        curve.delete();
+        return { first, last };
+    }
+    static sampleEdgeCurvePointRaw(edge, param) {
+        const oc = getOC();
+        const curve = new oc.BRepAdaptor_Curve(edge);
+        const gp = curve.Value(param);
+        const point = new Point(gp.X(), gp.Y(), gp.Z());
+        gp.delete();
+        curve.delete();
+        return point;
+    }
+    static getCircleDataFromEdgeRaw(edge) {
+        const oc = getOC();
+        const curve = new oc.BRepAdaptor_Curve(edge);
+        const circle = curve.Circle();
+        const center = circle.Location();
+        const radius = circle.Radius();
+        const axis = circle.Axis();
+        const dir = axis.Direction();
+        const result = {
+            center: new Point(center.X(), center.Y(), center.Z()),
+            radius,
+            axisDirection: new Vector3d(dir.X(), dir.Y(), dir.Z()),
+        };
+        dir.delete();
+        axis.delete();
+        center.delete();
+        circle.delete();
+        curve.delete();
+        return result;
+    }
+}

package/lib/dist/oc/explorer.d.ts

@@ -0,0 +1,34 @@
+import type { TopAbs_ShapeEnum, TopoDS_Compound, TopoDS_Edge, TopoDS_Face, TopoDS_Shape, TopoDS_Solid, TopoDS_Wire, TopoDS_Vertex } from "occjs-wrapper";
+import { Shape } from "../common/shape.js";
+import { Face } from "../common/face.js";
+import { Edge } from "../common/edge.js";
+import { Wire } from "../common/wire.js";
+import { Solid } from "../common/solid.js";
+import { Vertex } from "../common/vertex.js";
+export declare class Explorer {
+    static isWire(shape: TopoDS_Shape): boolean;
+    static isEdge(shape: TopoDS_Shape): boolean;
+    static isFace(shape: TopoDS_Shape): boolean;
+    static isVertex(shape: TopoDS_Shape): boolean;
+    static isCompound(shape: TopoDS_Shape): boolean;
+    static isShell(shape: TopoDS_Shape): boolean;
+    static isSolid(shape: TopoDS_Shape): boolean;
+    static isCompoundSolid(shape: TopoDS_Shape): boolean;
+    static getShapeType(shape: TopoDS_Shape): string;
+    static findShapes<T = TopoDS_Shape>(shape: TopoDS_Shape, lookFor: TopAbs_ShapeEnum): T[];
+    static findFirstShapeOfType<T = TopoDS_Shape>(shape: TopoDS_Shape, lookFor: TopAbs_ShapeEnum): T | null;
+    static findAllShapes(shape: TopoDS_Compound): any[];
+    static getOcShapeType(type: string): any;
+    static toSolid(shape: TopoDS_Shape): TopoDS_Solid;
+    static toFace(shape: TopoDS_Shape): TopoDS_Face;
+    static toWire(shape: TopoDS_Shape): TopoDS_Wire;
+    static toEdge(shape: TopoDS_Shape): TopoDS_Edge;
+    static toVertex(shape: TopoDS_Shape): TopoDS_Vertex;
+    static findFacesWrapped(shape: Shape): Face[];
+    static findEdgesWrapped(shape: Shape): Edge[];
+    static findEdgesInWireOrderWrapped(wire: Wire): Edge[];
+    static findSolidsWrapped(shape: Shape): Solid[];
+    static findVerticesWrapped(shape: Shape): Vertex[];
+    static findWiresWrapped(shape: Shape): Wire[];
+    static getShapeTypeFromWrapper(shape: Shape): string;
+}

package/lib/dist/oc/explorer.js

@@ -0,0 +1,179 @@
+import { getOC } from "./init.js";
+import { Face } from "../common/face.js";
+import { Edge } from "../common/edge.js";
+import { Wire } from "../common/wire.js";
+import { Solid } from "../common/solid.js";
+import { Vertex } from "../common/vertex.js";
+export class Explorer {
+    static isWire(shape) {
+        const oc = getOC();
+        return shape.ShapeType() === oc.TopAbs_ShapeEnum.TopAbs_WIRE;
+    }
+    static isEdge(shape) {
+        const oc = getOC();
+        return shape.ShapeType() === oc.TopAbs_ShapeEnum.TopAbs_EDGE;
+    }
+    static isFace(shape) {
+        const oc = getOC();
+        return shape.ShapeType() === oc.TopAbs_ShapeEnum.TopAbs_FACE;
+    }
+    static isVertex(shape) {
+        const oc = getOC();
+        return shape.ShapeType() === oc.TopAbs_ShapeEnum.TopAbs_VERTEX;
+    }
+    static isCompound(shape) {
+        const oc = getOC();
+        return shape.ShapeType() === oc.TopAbs_ShapeEnum.TopAbs_COMPOUND;
+    }
+    static isShell(shape) {
+        const oc = getOC();
+        return shape.ShapeType() === oc.TopAbs_ShapeEnum.TopAbs_SHELL;
+    }
+    static isSolid(shape) {
+        const oc = getOC();
+        return shape.ShapeType() === oc.TopAbs_ShapeEnum.TopAbs_SOLID;
+    }
+    static isCompoundSolid(shape) {
+        const oc = getOC();
+        return shape.ShapeType() === oc.TopAbs_ShapeEnum.TopAbs_COMPSOLID;
+    }
+    static getShapeType(shape) {
+        if (Explorer.isWire(shape))
+            return "Wire";
+        if (Explorer.isEdge(shape))
+            return "Edge";
+        if (Explorer.isFace(shape))
+            return "Face";
+        if (Explorer.isVertex(shape))
+            return "Vertex";
+        if (Explorer.isCompound(shape))
+            return "Compound";
+        if (Explorer.isShell(shape))
+            return "Shell";
+        if (Explorer.isSolid(shape))
+            return "Solid";
+        if (Explorer.isCompoundSolid(shape))
+            return "CompoundSolid";
+        return "Unknown";
+    }
+    static findShapes(shape, lookFor) {
+        const oc = getOC();
+        const explorer = new oc.TopExp_Explorer(shape, lookFor, oc.TopAbs_ShapeEnum.TopAbs_SHAPE);
+        const map = new oc.TopTools_MapOfShape();
+        const result = [];
+        while (explorer.More()) {
+            const current = explorer.Current();
+            if (map.Add(current)) {
+                result.push(current);
+            }
+            explorer.Next();
+        }
+        explorer.delete();
+        return result;
+    }
+    static findFirstShapeOfType(shape, lookFor) {
+        const oc = getOC();
+        const explorer = new oc.TopExp_Explorer(shape, lookFor, oc.TopAbs_ShapeEnum.TopAbs_SHAPE);
+        let result = null;
+        if (explorer.More()) {
+            result = explorer.Current();
+        }
+        explorer.delete();
+        return result;
+    }
+    static findAllShapes(shape) {
+        const oc = getOC();
+        const shapes = [];
+        const iterator = new oc.TopoDS_Iterator();
+        iterator.Initialize(shape, true, true);
+        while (iterator.More()) {
+            const shape = iterator.Value();
+            if (shape.ShapeType() === oc.TopAbs_ShapeEnum.TopAbs_SHELL) {
+                const faces = Explorer.findShapes(shape, oc.TopAbs_ShapeEnum.TopAbs_FACE);
+                for (const face of faces) {
+                    shapes.push(face);
+                }
+            }
+            else {
+                shapes.push(shape);
+            }
+            iterator.Next();
+        }
+        iterator.delete();
+        return shapes;
+    }
+    static getOcShapeType(type) {
+        const oc = getOC();
+        switch (type) {
+            case "edge":
+                return oc.TopAbs_ShapeEnum.TopAbs_EDGE;
+            case "wire":
+                return oc.TopAbs_ShapeEnum.TopAbs_WIRE;
+            case "face":
+                return oc.TopAbs_ShapeEnum.TopAbs_FACE;
+            case "solid":
+                return oc.TopAbs_ShapeEnum.TopAbs_SOLID;
+            case "vertex":
+                return oc.TopAbs_ShapeEnum.TopAbs_VERTEX;
+        }
+    }
+    static toSolid(shape) {
+        const oc = getOC();
+        return oc.TopoDS.Solid(shape);
+    }
+    static toFace(shape) {
+        const oc = getOC();
+        return oc.TopoDS.Face(shape);
+    }
+    static toWire(shape) {
+        const oc = getOC();
+        return oc.TopoDS.Wire(shape);
+    }
+    static toEdge(shape) {
+        const oc = getOC();
+        return oc.TopoDS.Edge(shape);
+    }
+    static toVertex(shape) {
+        const oc = getOC();
+        return oc.TopoDS.Vertex(shape);
+    }
+    static findFacesWrapped(shape) {
+        const oc = getOC();
+        const raw = Explorer.findShapes(shape.getShape(), oc.TopAbs_ShapeEnum.TopAbs_FACE);
+        return raw.map((f) => Face.fromTopoDSFace(Explorer.toFace(f)));
+    }
+    static findEdgesWrapped(shape) {
+        const oc = getOC();
+        const raw = Explorer.findShapes(shape.getShape(), oc.TopAbs_ShapeEnum.TopAbs_EDGE);
+        return raw.map((e) => Edge.fromTopoDSEdge(Explorer.toEdge(e)));
+    }
+    static findEdgesInWireOrderWrapped(wire) {
+        const oc = getOC();
+        const result = [];
+        const explorer = new oc.BRepTools_WireExplorer(wire.getShape());
+        while (explorer.More()) {
+            result.push(Edge.fromTopoDSEdge(Explorer.toEdge(explorer.Current())));
+            explorer.Next();
+        }
+        explorer.delete();
+        return result;
+    }
+    static findSolidsWrapped(shape) {
+        const oc = getOC();
+        const raw = Explorer.findShapes(shape.getShape(), oc.TopAbs_ShapeEnum.TopAbs_SOLID);
+        return raw.map((s) => Solid.fromTopoDSSolid(Explorer.toSolid(s)));
+    }
+    static findVerticesWrapped(shape) {
+        const oc = getOC();
+        const raw = Explorer.findShapes(shape.getShape(), oc.TopAbs_ShapeEnum.TopAbs_VERTEX);
+        return raw.map((e) => Vertex.fromTopoDSVertex(Explorer.toVertex(e)));
+    }
+    static findWiresWrapped(shape) {
+        const oc = getOC();
+        const raw = Explorer.findShapes(shape.getShape(), oc.TopAbs_ShapeEnum.TopAbs_WIRE);
+        return raw.map((w) => Wire.fromTopoDSWire(Explorer.toWire(w)));
+    }
+    static getShapeTypeFromWrapper(shape) {
+        return Explorer.getShapeType(shape.getShape());
+    }
+}

package/lib/dist/oc/extrude-ops.d.ts

@@ -0,0 +1,22 @@
+import type { TopoDS_Shape } from "occjs-wrapper";
+import { Vector3d } from "../math/vector3d.js";
+import { Plane } from "../math/plane.js";
+import { Axis } from "../math/axis.js";
+import { Shape } from "../common/shape.js";
+export declare class ExtrudeOps {
+    static makePrism(shape: Shape, direction: Vector3d, distance: number): Shape;
+    static makePrismFromVec(shape: Shape, vec: Vector3d): {
+        solid: Shape;
+        firstFace: Shape;
+        lastFace: Shape;
+    };
+    static makePrismInfinite(shape: Shape, direction: Vector3d): Shape;
+    static makePrismSymmetric(shape: Shape, direction: Vector3d): Shape;
+    static makeRevol(shape: Shape, axis: Axis, angle: number): Shape;
+    static applyDraftOnSideFaces(solid: Shape, firstFace: Shape, lastFace: Shape, plane: Plane, angle: number): {
+        solid: Shape;
+        firstFace: Shape;
+        lastFace: Shape;
+    };
+    static applyDraft(shape: TopoDS_Shape, direction: Vector3d, angle: number): TopoDS_Shape;
+}

package/lib/dist/oc/extrude-ops.js

@@ -0,0 +1,149 @@
+import { getOC } from "./init.js";
+import { Convert } from "./convert.js";
+import { Explorer } from "./explorer.js";
+import { ShapeFactory } from "../common/shape-factory.js";
+import { ShapeOps } from "./shape-ops.js";
+export class ExtrudeOps {
+    static makePrism(shape, direction, distance) {
+        const oc = getOC();
+        const [vec, disposeVec] = Convert.toGpVec(direction.multiply(distance));
+        const prism = new oc.BRepPrimAPI_MakePrism(shape.getShape(), vec, false, true);
+        const result = prism.Shape();
+        prism.delete();
+        disposeVec();
+        return ShapeFactory.fromShape(result);
+    }
+    static makePrismFromVec(shape, vec) {
+        const oc = getOC();
+        const [gpVec, disposeVec] = Convert.toGpVec(vec);
+        const prism = new oc.BRepPrimAPI_MakePrism(shape.getShape(), gpVec, true, true);
+        if (!prism.IsDone()) {
+            prism.delete();
+            disposeVec();
+            throw new Error("Extrusion failed");
+        }
+        const solid = prism.Shape();
+        const firstFace = prism.FirstShape();
+        const lastFace = prism.LastShape();
+        prism.delete();
+        disposeVec();
+        return {
+            solid: ShapeFactory.fromShape(solid),
+            firstFace: ShapeFactory.fromShape(firstFace),
+            lastFace: ShapeFactory.fromShape(lastFace),
+        };
+    }
+    static makePrismInfinite(shape, direction) {
+        const oc = getOC();
+        const [vec, disposeVec] = Convert.toGpVec(direction);
+        const prism = new oc.BRepPrimAPI_MakePrism(shape.getShape(), vec, true, true);
+        const result = prism.Shape();
+        prism.delete();
+        disposeVec();
+        return ShapeFactory.fromShape(result);
+    }
+    static makePrismSymmetric(shape, direction) {
+        const oc = getOC();
+        const [dir, disposeDir] = Convert.toGpDir(direction);
+        const prism = new oc.BRepPrimAPI_MakePrism(shape.getShape(), dir, true, false, true);
+        if (!prism.IsDone()) {
+            prism.delete();
+            disposeDir();
+            throw new Error("Symmetric extrusion failed");
+        }
+        const result = prism.Shape();
+        prism.delete();
+        disposeDir();
+        return ShapeFactory.fromShape(result);
+    }
+    static makeRevol(shape, axis, angle) {
+        const oc = getOC();
+        const [ax1, disposeAx1] = Convert.toGpAx1(axis);
+        const revol = new oc.BRepPrimAPI_MakeRevol(shape.getShape(), ax1, angle, true);
+        const result = revol.Shape();
+        revol.delete();
+        disposeAx1();
+        const clean = ShapeOps.cleanShapeRaw(result);
+        return ShapeFactory.fromShape(clean);
+    }
+    static applyDraftOnSideFaces(solid, firstFace, lastFace, plane, angle) {
+        const oc = getOC();
+        const [dir, disposeDir] = Convert.toGpDir(plane.normal);
+        const [pln, disposePln] = Convert.toGpPln(plane);
+        const solidRaw = solid.getShape();
+        const firstFaceRaw = firstFace.getShape();
+        const lastFaceRaw = lastFace.getShape();
+        const draftMaker = new oc.BRepOffsetAPI_DraftAngle(solidRaw);
+        const sideFaces = Explorer.findShapes(solidRaw, Explorer.getOcShapeType("face")).filter(f => !f.IsSame(firstFaceRaw) && !f.IsSame(lastFaceRaw));
+        for (const face of sideFaces) {
+            draftMaker.Add(Explorer.toFace(face), dir, angle, pln, true);
+        }
+        const progress = new oc.Message_ProgressRange();
+        draftMaker.Build(progress);
+        progress.delete();
+        if (!draftMaker.IsDone()) {
+            draftMaker.delete();
+            disposeDir();
+            disposePln();
+            throw new Error("Draft application failed");
+        }
+        const modifiedFirst = ShapeOps.shapeListToArray(draftMaker.Modified(firstFaceRaw));
+        const modifiedLast = ShapeOps.shapeListToArray(draftMaker.Modified(lastFaceRaw));
+        const newFirstFace = modifiedFirst.length > 0
+            ? ShapeFactory.fromShape(modifiedFirst[0])
+            : firstFace;
+        const newLastFace = modifiedLast.length > 0
+            ? ShapeFactory.fromShape(modifiedLast[0])
+            : lastFace;
+        const result = draftMaker.Shape();
+        draftMaker.delete();
+        disposeDir();
+        disposePln();
+        return {
+            solid: ShapeFactory.fromShape(result),
+            firstFace: newFirstFace,
+            lastFace: newLastFace,
+        };
+    }
+    static applyDraft(shape, direction, angle) {
+        const oc = getOC();
+        const [dir, disposeDir] = Convert.toGpDir(direction);
+        const draftMaker = new oc.BRepOffsetAPI_DraftAngle(shape);
+        const explorer = new oc.TopExp_Explorer(shape, oc.TopAbs_ShapeEnum.TopAbs_FACE, oc.TopAbs_ShapeEnum.TopAbs_SHAPE);
+        while (explorer.More()) {
+            const face = oc.TopoDS.Face(explorer.Current());
+            const adaptor = new oc.BRepAdaptor_Surface(face, true);
+            if (adaptor.GetType() !== oc.GeomAbs_SurfaceType.GeomAbs_Plane) {
+                adaptor.delete();
+                explorer.Next();
+                continue;
+            }
+            const facePlane = adaptor.Plane();
+            const faceNormal = facePlane.Axis().Direction();
+            const dot = Math.abs(faceNormal.Dot(dir));
+            faceNormal.delete();
+            adaptor.delete();
+            if (dot > 0.999) {
+                facePlane.delete();
+                explorer.Next();
+                continue;
+            }
+            draftMaker.Add(face, dir, angle, facePlane, true);
+            facePlane.delete();
+            explorer.Next();
+        }
+        explorer.delete();
+        const progress = new oc.Message_ProgressRange();
+        draftMaker.Build(progress);
+        progress.delete();
+        if (!draftMaker.IsDone()) {
+            draftMaker.delete();
+            disposeDir();
+            throw new Error("Draft operation failed");
+        }
+        const result = draftMaker.Shape();
+        draftMaker.delete();
+        disposeDir();
+        return result;
+    }
+}

package/lib/dist/oc/face-maker.d.ts

@@ -0,0 +1,14 @@
+import type { TopoDS_Compound, gp_Pln, TopoDS_Face, TopoDS_Wire } from "occjs-wrapper";
+import type { BoundingBox, FaceInfo } from "../helpers/types.js";
+export declare class OcFaceMaker {
+    static createFacesFromWires(wires: TopoDS_Wire[], gpPln: gp_Pln): TopoDS_Face[];
+    static fuseIntersectingFaces(faces: TopoDS_Face[]): TopoDS_Face[];
+    static unifyFaces(facesCompound: TopoDS_Compound): TopoDS_Face;
+    static boundingBoxesIntersect(bbox1: BoundingBox, bbox2: BoundingBox): boolean;
+    static getWiresFromFaces(faces: TopoDS_Face[]): TopoDS_Wire[];
+    static drillHoles(faceInfos: FaceInfo[]): FaceInfo[];
+    private static getFaceHoles;
+    private static wireIsInsideFace;
+    private static getFirstPointOfWire;
+    private static hitTest;
+}