fluidcad 0.0.13 → 0.0.15

package/lib/dist/rendering/render.js

@@ -1,6 +1,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";
 const meshBuilder = new MeshBuilder();
 function renderSceneObject(obj, scene) {
     const hasError = !!obj.getError();
@@ -134,7 +135,15 @@ export function renderSceneRollback(scene, rollbackIndex) {
 export function renderScene(scene) {
     const sceneObjects = scene.getAllSceneObjects();
     console.log("============ Rendering ==============", sceneObjects.length);
+    const skippedContainers = new Set();
     for (const object of sceneObjects) {
+        // Skip descendants of cloned sketches — their edges are already
+        // computed by the parent sketch's clone-mode build.
+        const parent = object.getParent();
+        if (parent && skippedContainers.has(parent)) {
+            skippedContainers.add(object);
+            continue;
+        }
         console.log("Rendering object:", object.getUniqueType());
         const isCached = scene.isCached(object);
         if (!isCached) {
@@ -171,9 +180,16 @@ export function renderScene(scene) {
                 object.setError(message);
             }
         }
+        // After building, mark cloned sketches so their children are skipped
+        if (object instanceof Sketch && object.getState('cloned-edges')) {
+            skippedContainers.add(object);
+        }
     }
     // Cleanup pass — let objects adjust based on final scene state
     for (const object of sceneObjects) {
+        if (skippedContainers.has(object)) {
+            continue;
+        }
         object.clean(scene.getPartScopedAllObjects(object));
     }
     for (const object of sceneObjects) {

package/lib/dist/tests/features/2d/arc.test.js

@@ -10,7 +10,7 @@ describe("arc", () => {
         it("should create an arc and form a closed shape", () => {
             sketch("xy", () => {
                 hLine(50);
-                arc([50, 30], 20);
+                arc([50, 30]).radius(20);
                 hLine(-50);
                 vLine(-30);
             });
@@ -25,7 +25,7 @@ describe("arc", () => {
     describe("from three points (start, end, center)", () => {
         it("should create an arc from start to end around a center point", () => {
             sketch("xy", () => {
-                arc([0, 0], [20, 0], [10, 0]);
+                arc([0, 0], [20, 0]).center([10, 0]);
                 line([0, 0]);
             });
             const e = extrude(10);

package/lib/dist/tests/features/2d/intersect.test.d.ts

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

package/lib/dist/tests/features/2d/intersect.test.js

@@ -0,0 +1,22 @@
+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 { intersect, rect } from "../../../core/2d/index.js";
+describe("intersect", () => {
+    setupOC();
+    describe("intersect 3D shape with sketch plane", () => {
+        it("should produce section edges from a box intersected by a sketch plane", () => {
+            sketch("xy", () => {
+                rect(100, 50);
+            });
+            const e = extrude(30);
+            const s = sketch("xy", () => {
+                intersect(e);
+            });
+            render();
+            const shapes = s.getShapes();
+            expect(shapes.length).toBeGreaterThan(0);
+        });
+    });
+});

package/lib/dist/tests/features/2d/rect.test.js

@@ -31,7 +31,7 @@ describe("rect", () => {
         });
         it("should create a centered rectangle", () => {
             sketch("xy", () => {
-                rect(100, 50).center();
+                rect(100, 50).centered();
             });
             const e = extrude(10);
             render();

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

@@ -70,7 +70,7 @@ describe("loft", () => {
     describe("loft between different shapes", () => {
         it("should loft between a rect and a circle", () => {
             const s1 = sketch("xy", () => {
-                rect(60, 60).center();
+                rect(60, 60).centered();
             });
             const s2 = sketch(plane("xy", { offset: 50 }), () => {
                 circle(60);

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

@@ -4,7 +4,7 @@ import sketch from "../../core/sketch.js";
 import extrude from "../../core/extrude.js";
 import select from "../../core/select.js";
 import cylinder from "../../core/cylinder.js";
-import { circle, rect } from "../../core/2d/index.js";
+import { circle, move, rect } from "../../core/2d/index.js";
 import { face, edge } from "../../filters/index.js";
 describe("select", () => {
     setupOC();
@@ -75,6 +75,54 @@ describe("select", () => {
                 expect(shapes).toHaveLength(4);
             });
         });
+        describe("intersectsWith / notIntersectsWith", () => {
+            it("should select faces that intersect with a plane", () => {
+                sketch("xy", () => {
+                    move([-50, -25]);
+                    rect(100, 50);
+                });
+                extrude(30);
+                // XZ plane (y=0) cuts through the centered box.
+                // Box spans x:-50..50, y:-25..25, z:0..30.
+                // Top, bottom, left, right faces are cut by the plane.
+                // Front (y=-25) and back (y=25) are parallel to XZ → not intersected.
+                const xzPlane = "xz";
+                const sel = select(face().intersectsWith(xzPlane));
+                render();
+                const shapes = sel.getShapes();
+                expect(shapes).toHaveLength(4);
+            });
+            it("should select faces not intersecting with a plane", () => {
+                sketch("xy", () => {
+                    move([-50, -25]);
+                    rect(100, 50);
+                });
+                extrude(30);
+                const xzPlane = "xz";
+                const sel = select(face().notIntersectsWith(xzPlane));
+                render();
+                // Front and back faces are parallel to XZ → not intersected
+                const shapes = sel.getShapes();
+                expect(shapes).toHaveLength(2);
+            });
+            it("should have complementary results between intersectsWith and notIntersectsWith", () => {
+                sketch("xy", () => {
+                    move([-50, -25]);
+                    rect(100, 50);
+                });
+                extrude(30);
+                const xzPlane = "xz";
+                const intersects = select(face().intersectsWith(xzPlane));
+                const notIntersects = select(face().notIntersectsWith(xzPlane));
+                render();
+                expect(intersects.getShapes()).toHaveLength(4);
+                expect(notIntersects.getShapes()).toHaveLength(2);
+                // No overlap
+                for (const s of intersects.getShapes()) {
+                    expect(notIntersects.getShapes().some(ns => ns.isSame(s))).toBe(false);
+                }
+            });
+        });
         describe("circle / notCircle", () => {
             it("should select circular faces", () => {
                 cylinder(30, 50);

package/lib/dist/tests/features/thin-extrude.test.d.ts

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

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

@@ -0,0 +1,137 @@
+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 { circle, rect, line, hLine, vLine } from "../../core/2d/index.js";
+import { ShapeOps } from "../../oc/shape-ops.js";
+describe("thin extrude", () => {
+    setupOC();
+    describe("closed profile", () => {
+        it("should create a thin-walled solid with single offset", () => {
+            sketch("xy", () => {
+                rect(100, 100);
+            });
+            const e = extrude(30).thin(5);
+            render();
+            const shapes = e.getShapes();
+            expect(shapes).toHaveLength(1);
+            expect(shapes[0].getType()).toBe('solid');
+            const bbox = ShapeOps.getBoundingBox(shapes[0]);
+            expect(bbox.maxZ - bbox.minZ).toBeCloseTo(30, 0);
+        });
+        it("should create a thin-walled solid with dual offset", () => {
+            sketch("xy", () => {
+                rect(100, 100);
+            });
+            const e = extrude(20).thin(5, -3).new();
+            render();
+            const shapes = e.getShapes();
+            expect(shapes).toHaveLength(1);
+            expect(shapes[0].getType()).toBe('solid');
+            const bbox = ShapeOps.getBoundingBox(shapes[0]);
+            expect(bbox.maxZ - bbox.minZ).toBeCloseTo(20, 0);
+        });
+        it("should create a thin-walled solid from a circle", () => {
+            sketch("xy", () => {
+                circle(50);
+            });
+            const e = extrude(25).thin(10).new();
+            render();
+            const shapes = e.getShapes();
+            expect(shapes).toHaveLength(1);
+            expect(shapes[0].getType()).toBe('solid');
+            const bbox = ShapeOps.getBoundingBox(shapes[0]);
+            // circle(50) = diameter 50 = radius 25. Outer radius = 25 + 10 = 35, so width = 70
+            expect(bbox.maxX - bbox.minX).toBeCloseTo(70, 0);
+            expect(bbox.maxZ - bbox.minZ).toBeCloseTo(25, 0);
+        });
+    });
+    describe("offset direction", () => {
+        it("should offset inward with a negative value", () => {
+            sketch("xy", () => {
+                rect(100, 100);
+            });
+            const e = extrude(20).thin(-5).new();
+            render();
+            const shapes = e.getShapes();
+            expect(shapes).toHaveLength(1);
+            expect(shapes[0].getType()).toBe('solid');
+            const bbox = ShapeOps.getBoundingBox(shapes[0]);
+            // Original rect is 100x100 centered. Inward offset by 5 means outer = original (100),
+            // inner = 90. So bounding box should be 100x100.
+            expect(bbox.maxX - bbox.minX).toBeCloseTo(100, 0);
+            expect(bbox.maxY - bbox.minY).toBeCloseTo(100, 0);
+        });
+    });
+    describe("open profile", () => {
+        it("should create a thin-walled solid from an open profile with single offset", () => {
+            sketch("xy", () => {
+                line([0, 0], [100, 0]);
+            });
+            const e = extrude(20).thin(10).new();
+            render();
+            const shapes = e.getShapes();
+            expect(shapes).toHaveLength(1);
+            expect(shapes[0].getType()).toBe('solid');
+            const bbox = ShapeOps.getBoundingBox(shapes[0]);
+            expect(bbox.maxX - bbox.minX).toBeCloseTo(100, 0);
+            expect(bbox.maxZ - bbox.minZ).toBeCloseTo(20, 0);
+        });
+        it("should create a thin-walled solid from an open profile with dual offset", () => {
+            sketch("xy", () => {
+                line([0, 0], [100, 0]);
+            });
+            const e = extrude(20).thin(5, -10).new();
+            render();
+            const shapes = e.getShapes();
+            expect(shapes).toHaveLength(1);
+            expect(shapes[0].getType()).toBe('solid');
+            const bbox = ShapeOps.getBoundingBox(shapes[0]);
+            expect(bbox.maxX - bbox.minX).toBeCloseTo(100, 0);
+            // Total Y extent = |5| + |-10| = 15
+            expect(bbox.maxY - bbox.minY).toBeCloseTo(15, 0);
+            expect(bbox.maxZ - bbox.minZ).toBeCloseTo(20, 0);
+        });
+        it("should create a thin-walled solid from an L-shaped open profile", () => {
+            sketch("xy", () => {
+                hLine([0, 0], 50);
+                vLine(50);
+            });
+            const e = extrude(15).thin(5).new();
+            render();
+            const shapes = e.getShapes();
+            expect(shapes).toHaveLength(1);
+            expect(shapes[0].getType()).toBe('solid');
+        });
+    });
+    describe("two-distance extrude", () => {
+        it("should create a thin-walled solid with two distances", () => {
+            sketch("xy", () => {
+                rect(80, 80);
+            });
+            const e = extrude(20, 10).thin(5).new();
+            render();
+            const shapes = e.getShapes();
+            expect(shapes).toHaveLength(1);
+            expect(shapes[0].getType()).toBe('solid');
+            const bbox = ShapeOps.getBoundingBox(shapes[0]);
+            expect(bbox.maxZ - bbox.minZ).toBeCloseTo(30, 0);
+        });
+    });
+    describe("remove mode", () => {
+        it("should cut a thin-walled shape from existing geometry", () => {
+            sketch("xy", () => {
+                rect(200, 200);
+            });
+            extrude(50);
+            render();
+            sketch("xy", () => {
+                rect(100, 100);
+            });
+            const e = extrude(50).thin(10).remove();
+            render();
+            const shapes = e.getShapes();
+            expect(shapes.length).toBeGreaterThan(0);
+        });
+    });
+});