fluidcad 0.0.22 → 0.0.24

package/lib/dist/filters/edge/intersects-with.d.ts

@@ -0,0 +1,18 @@
+import { Matrix4 } from "../../math/matrix4.js";
+import { Edge } from "../../common/shapes.js";
+import { FilterBase } from "../filter-base.js";
+import { SceneObject } from "../../common/scene-object.js";
+export declare class IntersectsWithFilter extends FilterBase<Edge> {
+    private sceneObject;
+    constructor(sceneObject: SceneObject);
+    match(shape: Edge): boolean;
+    compareTo(other: IntersectsWithFilter): boolean;
+    transform(_matrix: Matrix4): IntersectsWithFilter;
+}
+export declare class NotIntersectsWithFilter extends FilterBase<Edge> {
+    private sceneObject;
+    constructor(sceneObject: SceneObject);
+    match(shape: Edge): boolean;
+    compareTo(other: NotIntersectsWithFilter): boolean;
+    transform(_matrix: Matrix4): NotIntersectsWithFilter;
+}

package/lib/dist/filters/edge/intersects-with.js

@@ -0,0 +1,38 @@
+import { FilterBase } from "../filter-base.js";
+import { EdgeQuery } from "../../oc/edge-query.js";
+export class IntersectsWithFilter extends FilterBase {
+    sceneObject;
+    constructor(sceneObject) {
+        super();
+        this.sceneObject = sceneObject;
+    }
+    match(shape) {
+        const objectEdges = this.sceneObject.getShapes({ excludeGuide: false })
+            .flatMap(s => s.getSubShapes("edge"));
+        return objectEdges.some(objEdge => EdgeQuery.doEdgesIntersect(shape, objEdge));
+    }
+    compareTo(other) {
+        return this.sceneObject.compareTo(other.sceneObject);
+    }
+    transform(_matrix) {
+        return new IntersectsWithFilter(this.sceneObject);
+    }
+}
+export class NotIntersectsWithFilter extends FilterBase {
+    sceneObject;
+    constructor(sceneObject) {
+        super();
+        this.sceneObject = sceneObject;
+    }
+    match(shape) {
+        const objectEdges = this.sceneObject.getShapes({ excludeGuide: false })
+            .flatMap(s => s.getSubShapes("edge"));
+        return !objectEdges.some(objEdge => EdgeQuery.doEdgesIntersect(shape, objEdge));
+    }
+    compareTo(other) {
+        return this.sceneObject.compareTo(other.sceneObject);
+    }
+    transform(_matrix) {
+        return new NotIntersectsWithFilter(this.sceneObject);
+    }
+}

package/lib/dist/filters/edge/on-plane.d.ts

