fluidcad 0.0.2

package/lib/dist/features/state-select.js

@@ -0,0 +1,73 @@
+import { SceneObject } from "../common/scene-object.js";
+import { ShapeFilter } from "../filters/filter.js";
+export class StateSelectSceneObject extends SceneObject {
+    stateKey;
+    filters;
+    sourceParent;
+    _isBuilt = false;
+    constructor(stateKey, filters, sourceParent) {
+        super();
+        this.stateKey = stateKey;
+        this.filters = filters;
+        this.sourceParent = sourceParent;
+    }
+    build(_context) {
+        if (this._isBuilt) {
+            return;
+        }
+        const shapes = this.sourceParent.getState(this.stateKey) || [];
+        const filtered = this.applyFilters(shapes, this.filters);
+        this.addShapes(filtered);
+        this._isBuilt = true;
+    }
+    getShapes(filter, type) {
+        if (!this._isBuilt) {
+            this.build();
+        }
+        return super.getShapes(filter, type);
+    }
+    applyFilters(shapes, filters) {
+        if (filters.length === 0) {
+            return shapes;
+        }
+        return new ShapeFilter(shapes, ...filters).apply();
+    }
+    getDependencies() {
+        return [this.sourceParent];
+    }
+    createCopy(remap) {
+        const remappedParent = remap.get(this.sourceParent) || this.sourceParent;
+        return new StateSelectSceneObject(this.stateKey, this.filters, remappedParent);
+    }
+    compareTo(other) {
+        if (!(other instanceof StateSelectSceneObject)) {
+            return false;
+        }
+        if (!super.compareTo(other)) {
+            return false;
+        }
+        if (this.stateKey !== other.stateKey) {
+            return false;
+        }
+        if (!this.sourceParent.compareTo(other.sourceParent)) {
+            return false;
+        }
+        if (this.filters.length !== other.filters.length) {
+            return false;
+        }
+        for (let i = 0; i < this.filters.length; i++) {
+            if (!this.filters[i].equals(other.filters[i])) {
+                return false;
+            }
+        }
+        return true;
+    }
+    getType() {
+        return "state-select";
+    }
+    serialize() {
+        return {
+            stateKey: this.stateKey,
+        };
+    }
+}

package/lib/dist/features/static-scene-object.d.ts

@@ -0,0 +1,10 @@
+import { SceneObject } from "../common/scene-object.js";
+import { Shape } from "../common/shape.js";
+export declare class StaticSceneObject extends SceneObject {
+    shapes: Shape[];
+    constructor(shapes: Shape[]);
+    build(): void;
+    compareTo(other: StaticSceneObject): boolean;
+    getType(): string;
+    serialize(): {};
+}

package/lib/dist/features/static-scene-object.js

@@ -0,0 +1,21 @@
+import { SceneObject } from "../common/scene-object.js";
+export class StaticSceneObject extends SceneObject {
+    shapes;
+    constructor(shapes) {
+        super();
+        this.shapes = shapes;
+        this.build();
+    }
+    build() {
+        this.addShapes(this.shapes);
+    }
+    compareTo(other) {
+        return super.compareTo(other);
+    }
+    getType() {
+        return "static";
+    }
+    serialize() {
+        return {};
+    }
+}

package/lib/dist/features/subtract.d.ts

@@ -0,0 +1,13 @@
+import { SceneObject } from "../common/scene-object.js";
+export declare class Subtract extends SceneObject {
+    solid1: SceneObject;
+    solid2: SceneObject;
+    constructor(solid1: SceneObject, solid2: SceneObject);
+    build(): void;
+    compareTo(other: Subtract): boolean;
+    getType(): string;
+    serialize(): {
+        shape1: any;
+        shape2: any;
+    };
+}

package/lib/dist/features/subtract.js

