fluidcad 0.0.15 → 0.0.16

package/lib/dist/oc/thin-face-maker.js

@@ -3,6 +3,7 @@ import { Face } from "../common/face.js";
 import { Wire } from "../common/wire.js";
 import { WireOps } from "./wire-ops.js";
 import { FaceOps } from "./face-ops.js";
+import { EdgeOps } from "./edge-ops.js";
 import { Explorer } from "./explorer.js";
 import { Convert } from "./convert.js";
 import { getOC } from "./init.js";
@@ -21,17 +22,25 @@ export class ThinFaceMaker {
         }
         const groups = WireOps.groupConnectedEdges(edgesOnly);
         const faces = [];
+        const inwardEdges = [];
+        const outwardEdges = [];
         for (const group of groups) {
             const wire = WireOps.makeWireFromEdges(group);
             const isClosed = wire.isClosed();
             if (offset2 !== undefined) {
-                faces.push(this.makeDualOffsetFace(wire, isClosed, plane, offset1, offset2));
+                const result = this.makeDualOffsetFace(wire, isClosed, plane, offset1, offset2);
+                faces.push(result.face);
+                inwardEdges.push(...result.inwardEdges);
+                outwardEdges.push(...result.outwardEdges);
             }
             else {
-                faces.push(this.makeSingleOffsetFace(wire, isClosed, plane, offset1));
+                const result = this.makeSingleOffsetFace(wire, isClosed, plane, offset1);
+                faces.push(result.face);
+                inwardEdges.push(...result.inwardEdges);
+                outwardEdges.push(...result.outwardEdges);
             }
         }
