fluidcad 0.0.2

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

@@ -0,0 +1,110 @@
+import { Matrix4 } from "../math/matrix4.js";
+import { ShapeOps } from "../oc/shape-ops.js";
+import { GeometrySceneObject } from "./2d/geometry.js";
+import { LazyVertex } from "./lazy-vertex.js";
+import { Vertex } from "../common/vertex.js";
+export class MirrorShape2D extends GeometrySceneObject {
+    axis;
+    targetObjects;
+    constructor(axis, targetObjects = null) {
+        super();
+        this.axis = axis;
+        this.targetObjects = targetObjects;
+    }
+    build(context) {
+        let targetObjects = this.targetObjects;
+        let sketch = this.sketch;
+        let axis;
+        const objects = sketch.getPreviousSiblings(this);
+        const lastObj = context.getLastObject();
+        if (this.targetObjects && this.targetObjects.length > 0) {
+            targetObjects = objects.filter(obj => this.targetObjects.includes(obj));
+        }
+        else {
+            targetObjects = objects;
+        }
+        this.axis.removeShapes(this);
+        axis = this.axis.getAxis();
+        const transformedShapes = [];
+        const plane = sketch.getPlane();
+        const mirrorPlaneNormal = axis.direction.cross(plane.normal);
+        const matrix = Matrix4.mirrorPlane(mirrorPlaneNormal, axis.origin);
+        for (const obj of targetObjects) {
+            const shapes = obj.getShapes({ excludeMeta: false, excludeGuide: false });
+            for (const shape of shapes) {
+                const transformed = ShapeOps.transform(shape, matrix);
+                transformedShapes.push(transformed);
+            }
+        }
+        const firstShape = transformedShapes[0];
+        const lastShape = transformedShapes[transformedShapes.length - 1];
+        if (firstShape) {
+            const start = firstShape.getFirstVertex();
+            if (start) {
+                const localStart = plane.worldToLocal(start.toPoint());
+                this.setState('start', Vertex.fromPoint2D(localStart));
+            }
+        }
+        if (lastShape) {
+            const end = lastShape.getLastVertex();
+            if (end) {
+                const localEnd = plane.worldToLocal(end.toPoint());
+                this.setState('end', Vertex.fromPoint2D(localEnd));
+            }
+        }
+        if (lastObj) {
+            const lastTangent = lastObj.getTangent();
+            if (lastTangent) {
+                const transformedTangent = lastTangent.transform(matrix);
+                this.setTangent(transformedTangent);
+            }
+        }
+        const currentPos = this.getCurrentPosition();
+        if (currentPos) {
+            const worldPos = plane.localToWorld(currentPos);
+            const mirroredWorldPos = matrix.transformPoint(worldPos);
+            const mirroredLocalPos = plane.worldToLocal(mirroredWorldPos);
+            this.setCurrentPosition(mirroredLocalPos);
+        }
+        this.addShapes(transformedShapes);
+    }
+    start() {
+        return new LazyVertex(this.generateUniqueName('start-vertex'), () => [this.getState('start')]);
+    }
+    end() {
+        return new LazyVertex(this.generateUniqueName('end-vertex'), () => [this.getState('end')]);
+    }
+    compareTo(other) {
+        if (!(other instanceof MirrorShape2D)) {
+            return false;
+        }
+        if (!super.compareTo(other)) {
+            return false;
+        }
+        if (!this.axis.compareTo(other.axis)) {
+            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 "mirror";
+    }
+    getUniqueType() {
+        return 'mirror-shape-2d';
+    }
+    serialize() {
+        return {
+            axis: this.axis.serialize(),
+        };
+    }
+}

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

@@ -0,0 +1,12 @@
+import { BuildSceneObjectContext, SceneObject } from "../common/scene-object.js";
+export declare class Part extends SceneObject {
+    partName: string;
+    constructor(partName: string);
+    isContainer(): boolean;
+    build(_context?: BuildSceneObjectContext): void;
+    compareTo(other: Part): boolean;
+    getType(): string;
+    serialize(): {
+        name: string;
+    };
+}

package/lib/dist/features/part.js

@@ -0,0 +1,36 @@
+import { SceneObject } from "../common/scene-object.js";
+export class Part extends SceneObject {
+    partName;
+    constructor(partName) {
+        super();
+        this.partName = partName;
+        this.name(partName);
+        this.setAlwaysVisible();
+    }
+    isContainer() {
+        return true;
+    }
+    build(_context) {
+        // No-op — children produce geometry
+    }
+    compareTo(other) {
+        if (!(other instanceof Part)) {
+            return false;
+        }
+        if (!super.compareTo(other)) {
+            return false;
+        }
+        if (this.partName !== other.partName) {
+            return false;
+        }
+        return true;
+    }
+    getType() {
+        return "part";
+    }
+    serialize() {
+        return {
+            name: this.partName,
+        };
+    }
+}

package/lib/dist/features/plane-from-object.d.ts

@@ -0,0 +1,29 @@
+import { BuildSceneObjectContext, SceneObject } from "../common/scene-object.js";
+import { PlaneRenderableOptions } from "../core/plane.js";
+import { PlaneObjectBase } from "./plane-renderable-base.js";
+import { Face } from "../common/face.js";
+import { Point } from "../math/point.js";
+import { Plane } from "../math/plane.js";
+export declare class PlaneFromObject extends PlaneObjectBase {
+    sourceObject: SceneObject;
+    options?: PlaneRenderableOptions;
+    constructor(sourceObject: SceneObject, options?: PlaneRenderableOptions);
+    build(context?: BuildSceneObjectContext): void;
+    getFromSceneObject(sceneObject: SceneObject): {
+        plane: Plane;
+        sourceFace: Face;
+    };
+    getFromPlaneObject(sceneObject: PlaneObjectBase): Plane;
+    getDependencies(): SceneObject[];
+    createCopy(remap: Map<SceneObject, SceneObject>): SceneObject;
+    compareTo(other: PlaneFromObject): boolean;
+    getUniqueType(): string;
+    serialize(): {
+        origin: Point;
+        xDirection: import("../math/vector3d.js").Vector3d;
+        yDirection: import("../math/vector3d.js").Vector3d;
+        normal: import("../math/vector3d.js").Vector3d;
+        options: PlaneRenderableOptions;
+        center: any;
+    };
+}

package/lib/dist/features/plane-from-object.js

@@ -0,0 +1,103 @@
+import { PlaneObjectBase } from "./plane-renderable-base.js";
+import { FaceOps } from "../oc/face-ops.js";
+import { ShapeOps } from "../oc/shape-ops.js";
+import { Point } from "../math/point.js";
+export class PlaneFromObject extends PlaneObjectBase {
+    sourceObject;
+    options;
+    constructor(sourceObject, options) {
+        super();
+        this.sourceObject = sourceObject;
+        this.options = options;
+    }
+    build(context) {
+        let plane;
+        let sourceFace;
+        let center;
+        if (this.sourceObject instanceof PlaneObjectBase) {
+            plane = this.getFromPlaneObject(this.sourceObject);
+            center = this.sourceObject.getPlaneCenter();
+        }
+        else {
+            const extract = this.getFromSceneObject(this.sourceObject);
+            plane = extract.plane;
+            sourceFace = extract.sourceFace;
+        }
+        this.sourceObject.removeShapes(this);
+        if (this.options) {
+            plane = plane.transform(this.options);
+        }
+        if (sourceFace) {
+            const bbox = ShapeOps.getBoundingBox(sourceFace.getShape());
+            center = new Point(bbox.centerX, bbox.centerY, bbox.centerZ);
+        }
+        if (center) {
+            this.setState('plane-center', center);
+        }
+        const transform = context?.getTransform() ?? null;
+        if (transform) {
+            plane = plane.applyMatrix(transform);
+            if (center) {
+                center = center.transform(transform);
+                this.setState('plane-center', center);
+            }
+        }
+        this.setState('plane', plane);
+        const face = FaceOps.planeToFace(plane, center);
+        face.markAsMetaShape();
+        this.addShape(face);
+    }
+    getFromSceneObject(sceneObject) {
+        const shapes = sceneObject.getShapes();
+        console.log(`Plane: Retrieved ${shapes.length} shapes from selection`, shapes);
+        if (shapes.length === 0) {
+            throw new Error("Plane: Selected object has no shapes to extract plane from");
+        }
+        let sourceFace = shapes[0];
+        if (!sourceFace.isFace()) {
+            throw new Error("Plane: Selected shape is not a face; cannot extract plane: " + sourceFace.getType());
+        }
+        let plane = sourceFace.getPlane();
+        console.log('Plane: Extracted plane from face', plane.normal);
+        return { plane, sourceFace };
+    }
+    getFromPlaneObject(sceneObject) {
+        let plane = sceneObject.getPlane();
+        return plane;
+    }
+    getDependencies() {
+        return [];
+    }
+    createCopy(remap) {
+        return new PlaneFromObject(this, this.options);
+    }
+    compareTo(other) {
+        if (!(other instanceof PlaneFromObject)) {
+            return false;
+        }
+        if (!super.compareTo(other)) {
+            return false;
+        }
+        if (!this.sourceObject.compareTo(other.sourceObject)) {
+            return false;
+        }
+        if (JSON.stringify(this.options) !== JSON.stringify(other.options)) {
+            return false;
+        }
+        return true;
+    }
+    getUniqueType() {
+        return 'plane-from-face';
+    }
+    serialize() {
+        const plane = this.getPlane();
+        return {
+            origin: plane.origin,
+            xDirection: plane.xDirection,
+            yDirection: plane.yDirection,
+            normal: plane.normal,
+            options: this.options,
+            center: this.getState('plane-center') || plane.origin,
+        };
+    }
+}

package/lib/dist/features/plane-mid.d.ts

@@ -0,0 +1,18 @@
+import { PlaneRenderableOptions } from "../core/plane.js";
+import { PlaneObjectBase } from "./plane-renderable-base.js";
+export declare class PlaneMiddleRenderable extends PlaneObjectBase {
+    p1: PlaneObjectBase;
+    p2: PlaneObjectBase;
+    options?: PlaneRenderableOptions;
+    constructor(p1: PlaneObjectBase, p2: PlaneObjectBase, options?: PlaneRenderableOptions);
+    build(): void;
+    compareTo(other: PlaneMiddleRenderable): boolean;
+    serialize(): {
+        origin: import("../math/point.js").Point;
+        xDirection: import("../math/vector3d.js").Vector3d;
+        yDirection: import("../math/vector3d.js").Vector3d;
+        normal: import("../math/vector3d.js").Vector3d;
+        center: import("../math/point.js").Point;
+        options: PlaneRenderableOptions;
+    };
+}

package/lib/dist/features/plane-mid.js

@@ -0,0 +1,54 @@
+import { PlaneObjectBase } from "./plane-renderable-base.js";
+import { FaceOps } from "../oc/face-ops.js";
+import { Plane } from "../math/plane.js";
+export class PlaneMiddleRenderable extends PlaneObjectBase {
+    p1;
+    p2;
+    options;
+    constructor(p1, p2, options) {
+        super();
+        this.p1 = p1;
+        this.p2 = p2;
+        this.options = options;
+    }
+    build() {
+        const plane1 = this.p1.getPlane();
+        const plane2 = this.p2.getPlane();
+        const midpoint = plane1.origin.add(plane2.origin).multiplyScalar(0.5);
+        const xDirection = plane1.xDirection;
+        const normal = plane1.normal;
+        const result = new Plane(midpoint, xDirection, normal);
+        this.setState('plane', result);
+        const face = FaceOps.planeToFace(result);
+        this.addShape(face);
+    }
+    compareTo(other) {
+        if (!(other instanceof PlaneMiddleRenderable)) {
+            return false;
+        }
+        if (!super.compareTo(other)) {
+            return false;
+        }
+        if (!this.p1.compareTo(other.p1)) {
+            return false;
+        }
+        if (!this.p2.compareTo(other.p2)) {
+            return false;
+        }
+        if (JSON.stringify(this.options) !== JSON.stringify(other.options)) {
+            return false;
+        }
+        return true;
+    }
+    serialize() {
+        const plane = this.getPlane();
+        return {
+            origin: plane.origin,
+            xDirection: plane.xDirection,
+            yDirection: plane.yDirection,
+            normal: plane.normal,
+            center: plane.origin,
+            options: this.options,
+        };
+    }
+}

package/lib/dist/features/plane-renderable-base.d.ts

@@ -0,0 +1,9 @@
+import { Plane } from "../math/plane.js";
+import { SceneObject } from "../common/scene-object.js";
+import { IPlane } from "../core/interfaces.js";
+export declare abstract class PlaneObjectBase extends SceneObject implements IPlane {
+    constructor();
+    getPlane(): Plane;
+    getPlaneCenter(): any;
+    getType(): string;
+}

package/lib/dist/features/plane-renderable-base.js

@@ -0,0 +1,15 @@
+import { SceneObject } from "../common/scene-object.js";
+export class PlaneObjectBase extends SceneObject {
+    constructor() {
+        super();
+    }
+    getPlane() {
+        return this.getState('plane');
+    }
+    getPlaneCenter() {
+        return this.getState('plane-center') || this.getPlane().origin;
+    }
+    getType() {
+        return 'plane';
+    }
+}

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

@@ -0,0 +1,21 @@
+import { BuildSceneObjectContext, SceneObject } from "../common/scene-object.js";
+import { Plane } from "../math/plane.js";
+import { PlaneRenderableOptions } from "../core/plane.js";
+import { PlaneObjectBase } from "./plane-renderable-base.js";
+export declare class PlaneObject extends PlaneObjectBase {
+    plane: Plane;
+    options?: PlaneRenderableOptions;
+    constructor(plane: Plane, options?: PlaneRenderableOptions);
+    build(context?: BuildSceneObjectContext): void;
+    getDependencies(): SceneObject[];
+    createCopy(remap: Map<SceneObject, SceneObject>): SceneObject;
+    compareTo(other: PlaneObject): boolean;
+    serialize(): {
+        origin: import("../math/point.js").Point;
+        xDirection: import("../math/vector3d.js").Vector3d;
+        yDirection: import("../math/vector3d.js").Vector3d;
+        normal: import("../math/vector3d.js").Vector3d;
+        center: any;
+        options: PlaneRenderableOptions;
+    };
+}

package/lib/dist/features/plane.js

@@ -0,0 +1,64 @@
+import { PlaneObjectBase } from "./plane-renderable-base.js";
+import { FaceOps } from "../oc/face-ops.js";
+export class PlaneObject extends PlaneObjectBase {
+    plane;
+    options;
+    constructor(plane, options) {
+        super();
+        this.plane = plane;
+        this.options = options;
+        let p = this.plane;
+        if (this.options) {
+            p = p.transform(this.options);
+        }
+        this.setState('plane', p);
+    }
+    build(context) {
+        let plane = this.getPlane();
+        let center = this.getPlaneCenter();
+        const transform = context?.getTransform() ?? null;
+        if (transform) {
+            plane = plane.applyMatrix(transform);
+            this.setState('plane', plane);
+            if (center) {
+                center = center.transform(transform);
+                this.setState('plane-center', center);
+            }
+        }
+        const face = FaceOps.planeToFace(plane, center);
+        face.markAsMetaShape();
+        this.addShape(face);
+    }
+    getDependencies() {
+        return [];
+    }
+    createCopy(remap) {
+        return new PlaneObject(this.plane, this.options);
+    }
+    compareTo(other) {
+        if (!(other instanceof PlaneObject)) {
+            return false;
+        }
+        if (!super.compareTo(other)) {
+            return false;
+        }
+        if (!this.plane.compareTo(other.plane)) {
+            return false;
+        }
+        if (JSON.stringify(this.options) !== JSON.stringify(other.options)) {
+            return false;
+        }
+        return true;
+    }
+    serialize() {
+        const plane = this.getPlane();
+        return {
+            origin: plane.origin,
+            xDirection: plane.xDirection,
+            yDirection: plane.yDirection,
+            normal: plane.normal,
+            center: this.getPlaneCenter() || plane.origin,
+            options: this.options,
+        };
+    }
+}

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

@@ -0,0 +1,25 @@
+import { SceneObject } from "../common/scene-object.js";
+import { Edge } from "../common/edge.js";
+import { Wire } from "../common/wire.js";
+import { Extrudable } from "../helpers/types.js";
+import { LazyVertex } from "./lazy-vertex.js";
+import { GeometrySceneObject } from "./2d/geometry.js";
+export declare class Region2D extends SceneObject implements Extrudable {
+    private _points;
+    private _extrudable;
+    constructor(extrudable: Extrudable);
+    points(...ps: LazyVertex[]): this;
+    isExtrudable(): boolean;
+    build(): void;
+    getGeometries(): (Wire | Edge)[];
+    getGeometriesWithOwner(): Map<Wire | Edge, GeometrySceneObject>;
+    getPlane(): import("../math/plane.js").Plane;
+    getDependencies(): SceneObject[];
+    createCopy(remap: Map<SceneObject, SceneObject>): SceneObject;
+    compareTo(other: Region2D): boolean;
+    getType(): string;
+    serialize(): {
+        plane: any;
+        selections: any;
+    };
+}