@@ -0,0 +1,56 @@
+import { SceneObject } from "../common/scene-object.js";
+import { BooleanOps } from "../oc/boolean-ops.js";
+import { Explorer } from "../oc/explorer.js";
+import { ShapeOps } from "../oc/shape-ops.js";
+import { Solid } from "../common/shapes.js";
+export class Subtract extends SceneObject {
+    solid1;
+    solid2;
+    constructor(solid1, solid2) {
+        super();
+        this.solid1 = solid1;
+        this.solid2 = solid2;
+    }
+    build() {
+        const stock = this.solid1.getShapes();
+        const toBeRemoved = this.solid2.getShapes();
+        const stockCompound = ShapeOps.makeCompound(stock);
+        const toBeRemovedCompound = ShapeOps.makeCompound(toBeRemoved);
+        const result = BooleanOps.cutShapes(stockCompound, toBeRemovedCompound);
+        const shapes = Explorer.findShapes(result.getShape(), Explorer.getOcShapeType("solid"));
+        console.log('Subtract Result:::::', shapes.length);
+        const newShapes = shapes.map(s => ShapeOps.cleanShapeRaw(s)).map(s => Solid.fromTopoDSSolid(Explorer.toSolid(s)));
+        for (const shape of toBeRemoved) {
+            this.solid2.removeShape(shape, this);
+        }
+        for (const shape of stock) {
+            this.solid1.removeShape(shape, this);
+        }
+        this.addShapes(newShapes);
+    }
+    compareTo(other) {
+        if (!(other instanceof Subtract)) {
+            return false;
+        }
+        if (!super.compareTo(other)) {
+            return false;
+        }
+        if (this.solid1.constructor !== other.solid1.constructor
+            || this.solid2.constructor !== other.solid2.constructor) {
+            return false;
+        }
+        if (!this.solid1.compareTo(other.solid1) || !this.solid2.compareTo(other.solid2)) {
+            return false;
+        }
+        return true;
+    }
+    getType() {
+        return "subtract";
+    }
+    serialize() {
+        return {
+            shape1: this.solid1.serialize(),
+            shape2: this.solid2.serialize()
+        };
+    }
+}

package/lib/dist/features/sweep.d.ts

@@ -0,0 +1,22 @@
+import { BuildSceneObjectContext, SceneObject } from "../common/scene-object.js";
+import { Extrudable } from "../helpers/types.js";
+import { ExtrudeBase } from "./extrude-base.js";
+import { ISweep } from "../core/interfaces.js";
+export declare class Sweep extends ExtrudeBase implements ISweep {
+    private _path;
+    constructor(path: SceneObject, extrudable?: Extrudable);
+    get path(): SceneObject;
+    build(context: BuildSceneObjectContext): void;
+    private getSpineWire;
+    getDependencies(): SceneObject[];
+    createCopy(remap: Map<SceneObject, SceneObject>): SceneObject;
+    compareTo(other: Sweep): boolean;
+    getType(): string;
+    serialize(): {
+        path: any;
+        extrudable: any;
+        operationMode: "new" | "remove";
+        picking: true;
+        pickPoints: number[][];
+    };
+}

package/lib/dist/features/sweep.js

