fluidcad 0.0.21 → 0.0.23

package/lib/dist/filters/filter-builder-base.js

@@ -13,12 +13,21 @@ export class FilterBuilderBase {
         this._withTangents = true;
         return this;
     }
+    /**
+      * @internal
+    */
     hasTangentExpansion() {
         return this._withTangents;
     }
+    /**
+      * @internal
+    */
     getFilters() {
         return this.filters;
     }
+    /**
+      * @internal
+    */
     transform(matrix) {
         const transformedBuilder = new FilterBuilderBase();
         for (const filter of this.filters) {
@@ -27,6 +36,9 @@ export class FilterBuilderBase {
         transformedBuilder._withTangents = this._withTangents;
         return transformedBuilder;
     }
+    /**
+      * @internal
+    */
     equals(other) {
         if (this._withTangents !== other._withTangents) {
             return false;

package/lib/dist/helpers/clone-transform.js

@@ -34,6 +34,9 @@ export function cloneWithTransform(objects, transform, container) {
         remap.set(obj, copy);
         copy.setTransform(transform);
         copy.setCloneSource(obj);
+        if (obj.isReusable()) {
+            copy.reusable();
+        }
         allCloned.push(copy);
         const parent = obj.getParent();
         if (parent && remap.has(parent)) {

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

@@ -0,0 +1,5 @@
+import type { TopoDS_Shape } from "occjs-wrapper";
+import { Shape } from "../common/shape.js";
+export declare class DraftOps {
+    static applyDraft(solid: Shape, faceRaws: TopoDS_Shape[], angle: number): Shape;
+}

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

@@ -0,0 +1,51 @@
+import { getOC } from "./init.js";
+import { Convert } from "./convert.js";
+import { ShapeFactory } from "../common/shape-factory.js";
+import { ShapeOps } from "./shape-ops.js";
+import { Vector3d } from "../math/vector3d.js";
+import { Plane } from "../math/plane.js";
+import { Point } from "../math/point.js";
+export class DraftOps {
+    static applyDraft(solid, faceRaws, angle) {
+        const oc = getOC();
+        const solidRaw = solid.getShape();
+        const bbox = ShapeOps.getBoundingBox(solid);
+        const neutralPlane = new Plane(new Point(0, 0, bbox.minZ), new Vector3d(1, 0, 0), new Vector3d(0, 0, 1));
+        const [dir, disposeDir] = Convert.toGpDir(neutralPlane.normal);
+        const [pln, disposePln] = Convert.toGpPln(neutralPlane);
+        try {
+            const draftMaker = new oc.BRepOffsetAPI_DraftAngle(solidRaw);
+            let addedCount = 0;
+            const explorer = new oc.TopExp_Explorer(solidRaw, oc.TopAbs_ShapeEnum.TopAbs_FACE, oc.TopAbs_ShapeEnum.TopAbs_SHAPE);
+            while (explorer.More()) {
+                const currentShape = explorer.Current();
+                const isSelected = faceRaws.some(sel => sel.IsSame(currentShape));
+                if (isSelected) {
+                    const face = oc.TopoDS.Face(currentShape);
+                    draftMaker.Add(face, dir, -angle, pln, true);
+                    addedCount++;
+                }
+                explorer.Next();
+            }
+            explorer.delete();
+            if (addedCount === 0) {
+                draftMaker.delete();
+                return null;
+            }
+            const progress = new oc.Message_ProgressRange();
+            draftMaker.Build(progress);
+            progress.delete();
+            if (!draftMaker.IsDone()) {
+                draftMaker.delete();
+                throw new Error("Failed to apply draft angle.");
+            }
+            const result = draftMaker.Shape();
+            draftMaker.delete();
+            return ShapeFactory.fromShape(result);
+        }
+        finally {
+            disposeDir();
+            disposePln();
+        }
+    }
+}

package/lib/dist/oc/edge-query.d.ts

@@ -1,4 +1,4 @@
-import type { gp_Pln, gp_Vec, TopoDS_Edge, TopoDS_Shape } from "occjs-wrapper";
+import type { gp_Pln, gp_Vec, TopoDS_Edge, TopoDS_Face, TopoDS_Shape } from "occjs-wrapper";
 import { Point } from "../math/point.js";
 import { Vector3d } from "../math/vector3d.js";
 import { Plane } from "../math/plane.js";
@@ -23,6 +23,8 @@ export declare class EdgeQuery {
         radius: number;
         axisDirection: Vector3d;
     };
+    static doEdgesIntersect(edge1: Edge, edge2: Edge): boolean;
+    static doesEdgeIntersectPlane(edge: Edge, plane: Plane): boolean;
     static isCircleEdgeRaw(edge: TopoDS_Shape, diameter?: number): boolean;
     static isArcEdgeRaw(edge: TopoDS_Shape, radius?: number): boolean;
     static isLineEdgeRaw(edge: TopoDS_Shape, length?: number): boolean;
@@ -41,4 +43,6 @@ export declare class EdgeQuery {
         radius: number;
         axisDirection: Vector3d;
     };
+    static doEdgesIntersectRaw(edge1: TopoDS_Edge, edge2: TopoDS_Edge): boolean;
+    static doesEdgeIntersectPlaneRaw(edge: TopoDS_Edge, face: TopoDS_Face): boolean;
 }

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

@@ -1,5 +1,6 @@
 import { getOC } from "./init.js";
 import { Convert } from "./convert.js";
+import { FaceOps } from "./face-ops.js";
 import { Point } from "../math/point.js";
 import { Vector3d } from "../math/vector3d.js";
 export class EdgeQuery {
@@ -46,6 +47,17 @@ export class EdgeQuery {
     static getCircleDataFromEdge(edge) {
         return EdgeQuery.getCircleDataFromEdgeRaw(edge.getShape());
     }
+    static doEdgesIntersect(edge1, edge2) {
+        return EdgeQuery.doEdgesIntersectRaw(edge1.getShape(), edge2.getShape());
+    }
+    static doesEdgeIntersectPlane(edge, plane) {
+        const [gpPln, dispose] = Convert.toGpPln(plane);
+        const face = FaceOps.makeFaceFromPlane2(gpPln);
+        const result = EdgeQuery.doesEdgeIntersectPlaneRaw(edge.getShape(), face);
+        face.delete();
+        dispose();
+        return result;
+    }
     // Raw methods (for oc-internal and common/ use)
     static isCircleEdgeRaw(edge, diameter) {
         const oc = getOC();
@@ -241,4 +253,32 @@ export class EdgeQuery {
         curve.delete();
         return result;
     }
+    static doEdgesIntersectRaw(edge1, edge2) {
+        const oc = getOC();
+        const tool = new oc.IntTools_EdgeEdge(edge1, edge2);
+        tool.Perform();
+        let intersects = false;
+        if (tool.IsDone()) {
+            const parts = tool.CommonParts();
+            intersects = parts.Length() > 0;
+            parts.delete();
+        }
+        tool.delete();
+        return intersects;
+    }
+    static doesEdgeIntersectPlaneRaw(edge, face) {
+        const oc = getOC();
+        const tool = new oc.IntTools_EdgeFace();
+        tool.SetEdge(edge);
+        tool.SetFace(face);
+        tool.Perform();
+        let intersects = false;
+        if (tool.IsDone()) {
+            const parts = tool.CommonParts();
+            intersects = parts.Length() > 0;
+            parts.delete();
+        }
+        tool.delete();
+        return intersects;
+    }
 }

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

@@ -10,6 +10,8 @@ export interface MeshData {
 export declare class Mesh {
     static triangulateFace(face: Face, vertexOffset?: number): MeshData | null;
     static discretizeEdge(edge: Shape): MeshData;
+    static premeshShape(shape: TopoDS_Shape): void;
     static triangulateFaceRaw(face: TopoDS_Face, vertexOffset?: number): MeshData | null;
+    static extractFaceTriangulationRaw(face: TopoDS_Face, vertexOffset?: number): MeshData | null;
     static discretizeEdgeRaw(edge: TopoDS_Shape): MeshData;
 }

package/lib/dist/oc/mesh.js

@@ -7,12 +7,14 @@ export class Mesh {
     static discretizeEdge(edge) {
         return Mesh.discretizeEdgeRaw(edge.getShape());
     }
+    static premeshShape(shape) {
+        const oc = getOC();
+        const inc = new oc.BRepMesh_IncrementalMesh(shape, 0.3, false, 0.3, true);
+        inc.delete();
+    }
     // Raw methods (for oc-internal use)
     static triangulateFaceRaw(face, vertexOffset = 0) {
         const oc = getOC();
-        const vertices = [];
-        const normals = [];
-        const indices = [];
         let inc;
         try {
             inc = new oc.BRepMesh_IncrementalMesh(face, 0.3, false, 0.3, true);
@@ -21,12 +23,19 @@ export class Mesh {
             console.error("Face mesh failed", e);
             return null;
         }
+        inc.delete();
+        return Mesh.extractFaceTriangulationRaw(face, vertexOffset);
+    }
+    static extractFaceTriangulationRaw(face, vertexOffset = 0) {
+        const oc = getOC();
+        const vertices = [];
+        const normals = [];
+        const indices = [];
         const aLocation = new oc.TopLoc_Location();
         const myT = oc.BRep_Tool.Triangulation(face, aLocation, 0);
         if (myT.IsNull()) {
             aLocation.delete();
-            inc.delete();
-            throw new Error("No triangulation for face");
+            return null;
         }
         const pc = new oc.Poly_Connect(myT);
         const triangulation = myT.get();
@@ -69,7 +78,6 @@ export class Mesh {
         triangles.delete();
         myT.delete();
         aLocation.delete();
-        inc.delete();
         return { vertices, normals, indices, count: nbNodes };
     }
     static discretizeEdgeRaw(edge) {

package/lib/dist/rendering/mesh-transform.d.ts

@@ -0,0 +1,3 @@
+import { SceneObjectMesh } from "./scene.js";
+import { Matrix4 } from "../math/matrix4.js";
+export declare function transformMeshes(meshes: SceneObjectMesh[], matrix: Matrix4): SceneObjectMesh[];

package/lib/dist/rendering/mesh-transform.js

@@ -0,0 +1,22 @@
+export function transformMeshes(meshes, matrix) {
+    const m = matrix.elements;
+    return meshes.map(mesh => {
+        const srcV = mesh.vertices;
+        const srcN = mesh.normals;
+        const newV = new Array(srcV.length);
+        const newN = new Array(srcN.length);
+        for (let i = 0; i < srcV.length; i += 3) {
+            const x = srcV[i], y = srcV[i + 1], z = srcV[i + 2];
+            newV[i] = m[0] * x + m[4] * y + m[8] * z + m[12];
+            newV[i + 1] = m[1] * x + m[5] * y + m[9] * z + m[13];
+            newV[i + 2] = m[2] * x + m[6] * y + m[10] * z + m[14];
+        }
+        for (let i = 0; i < srcN.length; i += 3) {
+            const nx = srcN[i], ny = srcN[i + 1], nz = srcN[i + 2];
+            newN[i] = m[0] * nx + m[4] * ny + m[8] * nz;
+            newN[i + 1] = m[1] * nx + m[5] * ny + m[9] * nz;
+            newN[i + 2] = m[2] * nx + m[6] * ny + m[10] * nz;
+        }
+        return { ...mesh, vertices: newV, normals: newN };
+    });
+}

package/lib/dist/rendering/render-solid.js

@@ -1,7 +1,8 @@
-import { renderFace } from "./render-face.js";
 import { renderEdge } from "./render-edge.js";
 import { Explorer } from "../oc/explorer.js";
+import { Mesh } from "../oc/mesh.js";
 export function renderSolid(shapeObj) {
+    Mesh.premeshShape(shapeObj.getShape());
     const facesMeshes = getFacesMesh(shapeObj);
     const edgesMesh = getEdgesMesh(shapeObj);
     return [...facesMeshes, ...edgesMesh];
@@ -25,7 +26,7 @@ function getFacesMesh(shapeObj) {
     for (let faceIdx = 0; faceIdx < faces.length; faceIdx++) {
         const face = faces[faceIdx];
         const color = shapeObj.getColor(face.getShape());
-        const faceResult = renderFace(face, 0);
+        const faceResult = Mesh.extractFaceTriangulationRaw(face.getShape(), 0);
         if (faceResult) {
             if (!groups.has(color)) {
                 groups.set(color, { vertices: [], normals: [], indices: [], faceMapping: [], vertexOffset: 0 });

package/lib/dist/rendering/render.js

@@ -2,6 +2,7 @@ import { MeshBuilder } from "./mesh-builder.js";
 import { PlaneObjectBase } from "../features/plane-renderable-base.js";
 import { AxisObjectBase } from "../features/axis-renderable-base.js";
 import { Sketch } from "../features/2d/sketch.js";
+import { transformMeshes } from "./mesh-transform.js";
 const meshBuilder = new MeshBuilder();
 function renderSceneObject(obj, scene, buildDurationMs) {
     const hasError = !!obj.getError();
@@ -12,7 +13,18 @@ function renderSceneObject(obj, scene, buildDurationMs) {
         for (const shape of sceneShapes) {
             let meshes = shape.getMeshes();
             if (!meshes) {
-                meshes = meshBuilder.build(shape);
+                const meshSource = shape.getMeshSource();
+                if (meshSource) {
+                    let sourceMeshes = meshSource.shape.getMeshes();
+                    if (!sourceMeshes) {
+                        sourceMeshes = meshBuilder.build(meshSource.shape);
+                        meshSource.shape.setMeshes(sourceMeshes);
+                    }
+                    meshes = sourceMeshes ? transformMeshes(sourceMeshes, meshSource.matrix) : meshBuilder.build(shape);
+                }
+                else {
+                    meshes = meshBuilder.build(shape);
+                }
                 shape.setMeshes(meshes);
             }
             const shapeType = shape.getType();
@@ -71,7 +83,18 @@ export function renderSceneRollback(scene, rollbackIndex) {
             for (const shape of sceneShapes) {
                 let meshes = shape.getMeshes();
                 if (!meshes) {
-                    meshes = meshBuilder.build(shape);
+                    const meshSource = shape.getMeshSource();
+                    if (meshSource) {
+                        let sourceMeshes = meshSource.shape.getMeshes();
+                        if (!sourceMeshes) {
+                            sourceMeshes = meshBuilder.build(meshSource.shape);
+                            meshSource.shape.setMeshes(sourceMeshes);
+                        }
+                        meshes = sourceMeshes ? transformMeshes(sourceMeshes, meshSource.matrix) : meshBuilder.build(shape);
+                    }
+                    else {
+                        meshes = meshBuilder.build(shape);
+                    }
                     shape.setMeshes(meshes);
                 }
                 renderedSceneShapes.push({
@@ -184,8 +207,9 @@ export function renderScene(scene) {
             }
             buildDurations.set(object, performance.now() - buildStart);
         }
-        // After building, mark cloned sketches so their children are skipped
-        if (object instanceof Sketch && object.getState('cloned-edges')) {
+        // After building, mark cloned sketches so their children are skipped —
+        // the sketch's build() already populated them with transformed shapes.
+        if (object instanceof Sketch && object.getCloneSource()) {
             skippedContainers.add(object);
         }
     }
@@ -219,7 +243,5 @@ export function renderScene(scene) {
     for (const object of sceneObjects) {
         renderSceneObject(object, scene, buildDurations.get(object));
     }
-    const result = scene.getRenderedObjects();
-    console.table(result);
     return scene;
 }

package/lib/dist/tests/features/chamfer.test.js

@@ -104,7 +104,7 @@ describe("chamfer", () => {
                 rect(100, 50);
             });
             extrude(30);
-            const sel = select(edge().onPlane("xy", 30));
+            const sel = select(edge().onPlane("xy", { offset: 30 }));
             chamfer(3, sel);
             render();
             const solid = render().getAllSceneObjects()

package/lib/dist/tests/features/draft.test.d.ts

@@ -0,0 +1 @@
+export {};

package/lib/dist/tests/features/draft.test.js

@@ -0,0 +1,147 @@
+import { describe, it, expect } from "vitest";
+import { setupOC, render } from "../setup.js";
+import sketch from "../../core/sketch.js";
+import extrude from "../../core/extrude.js";
+import draft from "../../core/draft.js";
+import select from "../../core/select.js";
+import { rect } from "../../core/2d/index.js";
+import { countShapes } from "../utils.js";
+import { ShapeOps } from "../../oc/shape-ops.js";
+import { ShapeProps } from "../../oc/props.js";
+import { face } from "../../filters/index.js";
+describe("draft", () => {
+    setupOC();
+    describe("draft with implicit selection", () => {
+        it("should apply draft to the last selected face", () => {
+            sketch("xy", () => {
+                rect(100, 100);
+            });
+            extrude(80);
+            select(face().onPlane("front"));
+            draft(5);
+            const scene = render();
+            expect(countShapes(scene)).toBe(1);
+            const solid = scene.getAllSceneObjects()
+                .flatMap(o => o.getShapes())
+                .find(s => s.getType() === "solid");
+            expect(solid).toBeDefined();
+        });
+        it("should change the bounding box when drafting a side face", () => {
+            sketch("xy", () => {
+                rect(100, 100);
+            });
+            extrude(80);
+            select(face().onPlane("front"));
+            draft(5);
+            const scene = render();
+            const solid = scene.getAllSceneObjects()
+                .flatMap(o => o.getShapes())
+                .find(s => s.getType() === "solid");
+            const bbox = ShapeOps.getBoundingBox(solid);
+            // 5 deg draft over 80mm height: tan(5°) * 80 ≈ 7mm extension
+            expect(bbox.maxY - bbox.minY).toBeGreaterThan(103);
+        });
+        it("should change volume compared to original box", () => {
+            sketch("xy", () => {
+                rect(100, 100);
+            });
+            extrude(80);
+            select(face().onPlane("front"));
+            draft(5);
+            const scene = render();
+            const solid = scene.getAllSceneObjects()
+                .flatMap(o => o.getShapes())
+                .find(s => s.getType() === "solid");
+            const props = ShapeProps.getProperties(solid.getShape());
+            const originalVolume = 100 * 100 * 80;
+            expect(Math.abs(props.volumeMm3 - originalVolume)).toBeGreaterThan(1000);
+        });
+    });
+    describe("draft with explicit selection", () => {
+        it("should apply draft using e.sideFaces()", () => {
+            sketch("xy", () => {
+                rect(100, 100);
+            });
+            const e = extrude(80);
+            draft(5, e.sideFaces());
+            const scene = render();
+            expect(countShapes(scene)).toBe(1);
+            const solid = scene.getAllSceneObjects()
+                .flatMap(o => o.getShapes())
+                .find(s => s.getType() === "solid");
+            expect(solid).toBeDefined();
+        });
+        it("should apply draft using explicit select()", () => {
+            sketch("xy", () => {
+                rect(100, 100);
+            });
+            extrude(80);
+            const sel = select(face().onPlane("front"));
+            draft(5, sel);
+            const scene = render();
+            expect(countShapes(scene)).toBe(1);
+        });
+    });
+    describe("draft angle effect", () => {
+        it("should produce larger extension with 10 degrees than 3 degrees", () => {
+            sketch("xy", () => {
+                rect(100, 100);
+            });
+            extrude(80);
+            select(face().onPlane("front"));
+            draft(10);
+            const scene = render();
+            const solid = scene.getAllSceneObjects()
+                .flatMap(o => o.getShapes())
+                .find(s => s.getType() === "solid");
+            const bbox = ShapeOps.getBoundingBox(solid);
+            // tan(10°) * 80 ≈ 14.1mm
+            expect(bbox.maxY - bbox.minY).toBeGreaterThan(110);
+        });
+        it("should produce smaller extension with 3 degrees", () => {
+            sketch("xy", () => {
+                rect(100, 100);
+            });
+            extrude(80);
+            select(face().onPlane("front"));
+            draft(3);
+            const scene = render();
+            const solid = scene.getAllSceneObjects()
+                .flatMap(o => o.getShapes())
+                .find(s => s.getType() === "solid");
+            const bbox = ShapeOps.getBoundingBox(solid);
+            // tan(3°) * 80 ≈ 4.2mm
+            expect(bbox.maxY - bbox.minY).toBeGreaterThan(103);
+            expect(bbox.maxY - bbox.minY).toBeLessThan(110);
+        });
+    });
+    describe("draft removes selection shapes", () => {
+        it("should remove the face selection after drafting", () => {
+            sketch("xy", () => {
+                rect(100, 100);
+            });
+            extrude(80);
+            const sel = select(face().onPlane("front"));
+            draft(5, sel);
+            render();
+            expect(sel.getShapes()).toHaveLength(0);
+        });
+    });
+    describe("draft on multiple faces", () => {
+        it("should draft all four side faces via sideFaces()", () => {
+            sketch("xy", () => {
+                rect(100, 100);
+            });
+            const e = extrude(80);
+            draft(5, e.sideFaces());
+            const scene = render();
+            const solid = scene.getAllSceneObjects()
+                .flatMap(o => o.getShapes())
+                .find(s => s.getType() === "solid");
+            const bbox = ShapeOps.getBoundingBox(solid);
+            // All four sides drafted — bounding box should extend in both X and Y
+            expect(bbox.maxX - bbox.minX).toBeGreaterThan(103);
+            expect(bbox.maxY - bbox.minY).toBeGreaterThan(103);
+        });
+    });
+});

package/lib/dist/tests/features/fillet.test.js

@@ -106,7 +106,7 @@ describe("fillet", () => {
             });
             extrude(30);
             // Fillet only the top horizontal edges (4 edges)
-            const sel = select(edge().onPlane("xy", 30));
+            const sel = select(edge().onPlane("xy", { offset: 30 }));
             fillet(3, sel);
             render();
             const solid = render().getAllSceneObjects()