fluidcad 0.0.26 → 0.0.28

package/lib/dist/tests/common/scene-object-history.test.js

@@ -0,0 +1,274 @@
+import { describe, it, expect } from "vitest";
+import { SceneObject } from "../../common/scene-object.js";
+import { Face } from "../../common/face.js";
+import { Edge } from "../../common/edge.js";
+class FakeSceneObject extends SceneObject {
+    _container;
+    constructor(options = {}) {
+        super();
+        this._container = options.container ?? false;
+    }
+    isContainer() {
+        return this._container;
+    }
+    getType() {
+        return "fake";
+    }
+    serialize() {
+        return {};
+    }
+    build() { }
+}
+function makeFace() {
+    return new Face(null);
+}
+function makeEdge() {
+    return new Edge(null);
+}
+describe("SceneObject history tracking", () => {
+    describe("defaults", () => {
+        it("returns empty arrays for every new getter on a fresh object", () => {
+            const obj = new FakeSceneObject();
+            expect(obj.getAddedFaces()).toEqual([]);
+            expect(obj.getModifiedFaces()).toEqual([]);
+            expect(obj.getRemovedFaces()).toEqual([]);
+            expect(obj.getAddedEdges()).toEqual([]);
+            expect(obj.getModifiedEdges()).toEqual([]);
+            expect(obj.getRemovedEdges()).toEqual([]);
+            expect(obj.getFinalShapes()).toEqual([]);
+        });
+    });
+    describe("face additions", () => {
+        it("records an added face and preserves addedBy", () => {
+            const owner = new FakeSceneObject();
+            const by = new FakeSceneObject();
+            const face = makeFace();
+            owner.recordAddedFace(face, by);
+            expect(owner.getAddedFaces()).toEqual([face]);
+        });
+        it("scopes addition lookups by addedBy", () => {
+            const owner = new FakeSceneObject();
+            const a = new FakeSceneObject();
+            const b = new FakeSceneObject();
+            const fa = makeFace();
+            const fb = makeFace();
+            owner.recordAddedFace(fa, a);
+            owner.recordAddedFace(fb, b);
+            expect(owner.getAddedFaces()).toEqual([fa, fb]);
+            expect(owner.getAddedFaces(new Set([a]))).toEqual([fa]);
+            expect(owner.getAddedFaces(new Set([b]))).toEqual([fb]);
+            expect(owner.getAddedFaces(new Set([a, b]))).toEqual([fa, fb]);
+        });
+    });
+    describe("face modifications", () => {
+        it("records a 1:1 modification with length-1 source and result arrays", () => {
+            const owner = new FakeSceneObject();
+            const by = new FakeSceneObject();
+            const src = makeFace();
+            const dst = makeFace();
+            owner.recordModifiedFaces([src], [dst], by);
+            const records = owner.getModifiedFaces();
+            expect(records).toHaveLength(1);
+            expect(records[0].sources).toEqual([src]);
+            expect(records[0].results).toEqual([dst]);
+            expect(records[0].modifiedBy).toBe(by);
+        });
+        it("records a 1:N split as one record with multiple results", () => {
+            const owner = new FakeSceneObject();
+            const by = new FakeSceneObject();
+            const src = makeFace();
+            const r1 = makeFace();
+            const r2 = makeFace();
+            const r3 = makeFace();
+            owner.recordModifiedFaces([src], [r1, r2, r3], by);
+            const records = owner.getModifiedFaces();
+            expect(records).toHaveLength(1);
+            expect(records[0].sources).toEqual([src]);
+            expect(records[0].results).toEqual([r1, r2, r3]);
+        });
+        it("records an N:1 merge (UnifySameDomain shape) as one record with multiple sources", () => {
+            const owner = new FakeSceneObject();
+            const by = new FakeSceneObject();
+            const s1 = makeFace();
+            const s2 = makeFace();
+            const s3 = makeFace();
+            const merged = makeFace();
+            owner.recordModifiedFaces([s1, s2, s3], [merged], by);
+            const records = owner.getModifiedFaces();
+            expect(records).toHaveLength(1);
+            expect(records[0].sources).toEqual([s1, s2, s3]);
+            expect(records[0].results).toEqual([merged]);
+        });
+        it("scopes modification lookups by modifiedBy", () => {
+            const owner = new FakeSceneObject();
+            const a = new FakeSceneObject();
+            const b = new FakeSceneObject();
+            const fa = makeFace();
+            const fb = makeFace();
+            owner.recordModifiedFaces([fa], [makeFace()], a);
+            owner.recordModifiedFaces([fb], [makeFace()], b);
+            expect(owner.getModifiedFaces()).toHaveLength(2);
+            expect(owner.getModifiedFaces(new Set([a]))).toHaveLength(1);
+            expect(owner.getModifiedFaces(new Set([a]))[0].sources).toEqual([fa]);
+        });
+    });
+    describe("face removals", () => {
+        it("records a removed face with removedBy", () => {
+            const owner = new FakeSceneObject();
+            const by = new FakeSceneObject();
+            const face = makeFace();
+            owner.recordRemovedFace(face, by);
+            expect(owner.getRemovedFaces()).toEqual([face]);
+        });
+        it("scopes removal lookups by removedBy", () => {
+            const owner = new FakeSceneObject();
+            const a = new FakeSceneObject();
+            const b = new FakeSceneObject();
+            const fa = makeFace();
+            const fb = makeFace();
+            owner.recordRemovedFace(fa, a);
+            owner.recordRemovedFace(fb, b);
+            expect(owner.getRemovedFaces(new Set([a]))).toEqual([fa]);
+            expect(owner.getRemovedFaces(new Set([b]))).toEqual([fb]);
+        });
+        it("propagates to the owning child when called on a container", () => {
+            const container = new FakeSceneObject({ container: true });
+            const child1 = new FakeSceneObject();
+            const child2 = new FakeSceneObject();
+            container.addChildObject(child1);
+            container.addChildObject(child2);
+            const by = new FakeSceneObject();
+            const face = makeFace();
+            child1.recordAddedFace(face, child1);
+            container.recordRemovedFace(face, by);
+            expect(child1.getRemovedFaces()).toEqual([face]);
+            expect(child2.getRemovedFaces()).toEqual([]);
+            // The container itself must not store the record directly.
+            expect(container.getRemovedFaces()).toEqual([]);
+        });
+        it("does not propagate to children that do not own the face", () => {
+            const container = new FakeSceneObject({ container: true });
+            const child = new FakeSceneObject();
+            container.addChildObject(child);
+            const by = new FakeSceneObject();
+            const unowned = makeFace();
+            container.recordRemovedFace(unowned, by);
+            expect(child.getRemovedFaces()).toEqual([]);
+        });
+    });
+    describe("edge additions", () => {
+        it("records an added edge and preserves addedBy", () => {
+            const owner = new FakeSceneObject();
+            const by = new FakeSceneObject();
+            const edge = makeEdge();
+            owner.recordAddedEdge(edge, by);
+            expect(owner.getAddedEdges()).toEqual([edge]);
+        });
+        it("scopes addition lookups by addedBy", () => {
+            const owner = new FakeSceneObject();
+            const a = new FakeSceneObject();
+            const b = new FakeSceneObject();
+            const ea = makeEdge();
+            const eb = makeEdge();
+            owner.recordAddedEdge(ea, a);
+            owner.recordAddedEdge(eb, b);
+            expect(owner.getAddedEdges(new Set([a]))).toEqual([ea]);
+            expect(owner.getAddedEdges(new Set([b]))).toEqual([eb]);
+        });
+    });
+    describe("edge modifications", () => {
+        it("records a 1:1 edge modification", () => {
+            const owner = new FakeSceneObject();
+            const by = new FakeSceneObject();
+            const src = makeEdge();
+            const dst = makeEdge();
+            owner.recordModifiedEdges([src], [dst], by);
+            const records = owner.getModifiedEdges();
+            expect(records).toHaveLength(1);
+            expect(records[0].sources).toEqual([src]);
+            expect(records[0].results).toEqual([dst]);
+            expect(records[0].modifiedBy).toBe(by);
+        });
+        it("records a 1:N edge split", () => {
+            const owner = new FakeSceneObject();
+            const by = new FakeSceneObject();
+            const src = makeEdge();
+            const r1 = makeEdge();
+            const r2 = makeEdge();
+            owner.recordModifiedEdges([src], [r1, r2], by);
+            expect(owner.getModifiedEdges()).toHaveLength(1);
+            expect(owner.getModifiedEdges()[0].results).toEqual([r1, r2]);
+        });
+        it("records an N:1 edge merge", () => {
+            const owner = new FakeSceneObject();
+            const by = new FakeSceneObject();
+            const s1 = makeEdge();
+            const s2 = makeEdge();
+            const merged = makeEdge();
+            owner.recordModifiedEdges([s1, s2], [merged], by);
+            expect(owner.getModifiedEdges()).toHaveLength(1);
+            expect(owner.getModifiedEdges()[0].sources).toEqual([s1, s2]);
+            expect(owner.getModifiedEdges()[0].results).toEqual([merged]);
+        });
+        it("scopes edge modification lookups by modifiedBy", () => {
+            const owner = new FakeSceneObject();
+            const a = new FakeSceneObject();
+            const b = new FakeSceneObject();
+            owner.recordModifiedEdges([makeEdge()], [makeEdge()], a);
+            owner.recordModifiedEdges([makeEdge()], [makeEdge()], b);
+            expect(owner.getModifiedEdges()).toHaveLength(2);
+            expect(owner.getModifiedEdges(new Set([a]))).toHaveLength(1);
+            expect(owner.getModifiedEdges(new Set([a]))[0].modifiedBy).toBe(a);
+        });
+    });
+    describe("edge removals", () => {
+        it("records a removed edge with removedBy", () => {
+            const owner = new FakeSceneObject();
+            const by = new FakeSceneObject();
+            const edge = makeEdge();
+            owner.recordRemovedEdge(edge, by);
+            expect(owner.getRemovedEdges()).toEqual([edge]);
+        });
+        it("scopes removal lookups by removedBy", () => {
+            const owner = new FakeSceneObject();
+            const a = new FakeSceneObject();
+            const b = new FakeSceneObject();
+            const ea = makeEdge();
+            const eb = makeEdge();
+            owner.recordRemovedEdge(ea, a);
+            owner.recordRemovedEdge(eb, b);
+            expect(owner.getRemovedEdges(new Set([a]))).toEqual([ea]);
+            expect(owner.getRemovedEdges(new Set([b]))).toEqual([eb]);
+        });
+        it("propagates to the owning child when called on a container", () => {
+            const container = new FakeSceneObject({ container: true });
+            const child1 = new FakeSceneObject();
+            const child2 = new FakeSceneObject();
+            container.addChildObject(child1);
+            container.addChildObject(child2);
+            const by = new FakeSceneObject();
+            const edge = makeEdge();
+            child2.recordAddedEdge(edge, child2);
+            container.recordRemovedEdge(edge, by);
+            expect(child2.getRemovedEdges()).toEqual([edge]);
+            expect(child1.getRemovedEdges()).toEqual([]);
+            expect(container.getRemovedEdges()).toEqual([]);
+        });
+    });
+    describe("finalShapes", () => {
+        it("roundtrips through set/get", () => {
+            const owner = new FakeSceneObject();
+            const f1 = makeFace();
+            const f2 = makeFace();
+            owner.setFinalShapes([f1, f2]);
+            expect(owner.getFinalShapes()).toEqual([f1, f2]);
+        });
+        it("replaces prior values on subsequent calls", () => {
+            const owner = new FakeSceneObject();
+            owner.setFinalShapes([makeFace()]);
+            const replacement = makeFace();
+            owner.setFinalShapes([replacement]);
+            expect(owner.getFinalShapes()).toEqual([replacement]);
+        });
+    });
+});