@@ -0,0 +1,129 @@
+import { Explorer } from "../oc/explorer.js";
+import { SweepOps } from "../oc/sweep-ops.js";
+import { WireOps } from "../oc/wire-ops.js";
+import { FaceMaker2 } from "../oc/face-maker2.js";
+import { ExtrudeBase } from "./extrude-base.js";
+import { fuseWithSceneObjects, cutWithSceneObjects } from "../helpers/scene-helpers.js";
+export class Sweep extends ExtrudeBase {
+    _path;
+    constructor(path, extrudable) {
+        super(extrudable);
+        this._path = path;
+    }
+    get path() {
+        return this._path;
+    }
+    build(context) {
+        const plane = this.extrudable.getPlane();
+        const pickedFaces = this.resolvePickedFaces(plane);
+        if (pickedFaces !== null && pickedFaces.length === 0) {
+            return;
+        }
+        // Extract spine wire from path
+        const spineWire = this.getSpineWire(this._path);
+        // Extract profile faces from extrudable
+        const profileFaces = pickedFaces ?? FaceMaker2.getRegions(this.extrudable.getGeometries(), plane, this.getDrill());
+        if (profileFaces.length === 0) {
+            throw new Error("Could not extract profile faces from extrudable.");
+        }
+        // Perform sweep
+        const sweepResult = SweepOps.makeSweep(spineWire, profileFaces);
+        const newShapes = sweepResult.solids;
+        // Classify faces using FirstShape/LastShape from the OC result
+        const startFaces = [];
+        const endFaces = [];
+        const sideFaces = [];
+        const firstShapeFromOC = sweepResult.firstShape;
+        const lastShapeFromOC = sweepResult.lastShape;
+        for (const shape of newShapes) {
+            const shapeFaces = Explorer.findFacesWrapped(shape);
+            for (const f of shapeFaces) {
+                if (firstShapeFromOC && f.getShape().IsSame(firstShapeFromOC)) {
+                    startFaces.push(f);
+                }
+                else if (lastShapeFromOC && f.getShape().IsSame(lastShapeFromOC)) {
+                    endFaces.push(f);
+                }
+                else {
+                    sideFaces.push(f);
+                }
+            }
+        }
+        this.setState('start-faces', startFaces);
+        this.setState('end-faces', endFaces);
+        this.setState('side-faces', sideFaces);
+        // Remove consumed input shapes
+        this.extrudable.removeShapes(this);
+        this._path.removeShapes(this);
+        // Handle boolean operation based on operation mode
+        if (this._operationMode === 'remove') {
+            const scope = this.resolveFusionScope(context.getSceneObjects());
+            cutWithSceneObjects(scope, newShapes, plane, 0, this);
+            return;
+        }
+        const sceneObjects = this.resolveFusionScope(context.getSceneObjects());
+        if (sceneObjects.length === 0) {
+            this.addShapes(newShapes);
+            return;
+        }
+        const fusionResult = fuseWithSceneObjects(sceneObjects, newShapes);
+        for (const modifiedShape of fusionResult.modifiedShapes) {
+            if (modifiedShape.object) {
+                modifiedShape.object.removeShape(modifiedShape.shape, this);
+            }
+        }
+        this.addShapes(fusionResult.newShapes);
+    }
+    getSpineWire(pathObj) {
+        const shapes = pathObj.getShapes({ excludeMeta: false });
+        const edges = shapes.flatMap(s => s.getSubShapes('edge'));
+        console.log(`Sweep: Extracted ${edges.length} edges from path object for spine wire.`);
+        return WireOps.makeWireFromEdges(edges);
+    }
+    getDependencies() {
+        const deps = [];
+        if (this.extrudable) {
+            deps.push(this.extrudable);
+        }
+        if (this._path) {
+            deps.push(this._path);
+        }
+        return deps;
+    }
+    createCopy(remap) {
+        const extrudable = this.extrudable
+            ? (remap.get(this.extrudable) || this.extrudable)
+            : undefined;
+        const path = remap.get(this._path) || this._path;
+        return new Sweep(path, extrudable).syncWith(this);
+    }
+    compareTo(other) {
+        if (!(other instanceof Sweep)) {
+            return false;
+        }
+        if (!super.compareTo(other)) {
+            return false;
+        }
+        if (!this._path.compareTo(other._path)) {
+            return false;
+        }
+        if (!this.extrudable.compareTo(other.extrudable)) {
+            return false;
+        }
+        return true;
+    }
+    getType() {
+        return "sweep";
+    }
+    serialize() {
+        return {
+            path: this._path.serialize(),
+            extrudable: this.extrudable.serialize(),
+            operationMode: this._operationMode !== 'add' ? this._operationMode : undefined,
+            picking: this.isPicking() || undefined,
+            pickPoints: this.isPicking()
+                ? this._pickPoints.map(p => { const pt = p.asPoint2D(); return [pt.x, pt.y]; })
+                : undefined,
+        };
+    }
+}

package/lib/dist/features/translate.d.ts

@@ -0,0 +1,17 @@
+import { BuildSceneObjectContext, SceneObject } from "../common/scene-object.js";
+import { LazyVertex } from "./lazy-vertex.js";
+export declare class Translate extends SceneObject {
+    private amount;
+    private copy;
+    private _targetObjects;
+    constructor(amount: LazyVertex, copy?: boolean, ...targets: SceneObject[]);
+    get targetObjects(): SceneObject[];
+    build(context: BuildSceneObjectContext): void;
+    getDependencies(): SceneObject[];
+    createCopy(remap: Map<SceneObject, SceneObject>): SceneObject;
+    compareTo(other: Translate): boolean;
+    getType(): string;
+    serialize(): {
+        amount: LazyVertex;
+    };
+}

