fluidcad 0.0.2

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

@@ -0,0 +1,202 @@
+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 { tLine, tCircle, tArc, circle, aLine, vLine, move, arc } from "../../../core/2d/index.js";
+import { outside, enclosing } from "../../../features/2d/constraints/geometry-qualifier.js";
+describe("constrained geometries", () => {
+    setupOC();
+    describe("tLine between two circles", () => {
+        it("should create a tangent line between two outside circles", () => {
+            const s = sketch("xy", () => {
+                const c1 = circle(100);
+                const c2 = circle([200, 0], 60);
+                tLine(outside(c1), outside(c2));
+            });
+            render();
+            const shapes = s.getShapes();
+            expect(shapes.length).toBeGreaterThan(0);
+        });
+        it("should create a tangent line with enclosing constraint", () => {
+            const s = sketch("xy", () => {
+                const c1 = circle(100);
+                const c2 = circle([200, 0], 60);
+                tLine(enclosing(c1), enclosing(c2));
+            });
+            render();
+            const shapes = s.getShapes();
+            expect(shapes.length).toBeGreaterThan(0);
+        });
+        it("should create a tangent line between two arcs", () => {
+            const s = sketch("xy", () => {
+                const a1 = arc(50, 0, 180);
+                move([200, 0]);
+                const a2 = arc(30, 0, 180);
+                tLine(a1, a2);
+            });
+            render();
+            const shapes = s.getShapes();
+            expect(shapes.length).toBeGreaterThan(0);
+        });
+    });
+    describe("tLine result accessors", () => {
+        it("should expose start and end points", () => {
+            const s = sketch("xy", () => {
+                const c1 = circle(100);
+                const c2 = circle([200, 0], 60);
+                const t = tLine(outside(c1), outside(c2));
+                // start() and end() return LazyVertex / SceneObjects
+                const startPt = t.start();
+                const endPt = t.end();
+                expect(startPt).toBeDefined();
+                expect(endPt).toBeDefined();
+            });
+            render();
+        });
+    });
+    describe("tCircle between two circles", () => {
+        it("should create a tangent circle with outside constraints", () => {
+            const s = sketch("xy", () => {
+                const c1 = circle(160);
+                const c2 = circle([200, 0], 60);
+                tCircle(outside(c1), outside(c2), 160).guide();
+            });
+            render();
+            const shapes = s.getShapes();
+            expect(shapes.length).toBeGreaterThan(0);
+        });
+        it("should create a tangent circle with enclosing constraint", () => {
+            const s = sketch("xy", () => {
+                const c1 = circle(160);
+                const c2 = circle([200, 0], 60);
+                tCircle(c1, enclosing(c2), 160).guide();
+            });
+            render();
+            const shapes = s.getShapes();
+            expect(shapes.length).toBeGreaterThan(0);
+        });
+    });
+    describe("tCircle between two points", () => {
+        it("should create a tangent circle from two points", () => {
+            const s = sketch("xy", () => {
+                tCircle([-50, 0], [50, 0], 300);
+            });
+            render();
+            const shapes = s.getShapes();
+            expect(shapes.length).toBeGreaterThanOrEqual(1);
+        });
+    });
+    describe("tCircle between circle and line", () => {
+        it("should create a tangent circle to a circle and a line", () => {
+            const s = sketch("xy", () => {
+                const l = aLine(150, 45);
+                const c = circle([100, 0], 60);
+                tCircle(c, l, 100).guide();
+            });
+            render();
+            const shapes = s.getShapes();
+            expect(shapes.length).toBeGreaterThan(0);
+        });
+    });
+    describe("tCircle between two lines", () => {
+        it("should create a tangent circle between two lines", () => {
+            const s = sketch("xy", () => {
+                const l1 = aLine(300, 45);
+                move([-50, 0]);
+                const l2 = vLine(300);
+                tCircle(l1, l2, 200, true).guide();
+            });
+            render();
+            const shapes = s.getShapes();
+            expect(shapes.length).toBeGreaterThan(0);
+        });
+    });
+    describe("tArc between two circles", () => {
+        it("should create a tangent arc with outside constraints", () => {
+            const s = sketch("xy", () => {
+                const c1 = circle(160);
+                const c2 = circle([200, 0], 60);
+                tArc(outside(c1), outside(c2), 80).guide();
+            });
+            render();
+            const shapes = s.getShapes();
+            expect(shapes.length).toBeGreaterThan(0);
+        });
+        it("should create a tangent arc with enclosing constraint", () => {
+            const s = sketch("xy", () => {
+                const c1 = circle(170);
+                const c2 = circle([200, 0], 60);
+                tArc(c1, enclosing(c2), 50).guide();
+            });
+            render();
+            const shapes = s.getShapes();
+            expect(shapes.length).toBeGreaterThan(0);
+        });
+    });
+    describe("tArc between circle and line", () => {
+        it("should create a tangent arc to a circle and a line", () => {
+            const s = sketch("xy", () => {
+                const l = aLine(150, 45);
+                const c = circle([100, 0], 40);
+                tArc(c, l, 50).guide();
+            });
+            render();
+            const shapes = s.getShapes();
+            expect(shapes.length).toBeGreaterThan(0);
+        });
+    });
+    describe("tArc between two lines", () => {
+        it("should create a fillet arc between two lines", () => {
+            const s = sketch("xy", () => {
+                const l1 = aLine(150, 45);
+                move([-50, 0]);
+                const l2 = vLine(100);
+                tArc(l1, l2, 50).guide();
+            });
+            render();
+            const shapes = s.getShapes();
+            expect(shapes.length).toBeGreaterThan(0);
+        });
+    });
+    describe("tArc between circle and point", () => {
+        it("should create a tangent arc to a circle and a point", () => {
+            const s = sketch("xy", () => {
+                const c = circle([100, 0], 40);
+                const p = [100, 50];
+                tArc(outside(c), p, 100).guide();
+            });
+            render();
+            const shapes = s.getShapes();
+            expect(shapes.length).toBeGreaterThan(0);
+        });
+    });
+    describe("tArc between two arcs", () => {
+        it("should create a tangent arc between two arc geometries", () => {
+            const s = sketch("xy", () => {
+                const a1 = arc(100, 0, 180);
+                move([200, 0]);
+                const a2 = arc(50, 270, 0);
+                tArc(outside(a1), a2, 150).guide();
+            });
+            render();
+            const shapes = s.getShapes();
+            expect(shapes.length).toBeGreaterThan(0);
+        });
+    });
+    describe("constrained geometry produces extrudable shape", () => {
+        it("should extrude a closed shape formed by tLine and tArc between circles", () => {
+            sketch("xy", () => {
+                const c1 = circle(100);
+                const c2 = circle([200, 0], 60);
+                const t1 = tLine(outside(c1), outside(c2));
+                const t2 = tLine(enclosing(c1), enclosing(c2));
+                tArc(t1.end(), t2.end(), t1.tangent());
+                tArc(t1.start(), t2.start(), t1.tangent().reverse());
+            });
+            const e = extrude(10);
+            render();
+            const shapes = e.getShapes();
+            expect(shapes.length).toBeGreaterThanOrEqual(1);
+        });
+    });
+});

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

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

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