package/lib/dist/tests/common/shape-history-tracker.test.d.ts

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

package/lib/dist/tests/common/shape-history-tracker.test.js

@@ -0,0 +1,110 @@
+import { describe, it, expect } from "vitest";
+import { getOC } from "../../oc/init.js";
+import { ShapeHistoryTracker } from "../../common/shape-history-tracker.js";
+import { Primitives } from "../../oc/primitives.js";
+import { Explorer } from "../../oc/explorer.js";
+import { Convert } from "../../oc/convert.js";
+function countFaces(shape) {
+    const oc = getOC();
+    return Explorer.findShapes(shape.getShape(), oc.TopAbs_ShapeEnum.TopAbs_FACE).length;
+}
+function countEdges(shape) {
+    const oc = getOC();
+    return Explorer.findShapes(shape.getShape(), oc.TopAbs_ShapeEnum.TopAbs_EDGE).length;
+}
+describe("ShapeHistoryTracker", () => {
+    describe("BRepBuilderAPI_Transform (translation)", () => {
+        it("records every input face as a 1:1 modification on a sphere", () => {
+            const oc = getOC();
+            const sphere = Primitives.makeSphere(10, 2 * Math.PI);
+            const [trsf, disposeTrsf] = Convert.toGpTrsfTranslation(5, 0, 0);
+            const transformer = new oc.BRepBuilderAPI_Transform(trsf);
+            transformer.Perform(sphere.getShape(), true);
+            const history = ShapeHistoryTracker.collect(transformer, [sphere]);
+            const inputFaceCount = countFaces(sphere);
+            expect(inputFaceCount).toBeGreaterThan(0);
+            expect(history.modifiedFaces).toHaveLength(inputFaceCount);
+            // Every record should have exactly one source and one result (1:1).
+            for (const record of history.modifiedFaces) {
+                expect(record.sources).toHaveLength(1);
+                expect(record.results).toHaveLength(1);
+            }
+            expect(history.addedFaces).toEqual([]);
+            expect(history.removedFaces).toEqual([]);
+            expect(history.generatedFaces).toEqual([]);
+            transformer.delete();
+            disposeTrsf();
+        });
+        it("records every input edge as a 1:1 modification on a cylinder", () => {
+            const oc = getOC();
+            const cyl = Primitives.makeCylinder(5, 10);
+            const [trsf, disposeTrsf] = Convert.toGpTrsfTranslation(0, 0, 3);
+            const transformer = new oc.BRepBuilderAPI_Transform(trsf);
+            transformer.Perform(cyl.getShape(), true);
+            const history = ShapeHistoryTracker.collect(transformer, [cyl]);
+            const inputFaceCount = countFaces(cyl);
+            const inputEdgeCount = countEdges(cyl);
+            expect(inputFaceCount).toBeGreaterThan(0);
+            expect(inputEdgeCount).toBeGreaterThan(0);
+            expect(history.modifiedFaces).toHaveLength(inputFaceCount);
+            expect(history.modifiedEdges).toHaveLength(inputEdgeCount);
+            for (const record of history.modifiedFaces) {
+                expect(record.sources).toHaveLength(1);
+                expect(record.results).toHaveLength(1);
+            }
+            for (const record of history.modifiedEdges) {
+                expect(record.sources).toHaveLength(1);
+                expect(record.results).toHaveLength(1);
+            }
+            expect(history.addedFaces).toEqual([]);
+            expect(history.addedEdges).toEqual([]);
+            expect(history.removedFaces).toEqual([]);
+            expect(history.removedEdges).toEqual([]);
+            transformer.delete();
+            disposeTrsf();
+        });
+        it("leaves results pointing at the transformed output's subshapes", () => {
+            const oc = getOC();
+            const sphere = Primitives.makeSphere(8, 2 * Math.PI);
+            const [trsf, disposeTrsf] = Convert.toGpTrsfTranslation(1, 1, 1);
+            const transformer = new oc.BRepBuilderAPI_Transform(trsf);
+            transformer.Perform(sphere.getShape(), true);
+            const history = ShapeHistoryTracker.collect(transformer, [sphere]);
+            const outputFaces = Explorer.findShapes(transformer.Shape(), oc.TopAbs_ShapeEnum.TopAbs_FACE);
+            // Every modification result must correspond to a face in the actual output shape.
+            const outputMap = new oc.TopTools_MapOfShape();
+            for (const f of outputFaces) {
+                outputMap.Add(f);
+            }
+            for (const record of history.modifiedFaces) {
+                for (const result of record.results) {
+                    expect(outputMap.Contains(result.getShape())).toBe(true);
+                }
+            }
+            outputMap.delete();
+            transformer.delete();
+            disposeTrsf();
+        });
+    });
+    describe("with no inputs", () => {
+        it("returns empty history when no inputs are provided", () => {
+            const oc = getOC();
+            const sphere = Primitives.makeSphere(3, 2 * Math.PI);
+            const [trsf, disposeTrsf] = Convert.toGpTrsfTranslation(1, 0, 0);
+            const transformer = new oc.BRepBuilderAPI_Transform(trsf);
+            transformer.Perform(sphere.getShape(), true);
+            const history = ShapeHistoryTracker.collect(transformer, []);
+            // With no inputs, nothing is claimed as modified/generated, so every
+            // output face/edge gets classified as added. This is the expected
+            // contract: "inputs" defines what the caller considers pre-existing.
+            expect(history.modifiedFaces).toEqual([]);
+            expect(history.modifiedEdges).toEqual([]);
+            expect(history.removedFaces).toEqual([]);
+            expect(history.removedEdges).toEqual([]);
+            expect(history.addedFaces.length).toBeGreaterThan(0);
+            expect(history.addedEdges.length).toBeGreaterThan(0);
+            transformer.delete();
+            disposeTrsf();
+        });
+    });
+});

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

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

