fluidcad 0.0.2

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

@@ -0,0 +1,16 @@
+import { SceneObject } from "../common/scene-object.js";
+import { Shape } from "../common/shape.js";
+export declare class LazySelectionSceneObject extends SceneObject {
+    private uniqueName;
+    private getShapesFn;
+    private sourceParent;
+    private _originalParent;
+    constructor(uniqueName: string, getShapesFn: (parent: SceneObject) => Shape[], sourceParent: SceneObject);
+    build(): void;
+    getDependencies(): SceneObject[];
+    createCopy(remap: Map<SceneObject, SceneObject>): SceneObject;
+    compareTo(other: LazySelectionSceneObject): boolean;
+    getType(): string;
+    getUniqueType(): string;
+    serialize(): {};
+}

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

@@ -0,0 +1,52 @@
+import { SceneObject } from "../common/scene-object.js";
+export class LazySelectionSceneObject extends SceneObject {
+    uniqueName;
+    getShapesFn;
+    sourceParent;
+    _originalParent = null;
+    constructor(uniqueName, getShapesFn, sourceParent) {
+        super();
+        this.uniqueName = uniqueName;
+        this.getShapesFn = getShapesFn;
+        this.sourceParent = sourceParent;
+    }
+    build() {
+        const shapes = this.getShapesFn(this.sourceParent);
+        this.addShapes(shapes);
+    }
+    getDependencies() {
+        return [this.sourceParent];
+    }
+    createCopy(remap) {
+        const remappedParent = remap.get(this.sourceParent) || this.sourceParent;
+        const copy = new LazySelectionSceneObject(this.uniqueName, this.getShapesFn, remappedParent);
+        if (remappedParent !== this.sourceParent) {
+            copy._originalParent = this._originalParent || this.sourceParent;
+        }
+        return copy;
+    }
+    compareTo(other) {
+        if (!(other instanceof LazySelectionSceneObject)) {
+            return false;
+        }
+        if (this.uniqueName !== other.uniqueName) {
+            return false;
+        }
+        if (!super.compareTo(other)) {
+            return false;
+        }
+        if (!this.sourceParent.compareTo(other.sourceParent)) {
+            return false;
+        }
+        return true;
+    }
+    getType() {
+        return "select";
+    }
+    getUniqueType() {
+        return 'lazy-select';
+    }
+    serialize() {
+        return {};
+    }
+}

package/lib/dist/features/lazy-vertex.d.ts

@@ -0,0 +1,19 @@
+import { SceneObject } from "../common/scene-object.js";
+import { ShapeType } from "../common/shape-type.js";
+import { Shape, ShapeFilter } from "../common/shape.js";
+import { Vertex } from "../common/vertex.js";
+export declare class LazyVertex extends SceneObject {
+    private uniqueName;
+    private getShapesFn;
+    private _isBuilt;
+    constructor(uniqueName: string, getShapesFn: () => Shape[]);
+    build(): void;
+    getShapes(filter?: ShapeFilter, type?: ShapeType): Shape[];
+    asPoint(): import("../math/point.js").Point;
+    asPoint2D(): import("../math/point.js").Point2D;
+    reverse(): LazyVertex;
+    compareTo(other: LazyVertex): boolean;
+    getType(): string;
+    serialize(): {};
+    static fromVertex(vertex: Vertex): LazyVertex;
+}

package/lib/dist/features/lazy-vertex.js

