fluidcad 0.0.2

package/lib/dist/features/shell.js

@@ -0,0 +1,214 @@
+import { SceneObject } from "../common/scene-object.js";
+import { ShellOps } from "../oc/shell-ops.js";
+import { LazySelectionSceneObject } from "./lazy-scene-object.js";
+import { Explorer } from "../oc/explorer.js";
+import { EdgeOps } from "../oc/edge-ops.js";
+import { FaceQuery } from "../oc/face-query.js";
+import { FaceFilterBuilder } from "../filters/face/face-filter.js";
+import { EdgeFilterBuilder } from "../filters/edge/edge-filter.js";
+import { ShapeFilter } from "../filters/filter.js";
+export class Shell extends SceneObject {
+    thickness;
+    _faceSelections = [];
+    constructor(thickness, faceSelections) {
+        super();
+        this.thickness = thickness;
+        this._faceSelections = faceSelections ?? [];
+    }
+    get faceSelections() {
+        return this._faceSelections;
+    }
+    build(context) {
+        const shapeObjMap = new Map();
+        for (const obj of context.getSceneObjects()) {
+            if (obj.id === this.parentId) {
+                continue;
+            }
+            const shapes = obj.getShapes({ excludeMeta: false }, 'solid');
+            for (const shape of shapes) {
+                shapeObjMap.set(shape, obj);
+            }
+        }
+        if (!shapeObjMap.size) {
+            return;
+        }
+        const allFaceShapes = [];
+        for (const sel of this.faceSelections) {
+            allFaceShapes.push(...sel.getShapes());
+        }
+        const faces = allFaceShapes;
+        const newShapes = [];
+        const allTargetShapes = Array.from(shapeObjMap.keys());
+        for (const shape of allTargetShapes) {
+            const solid = shape;
+            const targetFaces = faces.filter(f => solid.hasFace(f.getShape()));
+            if (!targetFaces.length) {
+                continue;
+            }
+            try {
+                const newShape = ShellOps.makeThickSolid(shape, targetFaces, this.thickness);
+                newShapes.push(newShape);
+                const originalObj = shapeObjMap.get(shape);
+                originalObj.removeShape(shape, this);
+            }
+            catch {
+                newShapes.push(shape);
+                console.warn("Shell: Failed to create thick solid.");
+            }
+        }
+        for (const sel of this.faceSelections) {
+            sel.removeShapes(this);
+        }
+        this.addShapes(newShapes);
+        // Classify internal faces/edges: faces and edges in the shelled result
+        // that were not in the original stock are internal (inner walls).
+        // Edges on the plane of the removed face selection are excluded from
+        // internal edges since they form the opening rim, not inner walls.
+        const tolerance = 1e-6;
+        const stockEdgeMidpoints = [];
+        for (const shape of allTargetShapes) {
+            for (const edge of Explorer.findEdgesWrapped(shape)) {
+                stockEdgeMidpoints.push(EdgeOps.getEdgeMidPoint(edge));
+            }
+        }
+        // Collect planes from the face selection to exclude opening rim edges
+        const selectionPlanes = [];
+        for (const face of faces) {
+            try {
+                selectionPlanes.push(FaceQuery.getSurfacePlane(face));
+            }
+            catch {
+                // Non-planar face — skip
+            }
+        }
+        const isStockEdge = (edge) => {
+            const mid = EdgeOps.getEdgeMidPoint(edge);
+            return stockEdgeMidpoints.some(sm => Math.abs(mid.x - sm.x) < tolerance &&
+                Math.abs(mid.y - sm.y) < tolerance &&
+                Math.abs(mid.z - sm.z) < tolerance);
+        };
+        const isOnSelectionPlane = (edge) => {
+            const mid = EdgeOps.getEdgeMidPoint(edge);
+            return selectionPlanes.some(p => Math.abs(p.signedDistanceToPoint(mid)) < tolerance);
+        };
+        const internalFaces = [];
+        const internalEdges = [];
+        for (const shape of newShapes) {
+            const resultFaces = Explorer.findFacesWrapped(shape);
+            for (const f of resultFaces) {
+                const faceEdges = f.getEdges();
+                if (faceEdges.length > 0 && faceEdges.every(e => !isStockEdge(e))) {
+                    internalFaces.push(f);
+                }
+            }
+            const edges = Explorer.findEdgesWrapped(shape);
+            for (const edge of edges) {
+                if (!isStockEdge(edge) && !isOnSelectionPlane(edge)) {
+                    internalEdges.push(edge);
+                }
+            }
+        }
+        this.setState('internal-faces', internalFaces);
+        this.setState('internal-edges', internalEdges);
+    }
+    internalFaces(...args) {
+        const suffix = this.buildSuffix('internal-faces', args);
+        return new LazySelectionSceneObject(`${this.generateUniqueName(suffix)}`, (parent) => {
+            const faces = parent.getState('internal-faces') || [];
+            const transform = parent.getTransform();
+            const originalFaces = transform
+                ? (this.getState('internal-faces') || [])
+                : null;
+            return this.resolveFaces(faces, args, transform, originalFaces);
+        }, this);
+    }
+    internalEdges(...args) {
+        const suffix = this.buildSuffix('internal-edges', args);
+        return new LazySelectionSceneObject(`${this.generateUniqueName(suffix)}`, (parent) => {
+            const edges = parent.getState('internal-edges') || [];
+            const transform = parent.getTransform();
+            const originalEdges = transform
+                ? (this.getState('internal-edges') || [])
+                : null;
+            return this.resolveEdges(edges, args, transform, originalEdges);
+        }, this);
+    }
+    buildSuffix(prefix, args) {
+        if (args.length === 0) {
+            return prefix;
+        }
+        const key = args.map(a => typeof a === 'number' ? a : 'f').join('-');
+        return `${prefix}-${key}`;
+    }
+    resolveEdges(shapes, args, transform = null, originalShapes = null) {
+        if (args.length === 0) {
+            return shapes;
+        }
+        if (args.every(a => typeof a === 'number')) {
+            const indices = args;
+            let filters = indices.map(i => new EdgeFilterBuilder().atIndex(i, shapes, originalShapes));
+            if (transform) {
+                filters = filters.map(f => f.transform(transform));
+            }
+            return new ShapeFilter(shapes, ...filters).apply();
+        }
+        let filters = args.filter(a => a instanceof EdgeFilterBuilder);
+        if (transform) {
+            filters = filters.map(f => f.transform(transform));
+        }
+        return new ShapeFilter(shapes, ...filters).apply();
+    }
+    resolveFaces(shapes, args, transform = null, originalShapes = null) {
+        if (args.length === 0) {
+            return shapes;
+        }
+        if (args.every(a => typeof a === 'number')) {
+            const indices = args;
+            let filters = indices.map(i => new FaceFilterBuilder().atIndex(i, shapes, originalShapes));
+            if (transform) {
+                filters = filters.map(f => f.transform(transform));
+            }
+            return new ShapeFilter(shapes, ...filters).apply();
+        }
+        let filters = args.filter(a => a instanceof FaceFilterBuilder);
+        if (transform) {
+            filters = filters.map(f => f.transform(transform));
+        }
+        return new ShapeFilter(shapes, ...filters).apply();
+    }
+    compareTo(other) {
+        if (!(other instanceof Shell)) {
+            return false;
+        }
+        if (!super.compareTo(other)) {
+            return false;
+        }
+        if (this.thickness !== other.thickness) {
+            return false;
+        }
+        if (this._faceSelections.length !== other._faceSelections.length) {
+            return false;
+        }
+        for (let i = 0; i < this._faceSelections.length; i++) {
+            if (!this._faceSelections[i].compareTo(other._faceSelections[i])) {
+                return false;
+            }
+        }
+        return true;
+    }
+    getDependencies() {
+        return [...this._faceSelections];
+    }
+    createCopy(remap) {
+        const faceSelections = this._faceSelections.map(sel => (remap.get(sel) || sel));
+        return new Shell(this.thickness, faceSelections.length > 0 ? faceSelections : undefined);
+    }
+    getType() {
+        return 'shell';
+    }
+    serialize() {
+        return {
+            thickness: this.thickness
+        };
+    }
+}