@@ -0,0 +1,86 @@
+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 { line, hLine, vLine, aLine } from "../../../core/2d/index.js";
+import { ShapeOps } from "../../../oc/shape-ops.js";
+describe("line functions", () => {
+    setupOC();
+    describe("line", () => {
+        it("should create a line between two points", () => {
+            const s = sketch("xy", () => {
+                line([0, 0], [100, 0]);
+            });
+            render();
+            const shapes = s.getShapes();
+            expect(shapes.length).toBeGreaterThan(0);
+        });
+    });
+    describe("hLine", () => {
+        it("should create a horizontal line and form a closed rect", () => {
+            sketch("xy", () => {
+                hLine(80);
+                vLine(40);
+                hLine(-80);
+                vLine(-40);
+            });
+            const e = extrude(10);
+            render();
+            const solid = e.getShapes()[0];
+            const bbox = ShapeOps.getBoundingBox(solid);
+            expect(bbox.maxX - bbox.minX).toBeCloseTo(80, 0);
+            expect(bbox.maxY - bbox.minY).toBeCloseTo(40, 0);
+        });
+        it("should support standalone mode with targetPlane", () => {
+            hLine(50, "xy");
+            render();
+            // Just verify no error — standalone line doesn't form a closed shape
+        });
+    });
+    describe("vLine", () => {
+        it("should create a vertical line and form a closed rect", () => {
+            sketch("xy", () => {
+                vLine(60);
+                hLine(40);
+                vLine(-60);
+                hLine(-40);
+            });
+            const e = extrude(10);
+            render();
+            const solid = e.getShapes()[0];
+            const bbox = ShapeOps.getBoundingBox(solid);
+            expect(bbox.maxX - bbox.minX).toBeCloseTo(40, 0);
+            expect(bbox.maxY - bbox.minY).toBeCloseTo(60, 0);
+        });
+    });
+    describe("aLine", () => {
+        it("should create an angled line", () => {
+            sketch("xy", () => {
+                hLine(50);
+                aLine(50, 90);
+                hLine(-50);
+                vLine(-50);
+            });
+            const e = extrude(10);
+            render();
+            expect(e.getShapes()).toHaveLength(1);
+        });
+    });
+    describe("combined line functions", () => {
+        it("should create an L-shape with hLine and vLine", () => {
+            sketch("xy", () => {
+                hLine(100);
+                vLine(50);
+                hLine(-60);
+                vLine(30);
+                hLine(-40);
+                vLine(-80);
+            });
+            const e = extrude(10);
+            render();
+            const solid = e.getShapes()[0];
+            // L-shape has more than 6 faces
+            expect(solid.getFaces().length).toBeGreaterThan(6);
+        });
+    });
+});

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

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

