fluidcad 0.0.7 → 0.0.9

package/lib/dist/filters/face/face-filter.d.ts

@@ -2,20 +2,113 @@ import { PlaneLike } from "../../math/plane.js";
 import { Face } from "../../common/shapes.js";
 import { FilterBuilderBase } from "../filter-builder-base.js";
 import { PlaneObjectBase } from "../../features/plane-renderable-base.js";
+import { EdgeFilterBuilder } from "../edge/edge-filter.js";
+import { ISceneObject } from "../../core/interfaces.js";
 export declare class FaceFilterBuilder extends FilterBuilderBase<Face> {
     constructor();
+    /**
+     * Selects the face at the given index.
+     * @param index - Zero-based face index.
+     * @param shapes - The face array to index into.
+     * @param originalShapes - Optional original face array before filtering.
+     */
     atIndex(index: number, shapes: Face[], originalShapes?: Face[]): this;
+    /**
+     * Excludes the face at the given index.
+     * @param index - Zero-based face index to exclude.
+     * @param shapes - The face array to index into.
+     * @param originalShapes - Optional original face array before filtering.
+     */
     notAtIndex(index: number, shapes: Face[], originalShapes?: Face[]): this;
+    /**
+     * Selects faces that lie on the given plane.
+     * @param plane - The reference plane.
+     * @param offset - Optional distance to offset the plane before matching.
+     */
     onPlane(plane: PlaneLike | PlaneObjectBase, offset?: number): this;
+    /**
+     * Excludes faces that lie on the given plane.
+     * @param plane - The reference plane.
+     * @param offset - Optional distance to offset the plane before matching.
+     */
     notOnPlane(plane: PlaneLike | PlaneObjectBase, offset?: number): this;
+    /**
+     * Selects circular (flat, disc-shaped) faces, optionally matching a specific diameter.
+     * @param diameter - Optional diameter to match.
+     */
     circle(diameter?: number): this;
+    /**
+     * Excludes circular (flat, disc-shaped) faces, optionally matching a specific diameter.
+     * @param diameter - Optional diameter to exclude.
+     */
     notCircle(diameter?: number): this;
+    /**
+     * Selects cylindrical faces, optionally matching a specific diameter.
+     * @param diameter - Optional diameter to match.
+     */
     cylinder(diameter?: number): this;
+    /**
+     * Excludes cylindrical faces, optionally matching a specific diameter.
+     * @param diameter - Optional diameter to exclude.
+     */
     notCylinder(diameter?: number): this;
+    /**
+     * Selects faces bounded by cylindrical curves, optionally matching a specific diameter.
+     * @param diameter - Optional diameter to match.
+     */
     cylinderCurve(diameter?: number): this;
+    /**
+     * Excludes faces bounded by cylindrical curves, optionally matching a specific diameter.
+     * @param diameter - Optional diameter to exclude.
+     */
     notCylinderCurve(diameter?: number): this;
+    /**
+     * Selects faces whose normal is parallel to the given plane.
+     * @param plane - The reference plane.
+     */
     parallelTo(plane: PlaneLike | PlaneObjectBase): this;
+    /**
+     * Excludes faces whose normal is parallel to the given plane.
+     * @param plane - The reference plane.
+     */
     notParallelTo(plane: PlaneLike | PlaneObjectBase): this;
+    /**
+     * Selects conical faces.
+     */
     cone(): this;
+    /**
+     * Excludes conical faces.
+     */
     notCone(): this;
+    /**
+     * Selects faces that share an edge with the given scene object.
+     * @param sceneObject - A scene object whose edges are matched against.
+     */
+    hasEdge(sceneObject: ISceneObject): this;
+    /**
+     * Selects faces that have edges matching all of the given edge filters.
+     * Each edge filter builder must match at least one edge of the face.
+     * @param edgeFilters - One or more edge filter builders. All must be satisfied.
+     */
+    hasEdge(...edgeFilters: EdgeFilterBuilder[]): this;
+    /**
+     * Excludes faces that share an edge with the given scene object.
+     * @param sceneObject - A scene object whose edges are matched against.
+     */
+    notHasEdge(sceneObject: ISceneObject): this;
+    /**
+     * Excludes faces that have edges matching all of the given edge filters.
+     * @param edgeFilters - One or more edge filter builders. If all are satisfied, the face is excluded.
+     */
+    notHasEdge(...edgeFilters: EdgeFilterBuilder[]): this;
+    /**
+     * Selects faces with exactly the given number of edges.
+     * @param count - The exact number of edges to match.
+     */
+    edgeCount(count: number): this;
+    /**
+     * Excludes faces with the given number of edges.
+     * @param count - The number of edges to exclude.
+     */
+    notEdgeCount(count: number): this;
 }

