fluidcad 0.0.2

package/lib/dist/features/2d/offset.d.ts

@@ -0,0 +1,18 @@
+import { SceneObject } from "../../common/scene-object.js";
+import { PlaneObjectBase } from "../plane-renderable-base.js";
+import { ExtrudableGeometryBase } from "./extrudable-base.js";
+export declare class Offset extends ExtrudableGeometryBase {
+    private distance;
+    private removeOriginal;
+    private sourceGeometries;
+    constructor(distance: number, removeOriginal?: boolean, sourceGeometries?: SceneObject[], targetPlane?: PlaneObjectBase);
+    build(): void;
+    getDependencies(): SceneObject[];
+    createCopy(remap: Map<SceneObject, SceneObject>): SceneObject;
+    compareTo(other: Offset): boolean;
+    getType(): string;
+    serialize(): {
+        distance: number;
+        removeOriginal: boolean;
+    };
+}

package/lib/dist/features/2d/offset.js

@@ -0,0 +1,117 @@
+import { WireOps } from "../../oc/wire-ops.js";
+import { Edge } from "../../common/edge.js";
+import { Wire } from "../../common/wire.js";
+import { ExtrudableGeometryBase } from "./extrudable-base.js";
+export class Offset extends ExtrudableGeometryBase {
+    distance;
+    removeOriginal;
+    sourceGeometries;
+    constructor(distance, removeOriginal = false, sourceGeometries = null, targetPlane = null) {
+        super(targetPlane);
+        this.distance = distance;
+        this.removeOriginal = removeOriginal;
+        this.sourceGeometries = sourceGeometries;
+    }
+    build() {
+        let sourceObjects;
+        if (this.sketch) {
+            sourceObjects = this.sketch.getEdgesWithOwner();
+        }
+        else {
+            sourceObjects = new Map();
+            for (const obj of this.sourceGeometries) {
+                const shapes = obj.getShapes();
+                for (const shape of shapes) {
+                    if (shape instanceof Edge) {
+                        sourceObjects.set(shape, obj);
+                    }
+                    else if (shape instanceof Wire) {
+                        for (const edge of shape.getEdges()) {
+                            sourceObjects.set(edge, obj);
+                        }
+                    }
+                }
+            }
+            this.targetPlane.removeShapes(this);
+        }
+        const allEdges = Array.from(sourceObjects.keys());
+        const wires = [];
+        const groups = WireOps.groupConnectedEdges(allEdges);
+        for (const group of groups) {
+            const wire = WireOps.makeWireFromEdges(group);
+            wires.push({
+                wire,
+                edges: new Map(group.map(edge => [edge, sourceObjects.get(edge)]))
+            });
+        }
+        for (const wireInfo of wires) {
+            const isOpen = !wireInfo.wire.isClosed();
+            const offsetWire = WireOps.offsetWire(wireInfo.wire, this.distance, isOpen);
+            const edges = offsetWire.getEdges();
+            for (const edge of edges) {
+                this.addShape(edge);
+            }
+            if (this.removeOriginal) {
+                for (const [edge, owner] of wireInfo.edges) {
+                    owner.removeShape(edge, this);
+                }
+            }
+        }
+    }
+    getDependencies() {
+        const deps = [];
+        if (this.targetPlane) {
+            deps.push(this.targetPlane);
+        }
+        if (this.sourceGeometries) {
+            deps.push(...this.sourceGeometries);
+        }
+        return deps;
+    }
+    createCopy(remap) {
+        const targetPlane = this.targetPlane ? (remap.get(this.targetPlane) || this.targetPlane) : null;
+        const geometriesClone = this.sourceGeometries
+            ? this.sourceGeometries.map(obj => remap.get(obj) || obj)
+            : null;
+        return new Offset(this.distance, this.removeOriginal, geometriesClone, targetPlane);
+    }
+    compareTo(other) {
+        if (!(other instanceof Offset)) {
+            return false;
+        }
+        if (!super.compareTo(other)) {
+            return false;
+        }
+        if (this.targetPlane?.constructor !== other.targetPlane?.constructor) {
+            return false;
+        }
+        if (this.targetPlane && other.targetPlane && !this.targetPlane.compareTo(other.targetPlane)) {
+            return false;
+        }
+        if ((this.sourceGeometries === null) !== (other.sourceGeometries === null)) {
+            return false;
+        }
+        if (this.sourceGeometries && other.sourceGeometries) {
+            if (this.sourceGeometries.length !== other.sourceGeometries.length) {
+                return false;
+            }
+            for (let i = 0; i < this.sourceGeometries.length; i++) {
+                const obj1 = this.sourceGeometries[i];
+                const obj2 = other.sourceGeometries[i];
+                if (!obj1.compareTo(obj2)) {
+                    return false;
+                }
+            }
+        }
+        return this.distance === other.distance && this.removeOriginal === other.removeOriginal;
+    }
+    getType() {
+        return 'offset';
+    }
+    serialize() {
+        return {
+            distance: this.distance,
+            removeOriginal: this.removeOriginal
+        };
+    }
+}

