fluidcad 0.0.29 → 0.0.31

package/lib/dist/core/2d/vmove.js

@@ -1,11 +1,15 @@
 import { VMove } from "../../features/2d/vmove.js";
+import { SceneObject } from "../../common/scene-object.js";
 import { registerBuilder } from "../../index.js";
 function build(context) {
     return function move() {
-        const distance = arguments[0];
-        const move = new VMove(distance);
-        context.addSceneObject(move);
-        return move;
+        const arg = arguments[0];
+        const distanceOrTarget = arg instanceof SceneObject
+            ? arg
+            : arg;
+        const vmove = new VMove(distanceOrTarget);
+        context.addSceneObject(vmove);
+        return vmove;
     };
 }
 export default registerBuilder(build);

package/lib/dist/core/interfaces.d.ts

@@ -227,6 +227,33 @@ export interface ISlot extends IExtrudableGeometry {
      */
     rotate(angle: number): this;
 }
+export interface IALine extends IGeometry {
+    /**
+     * Controls whether the line is centered on the current position.
+     * When `true`, the line is offset backward by half its length so that the
+     * current position falls at its midpoint.
+     * @param value - `true` to center, `false` (default) to start from the current position.
+     */
+    centered(value?: boolean): this;
+}
+export interface IHLine extends IGeometry {
+    /**
+     * Controls whether the line is centered on the current position.
+     * When `true`, the line is offset backward by half its length so that the
+     * current position falls at its midpoint.
+     * @param value - `true` to center, `false` (default) to start from the current position.
+     */
+    centered(value?: boolean): this;
+}
+export interface IVLine extends IGeometry {
+    /**
+     * Controls whether the line is centered on the current position.
+     * When `true`, the line is offset backward by half its length so that the
+     * current position falls at its midpoint.
+     * @param value - `true` to center, `false` (default) to start from the current position.
+     */
+    centered(value?: boolean): this;
+}
 export interface IPolygon extends IExtrudableGeometry {
     /**
      * Returns a specific edge of the polygon by index.
@@ -629,6 +656,33 @@ export interface ISweep extends IBooleanOperation {
      */
     capEdges(...args: (number | EdgeFilterBuilder)[]): ISceneObject;
 }
