fluidcad 0.0.2

package/lib/dist/features/cut.js

@@ -0,0 +1,101 @@
+import { SceneObject } from "../common/scene-object.js";
+import { ExtrudeThroughAll } from "./infinite-extrude.js";
+import { Sketch } from "./2d/sketch.js";
+import { FaceMaker } from "../core/2d/face-maker.js";
+import { Extruder } from "./simple-extruder.js";
+import { BooleanOps } from "../oc/boolean-ops.js";
+import { ShapeOps } from "../oc/shape-ops.js";
+export class Cut extends SceneObject {
+    extrudable;
+    distance;
+    options;
+    isThroughAll = false;
+    constructor(extrudable, distance, options = {}) {
+        super();
+        this.extrudable = extrudable;
+        this.distance = distance;
+        this.options = options;
+        this.isThroughAll = this.distance === 0;
+    }
+    build(context) {
+        let sceneObjects;
+        sceneObjects = new Map();
+        for (const obj of context.getSceneObjects()) {
+            const shapes = obj.getShapes(false, 'solid');
+            if (shapes.length === 0) {
+                continue;
+            }
+            sceneObjects.set(obj, shapes);
+        }
+        console.log('Cut: Scene objects for cut:', Array.from(sceneObjects.keys()).map(o => o.getType()));
+        let distance = this.distance === 0 ? 0 : -this.distance;
+        let extrusionShapes = [];
+        if (this.isThroughAll) {
+            const extrudeThroughAll = new ExtrudeThroughAll(this.extrudable, false, true);
+            extrusionShapes = extrudeThroughAll.build();
+        }
+        else {
+            const wires = this.extrudable.getGeometries();
+            const faces = FaceMaker.getFaces(wires, this.extrudable.getPlane());
+            const plane = this.extrudable.getPlane();
+            const extruder = new Extruder(faces, plane, distance, this.options);
+            extrusionShapes = extruder.extrude();
+        }
+        this.extrudable.removeShapes(this);
+        const shapeObjectMap = new Map();
+        for (const [obj, shapes] of sceneObjects) {
+            for (const shape of shapes) {
+                shapeObjectMap.set(shape, obj);
+            }
+        }
+        const stock = Array.from(shapeObjectMap.keys());
+        console.log('Cut: Stock shapes count:', stock.length);
+        const toBeRemoved = extrusionShapes;
+        console.log('Cut: Stock shapes count:', stock.length);
+        console.log('Cut: To be removed shapes count:', toBeRemoved.length);
+        const cutResult = BooleanOps.cutMultiShape(stock, toBeRemoved);
+        for (const shape of stock) {
+            const list = cutResult.modified(shape);
+            console.log('Cut: Modified shapes for shape:', list.length);
+            if (list.length) {
+                for (const newShape of list) {
+                    const s = ShapeOps.cleanShape(newShape);
+                    console.log('Cut: Adding modified shape:', s);
+                    this.addShape(s);
+                }
+                const obj = shapeObjectMap.get(shape);
+                obj.removeShape(shape, this);
+            }
+            console.log('Cut: Shape modified count:', list.length);
+        }
+    }
+    clone() {
+        const extrudableClone = this.extrudable.clone();
+        const extrudable = extrudableClone.find(c => c instanceof Sketch);
+        const cutClone = new Cut(extrudable, this.distance, this.options);
+        return [...extrudableClone, cutClone];
+    }
+    compareTo(other) {
+        if (!(other instanceof Cut)) {
+            return false;
+        }
+        if (this.distance !== other.distance) {
+            return false;
+        }
+        if (JSON.stringify(this.options || {}) !== JSON.stringify(other.options || {})) {
+            return false;
+        }
+        return true;
+    }
+    getType() {
+        return "cut";
+    }
+    serialize() {
+        return {
+            extrudable: this.extrudable.serialize(),
+            distance: this.distance,
+            isThroughAll: this.isThroughAll,
+            options: this.options
+        };
+    }
+}

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

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