package/lib/dist/features/translate.js

@@ -0,0 +1,76 @@
+import { SceneObject } from "../common/scene-object.js";
+import { Matrix4 } from "../math/matrix4.js";
+import { ShapeOps } from "../oc/shape-ops.js";
+export class Translate extends SceneObject {
+    amount;
+    copy;
+    _targetObjects = null;
+    constructor(amount, copy = false, ...targets) {
+        super();
+        this.amount = amount;
+        this.copy = copy;
+        this._targetObjects = targets.length > 0 ? targets : null;
+    }
+    get targetObjects() {
+        return this._targetObjects;
+    }
+    build(context) {
+        const objects = this.targetObjects || context.getSceneObjects();
+        for (const obj of objects) {
+            const shapes = obj.getShapes();
+            for (const shape of shapes) {
+                if (!shape.isSolid()) {
+                    continue;
+                }
+                const amount = this.amount.asPoint();
+                let transformed = ShapeOps.transform(shape, Matrix4.fromTranslation(amount.x, amount.y, amount.z));
+                this.addShape(transformed);
+                if (!this.copy) {
+                    obj.removeShape(shape, this);
+                }
+            }
+        }
+    }
+    getDependencies() {
+        return this.targetObjects ? [...this.targetObjects] : [];
+    }
+    createCopy(remap) {
+        const targets = this.targetObjects
+            ? this.targetObjects.map(obj => remap.get(obj) || obj)
+            : [];
+        return new Translate(this.amount, this.copy, ...targets);
+    }
+    compareTo(other) {
+        if (!(other instanceof Translate)) {
+            return false;
+        }
+        if (!super.compareTo(other)) {
+            return false;
+        }
+        if (!this.amount.compareTo(other.amount)) {
+            return false;
+        }
+        if (this.copy !== other.copy) {
+            return false;
+        }
+        const thisTargetObjects = this.targetObjects || [];
+        const otherTargetObjects = other.targetObjects || [];
+        if (thisTargetObjects.length !== otherTargetObjects.length) {
+            return false;
+        }
+        for (let i = 0; i < thisTargetObjects.length; i++) {
+            if (!thisTargetObjects[i].compareTo(otherTargetObjects[i])) {
+                return false;
+            }
+        }
+        return true;
+    }
+    getType() {
+        return "translate";
+    }
+    serialize() {
+        return {
+            amount: this.amount
+        };
+    }
+}

package/lib/dist/features/translate2d.d.ts

@@ -0,0 +1,16 @@
+import { BuildSceneObjectContext, SceneObject } from "../common/scene-object.js";
+import { LazyVertex } from "./lazy-vertex.js";
+import { PlaneObjectBase } from "./plane-renderable-base.js";
+export declare class Translate2D extends SceneObject {
+    private targetObjects;
+    private amount;
+    private plane;
+    constructor(targetObjects: SceneObject[], amount: LazyVertex, plane: PlaneObjectBase);
+    build(context: BuildSceneObjectContext): void;
+    clone(): SceneObject[];
+    compareTo(other: Translate2D): boolean;
+    getType(): string;
+    serialize(): {
+        amount: LazyVertex;
+    };
+}

package/lib/dist/features/translate2d.js