package/lib/dist/features/2d/pmove.d.ts

@@ -0,0 +1,16 @@
+import { SceneObject } from "../../common/scene-object.js";
+import { GeometrySceneObject } from "./geometry.js";
+export declare class PolarMove extends GeometrySceneObject {
+    radius: number;
+    angle: number;
+    constructor(radius: number, angle: number);
+    getType(): string;
+    build(): void;
+    getDependencies(): SceneObject[];
+    createCopy(remap: Map<SceneObject, SceneObject>): SceneObject;
+    compareTo(other: this): boolean;
+    serialize(): {
+        radius: number;
+        angle: number;
+    };
+}

package/lib/dist/features/2d/pmove.js

@@ -0,0 +1,40 @@
+import { Point2D } from "../../math/point.js";
+import { GeometrySceneObject } from "./geometry.js";
+export class PolarMove extends GeometrySceneObject {
+    radius;
+    angle;
+    constructor(radius, angle) {
+        super();
+        this.radius = radius;
+        this.angle = angle;
+    }
+    getType() {
+        return 'pmove';
+    }
+    build() {
+        const pos = this.getCurrentPosition();
+        const newPos = new Point2D(pos.x + this.radius * Math.cos(this.angle), pos.y + this.radius * Math.sin(this.angle));
+        this.setCurrentPosition(newPos);
+    }
+    getDependencies() {
+        return [];
+    }
+    createCopy(remap) {
+        return new PolarMove(this.radius, this.angle);
+    }
+    compareTo(other) {
+        if (!(other instanceof PolarMove)) {
+            return false;
+        }
+        if (!super.compareTo(other)) {
+            return false;
+        }
+        return this.radius === other.radius && this.angle === other.angle;
+    }
+    serialize() {
+        return {
+            radius: this.radius,
+            angle: this.angle
+        };
+    }
+}

package/lib/dist/features/2d/polygon.d.ts

@@ -0,0 +1,25 @@
+import { SceneObject } from "../../common/scene-object.js";
+import { LazySelectionSceneObject } from "../lazy-scene-object.js";
+import { LazyVertex } from "../lazy-vertex.js";
+import { PlaneObjectBase } from "../plane-renderable-base.js";
+import { ExtrudableGeometryBase } from "./extrudable-base.js";
+import { IPolygon } from "../../core/interfaces.js";
+export type PolygonMode = 'inscribed' | 'circumscribed';
+export declare class Polygon extends ExtrudableGeometryBase implements IPolygon {
+    numberOfSides: number;
+    diameter: number;
+    mode: PolygonMode;
+    constructor(numberOfSides: number, diameter: number, mode: PolygonMode, targetPlane?: PlaneObjectBase);
+    getType(): string;
+    build(): void;
+    getDependencies(): SceneObject[];
+    createCopy(remap: Map<SceneObject, SceneObject>): SceneObject;
+    compareTo(other: this): boolean;
+    getEdge(index: number): LazySelectionSceneObject;
+    getVertex(index: number): LazyVertex;
+    serialize(): {
+        numberOfSides: number;
+        diameter: number;
+        mode: PolygonMode;
+    };
+}

package/lib/dist/features/2d/polygon.js