package/lib/dist/features/simple-extruder.d.ts

@@ -0,0 +1,22 @@
+import { Face } from "../common/face.js";
+import { Shape } from "../common/shape.js";
+import { Plane } from "../math/plane.js";
+export declare class Extruder {
+    private faces;
+    private plane;
+    distance: number;
+    draft?: [number, number];
+    endOffset?: number;
+    private firstFaces;
+    private lastFaces;
+    private sideFaces;
+    private _internalFaces;
+    constructor(faces: Face[], plane: Plane, distance: number, draft?: [number, number], endOffset?: number);
+    getStartFaces(): Face[];
+    getEndFaces(): Face[];
+    getSideFaces(): Face[];
+    getInternalFaces(): Face[];
+    extrude(): Shape<import("occjs-wrapper").TopoDS_Shape>[];
+    private isInternalFace;
+    private applyDraft;
+}

package/lib/dist/features/simple-extruder.js

@@ -0,0 +1,108 @@
+import { Explorer } from "../oc/explorer.js";
+import { ExtrudeOps } from "../oc/extrude-ops.js";
+import { rad } from "../helpers/math-helpers.js";
+import { BooleanOps } from "../oc/boolean-ops.js";
+export class Extruder {
+    faces;
+    plane;
+    distance;
+    draft;
+    endOffset;
+    firstFaces;
+    lastFaces;
+    sideFaces;
+    _internalFaces;
+    constructor(faces, plane, distance, draft, endOffset) {
+        this.faces = faces;
+        this.plane = plane;
+        this.distance = distance;
+        this.draft = draft;
+        this.endOffset = endOffset;
+    }
+    getStartFaces() {
+        return this.firstFaces;
+    }
+    getEndFaces() {
+        return this.lastFaces;
+    }
+    getSideFaces() {
+        return this.sideFaces;
+    }
+    getInternalFaces() {
+        return this._internalFaces;
+    }
+    extrude() {
+        let extrusions = [];
+        let distance = this.distance;
+        if (this.endOffset) {
+            distance -= Math.sign(distance) * this.endOffset;
+        }
+        const vec = this.plane.normal.multiply(distance);
+        let firstFaces = [];
+        let lastFaces = [];
+        let sideFaces = [];
+        let internalFaces = [];
+        const fusedFaces = BooleanOps.fuseFaces(this.faces);
+        for (const face of fusedFaces.result) {
+            let { solid, firstFace, lastFace } = ExtrudeOps.makePrismFromVec(face, vec);
+            if (this.draft) {
+                const draftResult = this.applyDraft(solid, firstFace, lastFace, this.plane);
+                solid = draftResult.solid;
+                firstFace = draftResult.firstFace;
+                lastFace = draftResult.lastFace;
+            }
+            const solidFaces = Explorer.findFacesWrapped(solid);
+            const remainingFaces = [];
+            for (const f of solidFaces) {
+                if (f.getShape().IsSame(firstFace.getShape())) {
+                    firstFace = f;
+                }
+                else if (f.getShape().IsSame(lastFace.getShape())) {
+                    lastFace = f;
+                }
+                else {
+                    remainingFaces.push(f);
+                }
+            }
+            // Use the firstFace from the solid to detect inner wires
+            // Inner wires (CCW) indicate holes — side faces sharing edges with them are internal
+            const resolvedFirst = firstFace;
+            const innerWireEdgeShapes = [];
+            const wires = resolvedFirst.getWires();
+            for (const wire of wires) {
+                if (!wire.isCW(this.plane.normal)) {
+                    for (const edge of wire.getEdges()) {
+                        innerWireEdgeShapes.push(edge);
+                    }
+                }
+            }
+            for (const f of remainingFaces) {
+                if (innerWireEdgeShapes.length > 0 && this.isInternalFace(f, innerWireEdgeShapes)) {
+                    internalFaces.push(f);
+                }
+                else {
+                    sideFaces.push(f);
+                }
+            }
+            extrusions.push(solid);
+            firstFaces.push(firstFace);
+            lastFaces.push(lastFace);
+        }
+        this.firstFaces = firstFaces;
+        this.lastFaces = lastFaces;
+        this.sideFaces = sideFaces;
+        this._internalFaces = internalFaces;
+        return extrusions;
+    }
+    isInternalFace(face, innerWireEdgeShapes) {
+        const faceEdges = face.getEdges();
+        return faceEdges.some(fe => innerWireEdgeShapes.some(iwe => fe.getShape().IsPartner(iwe.getShape())));
+    }
+    applyDraft(solid, firstFace, lastFace, plane) {
+        let angle = this.draft[0];
+        if (this.distance > 0) {
+            angle = -angle;
+        }
+        return ExtrudeOps.applyDraftOnSideFaces(solid, firstFace, lastFace, plane, rad(angle));
+    }
+}

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

