fluidcad 0.0.6 → 0.0.8

package/lib/dist/features/subtract2d.js

@@ -0,0 +1,80 @@
+import { Wire } from "../common/wire.js";
+import { Edge } from "../common/edge.js";
+import { Face } from "../common/face.js";
+import { GeometrySceneObject } from "./2d/geometry.js";
+import { BooleanOps } from "../oc/boolean-ops.js";
+import { ShapeOps } from "../oc/shape-ops.js";
+import { Explorer } from "../oc/explorer.js";
+import { FaceMaker2 } from "../oc/face-maker2.js";
+export class Subtract2D extends GeometrySceneObject {
+    target1;
+    target2;
+    constructor(target1, target2) {
+        super();
+        this.target1 = target1;
+        this.target2 = target2;
+    }
+    collectEdges(target) {
+        const edges = new Map();
+        for (const shape of target.getShapes()) {
+            if (shape instanceof Edge) {
+                edges.set(shape, target);
+            }
+            else if (shape instanceof Wire) {
+                for (const edge of shape.getEdges()) {
+                    edges.set(edge, target);
+                }
+            }
+        }
+        return edges;
+    }
+    build(context) {
+        const plane = this.sketch.getPlane();
+        const baseEdgeMap = this.collectEdges(this.target1);
+        const toolEdgeMap = this.collectEdges(this.target2);
+        const baseFaces = FaceMaker2.getRegions(Array.from(baseEdgeMap.keys()), plane);
+        const toolFaces = FaceMaker2.getRegions(Array.from(toolEdgeMap.keys()), plane);
+        if (baseFaces.length === 0 || toolFaces.length === 0) {
+            return;
+        }
+        const baseCompound = ShapeOps.makeCompoundRaw(baseFaces.map(f => f.getShape()));
+        const toolCompound = ShapeOps.makeCompoundRaw(toolFaces.map(f => f.getShape()));
+        const result = BooleanOps.cutShapesRaw(baseCompound, toolCompound);
+        const resultFaces = Explorer.findShapes(result, Explorer.getOcShapeType("face"))
+            .map(f => Face.fromTopoDSFace(Explorer.toFace(f)));
+        const newEdges = resultFaces.flatMap(face => face.getEdges());
+        for (const [edge, owner] of baseEdgeMap) {
+            owner.removeShape(edge, this);
+        }
+        for (const [edge, owner] of toolEdgeMap) {
+            owner.removeShape(edge, this);
+        }
+        this.addShapes(newEdges);
+    }
+    getDependencies() {
+        return [this.target1, this.target2];
+    }
+    createCopy(remap) {
+        const t1 = remap.get(this.target1) || this.target1;
+        const t2 = remap.get(this.target2) || this.target2;
+        return new Subtract2D(t1, t2);
+    }
+    compareTo(other) {
+        if (!(other instanceof Subtract2D)) {
+            return false;
+        }
+        if (!super.compareTo(other)) {
+            return false;
+        }
+        if (!this.target1.compareTo(other.target1) || !this.target2.compareTo(other.target2)) {
+            return false;
+        }
+        return true;
+    }
+    getType() {
+        return "subtract2d";
+    }
+    serialize() {
+        return {};
+    }
+}

package/lib/dist/filters/edge/belongs-to-face.d.ts

@@ -0,0 +1,22 @@
+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 BelongsToFaceFilter extends FilterBase<Edge> {
+    private faceFilterBuilders;
+    private scopeFaces;
+    constructor(faceFilterBuilders: FilterBuilderBase<Face>[]);
+    setScopeFaces(faces: Face[]): void;
+    match(shape: Edge): boolean;
+    compareTo(other: BelongsToFaceFilter): boolean;
+    transform(matrix: Matrix4): BelongsToFaceFilter;
+}
+export declare class NotBelongsToFaceFilter extends FilterBase<Edge> {
+    private faceFilterBuilders;
+    private scopeFaces;
+    constructor(faceFilterBuilders: FilterBuilderBase<Face>[]);
+    setScopeFaces(faces: Face[]): void;
+    match(shape: Edge): boolean;
+    compareTo(other: NotBelongsToFaceFilter): boolean;
+    transform(matrix: Matrix4): NotBelongsToFaceFilter;
+}

package/lib/dist/filters/edge/belongs-to-face.js

