fluidcad 0.0.2

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

@@ -0,0 +1,138 @@
+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 repeat from "../../core/repeat.js";
+import { rect } from "../../core/2d/index.js";
+import { countShapes } from "../utils.js";
+describe("repeat linear", () => {
+    setupOC();
+    it("should repeat along x axis with offset", () => {
+        sketch("xy", () => {
+            rect(20, 20);
+        });
+        const e = extrude(10).new();
+        repeat("linear", "x", { count: 3, offset: 40 }, e);
+        const scene = render();
+        // Original (1) + 2 repeated = 3
+        expect(countShapes(scene)).toBe(3);
+    });
+    it("should repeat along y axis", () => {
+        sketch("xy", () => {
+            rect(20, 20);
+        });
+        const e = extrude(10).new();
+        repeat("linear", "y", { count: 3, offset: 40 }, e);
+        const scene = render();
+        expect(countShapes(scene)).toBe(3);
+    });
+    it("should repeat along z axis", () => {
+        sketch("xy", () => {
+            rect(20, 20);
+        });
+        const e = extrude(10).new();
+        repeat("linear", "z", { count: 3, offset: 40 }, e);
+        const scene = render();
+        expect(countShapes(scene)).toBe(3);
+    });
+    it("should distribute instances by total length", () => {
+        sketch("xy", () => {
+            rect(20, 20);
+        });
+        const e = extrude(10).new();
+        // 4 instances over length 120 → offset = 120 / 3 = 40
+        repeat("linear", "x", { count: 4, length: 120 }, e);
+        const scene = render();
+        // Original (1) + 3 repeated = 4
+        expect(countShapes(scene)).toBe(4);
+    });
+    it("should create a 2D grid with multiple axes", () => {
+        sketch("xy", () => {
+            rect(10, 10);
+        });
+        const e = extrude(10).new();
+        // 3 along X × 2 along Y = 6 positions, minus origin = 5 clones
+        repeat("linear", ["x", "y"], { count: [3, 2], offset: 30 }, e);
+        const scene = render();
+        // Original (1) + 5 repeated = 6
+        expect(countShapes(scene)).toBe(6);
+    });
+    it("should use single count for all axes when count is a single-element array", () => {
+        sketch("xy", () => {
+            rect(10, 10);
+        });
+        const e = extrude(10).new();
+        // count: [2] shared for both axes → 2×2 = 4 positions, minus origin = 3 clones
+        repeat("linear", ["x", "y"], { count: [2], offset: 30 }, e);
+        const scene = render();
+        // Original (1) + 3 repeated = 4
+        expect(countShapes(scene)).toBe(4);
+    });
+    it("should support per-axis length arrays", () => {
+        sketch("xy", () => {
+            rect(10, 10);
+        });
+        const e = extrude(10).new();
+        // x: count=3, length=60 → offset=30; y: count=2, length=40 → offset=40
+        repeat("linear", ["x", "y"], { count: [3, 2], length: [60, 40] }, e);
+        const scene = render();
+        // 3×2 = 6, minus origin = 5 clones + 1 original = 6
+        expect(countShapes(scene)).toBe(6);
+    });
+    it("should center the pattern around the origin", () => {
+        sketch("xy", () => {
+            rect(20, 20);
+        });
+        const e = extrude(10).new();
+        repeat("linear", "x", { count: 5, offset: 20, centered: true }, e);
+        const scene = render();
+        // Original (1) + 4 repeated = 5
+        expect(countShapes(scene)).toBe(5);
+    });
+    it("should skip specified index", () => {
+        sketch("xy", () => {
+            rect(20, 20);
+        });
+        const e = extrude(10).new();
+        // 3 instances, skip index [1]
+        repeat("linear", "x", { count: 3, offset: 40, skip: [[1]] }, e);
+        const scene = render();
+        // Original (1) + 1 repeated (skipped index 1, kept index 2) = 2
+        expect(countShapes(scene)).toBe(2);
+    });
+    it("should skip positions in a multi-axis grid", () => {
+        sketch("xy", () => {
+            rect(10, 10);
+        });
+        const e = extrude(10).new();
+        // 3×2 grid, skip position [1,1]
+        repeat("linear", ["x", "y"], { count: [3, 2], offset: 30, skip: [[1, 1]] }, e);
+        const scene = render();
+        // 6 positions - 1 origin - 1 skipped = 4 clones + 1 original = 5
+        expect(countShapes(scene)).toBe(5);
+    });
+    it("should repeat multiple objects together", () => {
+        sketch("xy", () => {
+            rect(20, 20);
+        });
+        const e1 = extrude(10).new();
+        sketch("xy", () => {
+            rect(10, 10);
+        });
+        const e2 = extrude(5).new();
+        repeat("linear", "x", { count: 3, offset: 40 }, e1, e2);
+        const scene = render();
+        // 2 originals + 2 × 2 repeated = 6
+        expect(countShapes(scene)).toBe(6);
+    });
+    it("should use last object when no objects specified", () => {
+        sketch("xy", () => {
+            rect(20, 20);
+        });
+        extrude(10).new();
+        repeat("linear", "x", { count: 3, offset: 40 });
+        const scene = render();
+        // Original (1) + 2 repeated = 3
+        expect(countShapes(scene)).toBe(3);
+    });
+});

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

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

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