@@ -0,0 +1,61 @@
+import { SceneObject } from "../common/scene-object.js";
+import { Matrix4 } from "../math/matrix4.js";
+import { ShapeOps } from "../oc/shape-ops.js";
+export class Translate2D extends SceneObject {
+    targetObjects;
+    amount;
+    plane;
+    constructor(targetObjects, amount, plane) {
+        super();
+        this.targetObjects = targetObjects;
+        this.amount = amount;
+        this.plane = plane;
+    }
+    build(context) {
+        const objects = this.targetObjects || context.getSceneObjects();
+        const p = this.plane.getPlane();
+        const local = this.amount.asPoint2D();
+        const worldOffset = p.xDirection.multiply(local.x).add(p.yDirection.multiply(local.y));
+        for (const obj of objects) {
+            const shapes = obj.getShapes(false);
+            for (const shape of shapes) {
+                const transformed = ShapeOps.transform(shape, Matrix4.fromTranslation(worldOffset.x, worldOffset.y, worldOffset.z));
+                this.addShape(transformed);
+                obj.removeShape(shape, this);
+            }
+        }
+        this.plane.removeShapes(this);
+    }
+    clone() {
+        const targetObjects = this.targetObjects.map(obj => obj.clone()).flat();
+        const plane = this.plane.clone()[0];
+        return [new Translate2D(targetObjects, this.amount, plane)];
+    }
+    compareTo(other) {
+        if (!(other instanceof Translate2D)) {
+            return false;
+        }
+        if (!this.amount.compareTo(other.amount)) {
+            return false;
+        }
+        const thisTargetObjects = this.targetObjects || [];
+        const otherTargetObjects = other.targetObjects || [];
+        if (thisTargetObjects.length !== otherTargetObjects.length) {
+            return false;
+        }
+        for (let i = 0; i < thisTargetObjects.length; i++) {
+            if (!thisTargetObjects[i].compareTo(otherTargetObjects[i])) {
+                return false;
+            }
+        }
+        return true;
+    }
+    getType() {
+        return "translate2d";
+    }
+    serialize() {
+        return {
+            amount: this.amount
+        };
+    }
+}

package/lib/dist/features/trim2d.d.ts

@@ -0,0 +1,15 @@
+import { SceneObject } from "../common/scene-object.js";
+import { GeometrySceneObject } from "./2d/geometry.js";
+import { LazyVertex } from "./lazy-vertex.js";
+export declare class Trim2D extends GeometrySceneObject {
+    private _points;
+    constructor();
+    points(...ps: LazyVertex[]): this;
+    get trimPoints(): LazyVertex[];
+    build(): void;
+    getDependencies(): SceneObject[];
+    createCopy(remap: Map<SceneObject, SceneObject>): SceneObject;
+    compareTo(other: Trim2D): boolean;
+    getType(): string;
+    serialize(): {};
+}

package/lib/dist/features/trim2d.js