@@ -0,0 +1,67 @@
+import { FilterBase } from "../filter-base.js";
+export class BelongsToFaceFilter extends FilterBase {
+    faceFilterBuilders;
+    scopeFaces = [];
+    constructor(faceFilterBuilders) {
+        super();
+        this.faceFilterBuilders = faceFilterBuilders;
+    }
+    setScopeFaces(faces) {
+        this.scopeFaces = faces;
+    }
+    match(shape) {
+        const containingFaces = this.scopeFaces.filter(face => face.hasEdge(shape.getShape()) !== null);
+        return this.faceFilterBuilders.every(builder => {
+            const filters = builder.getFilters();
+            return containingFaces.some(face => filters.every(f => f.match(face)));
+        });
+    }
+    compareTo(other) {
+        if (this.faceFilterBuilders.length !== other.faceFilterBuilders.length) {
+            return false;
+        }
+        for (let i = 0; i < this.faceFilterBuilders.length; i++) {
+            if (!this.faceFilterBuilders[i].equals(other.faceFilterBuilders[i])) {
+                return false;
+            }
+        }
+        return true;
+    }
+    transform(matrix) {
+        const transformed = this.faceFilterBuilders.map(builder => builder.transform(matrix));
+        return new BelongsToFaceFilter(transformed);
+    }
+}
+export class NotBelongsToFaceFilter extends FilterBase {
+    faceFilterBuilders;
+    scopeFaces = [];
+    constructor(faceFilterBuilders) {
+        super();
+        this.faceFilterBuilders = faceFilterBuilders;
+    }
+    setScopeFaces(faces) {
+        this.scopeFaces = faces;
+    }
+    match(shape) {
+        const containingFaces = this.scopeFaces.filter(face => face.hasEdge(shape.getShape()) !== null);
+        return !this.faceFilterBuilders.every(builder => {
+            const filters = builder.getFilters();
+            return containingFaces.some(face => filters.every(f => f.match(face)));
+        });
+    }
+    compareTo(other) {
+        if (this.faceFilterBuilders.length !== other.faceFilterBuilders.length) {
+            return false;
+        }
+        for (let i = 0; i < this.faceFilterBuilders.length; i++) {
+            if (!this.faceFilterBuilders[i].equals(other.faceFilterBuilders[i])) {
+                return false;
+            }
+        }
+        return true;
+    }
+    transform(matrix) {
+        const transformed = this.faceFilterBuilders.map(builder => builder.transform(matrix));
+        return new NotBelongsToFaceFilter(transformed);
+    }
+}

package/lib/dist/filters/edge/belongs-to-object.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 BelongsToFaceFromSceneObjectFilter extends FilterBase<Edge> {
+    private sceneObject;
+    constructor(sceneObject: SceneObject);
+    match(shape: Edge): boolean;
+    compareTo(other: BelongsToFaceFromSceneObjectFilter): boolean;
+    transform(_matrix: Matrix4): BelongsToFaceFromSceneObjectFilter;
+}
+export declare class NotBelongsToFaceFromSceneObjectFilter extends FilterBase<Edge> {
+    private sceneObject;
+    constructor(sceneObject: SceneObject);
+    match(shape: Edge): boolean;
+    compareTo(other: NotBelongsToFaceFromSceneObjectFilter): boolean;
+    transform(_matrix: Matrix4): NotBelongsToFaceFromSceneObjectFilter;
+}

package/lib/dist/filters/edge/belongs-to-object.js

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

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

@@ -1,22 +1,107 @@
 import { PlaneLike } from "../../math/plane.js";
-import { Edge } from "../../common/shapes.js";
+import { Edge, Face } from "../../common/shapes.js";
 import { FilterBuilderBase } from "../filter-builder-base.js";
 import { PlaneObjectBase } from "../../features/plane-renderable-base.js";