package/lib/dist/tests/features/2d/move.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 { move, hMove, vMove, rect, circle } from "../../../core/2d/index.js";
+import { ShapeOps } from "../../../oc/shape-ops.js";
+describe("move functions", () => {
+    setupOC();
+    describe("move", () => {
+        it("should position geometry at a given point", () => {
+            sketch("xy", () => {
+                move([30, 20]);
+                rect(50, 50);
+            });
+            const e = extrude(10);
+            render();
+            const bbox = ShapeOps.getBoundingBox(e.getShapes()[0]);
+            expect(bbox.minX).toBeCloseTo(30, 0);
+            expect(bbox.minY).toBeCloseTo(20, 0);
+        });
+        it("should move to origin with no args", () => {
+            sketch("xy", () => {
+                move([50, 50]);
+                rect(20, 20);
+                move();
+                circle(20);
+            });
+            const e = extrude(10);
+            render();
+            // Both shapes should exist
+            expect(e.getShapes().length).toBeGreaterThanOrEqual(1);
+        });
+    });
+    describe("hMove", () => {
+        it("should move cursor horizontally", () => {
+            sketch("xy", () => {
+                hMove(40);
+                rect(30, 30);
+            });
+            const e = extrude(10);
+            render();
+            const bbox = ShapeOps.getBoundingBox(e.getShapes()[0]);
+            expect(bbox.minX).toBeCloseTo(40, 0);
+            expect(bbox.minY).toBeCloseTo(0, 0);
+        });
+    });
+    describe("vMove", () => {
+        it("should move cursor vertically", () => {
+            sketch("xy", () => {
+                vMove(50);
+                rect(30, 30);
+            });
+            const e = extrude(10);
+            render();
+            const bbox = ShapeOps.getBoundingBox(e.getShapes()[0]);
+            expect(bbox.minX).toBeCloseTo(0, 0);
+            expect(bbox.minY).toBeCloseTo(50, 0);
+        });
+    });
+    describe("combined moves", () => {
+        it("should chain horizontal and vertical moves", () => {
+            sketch("xy", () => {
+                hMove(20);
+                vMove(30);
+                rect(40, 40);
+            });
+            const e = extrude(10);
+            render();
+            const bbox = ShapeOps.getBoundingBox(e.getShapes()[0]);
+            expect(bbox.minX).toBeCloseTo(20, 0);
+            expect(bbox.minY).toBeCloseTo(30, 0);
+        });
+    });
+});

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

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

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

