fluidcad 0.0.2

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

@@ -0,0 +1,78 @@
+import { Vertex } from "../../common/vertex.js";
+import { Geometry } from "../../oc/geometry.js";
+import { rad } from "../../helpers/math-helpers.js";
+import { Point2D } from "../../math/point.js";
+import { GeometrySceneObject } from "./geometry.js";
+export class AngledLine extends GeometrySceneObject {
+    length;
+    angle;
+    centered;
+    targetPlane;
+    constructor(length, angle, centered = false, targetPlane = null) {
+        super();
+        this.length = length;
+        this.angle = angle;
+        this.centered = centered;
+        this.targetPlane = targetPlane;
+    }
+    build() {
+        const plane = this.targetPlane?.getPlane() || this.sketch.getPlane();
+        let tangent = this.sketch?.getTangentAt(this) || new Point2D(1, 0);
+        tangent = tangent.normalize();
+        const angleRad = rad(this.angle);
+        // 2D rotation of tangent by angle
+        const cos = Math.cos(angleRad);
+        const sin = Math.sin(angleRad);
+        const dirX = cos * tangent.x - sin * tangent.y;
+        const dirY = sin * tangent.x + cos * tangent.y;
+        const direction = new Point2D(dirX, dirY);
+        const currentPos = this.targetPlane
+            ? plane.worldToLocal(this.targetPlane.getPlaneCenter())
+            : this.getCurrentPosition();
+        const startPoint = this.centered
+            ? currentPos.translate(-direction.x * this.length / 2, -direction.y * this.length / 2)
+            : currentPos;
+        const start = plane.localToWorld(startPoint);
+        const worldDir = plane.xDirection.multiply(direction.x).add(plane.yDirection.multiply(direction.y));
+        const end = start.add(worldDir.multiply(this.length));
+        const endPoint = plane.worldToLocal(end);
+        let segment = Geometry.makeSegment(start, end);
+        const edge = Geometry.makeEdge(segment);
+        this.setState('start', Vertex.fromPoint2D(startPoint));
+        this.setState('end', Vertex.fromPoint2D(endPoint));
+        this.addShape(edge);
+        this.setTangent(direction.normalize());
+        if (this.sketch)
+            this.setCurrentPosition(endPoint);
+        if (this.targetPlane)
+            this.targetPlane.removeShapes(this);
+    }
+    compareTo(other) {
+        if (!(other instanceof AngledLine)) {
+            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.length === other.length && this.angle === other.angle && this.centered === other.centered;
+    }
+    getType() {
+        return 'line';
+    }
+    getUniqueType() {
+        return 'aline';
+    }
+    serialize() {
+        return {
+            length: this.length,
+            angle: this.angle,
+            centered: this.centered
+        };
+    }
+}

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

@@ -0,0 +1,14 @@
+import { SceneObject } from "../../common/scene-object.js";
+import { GeometrySceneObject } from "./geometry.js";
+import { LazyVertex } from "../lazy-vertex.js";
+export declare class Move extends GeometrySceneObject {
+    targetPosition: LazyVertex;
+    constructor(targetPosition: LazyVertex);
+    getType(): string;
+    build(): void;
+    clone(): SceneObject[];
+    compareTo(other: this): boolean;
+    serialize(): {
+        position: LazyVertex;
+    };
+}

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

@@ -0,0 +1,33 @@
+import { GeometrySceneObject } from "./geometry.js";
+export class Move extends GeometrySceneObject {
+    targetPosition;
+    constructor(targetPosition) {
+        super();
+        this.targetPosition = targetPosition;
+    }
+    getType() {
+        return 'move';
+    }
+    build() {
+        const point = this.targetPosition.asPoint2D();
+        this.setCurrentPosition(point);
+    }
+    clone() {
+        const move = new Move(this.targetPosition);
+        return [move];
+    }
+    compareTo(other) {
+        if (!(other instanceof Move)) {
+            return false;
+        }
+        if (!super.compareTo(other)) {
+            return false;
+        }
+        return this.targetPosition.compareTo(other.targetPosition);
+    }
+    serialize() {
+        return {
+            position: this.targetPosition
+        };
+    }
+}

package/lib/dist/features/2d/arc-from-center.d.ts

@@ -0,0 +1,16 @@
+import { LazyVertex } from "../lazy-vertex.js";
+import { GeometrySceneObject } from "./geometry.js";
+export declare class ArcFromCenterAndAngle extends GeometrySceneObject {
+    center: LazyVertex;
+    angle: number;
+    centered: boolean;
+    constructor(center: LazyVertex, angle: number, centered?: boolean);
+    build(): void;
+    compareTo(other: ArcFromCenterAndAngle): boolean;
+    getType(): string;
+    serialize(): {
+        center: {};
+        angle: number;
+        centered: boolean;
+    };
+}

package/lib/dist/features/2d/arc-from-center.js

@@ -0,0 +1,69 @@
+import { Vertex } from "../../common/vertex.js";
+import { Geometry } from "../../oc/geometry.js";
+import { rad } from "../../helpers/math-helpers.js";
+import { Point2D } from "../../math/point.js";
+import { GeometrySceneObject } from "./geometry.js";
+export class ArcFromCenterAndAngle extends GeometrySceneObject {
+    center;
+    angle;
+    centered;
+    constructor(center, angle, centered = false) {
+        super();
+        this.center = center;
+        this.angle = angle;
+        this.centered = centered;
+    }
+    build() {
+        const plane = this.sketch.getPlane();
+        const currentPos = this.getCurrentPosition();
+        const centerPoint = this.center.asPoint2D();
+        const dx = currentPos.x - centerPoint.x;
+        const dy = currentPos.y - centerPoint.y;
+        const radius = Math.sqrt(dx * dx + dy * dy);
+        const midAngleRad = Math.atan2(dy, dx);
+        const cw = this.angle < 0;
+        const halfSweep = rad(this.angle) / 2;
+        const startAngleRad = this.centered ? midAngleRad - halfSweep : midAngleRad;
+        const endAngleRad = this.centered ? midAngleRad + halfSweep : midAngleRad + rad(this.angle);
+        const normal = cw ? plane.normal.negate() : plane.normal;
+        const startPoint = this.centered
+            ? Geometry.getPointOnCircle(centerPoint, radius, startAngleRad)
+            : currentPos;
+        const endPoint = Geometry.getPointOnCircle(centerPoint, radius, endAngleRad);
+        const center = plane.localToWorld(centerPoint);
+        const start = plane.localToWorld(startPoint);
+        const end = plane.localToWorld(endPoint);
+        const arc = Geometry.makeArc(center, radius, normal, start, end);
+        const edge = Geometry.makeEdgeFromCurve(arc);
+        this.setState('start', Vertex.fromPoint2D(startPoint));
+        this.setState('end', Vertex.fromPoint2D(endPoint));
+        // Tangent at end point: CCW: (-sin θ, cos θ), CW: (sin θ, -cos θ)
+        const sign = cw ? -1 : 1;
+        const tx = sign * (-Math.sin(endAngleRad));
+        const ty = sign * Math.cos(endAngleRad);
+        this.setTangent(new Point2D(tx, ty));
+        this.addShape(edge);
+        this.setCurrentPosition(endPoint);
+    }
+    compareTo(other) {
+        if (!(other instanceof ArcFromCenterAndAngle)) {
+            return false;
+        }
+        if (!super.compareTo(other)) {
+            return false;
+        }
+        return this.center.compareTo(other.center) &&
+            this.angle === other.angle &&
+            this.centered === other.centered;
+    }
+    getType() {
+        return 'arc-from-center';
+    }
+    serialize() {
+        return {
+            center: this.center.serialize(),
+            angle: this.angle,
+            centered: this.centered
+        };
+    }
+}

package/lib/dist/features/2d/arc-to-point.d.ts

@@ -0,0 +1,17 @@
+import { GeometrySceneObject } from "./geometry.js";
+import { LazyVertex } from "../lazy-vertex.js";
+import { PlaneObjectBase } from "../plane-renderable-base.js";
+export declare class ArcToPoint extends GeometrySceneObject {
+    endPoint: LazyVertex;
+    radius: number;
+    private targetPlane;
+    constructor(endPoint: LazyVertex, radius?: number, targetPlane?: PlaneObjectBase);
+    build(): void;
+    compareTo(other: ArcToPoint): boolean;
+    getType(): string;
+    getUniqueType(): string;
+    serialize(): {
+        endPoint: {};
+        radius: number;
+    };
+}

package/lib/dist/features/2d/arc-to-point.js

@@ -0,0 +1,95 @@
+import { Vertex } from "../../common/vertex.js";
+import { Geometry } from "../../oc/geometry.js";
+import { Point2D } from "../../math/point.js";
+import { GeometrySceneObject } from "./geometry.js";
+export class ArcToPoint extends GeometrySceneObject {
+    endPoint;
+    radius;
+    targetPlane;
+    constructor(endPoint, radius = 0, targetPlane = null) {
+        super();
+        this.endPoint = endPoint;
+        this.radius = radius;
+        this.targetPlane = targetPlane;
+    }
+    build() {
+        const plane = this.targetPlane?.getPlane() || this.sketch.getPlane();
+        const targetPoint = this.endPoint.asPoint2D();
+        const startPoint = this.targetPlane
+            ? plane.worldToLocal(this.targetPlane.getPlaneCenter())
+            : this.getCurrentPosition();
+        const dx = targetPoint.x - startPoint.x;
+        const dy = targetPoint.y - startPoint.y;
+        const chordLen = Math.sqrt(dx * dx + dy * dy);
+        // Default radius: semicircle (half the chord length)
+        let r = this.radius || (chordLen / 2);
+        const cw = r < 0;
+        r = Math.abs(r);
+        // Ensure radius is at least half chord length
+        if (r < chordLen / 2) {
+            r = chordLen / 2;
+        }
+        // Find center using perpendicular bisector + radius constraint
+        const mx = (startPoint.x + targetPoint.x) / 2;
+        const my = (startPoint.y + targetPoint.y) / 2;
+        // Perpendicular direction to chord (normalized)
+        const px = -dy / chordLen;
+        const py = dx / chordLen;
+        // Distance from midpoint to center along perpendicular
+        const d = Math.sqrt(r * r - (chordLen / 2) * (chordLen / 2));
+        // Choose side based on CW/CCW
+        const sign = cw ? -1 : 1;
+        const centerPoint = new Point2D(mx + sign * d * px, my + sign * d * py);
+        const startAngle = Math.atan2(startPoint.y - centerPoint.y, startPoint.x - centerPoint.x);
+        const endAngle = Math.atan2(targetPoint.y - centerPoint.y, targetPoint.x - centerPoint.x);
+        const normal = cw ? plane.normal.negate() : plane.normal;
+        const center = plane.localToWorld(centerPoint);
+        const start = plane.localToWorld(startPoint);
+        const end = plane.localToWorld(targetPoint);
+        const arc = Geometry.makeArc(center, r, normal, start, end);
+        const edge = Geometry.makeEdgeFromCurve(arc);
+        // Tangent at end: perpendicular to radius direction at end point
+        // CCW: (-sin θ, cos θ), CW: (sin θ, -cos θ)
+        const signT = cw ? -1 : 1;
+        const endTx = signT * (-Math.sin(endAngle));
+        const endTy = signT * Math.cos(endAngle);
+        this.setTangent(new Point2D(endTx, endTy));
+        this.setState('start', Vertex.fromPoint2D(startPoint));
+        this.setState('end', Vertex.fromPoint2D(targetPoint));
+        this.addShape(edge);
+        if (this.sketch) {
+            this.setCurrentPosition(targetPoint);
+        }
+        if (this.targetPlane) {
+            this.targetPlane.removeShapes(this);
+        }
+    }
+    compareTo(other) {
+        if (!(other instanceof ArcToPoint)) {
+            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.endPoint.compareTo(other.endPoint) &&
+            this.radius === other.radius;
+    }
+    getType() {
+        return 'arc';
+    }
+    getUniqueType() {
+        return 'arc-to-point';
+    }
+    serialize() {
+        return {
+            endPoint: this.endPoint.serialize(),
+            radius: this.radius
+        };
+    }
+}

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

@@ -0,0 +1,19 @@
+import { PlaneObjectBase } from "../plane-renderable-base.js";
+import { GeometrySceneObject } from "./geometry.js";
+export declare class ArcFromTwoAngles extends GeometrySceneObject {
+    radius: number;
+    startAngle: number;
+    endAngle: number;
+    centered: boolean;
+    private targetPlane;
+    constructor(radius: number, startAngle: number, endAngle: number, centered?: boolean, targetPlane?: PlaneObjectBase);
+    build(): void;
+    getType(): string;
+    compareTo(other: ArcFromTwoAngles): boolean;
+    serialize(): {
+        radius: number;
+        startAngle: number;
+        endAngle: number;
+        centered: boolean;
+    };
+}

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

@@ -0,0 +1,94 @@
+import { Vertex } from "../../common/vertex.js";
+import { Geometry } from "../../oc/geometry.js";
+import { rad } from "../../helpers/math-helpers.js";
+import { Point2D } from "../../math/point.js";
+import { GeometrySceneObject } from "./geometry.js";
+export class ArcFromTwoAngles extends GeometrySceneObject {
+    radius;
+    startAngle;
+    endAngle;
+    centered;
+    targetPlane;
+    constructor(radius, startAngle, endAngle, centered = false, targetPlane = null) {
+        super();
+        this.radius = radius;
+        this.startAngle = startAngle;
+        this.endAngle = endAngle;
+        this.centered = centered;
+        this.targetPlane = targetPlane;
+    }
+    build() {
+        const plane = this.targetPlane?.getPlane() || this.sketch.getPlane();
+        const radius = this.radius;
+        // Current position (or plane center) is the center of the arc
+        const centerPoint = this.targetPlane
+            ? plane.worldToLocal(this.targetPlane.getPlaneCenter())
+            : this.getCurrentPosition();
+        // Negative angles indicate a clockwise arc
+        const cw = this.endAngle < 0;
+        const absStartAngle = Math.abs(this.startAngle);
+        const absEndAngle = Math.abs(this.endAngle);
+        let startAngleRad;
+        let endAngleRad;
+        if (this.centered) {
+            // Centered: the sweep is split equally around startAngle
+            const halfSweep = rad(absEndAngle) / 2;
+            const midAngle = rad(absStartAngle);
+            startAngleRad = midAngle - halfSweep;
+            endAngleRad = midAngle + halfSweep;
+        }
+        else {
+            startAngleRad = rad(absStartAngle);
+            endAngleRad = rad(absEndAngle);
+        }
+        const normal = cw ? plane.normal.negate() : plane.normal;
+        const startPoint = Geometry.getPointOnCircle(centerPoint, radius, startAngleRad);
+        const endPoint = Geometry.getPointOnCircle(centerPoint, radius, endAngleRad);
+        const center = plane.localToWorld(centerPoint);
+        const start = plane.localToWorld(startPoint);
+        const end = plane.localToWorld(endPoint);
+        const arc = Geometry.makeArc(center, radius, normal, start, end);
+        const edge = Geometry.makeEdgeFromCurve(arc);
+        this.setState('start', Vertex.fromPoint2D(startPoint));
+        this.setState('end', Vertex.fromPoint2D(endPoint));
+        // Tangent at end point: CCW: (-sin θ, cos θ), CW: (sin θ, -cos θ)
+        const sign = cw ? -1 : 1;
+        const tx = sign * (-Math.sin(endAngleRad));
+        const ty = sign * Math.cos(endAngleRad);
+        this.setTangent(new Point2D(tx, ty));
+        this.addShape(edge);
+        // Current position should NOT change — the center remains the current position
+        if (this.targetPlane) {
+            this.targetPlane.removeShapes(this);
+        }
+    }
+    getType() {
+        return 'arc';
+    }
+    compareTo(other) {
+        if (!(other instanceof ArcFromTwoAngles)) {
+            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.radius === other.radius &&
+            this.startAngle === other.startAngle &&
+            this.endAngle === other.endAngle &&
+            this.centered === other.centered;
+    }
+    serialize() {
+        return {
+            radius: this.radius,
+            startAngle: this.startAngle,
+            endAngle: this.endAngle,
+            centered: this.centered,
+        };
+    }
+}

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

@@ -0,0 +1,15 @@
+import { LazyVertex } from "../lazy-vertex.js";
+import { GeometrySceneObject } from "./geometry.js";
+export declare class BezierCurve extends GeometrySceneObject {
+    controlPoints: LazyVertex[];
+    constructor(controlPoints: LazyVertex[]);
+    build(): void;
+    compareTo(other: BezierCurve): boolean;
+    getType(): string;
+    getUniqueType(): string;
+    serialize(): {
+        controlPoints: LazyVertex[];
+        startPoint: number[];
+        resolvedPoints: number[][];
+    };
+}

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

@@ -0,0 +1,77 @@
+import { Vertex } from "../../common/vertex.js";
+import { Geometry } from "../../oc/geometry.js";
+import { Convert } from "../../oc/convert.js";
+import { getOC } from "../../oc/init.js";
+import { Point2D } from "../../math/point.js";
+import { GeometrySceneObject } from "./geometry.js";
+export class BezierCurve extends GeometrySceneObject {
+    controlPoints;
+    constructor(controlPoints) {
+        super();
+        this.controlPoints = controlPoints;
+    }
+    build() {
+        if (this.controlPoints.length === 0) {
+            return;
+        }
+        const plane = this.sketch.getPlane();
+        const currentPos = this.getCurrentPosition();
+        const points = this.controlPoints.map(cp => cp.asPoint2D());
+        // Poles: [currentPos (start), ...controlPoints, endPoint]
+        // All args are in order: control points then endpoint (last arg)
+        const poles2D = [currentPos, ...points];
+        const polesWorld = poles2D.map(p => plane.localToWorld(p));
+        const bezierCurve = Geometry.makeBezierCurve(polesWorld);
+        // Compute tangent at endpoint before creating the edge
+        const oc = getOC();
+        const gpP = new oc.gp_Pnt(0, 0, 0);
+        const gpV = new oc.gp_Vec(0, 0, 0);
+        bezierCurve.D1(bezierCurve.LastParameter(), gpP, gpV);
+        const tangentWorld = Convert.toVector3d(gpV, true);
+        gpP.delete();
+        // Project tangent to 2D sketch coordinates
+        const tangent2D = new Point2D(tangentWorld.dot(plane.xDirection), tangentWorld.dot(plane.yDirection)).normalize();
+        const edge = Geometry.makeEdgeFromBezier(bezierCurve);
+        const endPoint = points[points.length - 1];
+        this.setState('start', Vertex.fromPoint2D(currentPos));
+        this.setState('end', Vertex.fromPoint2D(endPoint));
+        this.addShape(edge);
+        this.setTangent(tangent2D);
+        this.setCurrentPosition(endPoint);
+    }
+    compareTo(other) {
+        if (!(other instanceof BezierCurve)) {
+            return false;
+        }
+        if (!super.compareTo(other)) {
+            return false;
+        }
+        if (this.controlPoints.length !== other.controlPoints.length) {
+            return false;
+        }
+        for (let i = 0; i < this.controlPoints.length; i++) {
+            if (!this.controlPoints[i].compareTo(other.controlPoints[i])) {
+                return false;
+            }
+        }
+        return true;
+    }
+    getType() {
+        return 'bezier';
+    }
+    getUniqueType() {
+        return `bezier-${this.controlPoints.length}`;
+    }
+    serialize() {
+        const startPos = this.getCurrentPosition();
+        const resolved = this.controlPoints.map(cp => {
+            const p = cp.asPoint2D();
+            return [p.x, p.y];
+        });
+        return {
+            controlPoints: this.controlPoints,
+            startPoint: [startPos.x, startPos.y],
+            resolvedPoints: resolved,
+        };
+    }
+}

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

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

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

@@ -0,0 +1,58 @@
+import { Geometry } from "../../oc/geometry.js";
+import { ExtrudableGeometryBase } from "./extrudable-base.js";
+export class Circle extends ExtrudableGeometryBase {
+    diameter;
+    options;
+    constructor(diameter, options = null, targetPlane = null) {
+        super(targetPlane);
+        this.diameter = diameter;
+        this.options = options;
+    }
+    getType() {
+        return 'circle';
+    }
+    build() {
+        const plane = this.targetPlane?.getPlane() || this.sketch.getPlane();
+        const center = this.targetPlane
+            ? plane.worldToLocal(this.targetPlane.getPlaneCenter())
+            : this.getCurrentPosition();
+        console.log('Circle: building edges');
+        const radius = this.diameter / 2;
+        const circle = Geometry.makeCircle(plane.localToWorld(center), radius, plane.normal);
+        let edge = Geometry.makeEdgeFromCircle(circle);
+        this.addShape(edge);
+        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 Circle(this.diameter, this.options, targetPlane);
+    }
+    compareTo(other) {
+        if (!(other instanceof Circle)) {
+            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.diameter === other.diameter
+            && JSON.stringify(this.options) === JSON.stringify(other.options);
+    }
+    serialize() {
+        return {
+            diameter: this.diameter,
+        };
+    }
+}

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

@@ -0,0 +1,12 @@
+import { GeometrySceneObject } from "./geometry.js";
+export type ConnectMode = 'line' | 'arc';
+export declare class Connect extends GeometrySceneObject {
+    private mode;
+    constructor(mode?: ConnectMode);
+    build(): void;
+    compareTo(other: Connect): boolean;
+    getType(): string;
+    serialize(): {
+        mode: ConnectMode;
+    };
+}