+import { ISceneObject } from "../../core/interfaces.js";
 export declare class EdgeFilterBuilder extends FilterBuilderBase<Edge> {
     constructor();
+    /**
+     * Selects the edge at the given index.
+     * @param index - Zero-based edge index.
+     * @param shapes - The edge array to index into.
+     * @param originalShapes - Optional original edge array before filtering.
+     */
     atIndex(index: number, shapes: Edge[], originalShapes?: Edge[]): this;
+    /**
+     * Excludes the edge at the given index.
+     * @param index - Zero-based edge index to exclude.
+     * @param shapes - The edge array to index into.
+     * @param originalShapes - Optional original edge array before filtering.
+     */
     notAtIndex(index: number, shapes: Edge[], originalShapes?: Edge[]): this;
+    /**
+     * Selects edges that lie on the given plane.
+     * @param plane - The reference plane.
+     * @param offset - Optional distance to offset the plane before matching.
+     * @param bothDirections - When true, also matches the plane offset in the opposite direction.
+     */
     onPlane(plane: PlaneLike | PlaneObjectBase, offset?: number, bothDirections?: boolean): this;
+    /**
+     * Excludes edges that lie on the given plane.
+     * @param plane - The reference plane.
+     * @param offset - Optional distance to offset the plane before matching.
+     * @param bothDirections - When true, also excludes the plane offset in the opposite direction.
+     */
     notOnPlane(plane: PlaneLike | PlaneObjectBase, offset?: number, bothDirections?: boolean): this;
+    /**
+     * Selects edges that are parallel to the given plane.
+     * @param plane - The reference plane.
+     */
     parallelTo(plane: PlaneLike | PlaneObjectBase): this;
+    /**
+     * Excludes edges that are parallel to the given plane.
+     * @param plane - The reference plane.
+     */
     notParallelTo(plane: PlaneLike | PlaneObjectBase): this;
+    /**
+     * Selects edges that are perpendicular (vertical) to the given plane.
+     * @param plane - The reference plane.
+     */
     verticalTo(plane: PlaneLike | PlaneObjectBase): this;
+    /**
+     * Excludes edges that are perpendicular (vertical) to the given plane.
+     * @param plane - The reference plane.
+     */
     notVerticalTo(plane: PlaneLike | PlaneObjectBase): this;
+    /**
+     * Selects circular edges, optionally matching a specific diameter.
+     * @param diameter - Optional diameter to match.
+     */
     circle(diameter?: number): this;
+    /**
+     * Excludes circular edges, optionally matching a specific diameter.
+     * @param diameter - Optional diameter to exclude.
+     */
     notCircle(diameter?: number): this;
+    /**
+     * Selects arc edges, optionally matching a specific radius.
+     * @param radius - Optional radius to match.
+     */
     arc(radius?: number): this;
+    /**
+     * Excludes arc edges, optionally matching a specific radius.
+     * @param radius - Optional radius to exclude.
+     */
     notArc(radius?: number): this;
-    line(): this;
-    notLine(): this;
+    /**
+     * Selects straight-line edges, optionally matching a specific length.
+     * @param length - Optional length to match.
+     */
+    line(length?: number): this;
+    /**
+     * Excludes straight-line edges, optionally matching a specific length.
+     * @param length - Optional length to exclude.
+     */
+    notLine(length?: number): this;
+    /**
+     * Selects edges that belong to a face from the given scene object.
+     * @param sceneObject - A scene object whose faces are matched against.
+     */
+    belongsToFace(sceneObject: ISceneObject): this;
+    /**
+     * Selects edges that belong to a face matching the given face filters.
+     * @param faceFilters - One or more face filter builders to match against.
+     */
+    belongsToFace(...faceFilters: FilterBuilderBase<Face>[]): this;
+    /**
+     * Excludes edges that belong to a face from the given scene object.
+     * @param sceneObject - A scene object whose faces are matched against.
+     */
+    notBelongsToFace(sceneObject: ISceneObject): this;
+    /**
+     * Excludes edges that belong to a face matching the given face filters.
+     * @param faceFilters - One or more face filter builders to match against.
+     */
+    notBelongsToFace(...faceFilters: FilterBuilderBase<Face>[]): this;
     static build(): EdgeFilterBuilder;
 }

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

@@ -9,20 +9,41 @@ import { NotVerticalFilter, VerticalFilter } from "./vertical-plane.js";
 import { PlaneObject } from "../../features/plane.js";
 import { PlaneObjectBase } from "../../features/plane-renderable-base.js";
 import { AtIndexFilter, NotAtIndexFilter } from "./at-index.js";