@@ -0,0 +1,111 @@
+import { describe, it, expect } from "vitest";
+import { setupOC, render } from "../../setup.js";
+import sketch from "../../../core/sketch.js";
+import { circle, hLine, vLine, offset } from "../../../core/2d/index.js";
+import { ShapeOps } from "../../../oc/shape-ops.js";
+describe("offset", () => {
+    setupOC();
+    describe("offset closed shape", () => {
+        it("should offset a circle outward with positive distance", () => {
+            const s = sketch("xy", () => {
+                circle(40);
+                offset(5);
+            });
+            render();
+            // Original circle (r=20) + offset circle (r=25)
+            const shapes = s.getShapes();
+            expect(shapes.length).toBeGreaterThan(1);
+            // The offset edges should produce a wider bounding box
+            const bbox = ShapeOps.getBoundingBox(shapes[shapes.length - 1]);
+            expect(bbox.maxX - bbox.minX).toBeGreaterThan(40);
+        });
+        it("should offset a circle inward with negative distance", () => {
+            const s = sketch("xy", () => {
+                circle(60);
+                offset(-5);
+            });
+            render();
+            const shapes = s.getShapes();
+            expect(shapes.length).toBeGreaterThan(1);
+        });
+    });
+    describe("offset open wire", () => {
+        it("should offset an open wire path", () => {
+            const s = sketch("xy", () => {
+                hLine(80);
+                vLine(40);
+                offset(5);
+            });
+            render();
+            // Offset produces new edges alongside the original open wire
+            const shapes = s.getShapes();
+            expect(shapes.length).toBeGreaterThan(2);
+        });
+    });
+    describe("offset direction", () => {
+        it("positive and negative offsets should produce different results", () => {
+            const s1 = sketch("xy", () => {
+                circle(40);
+                offset(10);
+            });
+            render();
+            const shapes1 = s1.getShapes();
+            const bbox1 = ShapeOps.getBoundingBox(shapes1[shapes1.length - 1]);
+            const width1 = bbox1.maxX - bbox1.minX;
+            const s2 = sketch("xy", () => {
+                circle(40);
+                offset(-5);
+            });
+            render();
+            const shapes2 = s2.getShapes();
+            const bbox2 = ShapeOps.getBoundingBox(shapes2[shapes2.length - 1]);
+            const width2 = bbox2.maxX - bbox2.minX;
+            // Positive offset produces wider result than negative
+            expect(width1).toBeGreaterThan(width2);
+        });
+    });
+    describe("removeOriginal", () => {
+        it("should keep original edges by default", () => {
+            const s = sketch("xy", () => {
+                const c = circle(40);
+                offset(5);
+            });
+            render();
+            // Original + offset edges both present
+            const shapes = s.getShapes();
+            expect(shapes.length).toBeGreaterThan(1);
+        });
+        it("should remove original edges when removeOriginal is true", () => {
+            const s = sketch("xy", () => {
+                circle(40);
+                offset(5, true);
+            });
+            render();
+            // Only offset edges remain — original circle removed
+            const shapes = s.getShapes();
+            expect(shapes).toHaveLength(1);
+        });
+    });
+    describe("specific targets (standalone)", () => {
+        it("should offset source geometries onto a target plane", () => {
+            const s = sketch("xy", () => {
+                circle(40);
+            });
+            offset(5, false, "xy", s);
+            render();
+            // Offset edges should exist on the target plane
+        });
+    });
+    describe("default distance", () => {
+        it("should use default distance of 1", () => {
+            const s = sketch("xy", () => {
+                circle(40);
+                offset();
+            });
+            render();
+            const shapes = s.getShapes();
+            // Original + offset with distance 1
+            expect(shapes.length).toBeGreaterThan(1);
+        });
+    });
+});

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

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

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