@@ -0,0 +1,154 @@
+import { Wire } from "../common/wire.js";
+import { Edge } from "../common/edge.js";
+import { GeometrySceneObject } from "./2d/geometry.js";
+import { EdgeOps } from "../oc/edge-ops.js";
+export class Trim2D extends GeometrySceneObject {
+    _points = [];
+    constructor() {
+        super();
+    }
+    points(...ps) {
+        this._points = ps;
+        return this;
+    }
+    get trimPoints() {
+        return this._points;
+    }
+    build() {
+        const plane = this.sketch.getPlane();
+        const sourceWires = this.sketch.getGeometriesWithOwner();
+        // Collect all individual edges from wires/edges in the sketch
+        const allEdges = [];
+        const edgeToOwner = new Map();
+        for (const [wireOrEdge, owner] of sourceWires) {
+            if (wireOrEdge instanceof Wire) {
+                for (const edge of wireOrEdge.getEdges()) {
+                    allEdges.push(edge);
+                    edgeToOwner.set(edge, { wire: wireOrEdge, owner });
+                }
+            }
+            else if (wireOrEdge instanceof Edge) {
+                allEdges.push(wireOrEdge);
+                edgeToOwner.set(wireOrEdge, { wire: wireOrEdge, owner });
+            }
+        }
+        if (allEdges.length === 0) {
+            return;
+        }
+        const TRIM_TOLERANCE = 50;
+        // Split all edges at intersection points
+        const splitResult = EdgeOps.splitEdgesWithMapping(allEdges);
+        const splitEdges = splitResult.edges;
+        const sourceIndex = splitResult.sourceIndex;
+        // Find split edges to remove
+        const splitEdgesToRemove = new Set();
+        if (this._points.length > 0) {
+            for (const lazyPoint of this._points) {
+                const point2d = lazyPoint.asPoint2D();
+                const point3d = plane.localToWorld(point2d);
+                for (const idx of EdgeOps.findNearestEdgeIndices(splitEdges, point3d, TRIM_TOLERANCE)) {
+                    splitEdgesToRemove.add(idx);
+                }
+            }
+            // Remove affected original wires and re-add surviving split edges
+            const removedWires = new Set();
+            for (const idx of splitEdgesToRemove) {
+                const origEdge = allEdges[sourceIndex[idx]];
+                const entry = edgeToOwner.get(origEdge);
+                if (!removedWires.has(entry.wire)) {
+                    removedWires.add(entry.wire);
+                    entry.owner.removeShape(entry.wire, this);
+                }
+            }
+            for (let i = 0; i < splitEdges.length; i++) {
+                if (splitEdgesToRemove.has(i)) {
+                    continue;
+                }
+                const origEdge = allEdges[sourceIndex[i]];
+                const entry = edgeToOwner.get(origEdge);
+                if (removedWires.has(entry.wire)) {
+                    this.addShape(splitEdges[i]);
+                }
+            }
+        }
+        // --- Meta shapes for segment-level hover ---
+        // Originals with trims need the first-pass split (to preserve trim boundaries).
+        // Originals without trims are re-split against only surviving edges
+        // (so ghost intersections from fully-removed edges disappear).
+        const origSurvives = new Set();
+        const origHasTrim = new Array(allEdges.length).fill(false);
+        for (let i = 0; i < splitEdges.length; i++) {
+            if (!splitEdgesToRemove.has(i)) {
+                origSurvives.add(sourceIndex[i]);
+            }
+            else {
+                origHasTrim[sourceIndex[i]] = true;
+            }
+        }
+        // Re-split only surviving originals (for clean meta shapes of untrimmed edges)
+        const metaInputEdges = [];
+        const metaInputToOrig = [];
+        for (let i = 0; i < allEdges.length; i++) {
+            if (origSurvives.has(i)) {
+                metaInputEdges.push(allEdges[i]);
+                metaInputToOrig.push(i);
+            }
+        }
+        const metaSplit = EdgeOps.splitEdgesWithMapping(metaInputEdges);
+        // Untrimmed originals: use re-split result (clean, no ghost intersections)
+        for (let i = 0; i < metaSplit.edges.length; i++) {
+            const origIdx = metaInputToOrig[metaSplit.sourceIndex[i]];
+            if (origHasTrim[origIdx]) {
+                continue;
+            }
+            const metaEdge = Edge.fromTopoDSEdge(metaSplit.edges[i].getShape());
+            metaEdge.markAsMetaShape('trim');
+            this.addShape(metaEdge);
+        }
+        // Trimmed originals: use first-pass surviving split edges (preserve boundaries)
+        for (let i = 0; i < splitEdges.length; i++) {
+            if (splitEdgesToRemove.has(i)) {
+                continue;
+            }
+            if (!origHasTrim[sourceIndex[i]]) {
+                continue;
+            }
+            const metaEdge = Edge.fromTopoDSEdge(splitEdges[i].getShape());
+            metaEdge.markAsMetaShape('trim');
+            this.addShape(metaEdge);
+        }
+    }
+    getDependencies() {
+        return [];
+    }
+    createCopy(remap) {
+        const copy = new Trim2D();
+        if (this._points.length > 0) {
+            copy.points(...this._points);
+        }
+        return copy;
+    }
+    compareTo(other) {
+        if (!(other instanceof Trim2D)) {
+            return false;
+        }
+        if (!super.compareTo(other)) {
+            return false;
+        }
+        if (this._points.length !== other._points.length) {
+            return false;
+        }
+        for (let i = 0; i < this._points.length; i++) {
+            if (!this._points[i].compareTo(other._points[i])) {
+                return false;
+            }
+        }
+        return true;
+    }
+    getType() {
+        return "trim2d";
+    }
+    serialize() {
+        return {};
+    }
+}

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

@@ -0,0 +1,8 @@
+import { Matrix4 } from "../math/matrix4.js";
+import { Shape } from "../common/shapes.js";
+import { FilterBase } from "./filter-base.js";
+export declare class AllFilter extends FilterBase<Shape> {
+    match(_shape: Shape): boolean;
+    compareTo(other: AllFilter): boolean;
+    transform(_matrix: Matrix4): AllFilter;
+}