@@ -0,0 +1,13 @@
+import { SceneObject } from "../common/scene-object.js";
+export declare class Sphere extends SceneObject {
+    radius: number;
+    angle: number;
+    constructor(radius: number, angle: number);
+    build(): void;
+    compareTo(other: Sphere): boolean;
+    getType(): string;
+    serialize(): {
+        radius: number;
+        angle: number;
+    };
+}

package/lib/dist/features/sphere.js

@@ -0,0 +1,33 @@
+import { SceneObject } from "../common/scene-object.js";
+import { Primitives } from "../oc/primitives.js";
+export class Sphere extends SceneObject {
+    radius;
+    angle;
+    constructor(radius, angle) {
+        super();
+        this.radius = radius;
+        this.angle = angle;
+    }
+    build() {
+        const sphere = Primitives.makeSphere(this.radius, this.angle);
+        this.addShapes([sphere]);
+    }
+    compareTo(other) {
+        if (!(other instanceof Sphere)) {
+            return false;
+        }
+        if (!super.compareTo(other)) {
+            return false;
+        }
+        return this.radius === other.radius && this.angle === other.angle;
+    }
+    getType() {
+        return "sphere";
+    }
+    serialize() {
+        return {
+            radius: this.radius,
+            angle: this.angle,
+        };
+    }
+}

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