@@ -0,0 +1,43 @@
+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 { pMove, rect } from "../../../core/2d/index.js";
+import { ShapeOps } from "../../../oc/shape-ops.js";
+describe("pMove", () => {
+    setupOC();
+    it("should move cursor by polar coordinates (0° = right)", () => {
+        sketch("xy", () => {
+            pMove(50, 0);
+            rect(20, 20);
+        });
+        const e = extrude(5);
+        render();
+        const bbox = ShapeOps.getBoundingBox(e.getShapes()[0]);
+        expect(bbox.minX).toBeCloseTo(50, 0);
+        expect(bbox.minY).toBeCloseTo(0, 0);
+    });
+    it("should move cursor by polar coordinates (90° = up)", () => {
+        sketch("xy", () => {
+            pMove(40, 90);
+            rect(20, 20);
+        });
+        const e = extrude(5);
+        render();
+        const bbox = ShapeOps.getBoundingBox(e.getShapes()[0]);
+        expect(bbox.minX).toBeCloseTo(0, 0);
+        expect(bbox.minY).toBeCloseTo(40, 0);
+    });
+    it("should move cursor diagonally (45°)", () => {
+        sketch("xy", () => {
+            pMove(50, 45);
+            rect(10, 10);
+        });
+        const e = extrude(5);
+        render();
+        const bbox = ShapeOps.getBoundingBox(e.getShapes()[0]);
+        const expected = 50 * Math.cos(Math.PI / 4);
+        expect(bbox.minX).toBeCloseTo(expected, 0);
+        expect(bbox.minY).toBeCloseTo(expected, 0);
+    });
+});

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

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

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