@@ -0,0 +1,205 @@
+import { describe, it, expect } from "vitest";
+import { setupOC, render } from "../setup.js";
+import sketch from "../../core/sketch.js";
+import revolve from "../../core/revolve.js";
+import { move, rect, circle } from "../../core/2d/index.js";
+import { countShapes, getFacesByType, getEdgesByType } from "../utils.js";
+import { ShapeOps } from "../../oc/shape-ops.js";
+import { ShapeProps } from "../../oc/props.js";
+describe("revolve", () => {
+    setupOC();
+    describe("full revolution of a rect", () => {
+        it("should revolve a rect 360° into a solid", () => {
+            sketch("xz", () => {
+                move([20, 0]);
+                rect(10, 30);
+            });
+            const r = revolve("z");
+            render();
+            const shapes = r.getShapes();
+            expect(shapes).toHaveLength(1);
+            expect(shapes[0].getType()).toBe("solid");
+        });
+        it("should produce a ring with correct volume", () => {
+            sketch("xz", () => {
+                move([20, 0]);
+                rect(10, 30);
+            });
+            const r = revolve("z");
+            render();
+            const solid = r.getShapes()[0];
+            // Ring volume = π * (R² - r²) * h where R=30, r=20, h=30
+            const expected = Math.PI * (30 * 30 - 20 * 20) * 30;
+            const props = ShapeProps.getProperties(solid.getShape());
+            expect(props.volumeMm3).toBeCloseTo(expected, -1);
+        });
+    });
+    describe("full revolution of a circle", () => {
+        it("should produce a single solid torus", () => {
+            sketch("xz", () => {
+                move([30, 15]);
+                circle(20);
+            });
+            const r = revolve("z");
+            render();
+            const shapes = r.getShapes();
+            expect(shapes).toHaveLength(1);
+            expect(shapes[0].getType()).toBe("solid");
+        });
+        it("should produce correct torus volume", () => {
+            const R = 30; // major radius (center of tube to axis)
+            const tubR = 10; // tube radius
+            sketch("xz", () => {
+                move([R, 15]);
+                circle(tubR * 2);
+            });
+            const r = revolve("z");
+            render();
+            const solid = r.getShapes()[0];
+            // Torus volume = 2π²Rr²
+            const expected = 2 * Math.PI * Math.PI * R * tubR * tubR;
+            const props = ShapeProps.getProperties(solid.getShape());
+            expect(props.volumeMm3).toBeCloseTo(expected, -1);
+        });
+    });
+    describe("partial revolution of a rect", () => {
+        it("should produce a solid with inner and outer cylindrical faces", () => {
+            sketch("xz", () => {
+                move([20, 0]);
+                rect(10, 30);
+            });
+            const r = revolve("z", 180);
+            render();
+            const solid = r.getShapes()[0];
+            // Inner cylinder (r=20) and outer cylinder (r=30)
+            const cylFaces = getFacesByType(solid, "cylinder");
+            expect(cylFaces).toHaveLength(2);
+        });
+        it("should produce planar sweep-end faces and profile faces", () => {
+            sketch("xz", () => {
+                move([20, 0]);
+                rect(10, 30);
+            });
+            const r = revolve("z", 90);
+            render();
+            const solid = r.getShapes()[0];
+            // 2 sweep-end faces + 2 profile (top/bottom annular rings) = 4 planar
+            const planeFaces = getFacesByType(solid, "plane");
+            expect(planeFaces).toHaveLength(4);
+            // 2 cylindrical faces (inner + outer)
+            const cylFaces = getFacesByType(solid, "cylinder");
+            expect(cylFaces).toHaveLength(2);
+        });
+        it("should produce half the volume of a full revolution at 180°", () => {
+            sketch("xz", () => {
+                move([20, 0]);
+                rect(10, 30);
+            });
+            const r = revolve("z", 180);
+            render();
+            const solid = r.getShapes()[0];
+            const fullVolume = Math.PI * (30 * 30 - 20 * 20) * 30;
+            const props = ShapeProps.getProperties(solid.getShape());
+            expect(props.volumeMm3).toBeCloseTo(fullVolume / 2, -1);
+        });
+    });
+    describe("partial revolution of a circle", () => {
+        it("should produce circular end faces and a swept surface", () => {
+            sketch("xz", () => {
+                move([30, 15]);
+                circle(20);
+            });
+            const r = revolve("z", 180);
+            render();
+            const solid = r.getShapes()[0];
+            // 2 circular end faces (the profile cross-section at each sweep end)
+            const circleFaces = getFacesByType(solid, "circle");
+            expect(circleFaces).toHaveLength(2);
+            // Total faces = 2 circular + 1 swept surface = 3
+            expect(solid.getFaces()).toHaveLength(3);
+        });
+        it("should have circular edges at the sweep ends", () => {
+            sketch("xz", () => {
+                move([30, 15]);
+                circle(20);
+            });
+            const r = revolve("z", 180);
+            render();
+            const solid = r.getShapes()[0];
+            const circleEdges = getEdgesByType(solid, "circle");
+            // 2 profile circles (one at each sweep end)
+            expect(circleEdges).toHaveLength(2);
+        });
+    });
+    // symmetric revolve is skipped due to known OC binding issue (SetRotation overload)
+    describe("symmetric revolution", () => {
+        it("should revolve symmetrically around the sketch plane", () => {
+            sketch("xz", () => {
+                move([20, 0]);
+                rect(10, 30);
+            });
+            const r = revolve("z", 180).symmetric();
+            render();
+            const shapes = r.getShapes();
+            expect(shapes).toHaveLength(1);
+            const bbox = ShapeOps.getBoundingBox(shapes[0]);
+            expect(bbox.minY).toBeLessThan(0);
+            expect(bbox.maxY).toBeGreaterThan(0);
+        });
+    });
+    describe("merge scope", () => {
+        it("should not merge when mergeScope is none", () => {
+            sketch("xz", () => {
+                move([20, 0]);
+                rect(10, 30);
+            });
+            revolve("z").new();
+            sketch("xz", () => {
+                move([20, 0]);
+                rect(10, 30);
+            });
+            revolve("z").new();
+            const scene = render();
+            expect(countShapes(scene)).toBe(2);
+        });
+    });
+    describe("extrudable", () => {
+        it("should remove the extrudable sketch shapes", () => {
+            const s = sketch("xz", () => {
+                move([20, 0]);
+                rect(10, 30);
+            });
+            revolve("z");
+            render();
+            expect(s.getShapes()).toHaveLength(0);
+        });
+        it("should revolve a specific extrudable", () => {
+            const s1 = sketch("xz", () => {
+                move([20, 0]);
+                rect(10, 30);
+            });
+            sketch("xz", () => {
+                move([40, 0]);
+                rect(5, 10);
+            });
+            const r = revolve("z", 360, s1);
+            render();
+            expect(r.extrudable).toBe(s1);
+            expect(r.getShapes()).toHaveLength(1);
+        });
+    });
+    describe("pick", () => {
+        it("should only revolve the picked region", () => {
+            sketch("xz", () => {
+                move([20, 0]);
+                circle(16);
+                move([20, 30]);
+                circle(16);
+            });
+            const r = revolve("z", 360).pick([20, 0]);
+            render();
+            const shapes = r.getShapes();
+            expect(shapes).toHaveLength(1);
+        });
+    });
+});

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

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

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