+import { BelongsToFaceFilter, NotBelongsToFaceFilter } from "./belongs-to-face.js";
+import { BelongsToFaceFromSceneObjectFilter, NotBelongsToFaceFromSceneObjectFilter } from "./belongs-to-object.js";
+import { SceneObject } from "../../common/scene-object.js";
 export class EdgeFilterBuilder extends FilterBuilderBase {
     constructor() {
         super();
     }
+    /**
+     * Selects the edge at the given index.
+     * @param index - Zero-based edge index.
+     * @param shapes - The edge array to index into.
+     * @param originalShapes - Optional original edge array before filtering.
+     */
     atIndex(index, shapes, originalShapes) {
         const filter = new AtIndexFilter(index, shapes, originalShapes);
         this.filters.push(filter);
         return this;
     }
+    /**
+     * Excludes the edge at the given index.
+     * @param index - Zero-based edge index to exclude.
+     * @param shapes - The edge array to index into.
+     * @param originalShapes - Optional original edge array before filtering.
+     */
     notAtIndex(index, shapes, originalShapes) {
         const filter = new NotAtIndexFilter(index, shapes, originalShapes);
         this.filters.push(filter);
         return this;
     }
+    /**
+     * Selects edges that lie on the given plane.
+     * @param plane - The reference plane.
+     * @param offset - Optional distance to offset the plane before matching.
+     * @param bothDirections - When true, also matches the plane offset in the opposite direction.
+     */
     onPlane(plane, offset = 0, bothDirections = false) {
         if (!plane) {
             throw new Error('Plane is required');
@@ -48,6 +69,12 @@ export class EdgeFilterBuilder extends FilterBuilderBase {
         this.filters.push(filter);
         return this;
     }
+    /**
+     * Excludes edges that lie on the given plane.
+     * @param plane - The reference plane.
+     * @param offset - Optional distance to offset the plane before matching.
+     * @param bothDirections - When true, also excludes the plane offset in the opposite direction.
+     */
     notOnPlane(plane, offset = 0, bothDirections = false) {
         if (!plane) {
             throw new Error('Plane is required');
@@ -73,6 +100,10 @@ export class EdgeFilterBuilder extends FilterBuilderBase {
         this.filters.push(filter);
         return this;
     }
+    /**
+     * Selects edges that are parallel to the given plane.
+     * @param plane - The reference plane.
+     */
     parallelTo(plane) {
         if (!plane) {
             throw new Error('Plane is required');
@@ -88,6 +119,10 @@ export class EdgeFilterBuilder extends FilterBuilderBase {
         this.filters.push(filter);
         return this;
     }
+    /**
+     * Excludes edges that are parallel to the given plane.
+     * @param plane - The reference plane.
+     */
     notParallelTo(plane) {
         if (!plane) {
             throw new Error('Plane is required');
@@ -103,6 +138,10 @@ export class EdgeFilterBuilder extends FilterBuilderBase {
         this.filters.push(filter);
         return this;
     }
+    /**
+     * Selects edges that are perpendicular (vertical) to the given plane.
+     * @param plane - The reference plane.
+     */
     verticalTo(plane) {
         if (!plane) {
             throw new Error('Plane is required');
@@ -118,6 +157,10 @@ export class EdgeFilterBuilder extends FilterBuilderBase {
         this.filters.push(filter);
         return this;
     }
+    /**
+     * Excludes edges that are perpendicular (vertical) to the given plane.
+     * @param plane - The reference plane.
+     */
     notVerticalTo(plane) {
         if (!plane) {
             throw new Error('Plane is required');
@@ -133,36 +176,90 @@ export class EdgeFilterBuilder extends FilterBuilderBase {
         this.filters.push(filter);
         return this;
     }
+    /**
+     * Selects circular edges, 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 edges, 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 arc edges, optionally matching a specific radius.
+     * @param radius - Optional radius to match.
+     */
     arc(radius) {
         const filter = new ArcFilter(radius);
         this.filters.push(filter);
         return this;
     }
+    /**
+     * Excludes arc edges, optionally matching a specific radius.
+     * @param radius - Optional radius to exclude.
+     */
     notArc(radius) {
         const filter = new NotArcFilter(radius);
         this.filters.push(filter);
         return this;
     }
-    line() {
-        const filter = new LineFilter();
+    /**
+     * Selects straight-line edges, optionally matching a specific length.
+     * @param length - Optional length to match.
+     */
+    line(length) {
+        const filter = new LineFilter(length);
         this.filters.push(filter);
         return this;
     }
-    notLine() {
-        const filter = new NotLineFilter();
+    /**
+     * Excludes straight-line edges, optionally matching a specific length.
+     * @param length - Optional length to exclude.
+     */
+    notLine(length) {
+        const filter = new NotLineFilter(length);
         this.filters.push(filter);
         return this;
     }
+    belongsToFace(...args) {
+        const filterBuilders = [];
+        for (const arg of args) {
+            if (arg instanceof SceneObject) {
+                this.filters.push(new BelongsToFaceFromSceneObjectFilter(arg));
+            }
+            else {
+                filterBuilders.push(arg);
+            }
+        }
+        if (filterBuilders.length > 0) {
+            this.filters.push(new BelongsToFaceFilter(filterBuilders));
+        }
+        return this;
+    }
+    notBelongsToFace(...args) {
+        const filterBuilders = [];
+        for (const arg of args) {
+            if (arg instanceof SceneObject) {
+                this.filters.push(new NotBelongsToFaceFromSceneObjectFilter(arg));
+            }
+            else {
+                filterBuilders.push(arg);
+            }
+        }
+        if (filterBuilders.length > 0) {
+            this.filters.push(new NotBelongsToFaceFilter(filterBuilders));
+        }
+        return this;
+    }
     static build() {
         return new EdgeFilterBuilder();
     }

package/lib/dist/filters/edge/line-filter.d.ts

@@ -2,12 +2,15 @@ import { Matrix4 } from "../../math/matrix4.js";
 import { Edge } from "../../common/shapes.js";
 import { FilterBase } from "../filter-base.js";
 export declare class LineFilter extends FilterBase<Edge> {
-    constructor();
+    private length?;
+    constructor(length?: number);
     match(shape: Edge): boolean;
     compareTo(other: LineFilter): boolean;
     transform(matrix: Matrix4): LineFilter;
 }
 export declare class NotLineFilter extends FilterBase<Edge> {
+    private length?;
+    constructor(length?: number);
     match(shape: Edge): boolean;
     compareTo(other: NotLineFilter): boolean;
     transform(matrix: Matrix4): NotLineFilter;

package/lib/dist/filters/edge/line-filter.js

@@ -1,27 +1,34 @@
 import { FilterBase } from "../filter-base.js";
 import { EdgeQuery } from "../../oc/edge-query.js";
 export class LineFilter extends FilterBase {
-    constructor() {
+    length;
+    constructor(length) {
         super();
+        this.length = length;
     }
     match(shape) {
-        return EdgeQuery.isLineEdge(shape);
+        return EdgeQuery.isLineEdge(shape, this.length);
     }
     compareTo(other) {
-        return true;
+        return this.length === other.length;
     }
     transform(matrix) {
-        return new LineFilter();
+        return new LineFilter(this.length);
     }
 }
 export class NotLineFilter extends FilterBase {
+    length;
+    constructor(length) {
+        super();
+        this.length = length;
+    }
     match(shape) {
-        return !EdgeQuery.isLineEdge(shape);
+        return !EdgeQuery.isLineEdge(shape, this.length);
     }
     compareTo(other) {
-        return true;
+        return this.length === other.length;
     }
     transform(matrix) {
-        return new NotLineFilter();
+        return new NotLineFilter(this.length);
     }
 }

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

@@ -0,0 +1,17 @@
+import { Matrix4 } from "../../math/matrix4.js";
+import { Face } from "../../common/shapes.js";
+import { FilterBase } from "../filter-base.js";
+export declare class EdgeCountFilter extends FilterBase<Face> {
+    private count;
+    constructor(count: number);
+    match(shape: Face): boolean;
+    compareTo(other: EdgeCountFilter): boolean;
+    transform(matrix: Matrix4): EdgeCountFilter;
+}
+export declare class NotEdgeCountFilter extends FilterBase<Face> {
+    private count;
+    constructor(count: number);
+    match(shape: Face): boolean;
+    compareTo(other: NotEdgeCountFilter): boolean;
+    transform(matrix: Matrix4): NotEdgeCountFilter;
+}

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

@@ -0,0 +1,33 @@
+import { FilterBase } from "../filter-base.js";
+export class EdgeCountFilter extends FilterBase {
+    count;
+    constructor(count) {
+        super();
+        this.count = count;
+    }
+    match(shape) {
+        return shape.getEdges().length === this.count;
+    }
+    compareTo(other) {
+        return this.count === other.count;
+    }
+    transform(matrix) {
+        return new EdgeCountFilter(this.count);
+    }
+}
+export class NotEdgeCountFilter extends FilterBase {
+    count;
+    constructor(count) {
+        super();
+        this.count = count;
+    }
+    match(shape) {
+        return shape.getEdges().length !== this.count;
+    }
+    compareTo(other) {
+        return this.count === other.count;
+    }
+    transform(matrix) {
+        return new NotEdgeCountFilter(this.count);
+    }
+}