@@ -0,0 +1,150 @@
+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 { polygon } from "../../../core/2d/index.js";
+import { ShapeOps } from "../../../oc/shape-ops.js";
+import { getEdgesByType, getBoundingBoxOfShapes } from "../../utils.js";
+describe("polygon", () => {
+    setupOC();
+    describe("face and edge count", () => {
+        it("should create a triangle (5 faces, 9 edges)", () => {
+            sketch("xy", () => {
+                polygon(3, 60);
+            });
+            const e = extrude(10);
+            render();
+            const solid = e.getShapes()[0];
+            expect(solid.getFaces()).toHaveLength(5);
+            expect(getEdgesByType(solid, "line")).toHaveLength(9);
+        });
+        it("should create a hexagon (8 faces, 18 edges)", () => {
+            sketch("xy", () => {
+                polygon(6, 60);
+            });
+            const e = extrude(10);
+            render();
+            const solid = e.getShapes()[0];
+            expect(solid.getFaces()).toHaveLength(8);
+            expect(getEdgesByType(solid, "line")).toHaveLength(18);
+        });
+        it("should create an octagon (10 faces, 24 edges)", () => {
+            sketch("xy", () => {
+                polygon(8, 60);
+            });
+            const e = extrude(10);
+            render();
+            const solid = e.getShapes()[0];
+            expect(solid.getFaces()).toHaveLength(10);
+            expect(getEdgesByType(solid, "line")).toHaveLength(24);
+        });
+    });
+    describe("inscribed mode (default)", () => {
+        it("should place vertices on the circle of given diameter", () => {
+            const diameter = 80;
+            // Hexagon inscribed: vertices at distance D/2 from center, bbox width = D
+            const s = sketch("xy", () => {
+                polygon(6, diameter);
+            });
+            render();
+            const shapes = s.getShapes({ excludeMeta: true });
+            const bbox = getBoundingBoxOfShapes(shapes);
+            expect(bbox.maxX - bbox.minX).toBeCloseTo(diameter, 0);
+        });
+        it("should produce a square with bbox = D x D", () => {
+            const diameter = 60;
+            // Square inscribed: 4 vertices at angles 0, 90, 180, 270 → bbox = D x D
+            const s = sketch("xy", () => {
+                polygon(4, diameter);
+            });
+            render();
+            const shapes = s.getShapes({ excludeMeta: true });
+            const bbox = getBoundingBoxOfShapes(shapes);
+            expect(bbox.maxX - bbox.minX).toBeCloseTo(diameter, 0);
+            expect(bbox.maxY - bbox.minY).toBeCloseTo(diameter, 0);
+        });
+    });
+    describe("circumscribed mode", () => {
+        it("should produce a larger shape than inscribed with same diameter", () => {
+            const diameter = 60;
+            const s1 = sketch("xy", () => {
+                polygon(6, diameter, "inscribed");
+            });
+            render();
+            const inscribedBbox = ShapeOps.getBoundingBox(s1.getShapes({ excludeMeta: true })[0]);
+            const inscribedWidth = inscribedBbox.maxX - inscribedBbox.minX;
+            const s2 = sketch("xy", () => {
+                polygon(6, diameter, "circumscribed");
+            });
+            render();
+            const circumscribedBbox = ShapeOps.getBoundingBox(s2.getShapes({ excludeMeta: true })[0]);
+            const circumscribedWidth = circumscribedBbox.maxX - circumscribedBbox.minX;
+            expect(circumscribedWidth).toBeGreaterThan(inscribedWidth);
+        });
+        it("should have correct vertex radius for hexagon", () => {
+            const diameter = 60;
+            const n = 6;
+            // Circumscribed: vertices at (diameter/2) / cos(π/n) from center
+            const effectiveRadius = (diameter / 2) / Math.cos(Math.PI / n);
+            const s = sketch("xy", () => {
+                polygon(n, diameter, "circumscribed");
+            });
+            render();
+            const shapes = s.getShapes({ excludeMeta: true });
+            const bbox = getBoundingBoxOfShapes(shapes);
+            expect(bbox.maxX - bbox.minX).toBeCloseTo(2 * effectiveRadius, 0);
+        });
+        it("should have correct vertex radius for square", () => {
+            const diameter = 50;
+            const n = 4;
+            // Circumscribed square: vertices at (diameter/2) * sqrt(2) from center
+            const effectiveRadius = (diameter / 2) / Math.cos(Math.PI / n);
+            const s = sketch("xy", () => {
+                polygon(n, diameter, "circumscribed");
+            });
+            render();
+            const shapes = s.getShapes({ excludeMeta: true });
+            const bbox = getBoundingBoxOfShapes(shapes);
+            expect(bbox.maxX - bbox.minX).toBeCloseTo(2 * effectiveRadius, 0);
+            expect(bbox.maxY - bbox.minY).toBeCloseTo(2 * effectiveRadius, 0);
+        });
+    });
+    describe("center position", () => {
+        it("should create a polygon at a given center", () => {
+            sketch("xy", () => {
+                polygon([50, 40], 6, 60);
+            });
+            const e = extrude(10);
+            render();
+            const bbox = ShapeOps.getBoundingBox(e.getShapes()[0]);
+            expect(bbox.centerX).toBeCloseTo(50, 0);
+            expect(bbox.centerY).toBeCloseTo(40, 0);
+        });
+        it("should center circumscribed polygon at given point", () => {
+            sketch("xy", () => {
+                polygon([20, 30], 6, 50, "circumscribed");
+            });
+            const e = extrude(10);
+            render();
+            const bbox = ShapeOps.getBoundingBox(e.getShapes()[0]);
+            expect(bbox.centerX).toBeCloseTo(20, 0);
+            expect(bbox.centerY).toBeCloseTo(30, 0);
+        });
+    });
+    describe("standalone with targetPlane", () => {
+        it("should create a polygon on a specific plane", () => {
+            polygon(5, 50, "xy");
+            const e = extrude(10);
+            render();
+            const solid = e.getShapes()[0];
+            expect(solid.getFaces()).toHaveLength(7);
+        });
+        it("should create a circumscribed polygon on a specific plane", () => {
+            polygon(6, 60, "circumscribed", "xy");
+            const e = extrude(10);
+            render();
+            const solid = e.getShapes()[0];
+            expect(solid.getFaces()).toHaveLength(8);
+        });
+    });
+});

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

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