package/lib/dist/tests/features/2d/project-regression.test.js

@@ -0,0 +1,69 @@
+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 cylinder from "../../../core/cylinder.js";
+import { project, rect, circle } from "../../../core/2d/index.js";
+import { Edge } from "../../../common/edge.js";
+import { EdgeOps } from "../../../oc/edge-ops.js";
+describe("project — regression: all projected edges land on sketch plane", () => {
+    setupOC();
+    it("projects endFaces of a plain extrude onto z=0 (the sketch plane)", () => {
+        sketch("xy", () => {
+            rect(100, 50);
+        });
+        const e = extrude(30);
+        const s = sketch("xy", () => {
+            project(e.endFaces());
+        });
+        render();
+        const shapes = s.getShapes();
+        expect(shapes.length).toBeGreaterThan(0);
+        // Every projected edge midpoint should lie on z=0.
+        for (const shape of shapes) {
+            if (shape instanceof Edge) {
+                const mid = EdgeOps.getEdgeMidPoint(shape);
+                expect(mid.z).toBeCloseTo(0, 4);
+            }
+        }
+    });
+    it("projects endFaces of an extrude fused with a cylinder onto z=0", () => {
+        // Mirrors the user's scenario: complex shape built by fusing an extrude
+        // with an existing cylinder, then projecting faces back onto the sketch plane.
+        cylinder(15, 40);
+        sketch("xy", () => {
+            rect(80, 40);
+        });
+        const e = extrude(20);
+        const s = sketch("xy", () => {
+            project(e.endFaces());
+        });
+        render();
+        const shapes = s.getShapes();
+        expect(shapes.length).toBeGreaterThan(0);
+        for (const shape of shapes) {
+            if (shape instanceof Edge) {
+                const mid = EdgeOps.getEdgeMidPoint(shape);
+                expect(mid.z).toBeCloseTo(0, 4);
+            }
+        }
+    });
+    it("projects sideFaces including a cylindrical one onto z=0", () => {
+        sketch("xy", () => {
+            circle([0, 0], 20);
+        });
+        const e = extrude(30);
+        const s = sketch("xy", () => {
+            project(e.sideFaces());
+        });
+        render();
+        const shapes = s.getShapes();
+        expect(shapes.length).toBeGreaterThan(0);
+        for (const shape of shapes) {
+            if (shape instanceof Edge) {
+                const mid = EdgeOps.getEdgeMidPoint(shape);
+                expect(mid.z).toBeCloseTo(0, 4);
+            }
+        }
+    });
+});

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

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