@@ -0,0 +1,62 @@
+import { SceneObject } from "../common/scene-object.js";
+import { Vertex } from "../common/vertex.js";
+export class LazyVertex extends SceneObject {
+    uniqueName;
+    getShapesFn;
+    _isBuilt = false;
+    constructor(uniqueName, getShapesFn) {
+        super();
+        this.uniqueName = uniqueName;
+        this.getShapesFn = getShapesFn;
+    }
+    build() {
+        const shapes = this.getShapesFn();
+        if (shapes.length === 0) {
+            throw new Error(`LazyVertex::build - getShapesFn returned empty array for uniqueName: ${this.uniqueName}`);
+        }
+        if (shapes.length > 1) {
+            throw new Error(`LazyVertex::build - getShapesFn returned more than one shape for uniqueName: ${this.uniqueName}`);
+        }
+        this.addShapes(shapes);
+    }
+    getShapes(filter, type) {
+        if (this._isBuilt) {
+            return super.getShapes(filter, type);
+        }
+        this.build();
+        this._isBuilt = true;
+        const shapes = super.getShapes(filter, type);
+        return shapes;
+    }
+    asPoint() {
+        const vertex = this.getShapes({ excludeMeta: false }, 'vertex')[0];
+        return vertex.toPoint();
+    }
+    asPoint2D() {
+        const vertex = this.getShapes({ excludeMeta: false }, 'vertex')[0];
+        return vertex.toPoint2D();
+    }
+    reverse() {
+        return new LazyVertex(`${this.uniqueName}-reversed`, () => {
+            const vertex = this.getShapes({ excludeMeta: false }, 'vertex')[0];
+            const point = vertex.toPoint();
+            const reversedPoint = point.negate();
+            const reversedVertex = Vertex.fromPoint(reversedPoint);
+            return [reversedVertex];
+        });
+    }
+    compareTo(other) {
+        return super.compareTo(other) && this.uniqueName === other.uniqueName;
+    }
+    getType() {
+        return "lazy-vertex";
+    }
+    serialize() {
+        return {};
+    }
+    static fromVertex(vertex) {
+        const point = vertex.toPoint();
+        const uniqueName = `lazy-vertex-${point.x}-${point.y}-${point.z}`;
+        return new LazyVertex(uniqueName, () => [vertex]);
+    }
+}

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

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

package/lib/dist/features/load.js

@@ -0,0 +1,31 @@
+import { SceneObject } from "../common/scene-object.js";
+import { FileImport } from "../io/file-import.js";
+export class LoadFile extends SceneObject {
+    fileName;
+    constructor(fileName) {
+        super();
+        this.fileName = fileName;
+    }
+    build() {
+        const shapes = FileImport.deserializeShapesWithMetadata(this.fileName);
+        this.addShapes(shapes);
+    }
+    compareTo(other) {
+        if (!(other instanceof LoadFile)) {
+            return false;
+        }
+        if (!super.compareTo(other)) {
+            return false;
+        }
+        if (this.fileName !== other.fileName) {
+            return false;
+        }
+        return true;
+    }
+    getType() {
+        return 'load';
+    }
+    serialize() {
+        return {};
+    }
+}

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

@@ -0,0 +1,27 @@
+import { BuildSceneObjectContext, SceneObject } from "../common/scene-object.js";
+import { FaceFilterBuilder } from "../filters/face/face-filter.js";
+import { EdgeFilterBuilder } from "../filters/edge/edge-filter.js";
+import { ILoft } from "../core/interfaces.js";
+export declare class Loft extends SceneObject implements ILoft {
+    private _profiles;
+    constructor(...profiles: SceneObject[]);
+    get profiles(): SceneObject[];
+    build(context: BuildSceneObjectContext): void;
+    private getProfilePlane;
+    startFaces(...args: (number | FaceFilterBuilder)[]): SceneObject;
+    endFaces(...args: (number | FaceFilterBuilder)[]): SceneObject;
+    sideFaces(...args: (number | FaceFilterBuilder)[]): SceneObject;
+    startEdges(...args: (number | EdgeFilterBuilder)[]): SceneObject;
+    endEdges(...args: (number | EdgeFilterBuilder)[]): SceneObject;
+    sideEdges(...args: (number | EdgeFilterBuilder)[]): SceneObject;
+    private buildSuffix;
+    private resolveEdges;
+    private resolveFaces;
+    private getWiresFromSceneObject;
+    compareTo(other: Loft): boolean;
+    getType(): string;
+    serialize(): {
+        profiles: any[];
+        operationMode: "new" | "remove";
+    };
+}