@@ -0,0 +1,14 @@
+import { BuildSceneObjectContext, SceneObject } from "../common/scene-object.js";
+import { GeometrySceneObject } from "./2d/geometry.js";
+export declare class Split2D extends GeometrySceneObject {
+    private _targetObjects;
+    constructor();
+    target(...objects: GeometrySceneObject[]): this;
+    get targetObjects(): GeometrySceneObject[] | null;
+    build(context: BuildSceneObjectContext): void;
+    getDependencies(): SceneObject[];
+    createCopy(remap: Map<SceneObject, SceneObject>): SceneObject;
+    compareTo(other: Split2D): boolean;
+    getType(): string;
+    serialize(): {};
+}

package/lib/dist/features/split.js

@@ -0,0 +1,74 @@
+import { Wire } from "../common/wire.js";
+import { Edge } from "../common/edge.js";
+import { GeometrySceneObject } from "./2d/geometry.js";
+import { FaceMaker } from "../core/2d/face-maker.js";
+export class Split2D extends GeometrySceneObject {
+    _targetObjects = null;
+    constructor() {
+        super();
+    }
+    target(...objects) {
+        this._targetObjects = objects;
+        return this;
+    }
+    get targetObjects() {
+        return this._targetObjects;
+    }
+    build(context) {
+        const plane = this.sketch.getPlane();
+        let sourceWires;
+        if (this._targetObjects === null) {
+            sourceWires = this.sketch.getGeometriesWithOwner();
+        }
+        else {
+            sourceWires = new Map();
+            for (const obj of this._targetObjects) {
+                for (const shape of obj.getShapes()) {
+                    if (shape instanceof Wire || shape instanceof Edge) {
+                        sourceWires.set(shape, obj);
+                    }
+                }
+            }
+        }
+        const fusedWires = FaceMaker.fuseWires(Array.from(sourceWires.keys()), plane);
+        for (const [wire, owner] of sourceWires) {
+            owner.removeShape(wire, this);
+        }
+        this.addShapes(fusedWires);
+    }
+    getDependencies() {
+        return this._targetObjects ? [...this._targetObjects] : [];
+    }
+    createCopy(remap) {
+        const copy = new Split2D();
+        if (this._targetObjects) {
+            copy.target(...this._targetObjects.map(t => remap.get(t) || t));
+        }
+        return copy;
+    }
+    compareTo(other) {
+        if (!(other instanceof Split2D)) {
+            return false;
+        }
+        if (!super.compareTo(other)) {
+            return false;
+        }
+        const thisTargets = this._targetObjects || [];
+        const otherTargets = other._targetObjects || [];
+        if (thisTargets.length !== otherTargets.length) {
+            return false;
+        }
+        for (let i = 0; i < thisTargets.length; i++) {
+            if (!thisTargets[i].compareTo(otherTargets[i])) {
+                return false;
+            }
+        }
+        return true;
+    }
+    getType() {
+        return "split2d";
+    }
+    serialize() {
+        return {};
+    }
+}

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

@@ -0,0 +1,13 @@
+import { BuildSceneObjectContext, SceneObject } from "../common/scene-object.js";
+import { GeometrySceneObject } from "./2d/geometry.js";
+export declare class Split2D extends GeometrySceneObject {
+    private _targetObjects;
+    constructor(...targets: GeometrySceneObject[]);
+    get targetObjects(): GeometrySceneObject[] | null;
+    build(context: BuildSceneObjectContext): void;
+    getDependencies(): SceneObject[];
+    createCopy(remap: Map<SceneObject, SceneObject>): SceneObject;
+    compareTo(other: Split2D): boolean;
+    getType(): string;
+    serialize(): {};
+}

package/lib/dist/features/split2d.js