package/lib/dist/features/cylinder.js

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

package/lib/dist/features/extrude-base.d.ts

@@ -0,0 +1,56 @@
+import { Face } from "../common/face.js";
+import { SceneObject } from "../common/scene-object.js";
+import { Extrudable } from "../helpers/types.js";
+import { IExtrude } from "../core/interfaces.js";
+import { LazyVertex } from "./lazy-vertex.js";
+import { Point2DLike } from "../math/point.js";
+import { Plane } from "../math/plane.js";
+import { FaceFilterBuilder } from "../filters/face/face-filter.js";
+import { EdgeFilterBuilder } from "../filters/edge/edge-filter.js";
+export declare abstract class ExtrudeBase extends SceneObject implements IExtrude {
+    protected _extrudable: Extrudable | null;
+    protected _draft?: number | [number, number];
+    protected _endOffset?: number;
+    protected _drill?: boolean;
+    protected _picking: boolean;
+    protected _pickPoints: LazyVertex[];
+    constructor(extrudable?: Extrudable);
+    get extrudable(): Extrudable;
+    startFaces(...args: number[] | FaceFilterBuilder[]): SceneObject;
+    endFaces(...args: number[] | FaceFilterBuilder[]): SceneObject;
+    startEdges(...args: number[] | EdgeFilterBuilder[]): SceneObject;
+    endEdges(...args: number[] | EdgeFilterBuilder[]): SceneObject;
+    sideFaces(...args: number[] | FaceFilterBuilder[]): SceneObject;
+    sideEdges(...args: number[] | EdgeFilterBuilder[]): SceneObject;
+    /**
+     * Returns the section edges created by a cut operation.
+     * Only meaningful when operationMode is 'remove'.
+     */
+    edges(...indices: number[]): SceneObject;
+    internalFaces(...args: number[] | FaceFilterBuilder[]): SceneObject;
+    internalEdges(...args: number[] | EdgeFilterBuilder[]): SceneObject;
+    private buildSuffix;
+    private resolveFaces;
+    private resolveEdges;
+    draft(value: number | [number, number]): this;
+    endOffset(value: number): this;
+    drill(value?: boolean): this;
+    pick(...points: Point2DLike[]): this;
+    isPicking(): boolean;
+    getPickPoints(): LazyVertex[];
+    /**
+     * Resolves pick mode: partitions sketch into cells via CellsBuilder,
+     * classifies which cells are selected, adds meta shapes for all cells + edges,
+     * and returns the selected faces to extrude.
+     * Returns null if not in pick mode.
+     */
+    protected resolvePickedFaces(plane: Plane): Face[] | null;
+    clean(allObjects: SceneObject[]): void;
+    removeMetaShapes(removedBy: SceneObject): void;
+    getDraft(): [number, number];
+    getEndOffset(): number | undefined;
+    getDrill(): boolean;
+    protected syncWith(other: ExtrudeBase): this;
+    compareTo(other: ExtrudeBase): boolean;
+    getType(): string;
+}

package/lib/dist/features/extrude-base.js