@@ -5,7 +5,8 @@ import { PlaneObjectBase } from "../../features/plane-renderable-base.js";
 export declare class OnPlaneFilter extends FilterBase<Edge> {
     private plane;
     private plane2?;
-    constructor(plane: PlaneObjectBase, plane2?: PlaneObjectBase);
+    private partial;
+    constructor(plane: PlaneObjectBase, plane2?: PlaneObjectBase, partial?: boolean);
     match(shape: Edge): boolean;
     compareTo(other: OnPlaneFilter): boolean;
     transform(matrix: Matrix4): OnPlaneFilter;
@@ -13,7 +14,8 @@ export declare class OnPlaneFilter extends FilterBase<Edge> {
 export declare class NotOnPlaneFilter extends FilterBase<Edge> {
     private plane;
     private plane2?;
-    constructor(plane: PlaneObjectBase, plane2?: PlaneObjectBase);
+    private partial;
+    constructor(plane: PlaneObjectBase, plane2?: PlaneObjectBase, partial?: boolean);
     match(shape: Edge): boolean;
     compareTo(other: NotOnPlaneFilter): boolean;
     transform(matrix: Matrix4): NotOnPlaneFilter;

package/lib/dist/filters/edge/on-plane.js

@@ -1,16 +1,31 @@
 import { FilterBase } from "../filter-base.js";
 import { EdgeQuery } from "../../oc/edge-query.js";
+import { EdgeOps } from "../../oc/edge-ops.js";
 import { PlaneObject } from "../../features/plane.js";
 export class OnPlaneFilter extends FilterBase {
     plane;
     plane2;
-    constructor(plane, plane2) {
+    partial;
+    constructor(plane, plane2, partial = false) {
         super();
         this.plane = plane;
         this.plane2 = plane2;
+        this.partial = partial;
     }
     match(shape) {
         const plane = this.plane.getPlane();
+        if (this.partial) {
+            const firstPoint = EdgeOps.getVertexPoint(EdgeOps.getFirstVertex(shape));
+            const lastPoint = EdgeOps.getVertexPoint(EdgeOps.getLastVertex(shape));
+            if (plane.containsPoint(firstPoint) || plane.containsPoint(lastPoint)) {
+                return true;
+            }
+            if (this.plane2) {
+                const plane2 = this.plane2.getPlane();
+                return plane2.containsPoint(firstPoint) || plane2.containsPoint(lastPoint);
+            }
+            return false;
+        }
         if (EdgeQuery.isEdgeOnPlane(shape, plane)) {
             return true;
         }
@@ -20,7 +35,7 @@ export class OnPlaneFilter extends FilterBase {
         return false;
     }
     compareTo(other) {
-        if (!this.plane.compareTo(other.plane)) {
+        if (!this.plane.compareTo(other.plane) || this.partial !== other.partial) {
             return false;
         }
         if (this.plane2 && other.plane2) {
@@ -29,31 +44,42 @@ export class OnPlaneFilter extends FilterBase {
         return this.plane2 === other.plane2;
     }
     transform(matrix) {
-        const plane = this.plane.getPlane();
-        const transformedPlane = plane.applyMatrix(matrix);
-        console.log('Plane', plane.normal, 'Origin:', plane.origin, ' Transformed plane:', transformedPlane.normal, ' Origin:', transformedPlane.origin);
-        const planeObj = new PlaneObject(transformedPlane);
+        const transformedPlane = this.plane.getPlane().applyMatrix(matrix);
         const planeObj2 = this.plane2 ? new PlaneObject(this.plane2.getPlane().applyMatrix(matrix)) : undefined;
-        return new OnPlaneFilter(planeObj, planeObj2);
+        return new OnPlaneFilter(new PlaneObject(transformedPlane), planeObj2, this.partial);
     }
 }
 export class NotOnPlaneFilter extends FilterBase {
     plane;
     plane2;
-    constructor(plane, plane2) {
+    partial;
+    constructor(plane, plane2, partial = false) {
         super();
         this.plane = plane;
         this.plane2 = plane2;
+        this.partial = partial;
     }
     match(shape) {
         const plane = this.plane.getPlane();
+        if (this.partial) {
+            const firstPoint = EdgeOps.getVertexPoint(EdgeOps.getFirstVertex(shape));
+            const lastPoint = EdgeOps.getVertexPoint(EdgeOps.getLastVertex(shape));
+            if (plane.containsPoint(firstPoint) || plane.containsPoint(lastPoint)) {
+                return false;
+            }
+            if (this.plane2) {
+                const plane2 = this.plane2.getPlane();
+                return !plane2.containsPoint(firstPoint) && !plane2.containsPoint(lastPoint);
+            }
+            return true;
+        }
         if (this.plane2) {
             return !EdgeQuery.isEdgeOnPlane(shape, plane) && !EdgeQuery.isEdgeOnPlane(shape, this.plane2.getPlane());
         }
         return !EdgeQuery.isEdgeOnPlane(shape, plane);
     }
     compareTo(other) {
-        if (!this.plane.compareTo(other.plane)) {
+        if (!this.plane.compareTo(other.plane) || this.partial !== other.partial) {
             return false;
         }
         if (this.plane2 && other.plane2) {
@@ -62,9 +88,8 @@ export class NotOnPlaneFilter extends FilterBase {
         return this.plane2 === other.plane2;
     }
     transform(matrix) {
-        const plane = this.plane.getPlane();
-        const planeObj = new PlaneObject(plane.applyMatrix(matrix));
+        const transformedPlane = this.plane.getPlane().applyMatrix(matrix);
         const planeObj2 = this.plane2 ? new PlaneObject(this.plane2.getPlane().applyMatrix(matrix)) : undefined;
-        return new NotOnPlaneFilter(planeObj, planeObj2);
+        return new NotOnPlaneFilter(new PlaneObject(transformedPlane), planeObj2, this.partial);
     }
 }

package/lib/dist/filters/filter-builder-base.d.ts

@@ -1,4 +1,3 @@
-import { Matrix4 } from "../math/matrix4.js";
 import { Shape } from "../common/shapes.js";
 import { FilterBase } from "./filter-base.js";
 export declare class FilterBuilderBase<TShape extends Shape = Shape> {
@@ -10,8 +9,4 @@ export declare class FilterBuilderBase<TShape extends Shape = Shape> {
      * by tangency (G1 continuity) to the initially matched shapes.
      */
     withTangents(): this;
-    hasTangentExpansion(): boolean;
-    getFilters(): FilterBase<TShape>[];
-    transform(matrix: Matrix4): FilterBuilderBase<TShape>;
-    equals(other: FilterBuilderBase<TShape>): boolean;
 }

package/lib/dist/filters/filter-builder-base.js

@@ -13,12 +13,21 @@ export class FilterBuilderBase {
         this._withTangents = true;
         return this;
     }
+    /**
+      * @internal
+    */
     hasTangentExpansion() {
         return this._withTangents;
     }
+    /**
+      * @internal
+    */
     getFilters() {
         return this.filters;
     }
+    /**
+      * @internal
+    */
     transform(matrix) {
         const transformedBuilder = new FilterBuilderBase();
         for (const filter of this.filters) {
@@ -27,6 +36,9 @@ export class FilterBuilderBase {
         transformedBuilder._withTangents = this._withTangents;
         return transformedBuilder;
     }
+    /**
+      * @internal
+    */
     equals(other) {
         if (this._withTangents !== other._withTangents) {
             return false;

package/lib/dist/helpers/clone-transform.js

@@ -34,6 +34,9 @@ export function cloneWithTransform(objects, transform, container) {
         remap.set(obj, copy);
         copy.setTransform(transform);
         copy.setCloneSource(obj);
+        if (obj.isReusable()) {
+            copy.reusable();
+        }
         allCloned.push(copy);
         const parent = obj.getParent();
         if (parent && remap.has(parent)) {

package/lib/dist/oc/edge-query.d.ts

@@ -1,4 +1,4 @@
-import type { gp_Pln, gp_Vec, TopoDS_Edge, TopoDS_Shape } from "occjs-wrapper";
+import type { gp_Pln, gp_Vec, TopoDS_Edge, TopoDS_Face, TopoDS_Shape } from "occjs-wrapper";
 import { Point } from "../math/point.js";
 import { Vector3d } from "../math/vector3d.js";
 import { Plane } from "../math/plane.js";
@@ -23,6 +23,8 @@ export declare class EdgeQuery {
         radius: number;
         axisDirection: Vector3d;
     };
+    static doEdgesIntersect(edge1: Edge, edge2: Edge): boolean;
+    static doesEdgeIntersectPlane(edge: Edge, plane: Plane): boolean;
     static isCircleEdgeRaw(edge: TopoDS_Shape, diameter?: number): boolean;
     static isArcEdgeRaw(edge: TopoDS_Shape, radius?: number): boolean;
     static isLineEdgeRaw(edge: TopoDS_Shape, length?: number): boolean;
@@ -41,4 +43,6 @@ export declare class EdgeQuery {
         radius: number;
         axisDirection: Vector3d;
     };
+    static doEdgesIntersectRaw(edge1: TopoDS_Edge, edge2: TopoDS_Edge): boolean;
+    static doesEdgeIntersectPlaneRaw(edge: TopoDS_Edge, face: TopoDS_Face): boolean;
 }

package/lib/dist/oc/edge-query.js

@@ -1,5 +1,6 @@
 import { getOC } from "./init.js";
 import { Convert } from "./convert.js";
+import { FaceOps } from "./face-ops.js";
 import { Point } from "../math/point.js";
 import { Vector3d } from "../math/vector3d.js";
 export class EdgeQuery {
@@ -46,6 +47,17 @@ export class EdgeQuery {
     static getCircleDataFromEdge(edge) {
         return EdgeQuery.getCircleDataFromEdgeRaw(edge.getShape());
     }
+    static doEdgesIntersect(edge1, edge2) {
+        return EdgeQuery.doEdgesIntersectRaw(edge1.getShape(), edge2.getShape());
+    }
+    static doesEdgeIntersectPlane(edge, plane) {
+        const [gpPln, dispose] = Convert.toGpPln(plane);
+        const face = FaceOps.makeFaceFromPlane2(gpPln);
+        const result = EdgeQuery.doesEdgeIntersectPlaneRaw(edge.getShape(), face);
+        face.delete();
+        dispose();
+        return result;
+    }
     // Raw methods (for oc-internal and common/ use)
     static isCircleEdgeRaw(edge, diameter) {
         const oc = getOC();
@@ -241,4 +253,32 @@ export class EdgeQuery {
         curve.delete();
         return result;
     }
+    static doEdgesIntersectRaw(edge1, edge2) {
+        const oc = getOC();
+        const tool = new oc.IntTools_EdgeEdge(edge1, edge2);
+        tool.Perform();
+        let intersects = false;
+        if (tool.IsDone()) {
+            const parts = tool.CommonParts();
+            intersects = parts.Length() > 0;
+            parts.delete();
+        }
+        tool.delete();
+        return intersects;
+    }
+    static doesEdgeIntersectPlaneRaw(edge, face) {
+        const oc = getOC();
+        const tool = new oc.IntTools_EdgeFace();
+        tool.SetEdge(edge);
+        tool.SetFace(face);
+        tool.Perform();
+        let intersects = false;
+        if (tool.IsDone()) {
+            const parts = tool.CommonParts();
+            intersects = parts.Length() > 0;
+            parts.delete();
+        }
+        tool.delete();
+        return intersects;
+    }
 }

package/lib/dist/rendering/render.js

@@ -207,8 +207,9 @@ export function renderScene(scene) {
             }
             buildDurations.set(object, performance.now() - buildStart);
         }
-        // After building, mark cloned sketches so their children are skipped
-        if (object instanceof Sketch && object.getState('cloned-edges')) {
+        // After building, mark cloned sketches so their children are skipped —
+        // the sketch's build() already populated them with transformed shapes.
+        if (object instanceof Sketch && object.getCloneSource()) {
             skippedContainers.add(object);
         }
     }

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

@@ -104,7 +104,7 @@ describe("chamfer", () => {
                 rect(100, 50);
             });
             extrude(30);
-            const sel = select(edge().onPlane("xy", 30));
+            const sel = select(edge().onPlane("xy", { offset: 30 }));
             chamfer(3, sel);
             render();
             const solid = render().getAllSceneObjects()

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

@@ -106,7 +106,7 @@ describe("fillet", () => {
             });
             extrude(30);
             // Fillet only the top horizontal edges (4 edges)
-            const sel = select(edge().onPlane("xy", 30));
+            const sel = select(edge().onPlane("xy", { offset: 30 }));
             fillet(3, sel);
             render();
             const solid = render().getAllSceneObjects()

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

@@ -222,7 +222,7 @@ describe("select", () => {
                     rect(100, 50);
                 });
                 extrude(30);
-                const sel = select(edge().onPlane("xy", 30));
+                const sel = select(edge().onPlane("xy", { offset: 30 }));
                 render();
                 expect(sel.getShapes()).toHaveLength(4);
             });
@@ -236,6 +236,104 @@ describe("select", () => {
                 render();
                 expect(sel.getShapes()).toHaveLength(8);
             });
+            it("should select edges on offset plane with bothDirections", () => {
+                sketch("xy", () => {
+                    rect(100, 50);
+                });
+                extrude(30);
+                // Edges on z=15 or z=-15 — none exist on an extruded box
+                const sel = select(edge().onPlane("xy", { offset: 15, bothDirections: true }));
+                render();
+                expect(sel.getShapes()).toHaveLength(0);
+            });
+            it("should select edges with partial match", () => {
+                sketch("xy", () => {
+                    rect(100, 50);
+                });
+                extrude(30);
+                // partial: true matches edges with at least one vertex on the plane
+                // Bottom 4 edges are fully on XY, plus the 4 vertical edges each have one vertex on XY
+                const sel = select(edge().onPlane("xy", { partial: true }));
+                render();
+                expect(sel.getShapes()).toHaveLength(8);
+            });
+            it("should exclude edges with partial notOnPlane", () => {
+                sketch("xy", () => {
+                    rect(100, 50);
+                });
+                extrude(30);
+                // notOnPlane partial: true excludes edges where any vertex touches XY
+                // Only the 4 top edges (z=30) have no vertex on XY
+                const sel = select(edge().notOnPlane("xy", { partial: true }));
+                render();
+                expect(sel.getShapes()).toHaveLength(4);
+            });
+        });
+        describe("above / below", () => {
+            it("should select edges entirely above a plane", () => {
+                sketch("xy", () => {
+                    rect(100, 50);
+                });
+                extrude(30);
+                // Edges above z=10: the 4 top edges (z=30) have both vertices above
+                // The 4 vertical edges straddle z=10, so they don't match
+                const sel = select(edge().above("xy", { offset: 10 }));
+                render();
+                expect(sel.getShapes()).toHaveLength(4);
+            });
+            it("should select edges entirely below a plane", () => {
+                sketch("xy", () => {
+                    rect(100, 50);
+                });
+                extrude(30);
+                // Edges below z=10: the 4 bottom edges (z=0) have both vertices below
+                const sel = select(edge().below("xy", { offset: 10 }));
+                render();
+                expect(sel.getShapes()).toHaveLength(4);
+            });
+            it("should not match edges on the plane itself", () => {
+                sketch("xy", () => {
+                    rect(100, 50);
+                });
+                extrude(30);
+                // Edges above z=0: bottom edges are ON the plane (dist=0), not above
+                // Only top 4 edges are above, vertical edges straddle
+                const sel = select(edge().above("xy"));
+                render();
+                expect(sel.getShapes()).toHaveLength(4);
+            });
+            it("should select partially above edges", () => {
+                sketch("xy", () => {
+                    rect(100, 50);
+                });
+                extrude(30);
+                // partial: true — match edges where at least one vertex is above z=0
+                // Top 4 edges (both vertices above) + 4 vertical edges (one vertex above)
+                const sel = select(edge().above("xy", { partial: true }));
+                render();
+                expect(sel.getShapes()).toHaveLength(8);
+            });
+            it("should select partially below edges", () => {
+                sketch("xy", () => {
+                    rect(100, 50);
+                });
+                extrude(30);
+                // partial: true — match edges where at least one vertex is below z=30
+                // Bottom 4 edges (both vertices below) + 4 vertical edges (one vertex below)
+                const sel = select(edge().below("xy", { offset: 30, partial: true }));
+                render();
+                expect(sel.getShapes()).toHaveLength(8);
+            });
+            it("should return empty when no edges match", () => {
+                sketch("xy", () => {
+                    rect(100, 50);
+                });
+                extrude(30);
+                // Nothing is below z=0 on a box sitting on XY
+                const sel = select(edge().below("xy"));
+                render();
+                expect(sel.getShapes()).toHaveLength(0);
+            });
         });
         describe("parallelTo / notParallelTo", () => {
             it("should select edges parallel to a plane", () => {
@@ -369,7 +467,7 @@ describe("select", () => {
             extrude(30);
             // Faces that have both a line edge on XY AND a line edge on XY offset 30
             // The 4 side faces each have edges on both bottom and top planes
-            const sel = select(face().hasEdge(edge().onPlane("xy"), edge().onPlane("xy", 30)));
+            const sel = select(face().hasEdge(edge().onPlane("xy"), edge().onPlane("xy", { offset: 30 })));
             render();
             expect(sel.getShapes()).toHaveLength(4);
         });
@@ -459,7 +557,7 @@ describe("select", () => {
             });
             extrude(30);
             // Edges on bottom OR edges on top
-            const sel = select(edge().onPlane("xy"), edge().onPlane("xy", 30));
+            const sel = select(edge().onPlane("xy"), edge().onPlane("xy", { offset: 30 }));
             render();
             expect(sel.getShapes()).toHaveLength(8);
         });