package/lib/dist/tests/features/2d/project-user-regression.test.js

@@ -0,0 +1,37 @@
+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 plane from "../../../core/plane.js";
+import { project, arc, connect, move } from "../../../core/2d/index.js";
+import { edge } from "../../../filters/index.js";
+import { Edge } from "../../../common/edge.js";
+import { EdgeOps } from "../../../oc/edge-ops.js";
+describe("project — user regression (symmetric arc extrude onto offset front plane)", () => {
+    setupOC();
+    it("projects arc end-edges of a symmetric extrude onto an offset front plane", () => {
+        sketch("front", () => {
+            arc(31);
+            connect();
+            move([0, 0]);
+        });
+        const circleExtrude = extrude(66).symmetric();
+        const p = plane("front", { offset: 20 });
+        const s = sketch(p, () => {
+            project(circleExtrude.endEdges(edge().arc()));
+        });
+        render();
+        const shapes = s.getShapes();
+        expect(shapes.length).toBeGreaterThan(0);
+        // Every projected edge must lie on the target plane `p`. Use the plane's
+        // containsPoint check to avoid hardcoding coordinate-system assumptions.
+        const targetPlane = p.getPlane();
+        for (const shape of shapes) {
+            if (shape instanceof Edge) {
+                const mid = EdgeOps.getEdgeMidPoint(shape);
+                const dist = targetPlane.distanceToPoint(mid);
+                expect(dist).toBeLessThan(1e-4);
+            }
+        }
+    });
+});

package/lib/dist/tests/features/color-lineage.test.d.ts

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