@@ -0,0 +1,107 @@
+import { Geometry } from "../../oc/geometry.js";
+import { Vertex } from "../../common/vertex.js";
+import { LazySelectionSceneObject } from "../lazy-scene-object.js";
+import { LazyVertex } from "../lazy-vertex.js";
+import { ExtrudableGeometryBase } from "./extrudable-base.js";
+export class Polygon extends ExtrudableGeometryBase {
+    numberOfSides;
+    diameter;
+    mode;
+    constructor(numberOfSides, diameter, mode, targetPlane = null) {
+        super(targetPlane);
+        this.numberOfSides = numberOfSides;
+        this.diameter = diameter;
+        this.mode = mode;
+        if (numberOfSides < 3) {
+            throw new Error("Polygon must have at least 3 sides");
+        }
+    }
+    getType() {
+        return 'polygon';
+    }
+    build() {
+        const plane = this.targetPlane?.getPlane() || this.getParent().getPlane();
+        const center = this.targetPlane
+            ? plane.worldToLocal(this.targetPlane.getPlaneCenter())
+            : this.getCurrentPosition();
+        const radius = this.diameter / 2;
+        let effectiveRadius = radius;
+        if (this.mode === 'circumscribed') {
+            effectiveRadius = radius / Math.cos(Math.PI / this.numberOfSides);
+        }
+        const vertices = [];
+        for (let i = 0; i < this.numberOfSides; i++) {
+            const angle = (2 * Math.PI * i) / this.numberOfSides;
+            vertices.push(Geometry.getPointOnCircle(center, effectiveRadius, angle));
+        }
+        const edges = [];
+        for (let i = 0; i < this.numberOfSides; i++) {
+            const from = vertices[i];
+            const to = vertices[(i + 1) % this.numberOfSides];
+            const segment = Geometry.makeSegment(plane.localToWorld(from), plane.localToWorld(to));
+            const edge = Geometry.makeEdge(segment);
+            edges.push(edge);
+            this.setState(`edge-${i}`, edge);
+        }
+        this.addShapes(edges);
+        const baseCircle = Geometry.makeCircle(plane.localToWorld(center), radius, plane.normal);
+        const baseCircleEdge = Geometry.makeEdgeFromCircle(baseCircle);
+        baseCircleEdge.markAsMetaShape();
+        this.addShape(baseCircleEdge);
+        if (this.sketch) {
+            this.setCurrentPosition(center);
+        }
+        if (this.targetPlane) {
+            this.targetPlane.removeShapes(this);
+        }
+    }
+    getDependencies() {
+        return this.targetPlane ? [this.targetPlane] : [];
+    }
+    createCopy(remap) {
+        const targetPlane = this.targetPlane ? (remap.get(this.targetPlane) || this.targetPlane) : null;
+        return new Polygon(this.numberOfSides, this.diameter, this.mode, targetPlane);
+    }
+    compareTo(other) {
+        if (!(other instanceof Polygon)) {
+            return false;
+        }
+        if (!super.compareTo(other)) {
+            return false;
+        }
+        if (this.targetPlane?.constructor !== other.targetPlane?.constructor) {
+            return false;
+        }
+        if (this.targetPlane && other.targetPlane && !this.targetPlane.compareTo(other.targetPlane)) {
+            return false;
+        }
+        return this.numberOfSides === other.numberOfSides
+            && this.diameter === other.diameter
+            && this.mode === other.mode;
+    }
+    getEdge(index) {
+        return new LazySelectionSceneObject(this.generateUniqueName(`edge-${index}`), (parent) => {
+            const edge = parent.getState(`edge-${index}`);
+            return edge ? [edge] : [];
+        }, this);
+    }
+    getVertex(index) {
+        return new LazyVertex(this.generateUniqueName(`vertex-${index}`), () => {
+            const edge = this.getState(`edge-${index}`);
+            if (!edge) {
+                return [];
+            }
+            const plane = this.sketch.getPlane();
+            const vertex = edge.getFirstVertex();
+            const localPos = plane.worldToLocal(vertex.toPoint());
+            return [Vertex.fromPoint2D(localPos)];
+        });
+    }
+    serialize() {
+        return {
+            numberOfSides: this.numberOfSides,
+            diameter: this.diameter,
+            mode: this.mode,
+        };
+    }
+}

package/lib/dist/features/2d/projection.d.ts

@@ -0,0 +1,15 @@
+import { BuildSceneObjectContext, SceneObject } from "../../common/scene-object.js";
+import { PlaneObjectBase } from "../plane-renderable-base.js";
+import { ExtrudableGeometryBase } from "./extrudable-base.js";
+export declare class Projection extends ExtrudableGeometryBase {
+    private sourceObjects;
+    constructor(sourceObjects: SceneObject[], targetPlane?: PlaneObjectBase);
+    build(context?: BuildSceneObjectContext): void;
+    getDependencies(): SceneObject[];
+    createCopy(remap: Map<SceneObject, SceneObject>): SceneObject;
+    compareTo(other: Projection): boolean;
+    getType(): string;
+    serialize(): {
+        objectIds: string[];
+    };
+}

package/lib/dist/features/2d/projection.js