package/lib/dist/features/loft.js

@@ -0,0 +1,273 @@
+import { SceneObject } from "../common/scene-object.js";
+import { Explorer } from "../oc/explorer.js";
+import { LoftOps } from "../oc/loft-ops.js";
+import { FaceMaker2 } from "../oc/face-maker2.js";
+import { LazySelectionSceneObject } from "./lazy-scene-object.js";
+import { FaceFilterBuilder } from "../filters/face/face-filter.js";
+import { EdgeFilterBuilder } from "../filters/edge/edge-filter.js";
+import { ShapeFilter } from "../filters/filter.js";
+import { FaceOps } from "../oc/face-ops.js";
+import { fuseWithSceneObjects, cutWithSceneObjects } from "../helpers/scene-helpers.js";
+export class Loft extends SceneObject {
+    _profiles = [];
+    constructor(...profiles) {
+        super();
+        this._profiles = profiles;
+    }
+    get profiles() {
+        return this._profiles;
+    }
+    build(context) {
+        if (this.profiles.length < 2) {
+            throw new Error("Loft requires at least two profiles.");
+        }
+        const allWires = [];
+        for (const profile of this.profiles) {
+            const wires = this.getWiresFromSceneObject(profile);
+            if (wires.length === 0) {
+                throw new Error("Could not extract wire from profile.");
+            }
+            for (const wire of wires) {
+                allWires.push(wire);
+            }
+        }
+        const newShapes = LoftOps.makeLoft(allWires);
+        for (const profile of this.profiles) {
+            profile.removeShapes(this);
+        }
+        // Classify faces into start/end/side using profile planes
+        const firstPlane = this.getProfilePlane(this.profiles[0]);
+        const lastPlane = this.getProfilePlane(this.profiles[this.profiles.length - 1]);
+        const startFaces = [];
+        const endFaces = [];
+        const sideFaces = [];
+        for (const shape of newShapes) {
+            const faces = Explorer.findFacesWrapped(shape);
+            for (const f of faces) {
+                if (firstPlane && FaceOps.faceOnPlaneWrapped(f, firstPlane)) {
+                    startFaces.push(f);
+                }
+                else if (lastPlane && FaceOps.faceOnPlaneWrapped(f, lastPlane)) {
+                    endFaces.push(f);
+                }
+                else {
+                    sideFaces.push(f);
+                }
+            }
+        }
+        this.setState('start-faces', startFaces);
+        this.setState('end-faces', endFaces);
+        this.setState('side-faces', sideFaces);
+        // Handle boolean operation based on operation mode
+        if (this._operationMode === 'remove') {
+            const scope = this.resolveFusionScope(context.getSceneObjects());
+            const plane = firstPlane || lastPlane;
+            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);
+    }
+    getProfilePlane(profile) {
+        if ('getPlane' in profile && typeof profile.getPlane === 'function') {
+            return profile.getPlane();
+        }
+        return null;
+    }
+    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);
+    }
+    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);
+    }
+    startEdges(...args) {
+        const suffix = this.buildSuffix('start-edges', args);
+        return new LazySelectionSceneObject(`${this.generateUniqueName(suffix)}`, (parent) => {
+            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) => {
+            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);
+    }
+    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);
+    }
+    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();
+    }
+    getWiresFromSceneObject(obj) {
+        const shapes = obj.getShapes({ excludeMeta: false });
+        // If shapes are faces, extract their outer wires
+        const faceShapes = shapes.filter(s => s.isFace());
+        if (faceShapes.length > 0) {
+            const wires = [];
+            for (const face of faceShapes) {
+                const faceWires = face.getWires();
+                if (faceWires.length > 0) {
+                    wires.push(faceWires[0]); // outer wire
+                }
+            }
+            return wires;
+        }
+        // If shapes are wires directly
+        const wireShapes = shapes.filter(s => s.isWire());
+        if (wireShapes.length > 0) {
+            return wireShapes;
+        }
+        // If it's an extrudable (sketch), get geometries and make faces to get wires
+        if ('getGeometries' in obj && 'getPlane' in obj) {
+            const extrudable = obj;
+            const geometries = extrudable.getGeometries();
+            const plane = extrudable.getPlane();
+            const faces = FaceMaker2.getRegions(geometries, plane);
+            const wires = [];
+            for (const face of faces) {
+                const faceWires = face.getWires();
+                if (faceWires.length > 0) {
+                    wires.push(faceWires[0]);
+                }
+            }
+            return wires;
+        }
+        // Try to extract wires from solid shapes
+        const solidShapes = shapes.filter(s => s.isSolid());
+        if (solidShapes.length > 0) {
+            const wires = [];
+            for (const solid of solidShapes) {
+                const solidWires = Explorer.findWiresWrapped(solid);
+                if (solidWires.length > 0) {
+                    wires.push(solidWires[0]);
+                }
+            }
+            return wires;
+        }
+        return [];
+    }
+    compareTo(other) {
+        if (!(other instanceof Loft)) {
+            return false;
+        }
+        if (!super.compareTo(other)) {
+            return false;
+        }
+        if (this.profiles.length !== other.profiles.length) {
+            return false;
+        }
+        for (let i = 0; i < this.profiles.length; i++) {
+            if (!this.profiles[i].compareTo(other.profiles[i])) {
+                return false;
+            }
+        }
+        return true;
+    }
+    getType() {
+        return "loft";
+    }
+    serialize() {
+        return {
+            profiles: this.profiles.map(f => f.serialize()),
+            operationMode: this._operationMode !== 'add' ? this._operationMode : undefined,
+        };
+    }
+}