+export interface IMirror extends IBooleanOperation {
+    /**
+     * Excludes the given objects from the mirror operation. Useful when
+     * mirroring "everything" but a few specific objects should be skipped,
+     * or when narrowing an explicit target list.
+     * @param objects - The objects to exclude from mirroring.
+     */
+    exclude(...objects: ISceneObject[]): this;
+}
+export interface ITranslate extends ISceneObject {
+    /**
+     * Excludes the given objects from the translate operation. Useful when
+     * translating "everything" but a few specific objects should be skipped,
+     * or when narrowing an explicit target list.
+     * @param objects - The objects to exclude from translating.
+     */
+    exclude(...objects: ISceneObject[]): this;
+}
+export interface IRotate extends ISceneObject {
+    /**
+     * Excludes the given objects from the rotate operation. Useful when
+     * rotating "everything" but a few specific objects should be skipped,
+     * or when narrowing an explicit target list.
+     * @param objects - The objects to exclude from rotating.
+     */
+    exclude(...objects: ISceneObject[]): this;
+}
 export interface IDraft extends ISceneObject {
 }
 export interface IShell extends ISceneObject {

package/lib/dist/core/mirror.d.ts

@@ -1,40 +1,40 @@
 import { PlaneLike } from "../math/plane.js";
 import { AxisLike } from "../math/axis.js";
-import { ISceneObject } from "./interfaces.js";
+import { IMirror, ISceneObject } from "./interfaces.js";
 interface MirrorFunction {
     /**
     * [2D] Mirror all sketch geometries across a given line.
     * @param line The line to mirror across
     */
-    (line: ISceneObject): ISceneObject;
+    (line: ISceneObject): IMirror;
     /**
     * [2D] Mirror all sketch geometries across a given axis.
     * @param axis The local axis to mirror across
     */
-    (axis: AxisLike): ISceneObject;
+    (axis: AxisLike): IMirror;
     /**
     * [2D] Mirror given sketch geometries across a given line.
     * @param line The line to mirror across
     * @param geometries The geometries to mirror
     */
-    (line: ISceneObject, ...geometries: ISceneObject[]): ISceneObject;
+    (line: ISceneObject, ...geometries: ISceneObject[]): IMirror;
     /**
     * [2D] Mirror given sketch geometries across a given axis.
     * @param axis The local axis to mirror across
     * @param geometries The geometries to mirror
     */
-    (axis: AxisLike, ...geometries: ISceneObject[]): ISceneObject;
+    (axis: AxisLike, ...geometries: ISceneObject[]): IMirror;
     /**
     * [3D] Mirror all scene shapes across a given plane.
     * @param plane The plane to mirror across
     */
-    (plane: PlaneLike): ISceneObject;
+    (plane: PlaneLike): IMirror;
     /**
     * [3D] Mirror given shapes across a given plane.
     * @param plane The plane to mirror across
     * @param objects The shapes to mirror
     */
-    (plane: PlaneLike, ...objects: ISceneObject[]): ISceneObject;
+    (plane: PlaneLike, ...objects: ISceneObject[]): IMirror;
 }
 declare const _default: MirrorFunction;
 export default _default;

package/lib/dist/core/rotate.d.ts

@@ -1,26 +1,26 @@
 import { AxisLike } from "../math/axis.js";
-import { ISceneObject } from "./interfaces.js";
+import { IRotate, ISceneObject } from "./interfaces.js";
 interface RotateFunction {
     /**
      * [2D] Rotates geometry by an angle inside a sketch.
      * @param angle - The rotation angle in degrees
      * @param targets - The geometries to rotate (defaults to last object)
      */
-    (angle: number, ...targets: ISceneObject[]): ISceneObject;
+    (angle: number, ...targets: ISceneObject[]): IRotate;
     /**
      * [2D] Rotates geometry by an angle inside a sketch, optionally making a copy.
      * @param angle - The rotation angle in degrees
      * @param copy - Whether to copy instead of move
      * @param targets - The geometries to rotate (defaults to last object)
      */
-    (angle: number, copy: boolean, ...targets: ISceneObject[]): ISceneObject;
+    (angle: number, copy: boolean, ...targets: ISceneObject[]): IRotate;
     /**
      * [3D] Rotates objects around an axis by an angle.
      * @param axis - The axis to rotate around
      * @param angle - The rotation angle in degrees
      * @param targets - The objects to rotate (defaults to last object)
      */
-    (axis: AxisLike, angle: number, ...targets: ISceneObject[]): ISceneObject;
+    (axis: AxisLike, angle: number, ...targets: ISceneObject[]): IRotate;
     /**
      * [3D] Rotates objects around an axis by an angle, optionally making a copy.
      * @param axis - The axis to rotate around
@@ -28,7 +28,7 @@ interface RotateFunction {
      * @param copy - Whether to copy instead of move
      * @param targets - The objects to rotate (defaults to last object)
      */
-    (axis: AxisLike, angle: number, copy: boolean, ...targets: ISceneObject[]): ISceneObject;
+    (axis: AxisLike, angle: number, copy: boolean, ...targets: ISceneObject[]): IRotate;
 }
 declare const _default: RotateFunction;
 export default _default;

package/lib/dist/core/translate.d.ts

@@ -1,26 +1,26 @@
 import { PointLike } from "../math/point.js";
-import { ISceneObject } from "./interfaces.js";
+import { ISceneObject, ITranslate } from "./interfaces.js";
 interface TranslateFunction {
     /**
      * Translates objects along the X axis.
      * @param x - The X distance
      * @param targets - The objects to translate (defaults to last object)
      */
-    (x: number, ...targets: ISceneObject[]): ISceneObject;
+    (x: number, ...targets: ISceneObject[]): ITranslate;
     /**
      * Translates objects along the X axis, optionally making a copy.
      * @param x - The X distance
      * @param copy - Whether to copy instead of move
      * @param targets - The objects to translate (defaults to last object)
      */
-    (x: number, copy: boolean, ...targets: ISceneObject[]): ISceneObject;
+    (x: number, copy: boolean, ...targets: ISceneObject[]): ITranslate;
     /**
      * Translates objects along the X and Y axes.
      * @param x - The X distance
      * @param y - The Y distance
      * @param targets - The objects to translate (defaults to last object)
      */
-    (x: number, y: number, ...targets: ISceneObject[]): ISceneObject;
+    (x: number, y: number, ...targets: ISceneObject[]): ITranslate;
     /**
      * Translates objects along the X and Y axes, optionally making a copy.
      * @param x - The X distance
@@ -28,7 +28,7 @@ interface TranslateFunction {
      * @param copy - Whether to copy instead of move
      * @param targets - The objects to translate (defaults to last object)
      */
-    (x: number, y: number, copy: boolean, ...targets: ISceneObject[]): ISceneObject;
+    (x: number, y: number, copy: boolean, ...targets: ISceneObject[]): ITranslate;
     /**
      * Translates objects along all three axes.
      * @param x - The X distance
@@ -36,7 +36,7 @@ interface TranslateFunction {
      * @param z - The Z distance
      * @param targets - The objects to translate (defaults to last object)
      */
-    (x: number, y: number, z: number, ...targets: ISceneObject[]): ISceneObject;
+    (x: number, y: number, z: number, ...targets: ISceneObject[]): ITranslate;
     /**
      * Translates objects along all three axes, optionally making a copy.
      * @param x - The X distance
@@ -45,20 +45,20 @@ interface TranslateFunction {
      * @param copy - Whether to copy instead of move
      * @param targets - The objects to translate (defaults to last object)
      */
-    (x: number, y: number, z: number, copy: boolean, ...targets: ISceneObject[]): ISceneObject;
+    (x: number, y: number, z: number, copy: boolean, ...targets: ISceneObject[]): ITranslate;
     /**
      * Translates objects by a point-like offset.
      * @param distance - The offset as a point
      * @param targets - The objects to translate (defaults to last object)
      */
-    (distance: PointLike, ...targets: ISceneObject[]): ISceneObject;
+    (distance: PointLike, ...targets: ISceneObject[]): ITranslate;
     /**
      * Translates objects by a point-like offset, optionally making a copy.
      * @param distance - The offset as a point
      * @param copy - Whether to copy instead of move
      * @param targets - The objects to translate (defaults to last object)
      */
-    (distance: PointLike, copy: boolean, ...targets: ISceneObject[]): ISceneObject;
+    (distance: PointLike, copy: boolean, ...targets: ISceneObject[]): ITranslate;
 }
 declare const _default: TranslateFunction;
 export default _default;

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

@@ -1,20 +1,23 @@
 import { SceneObject } from "../../common/scene-object.js";
 import { PlaneObjectBase } from "../plane-renderable-base.js";
 import { GeometrySceneObject } from "./geometry.js";
-export declare class AngledLine extends GeometrySceneObject {
-    length: number;
+import { IALine } from "../../core/interfaces.js";
+export declare class AngledLine extends GeometrySceneObject implements IALine {
     angle: number;
-    centered: boolean;
+    lengthOrTarget: number | SceneObject;
     private targetPlane;
-    constructor(length: number, angle: number, centered?: boolean, targetPlane?: PlaneObjectBase);
+    private _centered;
+    constructor(angle: number, lengthOrTarget: number | SceneObject, targetPlane?: PlaneObjectBase);
+    centered(value?: boolean): this;
     build(): void;
+    getDependencies(): SceneObject[];
     createCopy(remap: Map<SceneObject, SceneObject>): SceneObject;
     compareTo(other: AngledLine): boolean;
     getType(): string;
     getUniqueType(): string;
     serialize(): {
-        length: number;
         angle: number;
+        length: number;
         centered: boolean;
     };
 }

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

@@ -1,23 +1,28 @@
+import { SceneObject } from "../../common/scene-object.js";
 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";
+import { findNearestRayIntersection } from "../../oc/ray-intersect.js";
 export class AngledLine extends GeometrySceneObject {
-    length;
     angle;
-    centered;
+    lengthOrTarget;
     targetPlane;
-    constructor(length, angle, centered = false, targetPlane = null) {
+    _centered = false;
+    constructor(angle, lengthOrTarget, targetPlane = null) {
         super();
-        this.length = length;
         this.angle = angle;
-        this.centered = centered;
+        this.lengthOrTarget = lengthOrTarget;
         this.targetPlane = targetPlane;
     }
+    centered(value = true) {
+        this._centered = value;
+        return this;
+    }
     build() {
         const plane = this.targetPlane?.getPlane() || this.sketch.getPlane();
-        let tangent = this.sketch?.getTangentAt(this) || new Point2D(1, 0);
+        let tangent = this.sketch?.getTangentAt(this) ?? new Point2D(1, 0);
         tangent = tangent.normalize();
         const angleRad = rad(this.angle);
         // 2D rotation of tangent by angle
@@ -29,27 +34,67 @@ export class AngledLine extends GeometrySceneObject {
         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;
+        let startPoint;
+        let endPoint;
+        if (typeof this.lengthOrTarget === 'number') {
+            const length = this.lengthOrTarget;
+            startPoint = this._centered
+                ? currentPos.translate(-direction.x * length / 2, -direction.y * length / 2)
+                : currentPos;
+            endPoint = startPoint.translate(direction.x * length, direction.y * length);
+        }
+        else {
+            if (this._centered) {
+                throw new Error('aLine: .centered() cannot be combined with a target geometry');
+            }
+            startPoint = currentPos;
+            const hit = findNearestRayIntersection(plane, startPoint, direction, this.lengthOrTarget);
+            if (!hit) {
+                throw new Error("Line does not intersect target geometry");
+            }
+            endPoint = hit;
+        }
         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);
+        const end = plane.localToWorld(endPoint);
         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)
+        // Tangent at end points from start to end (sign-aware when target is behind start)
+        const endTangent = endPoint.subtract(startPoint);
+        const endLen = Math.hypot(endTangent.x, endTangent.y);
+        if (endLen > 1e-12) {
+            this.setTangent(new Point2D(endTangent.x / endLen, endTangent.y / endLen));
+        }
+        else {
+            this.setTangent(direction.normalize());
+        }
+        if (this.sketch) {
             this.setCurrentPosition(endPoint);
-        if (this.targetPlane)
+        }
+        if (this.targetPlane) {
             this.targetPlane.removeShapes(this);
+        }
+    }
+    getDependencies() {
+        const deps = [];
+        if (this.targetPlane) {
+            deps.push(this.targetPlane);
+        }
+        if (this.lengthOrTarget instanceof SceneObject) {
+            deps.push(this.lengthOrTarget);
+        }
+        return deps;
     }
     createCopy(remap) {
         const targetPlane = this.targetPlane ? (remap.get(this.targetPlane) || this.targetPlane) : null;
-        return new AngledLine(this.length, this.angle, this.centered, targetPlane);
+        const lengthOrTarget = this.lengthOrTarget instanceof SceneObject
+            ? (remap.get(this.lengthOrTarget) || this.lengthOrTarget)
+            : this.lengthOrTarget;
+        const copy = new AngledLine(this.angle, lengthOrTarget, targetPlane);
+        copy.centered(this._centered);
+        return copy;
     }
     compareTo(other) {
         if (!(other instanceof AngledLine)) {
@@ -64,7 +109,18 @@ export class AngledLine extends GeometrySceneObject {
         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;
+        if (typeof this.lengthOrTarget !== typeof other.lengthOrTarget) {
+            return false;
+        }
+        if (this.lengthOrTarget instanceof SceneObject && other.lengthOrTarget instanceof SceneObject) {
+            if (!this.lengthOrTarget.compareTo(other.lengthOrTarget)) {
+                return false;
+            }
+        }
+        else if (this.lengthOrTarget !== other.lengthOrTarget) {
+            return false;
+        }
+        return this.angle === other.angle && this._centered === other._centered;
     }
     getType() {
         return 'line';
@@ -74,9 +130,9 @@ export class AngledLine extends GeometrySceneObject {
     }
     serialize() {
         return {
-            length: this.length,
             angle: this.angle,
-            centered: this.centered
+            length: typeof this.lengthOrTarget === 'number' ? this.lengthOrTarget : null,
+            centered: this._centered
         };
     }
 }

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

@@ -3,6 +3,7 @@ import { PlaneObjectBase } from "../plane-renderable-base.js";
 import { GeometrySceneObject } from "./geometry.js";
 import { LazyVertex } from "../lazy-vertex.js";
 import { IArcPoints, IArcAngles } from "../../core/interfaces.js";
+import { SceneObject } from "../../common/scene-object.js";
 export declare class Arc extends GeometrySceneObject implements IArcPoints, IArcAngles {
     private _startPoint;
     private _endPoint;
@@ -27,6 +28,8 @@ export declare class Arc extends GeometrySceneObject implements IArcPoints, IArc
     private buildWithCenter;
     private buildFromAngles;
     getType(): string;
+    getDependencies(): SceneObject[];
+    createCopy(remap: Map<SceneObject, SceneObject>): SceneObject;
     compareTo(other: Arc): boolean;
     serialize(): Record<string, unknown>;
 }

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

@@ -167,7 +167,6 @@ export class Arc extends GeometrySceneObject {
         const d = Math.sqrt(r * r - (chordLen / 2) * (chordLen / 2));
         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);
@@ -224,6 +223,10 @@ export class Arc extends GeometrySceneObject {
         const centerPoint = this._targetPlane
             ? plane.worldToLocal(this._targetPlane.getPlaneCenter())
             : this.getCurrentPosition();
+        // Angles are measured relative to the current tangent (defaults to +X).
+        const tangent = (this._targetPlane ? null : this.sketch?.getTangentAt(this))
+            ?? new Point2D(1, 0);
+        const tangentAngle = Math.atan2(tangent.y, tangent.x);
         const cw = this._endAngle < 0;
         const absStartAngle = Math.abs(this._startAngle);
         const absEndAngle = Math.abs(this._endAngle);
@@ -239,6 +242,8 @@ export class Arc extends GeometrySceneObject {
             startAngleRad = rad(absStartAngle);
             endAngleRad = rad(absEndAngle);
         }
+        startAngleRad += tangentAngle;
+        endAngleRad += tangentAngle;
         const normal = cw ? plane.normal.negate() : plane.normal;
         const startPoint = Geometry.getPointOnCircle(centerPoint, radius, startAngleRad);
         const endPoint = Geometry.getPointOnCircle(centerPoint, radius, endAngleRad);
@@ -261,6 +266,28 @@ export class Arc extends GeometrySceneObject {
     getType() {
         return 'arc';
     }
+    getDependencies() {
+        return this._targetPlane ? [this._targetPlane] : [];
+    }
+    createCopy(remap) {
+        const targetPlane = this._targetPlane
+            ? (remap.get(this._targetPlane) || this._targetPlane)
+            : null;
+        let copy;
+        if (this._startPoint && this._endPoint) {
+            copy = Arc.twoPoints(this._startPoint, this._endPoint, targetPlane);
+        }
+        else if (this._endPoint) {
+            copy = Arc.toPoint(this._endPoint, targetPlane);
+        }
+        else {
+            copy = Arc.fromAngles(this._arcRadius, this._startAngle, this._endAngle, targetPlane);
+        }
+        copy._bulgeRadius = this._bulgeRadius;
+        copy._centerPoint = this._centerPoint;
+        copy._centered = this._centered;
+        return copy;
+    }
     compareTo(other) {
         if (!(other instanceof Arc)) {
             return false;

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

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

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

@@ -0,0 +1,35 @@
+import { GeometrySceneObject } from "./geometry.js";
+export class Back extends GeometrySceneObject {
+    count;
+    constructor(count) {
+        super();
+        this.count = count;
+    }
+    getType() {
+        return 'back';
+    }
+    build() {
+        const target = this.sketch.getPreviousPosition(this, this.count);
+        this.setCurrentPosition(target);
+    }
+    getDependencies() {
+        return [];
+    }
+    createCopy(remap) {
+        return new Back(this.count);
+    }
+    compareTo(other) {
+        if (!(other instanceof Back)) {
+            return false;
+        }
+        if (!super.compareTo(other)) {
+            return false;
+        }
+        return this.count === other.count;
+    }
+    serialize() {
+        return {
+            count: this.count
+        };
+    }
+}

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

@@ -1,11 +1,16 @@
 import { PlaneObjectBase } from "../plane-renderable-base.js";
 import { GeometrySceneObject } from "./geometry.js";
-export declare class HorizontalLine extends GeometrySceneObject {
-    distance: number;
-    centered: boolean;
+import { IHLine } from "../../core/interfaces.js";
+import { SceneObject } from "../../common/scene-object.js";
+export declare class HorizontalLine extends GeometrySceneObject implements IHLine {
+    distanceOrTarget: number | SceneObject;
     private targetPlane;
-    constructor(distance: number, centered?: boolean, targetPlane?: PlaneObjectBase);
+    private _centered;
+    constructor(distanceOrTarget: number | SceneObject, targetPlane?: PlaneObjectBase);
+    centered(value?: boolean): this;
     build(): void;
+    getDependencies(): SceneObject[];
+    createCopy(remap: Map<SceneObject, SceneObject>): SceneObject;
     compareTo(other: HorizontalLine): boolean;
     getType(): string;
     getUniqueType(): string;