@@ -0,0 +1,94 @@
+import { Face } from "../../common/face.js";
+import { ShapeOps } from "../../oc/shape-ops.js";
+import { Edge } from "../../common/edge.js";
+import { ProjectionOps } from "../../oc/intersection.js";
+import { Wire } from "../../common/wire.js";
+import { ExtrudableGeometryBase } from "./extrudable-base.js";
+export class Projection extends ExtrudableGeometryBase {
+    sourceObjects;
+    constructor(sourceObjects, targetPlane = null) {
+        super(targetPlane);
+        this.sourceObjects = sourceObjects;
+    }
+    build(context) {
+        const plane = this.targetPlane?.getPlane() || this.sketch.getPlane();
+        const shapes = this.sourceObjects.flatMap(obj => obj.getShapes());
+        const transform = context?.getTransform() ?? null;
+        console.log('Projection: building with shapes:', shapes.length);
+        for (let shape of shapes) {
+            if (transform) {
+                shape = ShapeOps.transform(shape, transform);
+            }
+            let wires = [];
+            if (shape instanceof Face) {
+                wires = ProjectionOps.projectFaceOntoPlane(plane, shape);
+            }
+            else if (shape instanceof Wire) {
+                const firstEdge = shape.getEdges()[0];
+                wires = ProjectionOps.projectEdgeOntoPlane(plane, firstEdge);
+            }
+            else if (shape instanceof Edge) {
+                wires = ProjectionOps.projectEdgeOntoPlane(plane, shape);
+            }
+            for (const wire of wires) {
+                this.addShapes(wire.getEdges());
+            }
+        }
+        for (const obj of this.sourceObjects) {
+            obj.removeShapes(this);
+        }
+        if (this.targetPlane) {
+            this.targetPlane.removeShapes(this);
+        }
+        if (this.sketch) {
+            this.setCurrentPosition(this.getCurrentPosition());
+        }
+    }
+    getDependencies() {
+        const deps = [...this.sourceObjects];
+        if (this.targetPlane) {
+            deps.push(this.targetPlane);
+        }
+        return deps;
+    }
+    createCopy(remap) {
+        const objects = this.sourceObjects.map(obj => remap.get(obj) || obj);
+        const targetPlane = this.targetPlane ? (remap.get(this.targetPlane) || this.targetPlane) : null;
+        return new Projection(objects, targetPlane);
+    }
+    compareTo(other) {
+        if (!(other instanceof Projection)) {
+            return false;
+        }
+        if (!super.compareTo(other)) {
+            return false;
+        }
+        if (this.targetPlane?.constructor !== other.targetPlane?.constructor) {
+            return false;
+        }
+        if (this.targetPlane && other.targetPlane && !this.targetPlane.compareTo(other.targetPlane)) {
+            return false;
+        }
+        const thisObjects = this.sourceObjects || [];
+        const otherObjects = other.sourceObjects || [];
+        if (thisObjects.length !== otherObjects.length) {
+            return false;
+        }
+        for (let i = 0; i < thisObjects.length; i++) {
+            const thisObj = thisObjects[i];
+            const otherObj = otherObjects[i];
+            if (!thisObj.compareTo(otherObj)) {
+                return false;
+            }
+        }
+        return true;
+    }
+    getType() {
+        return 'projection';
+    }
+    serialize() {
+        return {
+            objectIds: this.sourceObjects.map(o => o.id)
+        };
+    }
+}

package/lib/dist/features/2d/rect.d.ts

@@ -0,0 +1,45 @@
+import { Point2D } from "../../math/point.js";
+import { SceneObject } from "../../common/scene-object.js";
+import { Edge } from "../../common/edge.js";
+import { LazySelectionSceneObject } from "../lazy-scene-object.js";
+import { LazyVertex } from "../lazy-vertex.js";
+import { PlaneObjectBase } from "../plane-renderable-base.js";
+import { Plane } from "../../math/plane.js";
+import { ExtrudableGeometryBase } from "./extrudable-base.js";
+import { IRect } from "../../core/interfaces.js";
+type CenteringOptions = boolean | 'horizontal' | 'vertical';
+export declare class Rect extends ExtrudableGeometryBase implements IRect {
+    width: number;
+    height: number;
+    private _radius?;
+    private _center;
+    constructor(width: number, height: number, targetPlane?: PlaneObjectBase);
+    build(): void;
+    buildSimpleRect(start: Point2D, plane: Plane): Edge[];
+    buildRoundedRect(start: Point2D, plane: Plane): Edge[];
+    getType(): string;
+    getDependencies(): SceneObject[];
+    createCopy(remap: Map<SceneObject, SceneObject>): SceneObject;
+    compareTo(other: Rect): boolean;
+    topEdge(): LazySelectionSceneObject;
+    bottomEdge(): LazySelectionSceneObject;
+    leftEdge(): LazySelectionSceneObject;
+    rightEdge(): LazySelectionSceneObject;
+    topLeftArcEdge(): LazySelectionSceneObject;
+    topRightArcEdge(): LazySelectionSceneObject;
+    bottomLeftArcEdge(): LazySelectionSceneObject;
+    bottomRightArcEdge(): LazySelectionSceneObject;
+    topLeft(): LazyVertex;
+    topRight(): LazyVertex;
+    bottomLeft(): LazyVertex;
+    bottomRight(): LazyVertex;
+    radius(...r: number[]): this;
+    center(value?: CenteringOptions): this;
+    serialize(): {
+        width: number;
+        height: number;
+        radius: number | number[];
+        center: CenteringOptions;
+    };
+}
+export {};