@@ -0,0 +1,69 @@
+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 Split2D extends GeometrySceneObject {
+    _targetObjects = null;
+    constructor(...targets) {
+        super();
+        this._targetObjects = targets.length > 0 ? targets : null;
+    }
+    get targetObjects() {
+        return this._targetObjects;
+    }
+    build(context) {
+        let sourceWires;
+        if (this._targetObjects === null) {
+            sourceWires = this.sketch.getGeometriesWithOwner();
+        }
+        else {
+            sourceWires = new Map();
+            for (const obj of this._targetObjects) {
+                for (const shape of obj.getShapes()) {
+                    if (shape instanceof Wire || shape instanceof Edge) {
+                        sourceWires.set(shape, obj);
+                    }
+                }
+            }
+        }
+        const edges = EdgeOps.splitEdges(Array.from(sourceWires.keys()));
+        for (const [wire, owner] of sourceWires) {
+            owner.removeShape(wire, this);
+        }
+        this.addShapes(edges);
+    }
+    getDependencies() {
+        return this._targetObjects ? [...this._targetObjects] : [];
+    }
+    createCopy(remap) {
+        const targets = this._targetObjects
+            ? this._targetObjects.map(t => remap.get(t) || t)
+            : [];
+        return new Split2D(...targets);
+    }
+    compareTo(other) {
+        if (!(other instanceof Split2D)) {
+            return false;
+        }
+        if (!super.compareTo(other)) {
+            return false;
+        }
+        const thisTargets = this._targetObjects || [];
+        const otherTargets = other._targetObjects || [];
+        if (thisTargets.length !== otherTargets.length) {
+            return false;
+        }
+        for (let i = 0; i < thisTargets.length; i++) {
+            if (!thisTargets[i].compareTo(otherTargets[i])) {
+                return false;
+            }
+        }
+        return true;
+    }
+    getType() {
+        return "split2d";
+    }
+    serialize() {
+        return {};
+    }
+}

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

@@ -0,0 +1,15 @@
+import { SceneObject } from "../common/scene-object.js";
+import { ShapeType } from "../common/shape-type.js";
+import { ShapeFilter, Shape } from "../common/shape.js";
+export declare class StateSceneObject extends SceneObject {
+    private source;
+    private key;
+    constructor(source: SceneObject, key: string);
+    build(): void;
+    getShapes(filter?: ShapeFilter, type?: ShapeType): Shape[];
+    compareTo(other: StateSceneObject): boolean;
+    getDependencies(): SceneObject[];
+    createCopy(remap: Map<SceneObject, SceneObject>): SceneObject;
+    getType(): string;
+    serialize(): {};
+}

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

@@ -0,0 +1,44 @@
+import { SceneObject } from "../common/scene-object.js";
+export class StateSceneObject extends SceneObject {
+    source;
+    key;
+    constructor(source, key) {
+        super();
+        this.source = source;
+        this.key = key;
+    }
+    build() {
+    }
+    getShapes(filter, type) {
+        const shapes = this.source.getState(this.key);
+        console.log(`============ StateSceneObject::getShapes - key: ${this.key}, shapes: ${shapes ? shapes.length : 0}`);
+        return shapes ? shapes : [];
+    }
+    compareTo(other) {
+        if (!(other instanceof StateSceneObject)) {
+            return false;
+        }
+        if (this.key !== other.key) {
+            return false;
+        }
+        if (!this.source.compareTo(other.source)) {
+            return false;
+        }
+        return super.compareTo(other);
+    }
+    getDependencies() {
+        return this.source ? [this.source] : [];
+    }
+    createCopy(remap) {
+        const remappedSource = this.source
+            ? (remap.get(this.source) || this.source)
+            : undefined;
+        return new StateSceneObject(remappedSource, this.key);
+    }
+    getType() {
+        return "state";
+    }
+    serialize() {
+        return {};
+    }
+}

package/lib/dist/features/state-select.d.ts

@@ -0,0 +1,21 @@
+import { BuildSceneObjectContext, SceneObject } from "../common/scene-object.js";
+import { Shape, ShapeFilter as ShapeFilterType } from "../common/shape.js";
+import { ShapeType } from "../common/shape-type.js";
+import { FilterBuilderBase } from "../filters/filter-builder-base.js";
+export declare class StateSelectSceneObject extends SceneObject {
+    private stateKey;
+    private filters;
+    private sourceParent;
+    private _isBuilt;
+    constructor(stateKey: string, filters: FilterBuilderBase<Shape>[], sourceParent: SceneObject);
+    build(_context?: BuildSceneObjectContext): void;
+    getShapes(filter?: ShapeFilterType, type?: ShapeType): Shape[];
+    private applyFilters;
+    getDependencies(): SceneObject[];
+    createCopy(remap: Map<SceneObject, SceneObject>): SceneObject;
+    compareTo(other: SceneObject): boolean;
+    getType(): string;
+    serialize(): {
+        stateKey: string;
+    };
+}