package/lib/dist/filters/face/face-filter.js

@@ -9,20 +9,41 @@ import { NotParallelFilter, ParallelFilter } from "./parallel.js";
 import { PlaneObject } from "../../features/plane.js";
 import { PlaneObjectBase } from "../../features/plane-renderable-base.js";
 import { AtIndexFilter, NotAtIndexFilter } from "./at-index.js";
+import { HasEdgeFilter, NotHasEdgeFilter } from "./has-edge.js";
+import { HasEdgeFromSceneObjectFilter, NotHasEdgeFromSceneObjectFilter } from "./has-object.js";
+import { EdgeCountFilter, NotEdgeCountFilter } from "./edge-count.js";
+import { SceneObject } from "../../common/scene-object.js";
 export class FaceFilterBuilder extends FilterBuilderBase {
     constructor() {
         super();
     }
+    /**
+     * Selects the face at the given index.
+     * @param index - Zero-based face index.
+     * @param shapes - The face array to index into.
+     * @param originalShapes - Optional original face array before filtering.
+     */
     atIndex(index, shapes, originalShapes) {
         const filter = new AtIndexFilter(index, shapes, originalShapes);
         this.filters.push(filter);
         return this;
     }
+    /**
+     * Excludes the face at the given index.
+     * @param index - Zero-based face index to exclude.
+     * @param shapes - The face array to index into.
+     * @param originalShapes - Optional original face array before filtering.
+     */
     notAtIndex(index, shapes, originalShapes) {
         const filter = new NotAtIndexFilter(index, shapes, originalShapes);
         this.filters.push(filter);
         return this;
     }
+    /**
+     * Selects faces that lie on the given plane.
+     * @param plane - The reference plane.
+     * @param offset - Optional distance to offset the plane before matching.
+     */
     onPlane(plane, offset = 0) {
         if (!plane) {
             throw new Error('Plane is required');
@@ -42,6 +63,11 @@ export class FaceFilterBuilder extends FilterBuilderBase {
         this.filters.push(filter);
         return this;
     }
+    /**
+     * Excludes faces that lie on the given plane.
+     * @param plane - The reference plane.
+     * @param offset - Optional distance to offset the plane before matching.
+     */
     notOnPlane(plane, offset = 0) {
         if (!plane) {
             throw new Error('Plane is required');
@@ -61,36 +87,64 @@ export class FaceFilterBuilder extends FilterBuilderBase {
         this.filters.push(filter);
         return this;
     }
+    /**
+     * Selects circular (flat, disc-shaped) faces, optionally matching a specific diameter.
+     * @param diameter - Optional diameter to match.
+     */
     circle(diameter) {
         const filter = new CircleFilter(diameter);
         this.filters.push(filter);
         return this;
     }
+    /**
+     * Excludes circular (flat, disc-shaped) faces, optionally matching a specific diameter.
+     * @param diameter - Optional diameter to exclude.
+     */
     notCircle(diameter) {
         const filter = new NotCircleFilter(diameter);
         this.filters.push(filter);
         return this;
     }
+    /**
+     * Selects cylindrical faces, optionally matching a specific diameter.
+     * @param diameter - Optional diameter to match.
+     */
     cylinder(diameter) {
         const filter = new CylinderFilter(diameter);
         this.filters.push(filter);
         return this;
     }
+    /**
+     * Excludes cylindrical faces, optionally matching a specific diameter.
+     * @param diameter - Optional diameter to exclude.
+     */
     notCylinder(diameter) {
         const filter = new NotCylinderFilter(diameter);
         this.filters.push(filter);
         return this;
     }
+    /**
+     * Selects faces bounded by cylindrical curves, optionally matching a specific diameter.
+     * @param diameter - Optional diameter to match.
+     */
     cylinderCurve(diameter) {
         const filter = new CylinderCurveFilter(diameter);
         this.filters.push(filter);
         return this;
     }
+    /**
+     * Excludes faces bounded by cylindrical curves, optionally matching a specific diameter.
+     * @param diameter - Optional diameter to exclude.
+     */
     notCylinderCurve(diameter) {
         const filter = new NotCylinderCurveFilter(diameter);
         this.filters.push(filter);
         return this;
     }
+    /**
+     * Selects faces whose normal is parallel to the given plane.
+     * @param plane - The reference plane.
+     */
     parallelTo(plane) {
         if (!plane) {
             throw new Error('Plane is required');
@@ -106,6 +160,10 @@ export class FaceFilterBuilder extends FilterBuilderBase {
         this.filters.push(filter);
         return this;
     }
+    /**
+     * Excludes faces whose normal is parallel to the given plane.
+     * @param plane - The reference plane.
+     */
     notParallelTo(plane) {
         if (!plane) {
             throw new Error('Plane is required');
@@ -121,14 +179,68 @@ export class FaceFilterBuilder extends FilterBuilderBase {
         this.filters.push(filter);
         return this;
     }
+    /**
+     * Selects conical faces.
+     */
     cone() {
         const filter = new ConeFilter();
         this.filters.push(filter);
         return this;
     }
+    /**
+     * Excludes conical faces.
+     */
     notCone() {
         const filter = new NotConeFilter();
         this.filters.push(filter);
         return this;
     }
+    hasEdge(...args) {
+        const filterBuilders = [];
+        for (const arg of args) {
+            if (arg instanceof SceneObject) {
+                this.filters.push(new HasEdgeFromSceneObjectFilter(arg));
+            }
+            else {
+                filterBuilders.push(arg);
+            }
+        }
+        if (filterBuilders.length > 0) {
+            this.filters.push(new HasEdgeFilter(filterBuilders));
+        }
+        return this;
+    }
+    notHasEdge(...args) {
+        const filterBuilders = [];
+        for (const arg of args) {
+            if (arg instanceof SceneObject) {
+                this.filters.push(new NotHasEdgeFromSceneObjectFilter(arg));
+            }
+            else {
+                filterBuilders.push(arg);
+            }
+        }
+        if (filterBuilders.length > 0) {
+            this.filters.push(new NotHasEdgeFilter(filterBuilders));
+        }
+        return this;
+    }
+    /**
+     * Selects faces with exactly the given number of edges.
+     * @param count - The exact number of edges to match.
+     */
+    edgeCount(count) {
+        const filter = new EdgeCountFilter(count);
+        this.filters.push(filter);
+        return this;
+    }
+    /**
+     * Excludes faces with the given number of edges.
+     * @param count - The number of edges to exclude.
+     */
+    notEdgeCount(count) {
+        const filter = new NotEdgeCountFilter(count);
+        this.filters.push(filter);
+        return this;
+    }
 }

package/lib/dist/filters/face/has-edge.d.ts

@@ -0,0 +1,18 @@
+import { Matrix4 } from "../../math/matrix4.js";
+import { Edge, Face } from "../../common/shapes.js";
+import { FilterBase } from "../filter-base.js";
+import { FilterBuilderBase } from "../filter-builder-base.js";
+export declare class HasEdgeFilter extends FilterBase<Face> {
+    private edgeFilterBuilders;
+    constructor(edgeFilterBuilders: FilterBuilderBase<Edge>[]);
+    match(shape: Face): boolean;
+    compareTo(other: HasEdgeFilter): boolean;
+    transform(matrix: Matrix4): HasEdgeFilter;
+}
+export declare class NotHasEdgeFilter extends FilterBase<Face> {
+    private edgeFilterBuilders;
+    constructor(edgeFilterBuilders: FilterBuilderBase<Edge>[]);
+    match(shape: Face): boolean;
+    compareTo(other: NotHasEdgeFilter): boolean;
+    transform(matrix: Matrix4): NotHasEdgeFilter;
+}

package/lib/dist/filters/face/has-edge.js

@@ -0,0 +1,59 @@
+import { FilterBase } from "../filter-base.js";
+export class HasEdgeFilter extends FilterBase {
+    edgeFilterBuilders;
+    constructor(edgeFilterBuilders) {
+        super();
+        this.edgeFilterBuilders = edgeFilterBuilders;
+    }
+    match(shape) {
+        const edges = shape.getEdges();
+        return this.edgeFilterBuilders.every(builder => {
+            const filters = builder.getFilters();
+            return edges.some(edge => filters.every(f => f.match(edge)));
+        });
+    }
+    compareTo(other) {
+        if (this.edgeFilterBuilders.length !== other.edgeFilterBuilders.length) {
+            return false;
+        }
+        for (let i = 0; i < this.edgeFilterBuilders.length; i++) {
+            if (!this.edgeFilterBuilders[i].equals(other.edgeFilterBuilders[i])) {
+                return false;
+            }
+        }
+        return true;
+    }
+    transform(matrix) {
+        const transformed = this.edgeFilterBuilders.map(builder => builder.transform(matrix));
+        return new HasEdgeFilter(transformed);
+    }
+}
+export class NotHasEdgeFilter extends FilterBase {
+    edgeFilterBuilders;
+    constructor(edgeFilterBuilders) {
+        super();
+        this.edgeFilterBuilders = edgeFilterBuilders;
+    }
+    match(shape) {
+        const edges = shape.getEdges();
+        return !this.edgeFilterBuilders.every(builder => {
+            const filters = builder.getFilters();
+            return edges.some(edge => filters.every(f => f.match(edge)));
+        });
+    }
+    compareTo(other) {
+        if (this.edgeFilterBuilders.length !== other.edgeFilterBuilders.length) {
+            return false;
+        }
+        for (let i = 0; i < this.edgeFilterBuilders.length; i++) {
+            if (!this.edgeFilterBuilders[i].equals(other.edgeFilterBuilders[i])) {
+                return false;
+            }
+        }
+        return true;
+    }
+    transform(matrix) {
+        const transformed = this.edgeFilterBuilders.map(builder => builder.transform(matrix));
+        return new NotHasEdgeFilter(transformed);
+    }
+}

package/lib/dist/filters/face/has-object.d.ts

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

package/lib/dist/filters/face/has-object.js

@@ -0,0 +1,37 @@
+import { FilterBase } from "../filter-base.js";
+export class HasEdgeFromSceneObjectFilter extends FilterBase {
+    sceneObject;
+    constructor(sceneObject) {
+        super();
+        this.sceneObject = sceneObject;
+    }
+    match(shape) {
+        const objectEdges = this.sceneObject.getShapes()
+            .flatMap(s => s.getSubShapes("edge"));
+        return objectEdges.some(objEdge => shape.hasEdge(objEdge.getShape()) !== null);
+    }
+    compareTo(other) {
+        return this.sceneObject.compareTo(other.sceneObject);
+    }
+    transform(_matrix) {
+        return new HasEdgeFromSceneObjectFilter(this.sceneObject);
+    }
+}
+export class NotHasEdgeFromSceneObjectFilter extends FilterBase {
+    sceneObject;
+    constructor(sceneObject) {
+        super();
+        this.sceneObject = sceneObject;
+    }
+    match(shape) {
+        const objectEdges = this.sceneObject.getShapes()
+            .flatMap(s => s.getSubShapes("edge"));
+        return !objectEdges.some(objEdge => shape.hasEdge(objEdge.getShape()) !== null);
+    }
+    compareTo(other) {
+        return this.sceneObject.compareTo(other.sceneObject);
+    }
+    transform(_matrix) {
+        return new NotHasEdgeFromSceneObjectFilter(this.sceneObject);
+    }
+}

package/lib/dist/filters/index.d.ts

@@ -1,4 +1,10 @@
 import { FaceFilterBuilder } from './face/face-filter.js';
 import { EdgeFilterBuilder } from './edge/edge-filter.js';
+/**
+ * Creates a new face filter builder for selecting faces by geometric properties.
+ */
 export declare function face(): FaceFilterBuilder;
+/**
+ * Creates a new edge filter builder for selecting edges by geometric properties.
+ */
 export declare function edge(): EdgeFilterBuilder;

package/lib/dist/filters/index.js

@@ -1,8 +1,14 @@
 import { FaceFilterBuilder } from './face/face-filter.js';
 import { EdgeFilterBuilder } from './edge/edge-filter.js';
+/**
+ * Creates a new face filter builder for selecting faces by geometric properties.
+ */
 export function face() {
     return new FaceFilterBuilder();
 }
+/**
+ * Creates a new edge filter builder for selecting edges by geometric properties.
+ */
 export function edge() {
     return new EdgeFilterBuilder();
 }

package/lib/dist/index.js

@@ -7,7 +7,7 @@ export function captureSourceLocation() {
     }
     const lines = stack.split('\n');
     for (const frame of lines) {
-        const match = frame.match(/(\/[^:]+\.fluid\.js):(\d+):(\d+)/);
+        const match = frame.match(/((?:[A-Za-z]:)?\/[^\s]+?\.fluid\.js):(\d+):(\d+)/);
         if (match) {
             return {
                 filePath: match[1],

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

@@ -7,7 +7,7 @@ import { Edge } from "../common/edge.js";
 export declare class EdgeQuery {
     static isCircleEdge(edge: Shape, diameter?: number): boolean;
     static isArcEdge(edge: Shape, radius?: number): boolean;
-    static isLineEdge(edge: Shape): boolean;
+    static isLineEdge(edge: Shape, length?: number): boolean;
     static isEdgeOnPlane(edge: Shape, plane: Plane): boolean;
     static isEdgeParallelToPlane(edge: Shape, planeNormal: Vector3d): boolean;
     static isEdgeAlignedWithNormal(edge: Shape, planeNormal: Vector3d): boolean;
@@ -25,7 +25,7 @@ export declare class EdgeQuery {
     };
     static isCircleEdgeRaw(edge: TopoDS_Shape, diameter?: number): boolean;
     static isArcEdgeRaw(edge: TopoDS_Shape, radius?: number): boolean;
-    static isLineEdgeRaw(edge: TopoDS_Shape): boolean;
+    static isLineEdgeRaw(edge: TopoDS_Shape, length?: number): boolean;
     static isEdgeOnPlaneRaw(edge: TopoDS_Shape, plane: gp_Pln): boolean;
     static isEdgeParallelToPlaneRaw(edge: TopoDS_Shape, planeNormal: gp_Vec): boolean;
     static isEdgeAlignedWithNormalRaw(edge: TopoDS_Shape, planeNormal: gp_Vec): boolean;

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

@@ -10,8 +10,8 @@ export class EdgeQuery {
     static isArcEdge(edge, radius) {
         return EdgeQuery.isArcEdgeRaw(edge.getShape(), radius);
     }
-    static isLineEdge(edge) {
-        return EdgeQuery.isLineEdgeRaw(edge.getShape());
+    static isLineEdge(edge, length) {
+        return EdgeQuery.isLineEdgeRaw(edge.getShape(), length);
     }
     static isEdgeOnPlane(edge, plane) {
         const [gpPln, dispose] = Convert.toGpPln(plane);
@@ -93,13 +93,22 @@ export class EdgeQuery {
         curveAdaptor.delete();
         return Math.abs(r - radius) <= oc.Precision.Confusion();
     }
-    static isLineEdgeRaw(edge) {
+    static isLineEdgeRaw(edge, length) {
         const oc = getOC();
         const ocEdge = oc.TopoDS.Edge(edge);
         const curveAdaptor = new oc.BRepAdaptor_Curve(ocEdge);
         const curveType = curveAdaptor.GetType();
+        if (curveType !== oc.GeomAbs_CurveType.GeomAbs_Line) {
+            curveAdaptor.delete();
+            return false;
+        }
+        if (length === undefined) {
+            curveAdaptor.delete();
+            return true;
+        }
+        const edgeLength = Math.abs(curveAdaptor.LastParameter() - curveAdaptor.FirstParameter());
         curveAdaptor.delete();
-        return curveType === oc.GeomAbs_CurveType.GeomAbs_Line;
+        return Math.abs(edgeLength - length) <= oc.Precision.Confusion();
     }
     static isEdgeOnPlaneRaw(edge, plane) {
         const oc = getOC();

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

@@ -2,7 +2,7 @@ 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 { arc, hLine, vLine } from "../../../core/2d/index.js";
+import { arc, hLine, vLine, line } from "../../../core/2d/index.js";
 import { getEdgesByType } from "../../utils.js";
 describe("arc", () => {
     setupOC();
@@ -22,6 +22,20 @@ describe("arc", () => {
             expect(arcEdges.length).toBeGreaterThan(0);
         });
     });
+    describe("from three points (start, end, center)", () => {
+        it("should create an arc from start to end around a center point", () => {
+            sketch("xy", () => {
+                arc([0, 0], [20, 0], [10, 0]);
+                line([0, 0]);
+            });
+            const e = extrude(10);
+            render();
+            expect(e.getShapes()).toHaveLength(1);
+            const solid = e.getShapes()[0];
+            const arcEdges = getEdgesByType(solid, "arc");
+            expect(arcEdges.length).toBeGreaterThan(0);
+        });
+    });
     describe("combined with lines", () => {
         it("should create a shape with straight and curved edges", () => {
             sketch("xy", () => {