package/lib/dist/features/mirror-feature.d.ts

@@ -0,0 +1,15 @@
+import { BuildSceneObjectContext, SceneObject } from "../common/scene-object.js";
+import { Matrix4 } from "../math/matrix4.js";
+import { PlaneObjectBase } from "./plane-renderable-base.js";
+export declare class MirrorFeature extends SceneObject {
+    private plane;
+    private _matrix?;
+    constructor(plane: PlaneObjectBase, _matrix?: Matrix4);
+    getTransformMatrix(): Matrix4 | null;
+    isContainer(): boolean;
+    build(context: BuildSceneObjectContext): void;
+    compareTo(other: MirrorFeature): boolean;
+    getType(): string;
+    getUniqueType(): string;
+    serialize(): {};
+}

package/lib/dist/features/mirror-feature.js

@@ -0,0 +1,39 @@
+import { SceneObject } from "../common/scene-object.js";
+export class MirrorFeature extends SceneObject {
+    plane;
+    _matrix;
+    constructor(plane, _matrix) {
+        super();
+        this.plane = plane;
+        this._matrix = _matrix;
+        this.setAlwaysVisible();
+    }
+    getTransformMatrix() {
+        return this._matrix || null;
+    }
+    isContainer() {
+        return true;
+    }
+    build(context) {
+        this.plane.removeShapes(this);
+        this.saveShapesSnapshot(context);
+    }
+    compareTo(other) {
+        if (!(other instanceof MirrorFeature)) {
+            return false;
+        }
+        if (!super.compareTo(other)) {
+            return false;
+        }
+        return true;
+    }
+    getType() {
+        return "mirror";
+    }
+    getUniqueType() {
+        return 'mirror-feature';
+    }
+    serialize() {
+        return {};
+    }
+}

package/lib/dist/features/mirror-shape.d.ts

@@ -0,0 +1,14 @@
+import { BuildSceneObjectContext, SceneObject } from "../common/scene-object.js";
+import { PlaneObjectBase } from "./plane-renderable-base.js";
+export declare class MirrorShape extends SceneObject {
+    private plane;
+    targetObjects: SceneObject[] | null;
+    constructor(plane: PlaneObjectBase, targetObjects?: SceneObject[] | null);
+    build(context: BuildSceneObjectContext): void;
+    compareTo(other: MirrorShape): boolean;
+    getType(): string;
+    getUniqueType(): string;
+    serialize(): {
+        plane: PlaneObjectBase;
+    };
+}