@@ -0,0 +1,133 @@
+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 rotate from "../../core/rotate.js";
+import { rect } from "../../core/2d/index.js";
+import { countShapes } from "../utils.js";
+import { ShapeOps } from "../../oc/shape-ops.js";
+describe("rotate", () => {
+    setupOC();
+    describe("rotate around standard axes", () => {
+        it("should rotate around the Z axis", () => {
+            sketch("xy", () => {
+                rect(20, 10);
+            });
+            const e = extrude(5).new();
+            // Box at (0..20, 0..10). Rotate 90° around Z → should move to (-10..0, 0..20)
+            const r = rotate("z", 90, e);
+            render();
+            const shapes = r.getShapes();
+            expect(shapes).toHaveLength(1);
+            const bbox = ShapeOps.getBoundingBox(shapes[0]);
+            expect(bbox.minX).toBeCloseTo(-10, 0);
+            expect(bbox.maxX).toBeCloseTo(0, 0);
+            expect(bbox.minY).toBeCloseTo(0, 0);
+            expect(bbox.maxY).toBeCloseTo(20, 0);
+        });
+        it("should rotate around the X axis", () => {
+            sketch("xy", () => {
+                rect(20, 10);
+            });
+            const e = extrude(5).new();
+            // Rotate 90° around X → Y becomes Z, Z becomes -Y
+            const r = rotate("x", 90, e);
+            render();
+            const shapes = r.getShapes();
+            const bbox = ShapeOps.getBoundingBox(shapes[0]);
+            expect(bbox.minZ).toBeCloseTo(0, 0);
+            expect(bbox.maxZ).toBeCloseTo(10, 0);
+        });
+        it("should rotate around the Y axis", () => {
+            sketch("xy", () => {
+                rect(20, 10);
+            });
+            const e = extrude(5).new();
+            // Rotate 90° around Y → X becomes -Z, Z becomes X
+            const r = rotate("y", 90, e);
+            render();
+            const shapes = r.getShapes();
+            const bbox = ShapeOps.getBoundingBox(shapes[0]);
+            expect(bbox.minX).toBeCloseTo(0, 0);
+            expect(bbox.maxX).toBeCloseTo(5, 0);
+        });
+    });
+    describe("move vs copy", () => {
+        it("should move the original by default", () => {
+            sketch("xy", () => {
+                rect(20, 10);
+            });
+            const e = extrude(5).new();
+            rotate("z", 90, e);
+            render();
+            expect(e.getShapes()).toHaveLength(0);
+        });
+        it("should keep the original when copy is true", () => {
+            sketch("xy", () => {
+                rect(20, 10);
+            });
+            const e = extrude(5).new();
+            rotate("z", 90, true, e);
+            render();
+            expect(e.getShapes()).toHaveLength(1);
+        });
+        it("should produce two shapes in the scene when copy is true", () => {
+            sketch("xy", () => {
+                rect(20, 10);
+            });
+            const e = extrude(5).new();
+            rotate("z", 90, true, e);
+            const scene = render();
+            expect(countShapes(scene)).toBe(2);
+        });
+    });
+    describe("rotate specific target", () => {
+        it("should only rotate the specified object", () => {
+            sketch("xy", () => {
+                rect(20, 10);
+            });
+            const e1 = extrude(5).new();
+            sketch("xy", () => {
+                rect(20, 10);
+            });
+            const e2 = extrude(5).new();
+            rotate("z", 90, e1);
+            render();
+            expect(e1.getShapes()).toHaveLength(0);
+            expect(e2.getShapes()).toHaveLength(1);
+            // e2 should still be at original position
+            const bbox = ShapeOps.getBoundingBox(e2.getShapes()[0]);
+            expect(bbox.minX).toBeCloseTo(0, 0);
+            expect(bbox.minY).toBeCloseTo(0, 0);
+        });
+    });
+    describe("rotate by arbitrary angle", () => {
+        it("should rotate by 45 degrees", () => {
+            sketch("xy", () => {
+                rect(20, 20);
+            });
+            const e = extrude(5).new();
+            const r = rotate("z", 45, e);
+            render();
+            const shapes = r.getShapes();
+            const bbox = ShapeOps.getBoundingBox(shapes[0]);
+            // A 20x20 square rotated 45° has a diagonal of ~28.3
+            const width = bbox.maxX - bbox.minX;
+            expect(width).toBeCloseTo(20 * Math.sqrt(2), 0);
+        });
+        it("should rotate by 180 degrees", () => {
+            sketch("xy", () => {
+                rect(20, 10);
+            });
+            const e = extrude(5).new();
+            // Box at (0..20, 0..10). Rotate 180° around Z → (-20..0, -10..0)
+            const r = rotate("z", 180, e);
+            render();
+            const bbox = ShapeOps.getBoundingBox(r.getShapes()[0]);
+            expect(bbox.minX).toBeCloseTo(-20, 0);
+            expect(bbox.maxX).toBeCloseTo(0, 0);
+            expect(bbox.minY).toBeCloseTo(-10, 0);
+            expect(bbox.maxY).toBeCloseTo(0, 0);
+        });
+    });
+});

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

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

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