-        return faces;
+        return { faces, inwardEdges, outwardEdges };
     }
     static makeSingleOffsetFace(wire, isClosed, plane, offset) {
         const offsetWire = this.doOffset(wire, plane, offset, isClosed);
@@ -41,12 +50,22 @@ export class ThinFaceMaker {
                 ? [offsetWire, wire]
                 : [wire, offsetWire];
             const reversedInner = WireOps.reverseWire(inner);
-            return Face.fromTopoDSFace(FaceOps.makeFaceFromWires([
-                outer.getShape(),
-                reversedInner.getShape(),
-            ]));
+            return {
+                face: Face.fromTopoDSFace(FaceOps.makeFaceFromWires([
+                    outer.getShape(),
+                    reversedInner.getShape(),
+                ])),
+                inwardEdges: [],
+                outwardEdges: [],
+            };
         }
-        return this.makeOpenFaceWithCaps(wire, offsetWire);
+        // For open profiles: positive offset goes inward (toward profile interior)
+        const inwardWireEdges = offset >= 0 ? offsetWire.getEdges() : wire.getEdges();
+        const outwardWireEdges = offset >= 0 ? wire.getEdges() : offsetWire.getEdges();
+        const face = this.makeOpenFaceWithCaps(wire, offsetWire);
+        const inwardEdges = this.matchFaceEdgesByMidpoint(face, inwardWireEdges);
+        const outwardEdges = this.matchFaceEdgesByMidpoint(face, outwardWireEdges);
+        return { face, inwardEdges, outwardEdges };
     }
     static makeDualOffsetFace(wire, isClosed, plane, offset1, offset2) {
         // Ensure offset2 goes in the opposite direction of offset1
@@ -61,12 +80,22 @@ export class ThinFaceMaker {
                 ? [wire1, wire2]
                 : [wire2, wire1];
             const reversedInner = WireOps.reverseWire(inner);
-            return Face.fromTopoDSFace(FaceOps.makeFaceFromWires([
-                outer.getShape(),
-                reversedInner.getShape(),
-            ]));
+            return {
+                face: Face.fromTopoDSFace(FaceOps.makeFaceFromWires([
+                    outer.getShape(),
+                    reversedInner.getShape(),
+                ])),
+                inwardEdges: [],
+                outwardEdges: [],
+            };
         }
-        return this.makeOpenFaceWithCaps(wire1, wire2);
+        // For open profiles: positive offset goes inward (toward profile interior)
+        const inwardWireEdges = offset1 > 0 ? wire1.getEdges() : wire2.getEdges();
+        const outwardWireEdges = offset1 > 0 ? wire2.getEdges() : wire1.getEdges();
+        const face = this.makeOpenFaceWithCaps(wire1, wire2);
+        const inwardEdges = this.matchFaceEdgesByMidpoint(face, inwardWireEdges);
+        const outwardEdges = this.matchFaceEdgesByMidpoint(face, outwardWireEdges);
+        return { face, inwardEdges, outwardEdges };
     }
     /**
      * Offsets a wire by the given distance, handling both closed and open wires.
@@ -121,6 +150,18 @@ export class ThinFaceMaker {
         }
         return Wire.fromTopoDSWire(oc.TopoDS.Wire(wires[0]));
     }
+    /**
+     * Finds face edges that geometrically match the given wire edges by comparing midpoints.
+     * This is needed because wire reversal (ShapeExtend_WireData.Reverse) creates new TShapes,
+     * breaking IsPartner identity between original wire edges and face edges.
+     */
+    static matchFaceEdgesByMidpoint(face, wireEdges) {
+        const wireMidpoints = wireEdges.map(we => EdgeOps.getEdgeMidPointRaw(we.getShape()));
+        return face.getEdges().filter(fe => {
+            const feMid = EdgeOps.getEdgeMidPointRaw(fe.getShape());
+            return wireMidpoints.some(mp => feMid.distanceTo(mp) < 1e-4);
+        });
+    }
     static makeLineEdge(p1, p2) {
         const oc = getOC();
         const [gp1, dispose1] = Convert.toGpPnt(p1);

package/lib/dist/rendering/scene.js

@@ -10,15 +10,16 @@ export class Scene {
     constructor() {
     }
     addSceneObject(obj) {
+        if (this.sceneObjects.includes(obj)) {
+            return;
+        }
         obj.setOrder(this.sceneObjects.length);
         const activeObj = this.getActiveContainer();
         if (activeObj && !obj.getParent()) {
             activeObj.addChildObject(obj);
         }
-        if (!this.sceneObjects.includes(obj)) {
-            this.sceneObjects.push(obj);
-            this.idMap.set(obj.id, obj);
-        }
+        this.sceneObjects.push(obj);
+        this.idMap.set(obj.id, obj);
     }
     startProgressiveContainer(obj) {
         this.addSceneObject(obj);

package/lib/dist/tests/features/extrude-two-distances.test.js

@@ -213,6 +213,22 @@ describe("extrude two distances", () => {
             expect(bbox.maxX - bbox.minX).toBeGreaterThan(100);
             expect(bbox.maxY - bbox.minY).toBeGreaterThan(50);
         });
+        it("should apply different draft angles per direction", () => {
+            sketch("xy", () => {
+                rect(100, 50);
+            });
+            const e = extrude(20, 20).draft([8, 2]);
+            render();
+            const startFaces = e.getState('start-faces');
+            const endFaces = e.getState('end-faces');
+            const startBbox = ShapeOps.getBoundingBox(startFaces[0].getShape());
+            const endBbox = ShapeOps.getBoundingBox(endFaces[0].getShape());
+            const startWidth = startBbox.maxX - startBbox.minX;
+            const endWidth = endBbox.maxX - endBbox.minX;
+            // Start face (distance1=20, draft=8°) should be wider than
+            // end face (distance2=20, draft=2°) due to greater taper
+            expect(startWidth).toBeGreaterThan(endWidth);
+        });
     });
     describe("drill", () => {
         it("should drill hole when inner shape is nested (default)", () => {

package/lib/dist/tests/features/repeat-circular.test.js

@@ -40,6 +40,18 @@ describe("repeat circular", () => {
         // Original (1) + 2 repeated = 3
         expect(countShapes(scene)).toBe(3);
     });
+    it("should evenly space 3 instances around full circle", () => {
+        sketch("xy", () => {
+            move([50, 0]);
+            rect(20, 20);
+        });
+        const e = extrude(10).new();
+        // count: 3, angle: 360 → 120° apart
+        repeat("circular", "z", { count: 3, angle: 360 }, e);
+        const scene = render();
+        // Original (1) + 2 repeated = 3
+        expect(countShapes(scene)).toBe(3);
+    });
     it("should use explicit offset between instances", () => {
         sketch("xy", () => {
             move([50, 0]);

package/lib/dist/tests/features/repeat-linear.test.js

@@ -89,6 +89,28 @@ describe("repeat linear", () => {
         // Original (1) + 4 repeated = 5
         expect(countShapes(scene)).toBe(5);
     });
+    it("should center correctly with count 3", () => {
+        sketch("xy", () => {
+            rect(20, 20);
+        });
+        const e = extrude(10).new();
+        // count: 3, centered → one clone on each side of the original
+        repeat("linear", "x", { count: 3, offset: 25, centered: true }, e);
+        const scene = render();
+        // Original (1) + 2 repeated = 3
+        expect(countShapes(scene)).toBe(3);
+    });
+    it("should center correctly in a multi-axis grid", () => {
+        sketch("xy", () => {
+            rect(10, 10);
+        });
+        const e = extrude(10).new();
+        // 3×3 centered grid → 9 positions, 1 is the center (original) = 8 clones
+        repeat("linear", ["x", "y"], { count: [3, 3], offset: 30, centered: true }, e);
+        const scene = render();
+        // Original (1) + 8 repeated = 9
+        expect(countShapes(scene)).toBe(9);
+    });
     it("should skip specified index", () => {
         sketch("xy", () => {
             rect(20, 20);

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

@@ -631,4 +631,59 @@ describe("select", () => {
             expect(sel.getShapes()).toHaveLength(1);
         });
     });
+    describe("withTangents", () => {
+        describe("face withTangents", () => {
+            it("should expand to tangent side faces but not perpendicular top/bottom", () => {
+                sketch("xy", () => {
+                    rect(200, 100).radius(10);
+                });
+                extrude(50);
+                // "front" = XZ plane (y=0). Matches one flat side face.
+                // withTangents should follow cylindrical fillets to adjacent side faces,
+                // but NOT cross to top/bottom faces (90° angle = not tangent).
+                const sel = select(face().onPlane("front").withTangents());
+                render();
+                const shapes = sel.getShapes();
+                // Rounded rect extrusion has:
+                // - 2 cap faces (top/bottom on XY planes)
+                // - 4 flat side faces
+                // - 4 cylindrical fillet faces connecting adjacent sides
+                // Total = 10 faces
+                //
+                // Starting from front face, tangent expansion should include:
+                // 4 flat side faces + 4 cylindrical fillet faces = 8
+                // (NOT the 2 cap faces which meet at 90°)
+                expect(shapes.length).toBe(8);
+            });
+            it("should not expand when no tangent neighbors exist (sharp box)", () => {
+                sketch("xy", () => {
+                    rect(100, 50);
+                });
+                extrude(30);
+                // Sharp box: all edges are 90° → no tangent expansion
+                const sel = select(face().onPlane("front").withTangents());
+                render();
+                // Should still be just the 1 front face
+                expect(sel.getShapes()).toHaveLength(1);
+            });
+        });
+        describe("edge withTangents", () => {
+            it("should expand to tangent edges along a filleted box bottom", () => {
+                sketch("xy", () => {
+                    rect(200, 100).radius(10);
+                });
+                extrude(50);
+                // Bottom edges on XY plane: 4 line edges + 4 arc edges = 8 edges
+                // All are tangent-connected (line→arc→line→arc→...)
+                // Selecting one line edge on "front" plane + withTangents should get all 8
+                const sel = select(edge().onPlane("xy").onPlane("front").withTangents());
+                render();
+                const shapes = sel.getShapes();
+                // The front-bottom edge is tangent to the 2 corner arcs,
+                // which are tangent to the left/right bottom edges, etc.
+                // All 8 bottom edges form a tangent chain.
+                expect(shapes.length).toBe(8);
+            });
+        });
+    });
 });

package/lib/dist/tests/features/thin-extrude.test.js

@@ -19,6 +19,15 @@ describe("thin extrude", () => {
             const bbox = ShapeOps.getBoundingBox(shapes[0]);
             expect(bbox.maxZ - bbox.minZ).toBeCloseTo(30, 0);
         });
+        it("should still classify internal faces for closed profile", () => {
+            sketch("xy", () => {
+                rect(100, 100);
+            });
+            const e = extrude(30).thin(5);
+            render();
+            const internalFaces = e.getState('internal-faces');
+            expect(internalFaces.length).toBeGreaterThan(0);
+        });
         it("should create a thin-walled solid with dual offset", () => {
             sketch("xy", () => {
                 rect(100, 100);
@@ -103,6 +112,58 @@ describe("thin extrude", () => {
             expect(shapes).toHaveLength(1);
             expect(shapes[0].getType()).toBe('solid');
         });
+        it("should classify side, internal, and cap faces for positive offset", () => {
+            sketch("xy", () => {
+                line([0, 0], [100, 0]);
+            });
+            const e = extrude(20).thin(10).new();
+            render();
+            const sideFaces = e.getState('side-faces');
+            const internalFaces = e.getState('internal-faces');
+            const capFaces = e.getState('cap-faces');
+            expect(sideFaces.length).toBeGreaterThan(0);
+            expect(internalFaces.length).toBeGreaterThan(0);
+            expect(capFaces.length).toBe(2);
+        });
+        it("should classify side, internal, and cap faces for negative offset", () => {
+            sketch("xy", () => {
+                line([0, 0], [100, 0]);
+            });
+            const e = extrude(20).thin(-10).new();
+            render();
+            const sideFaces = e.getState('side-faces');
+            const internalFaces = e.getState('internal-faces');
+            const capFaces = e.getState('cap-faces');
+            expect(sideFaces.length).toBeGreaterThan(0);
+            expect(internalFaces.length).toBeGreaterThan(0);
+            expect(capFaces.length).toBe(2);
+        });
+        it("should classify side, internal, and cap faces for dual offset", () => {
+            sketch("xy", () => {
+                line([0, 0], [100, 0]);
+            });
+            const e = extrude(20).thin(5, -10).new();
+            render();
+            const sideFaces = e.getState('side-faces');
+            const internalFaces = e.getState('internal-faces');
+            const capFaces = e.getState('cap-faces');
+            expect(sideFaces.length).toBeGreaterThan(0);
+            expect(internalFaces.length).toBeGreaterThan(0);
+            expect(capFaces.length).toBe(2);
+        });
+        it("should classify faces correctly with symmetric thin extrude", () => {
+            sketch("xy", () => {
+                line([0, 0], [100, 0]);
+            });
+            const e = extrude(20).thin(10).symmetric().new();
+            render();
+            const sideFaces = e.getState('side-faces');
+            const internalFaces = e.getState('internal-faces');
+            const capFaces = e.getState('cap-faces');
+            expect(sideFaces.length).toBeGreaterThan(0);
+            expect(internalFaces.length).toBeGreaterThan(0);
+            expect(capFaces.length).toBe(2);
+        });
     });
     describe("two-distance extrude", () => {
         it("should create a thin-walled solid with two distances", () => {