package/lib/dist/features/mirror-shape.js

@@ -0,0 +1,86 @@
+import { SceneObject } from "../common/scene-object.js";
+import { Matrix4 } from "../math/matrix4.js";
+import { ShapeOps } from "../oc/shape-ops.js";
+import { fuseWithSceneObjects } from "../helpers/scene-helpers.js";
+export class MirrorShape extends SceneObject {
+    plane;
+    targetObjects;
+    constructor(plane, targetObjects = null) {
+        super();
+        this.plane = plane;
+        this.targetObjects = targetObjects;
+    }
+    build(context) {
+        let objects;
+        let targetObjects = this.targetObjects;
+        let parent = null;
+        let plane;
+        const allSceneObjects = context.getSceneObjects();
+        const lastObj = context.getLastObject();
+        if (this.parentId) {
+            parent = this.getParent();
+            objects = parent.getPreviousSiblings(this);
+        }
+        else {
+            objects = allSceneObjects;
+        }
+        if (this.targetObjects && this.targetObjects.length > 0) {
+            targetObjects = objects.filter(obj => this.targetObjects.includes(obj));
+        }
+        else {
+            targetObjects = lastObj ? [lastObj] : objects;
+        }
+        if (this.plane) {
+            this.plane.removeShapes(this);
+        }
+        plane = this.plane.getPlane();
+        const shapesMap = new Map();
+        for (const obj of allSceneObjects) {
+            const shapes = obj.getShapes({ excludeMeta: false }, 'solid');
+            for (const shape of shapes) {
+                shapesMap.set(shape, obj);
+            }
+        }
+        const transformedShapes = [];
+        for (const obj of targetObjects) {
+            const shapes = obj.getShapes({ excludeMeta: false }, 'solid');
+            for (const shape of shapes) {
+                const matrix = Matrix4.mirrorPlane(plane.normal, plane.origin);
+                const transformed = ShapeOps.transform(shape, matrix);
+                transformedShapes.push(transformed);
+            }
+        }
+        const fusionResult = fuseWithSceneObjects(allSceneObjects, transformedShapes);
+        for (const modifiedShape of fusionResult.modifiedShapes) {
+            if (modifiedShape.object) {
+                modifiedShape.object.removeShape(modifiedShape.shape, this);
+            }
+        }
+        for (const shape of fusionResult.newShapes) {
+            this.addShape(shape);
+        }
+    }
+    compareTo(other) {
+        if (!(other instanceof MirrorShape)) {
+            return false;
+        }
+        if (!super.compareTo(other)) {
+            return false;
+        }
+        if (!this.plane.compareTo(other.plane)) {
+            return false;
+        }
+        return true;
+    }
+    getType() {
+        return "mirror";
+    }
+    getUniqueType() {
+        return 'mirror-shape';
+    }
+    serialize() {
+        return {
+            plane: this.plane,
+        };
+    }
+}

package/lib/dist/features/mirror-shape2d.d.ts

@@ -0,0 +1,18 @@
+import { BuildSceneObjectContext, SceneObject } from "../common/scene-object.js";
+import { GeometrySceneObject } from "./2d/geometry.js";
+import { AxisObjectBase } from "./axis-renderable-base.js";
+import { LazyVertex } from "./lazy-vertex.js";
+export declare class MirrorShape2D extends GeometrySceneObject {
+    private axis;
+    private targetObjects;
+    constructor(axis: AxisObjectBase, targetObjects?: SceneObject[]);
+    build(context: BuildSceneObjectContext): void;
+    start(): LazyVertex;
+    end(): LazyVertex;
+    compareTo(other: MirrorShape2D): boolean;
+    getType(): string;
+    getUniqueType(): string;
+    serialize(): {
+        axis: any;
+    };
+}