@@ -0,0 +1,74 @@
+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 rotate from "../../core/rotate.js";
+import { move, rect } from "../../core/2d/index.js";
+describe("rotate 2D", () => {
+    setupOC();
+    describe("rotate geometry inside sketch", () => {
+        it("should rotate a rect inside a sketch", () => {
+            sketch("xy", () => {
+                move([30, 0]);
+                const r = rect(20, 10);
+                rotate(90, r);
+            });
+            const e = extrude(5);
+            render();
+            const shapes = e.getShapes();
+            expect(shapes).toHaveLength(1);
+        });
+        it("should rotate all geometry when no target specified", () => {
+            sketch("xy", () => {
+                move([30, 0]);
+                rect(20, 10);
+                rotate(90);
+            });
+            const e = extrude(5);
+            render();
+            const shapes = e.getShapes();
+            expect(shapes).toHaveLength(1);
+        });
+    });
+    describe("move vs copy (2D)", () => {
+        it("should move the geometry by default", () => {
+            const s = sketch("xy", () => {
+                move([30, 0]);
+                const r = rect(20, 10);
+                rotate(90, r);
+            });
+            render();
+            // The rect's original edges should be removed
+            const children = s.getChildren();
+            const rectObj = children[1]; // move is 0, rect is 1
+            expect(rectObj.getShapes()).toHaveLength(0);
+        });
+        it("should keep original when copy is true", () => {
+            const s = sketch("xy", () => {
+                move([30, 0]);
+                const r = rect(20, 10);
+                rotate(90, true, r);
+            });
+            render();
+            const children = s.getChildren();
+            const rectObj = children[1];
+            expect(rectObj.getShapes().length).toBeGreaterThan(0);
+        });
+    });
+    describe("rotate specific target (2D)", () => {
+        it("should only rotate the specified geometry", () => {
+            sketch("xy", () => {
+                move([30, 0]);
+                const r1 = rect(20, 10);
+                move([0, 50]);
+                const r2 = rect(20, 10);
+                rotate(90, r1);
+            });
+            const e = extrude(5);
+            render();
+            // Both rects produce solids (one rotated, one not)
+            const shapes = e.getShapes();
+            expect(shapes.length).toBeGreaterThanOrEqual(1);
+        });
+    });
+});

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

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