@@ -0,0 +1,331 @@
+import { SceneObject } from "../common/scene-object.js";
+import { LazySelectionSceneObject } from "./lazy-scene-object.js";
+import { normalizePoint2D } from "../helpers/normalize.js";
+import { FaceOps } from "../oc/face-ops.js";
+import { FaceMaker2 } from "../oc/face-maker2.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 ExtrudeBase extends SceneObject {
+    _extrudable = null;
+    _draft;
+    _endOffset;
+    _drill = true;
+    _picking = false;
+    _pickPoints = [];
+    constructor(extrudable) {
+        super();
+        this._extrudable = extrudable ?? null;
+    }
+    get extrudable() {
+        return this._extrudable;
+    }
+    startFaces(...args) {
+        const suffix = this.buildSuffix('start-faces', args);
+        return new LazySelectionSceneObject(`${this.generateUniqueName(suffix)}`, (parent) => {
+            const faces = parent.getState('start-faces') || [];
+            const transform = parent.getTransform();
+            const originalFaces = transform
+                ? (this.getState('start-faces') || [])
+                : null;
+            return this.resolveFaces(faces, args, transform, originalFaces);
+        }, this);
+    }
+    endFaces(...args) {
+        const suffix = this.buildSuffix('end-faces', args);
+        return new LazySelectionSceneObject(`${this.generateUniqueName(suffix)}`, (parent) => {
+            const faces = parent.getState('end-faces') || [];
+            const transform = parent.getTransform();
+            const originalFaces = transform
+                ? (this.getState('end-faces') || [])
+                : null;
+            return this.resolveFaces(faces, args, transform, originalFaces);
+        }, this);
+    }
+    startEdges(...args) {
+        const suffix = this.buildSuffix('start-edges', args);
+        return new LazySelectionSceneObject(`${this.generateUniqueName(suffix)}`, (parent) => {
+            if (this._operationMode === 'remove') {
+                const edges = parent.getState('start-edges') || [];
+                const transform = parent.getTransform();
+                const originalEdges = transform
+                    ? (this.getState('start-edges') || [])
+                    : null;
+                return this.resolveEdges(edges, args, transform, originalEdges);
+            }
+            const faces = parent.getState('start-faces') || [];
+            const edges = faces.flatMap(f => f.getEdges());
+            const transform = parent.getTransform();
+            const originalEdges = transform
+                ? (this.getState('start-faces') || []).flatMap(f => f.getEdges())
+                : null;
+            return this.resolveEdges(edges, args, transform, originalEdges);
+        }, this);
+    }
+    endEdges(...args) {
+        const suffix = this.buildSuffix('end-edges', args);
+        return new LazySelectionSceneObject(`${this.generateUniqueName(suffix)}`, (parent) => {
+            if (this._operationMode === 'remove') {
+                const edges = parent.getState('end-edges') || [];
+                const transform = parent.getTransform();
+                const originalEdges = transform
+                    ? (this.getState('end-edges') || [])
+                    : null;
+                return this.resolveEdges(edges, args, transform, originalEdges);
+            }
+            const faces = parent.getState('end-faces') || [];
+            const edges = faces.flatMap(f => f.getEdges());
+            const transform = parent.getTransform();
+            const originalEdges = transform
+                ? (this.getState('end-faces') || []).flatMap(f => f.getEdges())
+                : null;
+            return this.resolveEdges(edges, args, transform, originalEdges);
+        }, this);
+    }
+    sideFaces(...args) {
+        const suffix = this.buildSuffix('side-faces', args);
+        return new LazySelectionSceneObject(`${this.generateUniqueName(suffix)}`, (parent) => {
+            const faces = parent.getState('side-faces') || [];
+            const transform = parent.getTransform();
+            const originalFaces = transform
+                ? (this.getState('side-faces') || [])
+                : null;
+            return this.resolveFaces(faces, args, transform, originalFaces);
+        }, this);
+    }
+    sideEdges(...args) {
+        const suffix = this.buildSuffix('side-edges', args);
+        return new LazySelectionSceneObject(`${this.generateUniqueName(suffix)}`, (parent) => {
+            const sideFaces = parent.getState('side-faces') || [];
+            const startFaces = parent.getState('start-faces') || [];
+            const endFaces = parent.getState('end-faces') || [];
+            const excludedEdges = [...startFaces, ...endFaces].flatMap(f => f.getEdges());
+            const edges = sideFaces.flatMap(f => f.getEdges())
+                .filter(e => !excludedEdges.some(ex => e.getShape().IsSame(ex.getShape())));
+            return this.resolveEdges(edges, args);
+        }, this);
+    }
+    /**
+     * Returns the section edges created by a cut operation.
+     * Only meaningful when operationMode is 'remove'.
+     */
+    edges(...indices) {
+        const suffix = indices.length > 0 ? `section-edges-${indices.join('-')}` : 'section-edges';
+        return new LazySelectionSceneObject(`${this.generateUniqueName(suffix)}`, (parent) => {
+            const edges = parent.getState('section-edges') || [];
+            if (indices.length === 0) {
+                return edges;
+            }
+            return indices.filter(i => i >= 0 && i < edges.length).map(i => edges[i]);
+        }, this);
+    }
+    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) => {
+            if (this._operationMode === 'remove') {
+                const edges = parent.getState('internal-edges') || [];
+                return this.resolveEdges(edges, args);
+            }
+            const faces = parent.getState('internal-faces') || [];
+            const edges = faces.flatMap(f => f.getEdges());
+            return this.resolveEdges(edges, args);
+        }, this);
+    }
+    buildSuffix(prefix, args) {
+        if (args.length === 0) {
+            return prefix;
+        }
+        const key = args.map(a => typeof a === 'number' ? a : 'f').join('-');
+        return `${prefix}-${key}`;
+    }
+    resolveFaces(shapes, args, transform = null, originalShapes = null) {
+        if (args.length === 0) {
+            return new ShapeFilter(shapes).apply();
+        }
+        if (args.some(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;
+        if (transform) {
+            filters = filters.map(f => f.transform(transform));
+        }
+        return new ShapeFilter(shapes, ...filters).apply();
+    }
+    resolveEdges(shapes, args, transform = null, originalShapes = null) {
+        if (args.length === 0) {
+            return new ShapeFilter(shapes).apply();
+        }
+        if (args.some(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;
+        if (transform) {
+            filters = filters.map(f => f.transform(transform));
+        }
+        return new ShapeFilter(shapes, ...filters).apply();
+    }
+    draft(value) {
+        this._draft = value;
+        return this;
+    }
+    endOffset(value) {
+        this._endOffset = value;
+        return this;
+    }
+    drill(value = true) {
+        this._drill = value;
+        return this;
+    }
+    pick(...points) {
+        this._picking = true;
+        this._pickPoints = points.map(p => normalizePoint2D(p));
+        return this;
+    }
+    isPicking() {
+        return this._picking;
+    }
+    getPickPoints() {
+        return this._pickPoints;
+    }
+    /**
+     * Resolves pick mode: partitions sketch into cells via CellsBuilder,
+     * classifies which cells are selected, adds meta shapes for all cells + edges,
+     * and returns the selected faces to extrude.
+     * Returns null if not in pick mode.
+     */
+    resolvePickedFaces(plane) {
+        if (!this.isPicking()) {
+            return null;
+        }
+        let cells = this.extrudable.getState('pick-region-cells');
+        if (!cells) {
+            console.log(':::::::: No cached cells found, computing cells for the first time');
+            const sketchShapes = this.extrudable.getGeometries();
+            cells = FaceMaker2.getRegions(sketchShapes, plane, false);
+            this.extrudable.setState('pick-region-cells', cells);
+        }
+        if (cells.length === 0) {
+            return [];
+        }
+        const pickPoints = this.getPickPoints();
+        const selectedCells = [];
+        for (const cell of cells) {
+            let isSelected = false;
+            let pickPoint = null;
+            for (const lazyPt of pickPoints) {
+                const pt2d = lazyPt.asPoint2D();
+                const pt3d = plane.localToWorld(pt2d);
+                if (FaceOps.isPointInsideFace(pt3d, cell)) {
+                    isSelected = true;
+                    pickPoint = [pt2d.x, pt2d.y];
+                    break;
+                }
+            }
+            if (isSelected) {
+                cell.markAsMetaShape('pick-region-selected');
+                cell.metaData = { pickPoint };
+                selectedCells.push(cell);
+            }
+            else {
+                cell.markAsMetaShape('pick-region');
+            }
+            this.addShape(cell);
+            for (const edge of cell.getEdges()) {
+                edge.markAsMetaShape('pick-edge');
+                this.addShape(edge);
+            }
+        }
+        return selectedCells;
+    }
+    clean(allObjects) {
+        if (!this.isPicking()) {
+            return;
+        }
+        const lastObject = allObjects[allObjects.length - 1];
+        if (lastObject !== this) {
+            this.removeMetaShapes(lastObject);
+        }
+    }
+    removeMetaShapes(removedBy) {
+        for (const shape of this.getAddedShapes()) {
+            if (shape.isMetaShape()) {
+                this.removeShape(shape, removedBy);
+            }
+        }
+    }
+    getDraft() {
+        const draft = this._draft;
+        if (!draft) {
+            return null;
+        }
+        return draft instanceof Array ? draft : [draft, draft];
+    }
+    getEndOffset() {
+        return this._endOffset;
+    }
+    getDrill() {
+        return this._drill;
+    }
+    syncWith(other) {
+        this._draft = other._draft;
+        this._endOffset = other._endOffset;
+        this._fusionScope = other._fusionScope;
+        this._operationMode = other._operationMode;
+        this._symmetric = other._symmetric;
+        this._picking = other._picking;
+        this._pickPoints = other._pickPoints;
+        return this;
+    }
+    compareTo(other) {
+        if (!super.compareTo(other)) {
+            return false;
+        }
+        if (this._endOffset !== other._endOffset
+            || this._drill !== other._drill) {
+            return false;
+        }
+        if (this._picking !== other._picking) {
+            return false;
+        }
+        if (this._pickPoints.length !== other._pickPoints.length) {
+            return false;
+        }
+        for (let i = 0; i < this._pickPoints.length; i++) {
+            if (!this._pickPoints[i].compareTo(other._pickPoints[i])) {
+                return false;
+            }
+        }
+        let thisDraft = this._draft || [0, 0];
+        let otherDraft = other._draft || [0, 0];
+        thisDraft = this._draft instanceof Array ? this._draft : [this._draft, this._draft];
+        otherDraft = other._draft instanceof Array ? other._draft : [other._draft, other._draft];
+        if (thisDraft[0] !== otherDraft[0] || thisDraft[1] !== otherDraft[1]) {
+            return false;
+        }
+        return true;
+    }
+    getType() {
+        return "extrude";
+    }
+}

package/lib/dist/features/extrude-options.d.ts

@@ -0,0 +1,8 @@
+import { SceneObject } from "../common/scene-object.js";
+export type FusionScope = 'all' | 'none' | SceneObject | SceneObject[];
+export type OperationMode = 'add' | 'new' | 'remove';
+export type ExtrudeOptions = {
+    draft?: number | [number, number];
+    endOffset?: number;
+    mergeScope?: FusionScope;
+};

package/lib/dist/features/extrude-options.js

@@ -0,0 +1 @@
+export {};

package/lib/dist/features/extrude-symmetric.d.ts

@@ -0,0 +1,28 @@
+import { BuildSceneObjectContext } from "../common/scene-object.js";
+import { ExtrudeOptions } from "./extrude-options.js";
+import { ExtrudeBase } from "./extrude-base.js";
+import { SceneObject } from "../common/scene-object.js";
+import { Extrudable } from "../helpers/types.js";
+export declare class ExtrudeSymmetric extends ExtrudeBase {
+    extrudable: Extrudable;
+    distance?: number;
+    options: ExtrudeOptions;
+    constructor(extrudable: Extrudable, distance?: number, options?: ExtrudeOptions);
+    build(context: BuildSceneObjectContext): void;
+    private applyDraft;
+    private doExtrude;
+    private getUniqueName;
+    startFace(...indices: number[]): SceneObject;
+    endFace(...indices: number[]): SceneObject;
+    startEdge(...indices: number[]): SceneObject;
+    endEdge(...indices: number[]): SceneObject;
+    sideFace(...indices: number[]): SceneObject;
+    compareTo(other: ExtrudeSymmetric): boolean;
+    getUniqueType(): string;
+    serialize(): {
+        extrudables: any;
+        distance: number;
+        symmetric: boolean;
+        options: ExtrudeOptions;
+    };
+}