fluidcad 0.0.2

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

@@ -0,0 +1,38 @@
+import { Point2DLike } from "../../math/point.js";
+import { PolygonMode } from "../../features/2d/polygon.js";
+import { PlaneLike } from "../../math/plane.js";
+import { IPolygon, ISceneObject } from "../interfaces.js";
+interface PolygonFunction {
+    /**
+     * Draws a regular polygon with the given number of sides and diameter.
+     * @param numberOfSides - The number of sides
+     * @param diameter - The circumscribed or inscribed diameter
+     * @param mode - `'inscribed'` or `'circumscribed'` (defaults to `'inscribed'`)
+     */
+    (numberOfSides: number, diameter: number, mode?: PolygonMode): IPolygon;
+    /**
+     * Draws a regular polygon at a given center point.
+     * @param center - The center point
+     * @param numberOfSides - The number of sides
+     * @param diameter - The circumscribed or inscribed diameter
+     * @param mode - `'inscribed'` or `'circumscribed'` (defaults to `'inscribed'`)
+     */
+    (center: Point2DLike, numberOfSides: number, diameter: number, mode?: PolygonMode): IPolygon;
+    /**
+     * Draws a regular polygon on a specific plane.
+     * @param numberOfSides - The number of sides
+     * @param diameter - The circumscribed or inscribed diameter
+     * @param targetPlane - The plane to draw on
+     */
+    (numberOfSides: number, diameter: number, targetPlane: PlaneLike | ISceneObject): IPolygon;
+    /**
+     * Draws a regular polygon with a given mode on a specific plane.
+     * @param numberOfSides - The number of sides
+     * @param diameter - The circumscribed or inscribed diameter
+     * @param mode - `'inscribed'` or `'circumscribed'`
+     * @param targetPlane - The plane to draw on
+     */
+    (numberOfSides: number, diameter: number, mode: PolygonMode, targetPlane: PlaneLike | ISceneObject): IPolygon;
+}
+declare const _default: PolygonFunction;
+export default _default;

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

@@ -0,0 +1,63 @@
+import { isPoint2DLike } from "../../math/point.js";
+import { Polygon } from "../../features/2d/polygon.js";
+import { Move } from "../../features/2d/move.js";
+import { normalizePoint2D } from "../../helpers/normalize.js";
+import { registerBuilder } from "../../index.js";
+import { isPlaneLike } from "../../math/plane.js";
+import { SceneObject } from "../../common/scene-object.js";
+import { resolvePlane } from "../../helpers/resolve.js";
+function build(context) {
+    return function polygon() {
+        let numberOfSides;
+        let diameter;
+        let mode;
+        let center;
+        let poly;
+        let planeObj = null;
+        let argCount = arguments.length;
+        // Detect plane as last argument
+        // PolygonMode strings ('inscribed'/'circumscribed') don't overlap with StandardPlane strings
+        if (argCount > 0) {
+            const lastArg = arguments[argCount - 1];
+            if (isPlaneLike(lastArg) || (lastArg instanceof SceneObject && !isPoint2DLike(lastArg))) {
+                planeObj = resolvePlane(lastArg, context);
+                context.addSceneObject(planeObj);
+                argCount--;
+            }
+        }
+        if (argCount === 2) {
+            numberOfSides = arguments[0];
+            diameter = arguments[1];
+            mode = 'inscribed';
+            poly = new Polygon(numberOfSides, diameter, mode, planeObj);
+            context.addSceneObject(poly);
+        }
+        else if (argCount === 3) {
+            if (typeof arguments[0] === 'number') {
+                numberOfSides = arguments[0];
+                diameter = arguments[1];
+                mode = arguments[2];
+                poly = new Polygon(numberOfSides, diameter, mode, planeObj);
+                context.addSceneObject(poly);
+            }
+            else {
+                center = normalizePoint2D(arguments[0]);
+                numberOfSides = arguments[1];
+                diameter = arguments[2];
+                mode = 'inscribed';
+                poly = new Polygon(numberOfSides, diameter, mode, planeObj);
+                context.addSceneObjects([new Move(center), poly]);
+            }
+        }
+        else if (argCount === 4) {
+            center = normalizePoint2D(arguments[0]);
+            numberOfSides = arguments[1];
+            diameter = arguments[2];
+            mode = arguments[3];
+            poly = new Polygon(numberOfSides, diameter, mode, planeObj);
+            context.addSceneObjects([new Move(center), poly]);
+        }
+        return poly;
+    };
+}
+export default registerBuilder(build);

package/lib/dist/core/2d/project.d.ts

@@ -0,0 +1,17 @@
+import { PlaneLike } from "../../math/plane.js";
+import { IExtrudableGeometry, ISceneObject } from "../interfaces.js";
+interface ProjectFunction {
+    /**
+     * Projects 3D objects onto the current sketch plane.
+     * @param sourceObjects - The 3D objects to project
+     */
+    (...sourceObjects: ISceneObject[]): IExtrudableGeometry;
+    /**
+     * Projects 3D objects onto a target plane.
+     * @param sourceObjects - The 3D objects to project
+     * @param targetPlane - The plane to project onto
+     */
+    (sourceObjects: ISceneObject[], targetPlane: PlaneLike | ISceneObject): IExtrudableGeometry;
+}
+declare const _default: ProjectFunction;
+export default _default;

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

@@ -0,0 +1,20 @@
+import { Projection } from "../../features/2d/projection.js";
+import { resolvePlane } from "../../helpers/resolve.js";
+import { registerBuilder } from "../../index.js";
+function build(context) {
+    return function project(...args) {
+        if (Array.isArray(args[0])) {
+            const sourceObjects = args[0];
+            context.addSceneObjects(sourceObjects);
+            const planeObj = resolvePlane(args[1], context);
+            const projection = new Projection(sourceObjects, planeObj);
+            context.addSceneObject(projection);
+            return projection;
+        }
+        const projection = new Projection(args);
+        context.addSceneObjects(args);
+        context.addSceneObject(projection);
+        return projection;
+    };
+}
+export default registerBuilder(build);

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

@@ -0,0 +1,27 @@
+import { Point2DLike } from "../../math/point.js";
+import { PlaneLike } from "../../math/plane.js";
+import { IRect, ISceneObject } from "../interfaces.js";
+interface RectFunction {
+    /**
+     * Draws a rectangle with the given width and optional height.
+     * @param width - The rectangle width
+     * @param height - The rectangle height (defaults to width)
+     */
+    (width: number, height?: number): IRect;
+    /**
+     * Draws a rectangle at a given start point.
+     * @param start - The start point (bottom-left corner)
+     * @param width - The rectangle width
+     * @param height - The rectangle height (defaults to width)
+     */
+    (start: Point2DLike, width: number, height?: number): IRect;
+    /**
+     * Draws a rectangle with given dimensions on a specific plane.
+     * @param width - The rectangle width
+     * @param height - The rectangle height
+     * @param targetPlane - The plane to draw on
+     */
+    (width: number, height: number, targetPlane: PlaneLike | ISceneObject): IRect;
+}
+declare const _default: RectFunction;
+export default _default;

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

@@ -0,0 +1,58 @@
+import { isPoint2DLike } from "../../math/point.js";
+import { Move } from "../../features/2d/move.js";
+import { Rect } from "../../features/2d/rect.js";
+import { normalizePoint2D } from "../../helpers/normalize.js";
+import { registerBuilder } from "../../index.js";
+import { isPlaneLike } from "../../math/plane.js";
+import { SceneObject } from "../../common/scene-object.js";
+import { resolvePlane } from "../../helpers/resolve.js";
+function build(context) {
+    return function cRect() {
+        let argCount = arguments.length;
+        if (argCount === 1) {
+            const width = arguments[0];
+            const rect = new Rect(width, width);
+            context.addSceneObject(rect);
+            return rect;
+        }
+        else if (argCount === 2) {
+            if (typeof arguments[0] === 'number') {
+                const width = arguments[0];
+                const height = arguments[1];
+                const rect = new Rect(width, height);
+                context.addSceneObject(rect);
+                return rect;
+            }
+            else {
+                const start = normalizePoint2D(arguments[0]);
+                const width = arguments[1];
+                const rect = new Rect(width, width);
+                context.addSceneObjects([new Move(start), rect]);
+                return rect;
+            }
+        }
+        else if (argCount === 3) {
+            if (typeof arguments[0] === 'number') {
+                const width = arguments[0];
+                const height = arguments[1];
+                const lastArg = arguments[argCount - 1];
+                let planeObj;
+                if (isPlaneLike(lastArg) || (lastArg instanceof SceneObject && !isPoint2DLike(lastArg))) {
+                    planeObj = resolvePlane(lastArg, context);
+                }
+                const rect = new Rect(width, height, planeObj);
+                context.addSceneObject(rect);
+                return rect;
+            }
+            else {
+                const start = normalizePoint2D(arguments[0]);
+                const width = arguments[1];
+                const height = arguments[2];
+                const rect = new Rect(width, height);
+                context.addSceneObjects([new Move(start), rect]);
+                return rect;
+            }
+        }
+    };
+}
+export default registerBuilder(build);

package/lib/dist/core/2d/rmove.d.ts

@@ -0,0 +1,17 @@
+import { Point2DLike } from "../../math/point.js";
+import { IGeometry } from "../interfaces.js";
+interface RMoveFunction {
+    /**
+     * Rotates the cursor direction by the given angle in degrees.
+     * @param angle - The rotation angle in degrees
+     */
+    (angle: number): IGeometry;
+    /**
+     * Rotates the cursor direction by the given angle around a pivot point.
+     * @param angle - The rotation angle in degrees
+     * @param pivot - The pivot point to rotate around
+     */
+    (angle: number, pivot: Point2DLike): IGeometry;
+}
+declare const _default: RMoveFunction;
+export default _default;

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

@@ -0,0 +1,14 @@
+import { Point2D } from "../../math/point.js";
+import { RMove } from "../../features/2d/rmove.js";
+import { normalizePoint2D } from "../../helpers/normalize.js";
+import { registerBuilder } from "../../index.js";
+function build(context) {
+    return function rmove() {
+        const angle = arguments[0] * Math.PI / 180;
+        const pivot = normalizePoint2D(arguments[1] || new Point2D(0, 0));
+        const rmove = new RMove(pivot, angle);
+        context.addSceneObject(rmove);
+        return rmove;
+    };
+}
+export default registerBuilder(build);

package/lib/dist/core/2d/slot.d.ts

@@ -0,0 +1,49 @@
+import { Point2DLike } from "../../math/point.js";
+import { PlaneLike } from "../../math/plane.js";
+import { ISlot, ISceneObject } from "../interfaces.js";
+interface SlotFunction {
+    /**
+     * Draws a slot with the given length and end radius.
+     * @param distance - The slot length
+     * @param radius - The end cap radius
+     */
+    (distance: number, radius: number): ISlot;
+    /**
+     * Draws a slot on a specific plane.
+     * @param distance - The slot length
+     * @param radius - The end cap radius
+     * @param targetPlane - The plane to draw on
+     */
+    (distance: number, radius: number, targetPlane: PlaneLike | ISceneObject): ISlot;
+    /**
+     * Draws a slot from a start point with the given length and end radius.
+     * @param start - The start point
+     * @param distance - The slot length
+     * @param radius - The end cap radius
+     */
+    (start: Point2DLike, distance: number, radius: number): ISlot;
+    /**
+     * Creates a slot from a geometry edge with the given radius.
+     * @param geometry - The source geometry edge
+     * @param radius - The end cap radius
+     * @param deleteSource - Whether to delete the source geometry (defaults to true)
+     */
+    (geometry: ISceneObject, radius: number, deleteSource?: boolean): ISlot;
+    /**
+     * Creates a slot from a geometry edge on a specific plane.
+     * @param geometry - The source geometry edge
+     * @param radius - The end cap radius
+     * @param targetPlane - The plane to draw on
+     */
+    (geometry: ISceneObject, radius: number, targetPlane: PlaneLike | ISceneObject): ISlot;
+    /**
+     * Creates a slot from a geometry edge, optionally keeping the source, on a specific plane.
+     * @param geometry - The source geometry edge
+     * @param radius - The end cap radius
+     * @param deleteSource - Whether to delete the source geometry
+     * @param targetPlane - The plane to draw on
+     */
+    (geometry: ISceneObject, radius: number, deleteSource: boolean, targetPlane: PlaneLike | ISceneObject): ISlot;
+}
+declare const _default: SlotFunction;
+export default _default;

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

@@ -0,0 +1,65 @@
+import { isPoint2DLike } from "../../math/point.js";
+import { Move } from "../../features/2d/move.js";
+import { Slot } from "../../features/2d/slot.js";
+import { SlotFromEdge } from "../../features/2d/slot-from-edge.js";
+import { normalizePoint2D } from "../../helpers/normalize.js";
+import { registerBuilder } from "../../index.js";
+import { SceneObject } from "../../common/scene-object.js";
+import { isPlaneLike } from "../../math/plane.js";
+import { resolvePlane } from "../../helpers/resolve.js";
+function build(context) {
+    return function slot() {
+        // SlotFromEdge path: first arg is a SceneObject (geometry)
+        if (arguments[0] instanceof SceneObject) {
+            const geometry = arguments[0];
+            const radius = arguments[1];
+            let deleteSource = true;
+            let planeObj = null;
+            let argIdx = 2;
+            // Check if there's a deleteSource boolean before a potential plane
+            if (argIdx < arguments.length && typeof arguments[argIdx] === 'boolean') {
+                deleteSource = arguments[argIdx];
+                argIdx++;
+            }
+            // Check if there's a plane arg remaining
+            if (argIdx < arguments.length) {
+                const planeArg = arguments[argIdx];
+                if (isPlaneLike(planeArg) || planeArg instanceof SceneObject) {
+                    planeObj = resolvePlane(planeArg, context);
+                }
+            }
+            const slotFromEdge = new SlotFromEdge(geometry, radius, deleteSource, planeObj);
+            context.addSceneObject(slotFromEdge);
+            return slotFromEdge;
+        }
+        let planeObj = null;
+        let argCount = arguments.length;
+        // Detect plane as last argument
+        if (argCount > 0) {
+            const lastArg = arguments[argCount - 1];
+            if (isPlaneLike(lastArg) || (lastArg instanceof SceneObject && !isPoint2DLike(lastArg))) {
+                planeObj = resolvePlane(lastArg, context);
+                argCount--;
+            }
+        }
+        // slot(distance, radius)
+        if (argCount === 2 && typeof arguments[0] === 'number') {
+            const distance = arguments[0];
+            const radius = arguments[1];
+            const s = new Slot(distance, radius, planeObj);
+            context.addSceneObject(s);
+            return s;
+        }
+        // slot(start, distance, radius)
+        if (argCount === 3) {
+            const start = normalizePoint2D(arguments[0]);
+            const distance = arguments[1];
+            const radius = arguments[2];
+            const s = new Slot(distance, radius, planeObj);
+            context.addSceneObjects([new Move(start), s]);
+            return s;
+        }
+        throw new Error("Invalid arguments for slot()");
+    };
+}
+export default registerBuilder(build);

package/lib/dist/core/2d/tarc.d.ts

@@ -0,0 +1,46 @@
+import { Point2DLike } from "../../math/point.js";
+import { QualifiedSceneObject } from "../../features/2d/constraints/qualified-geometry.js";
+import { IGeometry, ISceneObject, ITangentArcTwoObjects } from "../interfaces.js";
+interface TArcFunction {
+    /**
+     * Draws a tangent arc with a given radius and end angle.
+     * @param radius - The arc radius (defaults to 100)
+     * @param endAngle - The sweep angle in degrees (defaults to 90)
+     */
+    (radius?: number, endAngle?: number): IGeometry;
+    /**
+     * Draws a tangent arc with a given radius, angle, and start tangent direction.
+     * @param radius - The arc radius
+     * @param angle - The sweep angle in degrees
+     * @param tangent - The start tangent direction
+     */
+    (radius: number, angle: number, tangent: Point2DLike): IGeometry;
+    /**
+     * Draws a tangent arc to a given end point.
+     * @param endPoint - The end point of the arc
+     */
+    (endPoint: Point2DLike): IGeometry;
+    /**
+     * Draws a tangent arc to a given end point with an explicit end tangent.
+     * @param endPoint - The end point of the arc
+     * @param tangent - The end tangent direction
+     */
+    (endPoint: Point2DLike, tangent: Point2DLike): IGeometry;
+    /**
+     * Draws a tangent arc from a start point to an end point with a tangent.
+     * @param startPoint - The start point of the arc
+     * @param endPoint - The end point of the arc
+     * @param tangent - The end tangent direction
+     */
+    (startPoint: Point2DLike, endPoint: Point2DLike, tangent: Point2DLike): IGeometry;
+    /**
+     * Draws a tangent arc between two objects with a given radius.
+     * @param c1 - The first constraint object or point
+     * @param c2 - The second constraint object or point
+     * @param radius - The arc radius
+     * @param mustTouch - Whether the arc must touch both objects
+     */
+    (c1: ISceneObject | QualifiedSceneObject | Point2DLike, c2: ISceneObject | QualifiedSceneObject | Point2DLike, radius: number, mustTouch?: boolean): ITangentArcTwoObjects;
+}
+declare const _default: TArcFunction;
+export default _default;

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

@@ -0,0 +1,61 @@
+import { isPoint2DLike } from "../../math/point.js";
+import { TangentArc } from "../../features/2d/tarc.js";
+import { TangentArcToPoint } from "../../features/2d/tarc-to-point.js";
+import { TangentArcToPointTangent } from "../../features/2d/tarc-to-point-tangent.js";
+import { TangentArcWithTangent } from "../../features/2d/tarc-with-tangent.js";
+import { Move } from "../../features/2d/move.js";
+import { normalizePoint2D } from "../../helpers/normalize.js";
+import { registerBuilder } from "../../index.js";
+import { QualifiedSceneObject } from "../../features/2d/constraints/qualified-geometry.js";
+import { TangentArcTwoObjects } from "../../features/2d/tarc-constrained.js";
+function build(context) {
+    return function tarc() {
+        // tarc(c1, c2, radius): fillet arc tangent to two circles/points
+        if ((arguments.length === 3 || arguments.length === 4) && typeof arguments[2] === 'number') {
+            const o1 = isPoint2DLike(arguments[0]) ? normalizePoint2D(arguments[0]) : arguments[0];
+            const o2 = isPoint2DLike(arguments[1]) ? normalizePoint2D(arguments[1]) : arguments[1];
+            const c1 = QualifiedSceneObject.from(o1);
+            const c2 = QualifiedSceneObject.from(o2);
+            const radius = arguments[2];
+            const mustTouch = typeof arguments[3] === 'boolean' ? arguments[3] : false;
+            const arc = new TangentArcTwoObjects(c1, c2, radius, mustTouch);
+            context.addSceneObject(arc);
+            return arc;
+        }
+        if (arguments.length > 0 && isPoint2DLike(arguments[0])) {
+            // 3 Point2DLike args: tArc(startPoint, endPoint, tangent)
+            if (arguments.length > 2 && isPoint2DLike(arguments[1]) && isPoint2DLike(arguments[2])) {
+                const startPoint = normalizePoint2D(arguments[0]);
+                const endPoint = normalizePoint2D(arguments[1]);
+                const tangent = normalizePoint2D(arguments[2]);
+                const arc = new TangentArcToPointTangent(endPoint, tangent);
+                context.addSceneObjects([new Move(startPoint), arc]);
+                return arc;
+            }
+            const endPoint = normalizePoint2D(arguments[0]);
+            // 2 Point2DLike args: tArc(endPoint, tangent)
+            if (arguments.length > 1 && isPoint2DLike(arguments[1])) {
+                const tangent = normalizePoint2D(arguments[1]);
+                const arc = new TangentArcToPointTangent(endPoint, tangent);
+                context.addSceneObject(arc);
+                return arc;
+            }
+            const arc = new TangentArcToPoint(endPoint);
+            context.addSceneObject(arc);
+            return arc;
+        }
+        const radius = arguments[0] || 100;
+        const endAngle = arguments[1] || 90;
+        // tArc(radius, angle, tangent): explicit start tangent instead of reading from previous sibling
+        if (arguments.length === 3 && isPoint2DLike(arguments[2])) {
+            const tangent = normalizePoint2D(arguments[2]);
+            const arc = new TangentArcWithTangent(radius, endAngle, tangent);
+            context.addSceneObject(arc);
+            return arc;
+        }
+        const arc = new TangentArc(radius, endAngle);
+        context.addSceneObject(arc);
+        return arc;
+    };
+}
+export default registerBuilder(build);

package/lib/dist/core/2d/tcircle.d.ts

@@ -0,0 +1,15 @@
+import { QualifiedSceneObject } from "../../features/2d/constraints/qualified-geometry.js";
+import { Point2DLike } from "../../math/point.js";
+import { IGeometry, ISceneObject } from "../interfaces.js";
+interface TCircleFunction {
+    /**
+     * Draws a circle tangent to two objects with the given diameter.
+     * @param c1 - The first constraint object or point
+     * @param c2 - The second constraint object or point
+     * @param diameter - The circle diameter
+     * @param mustTouch - Whether the circle must touch both objects
+     */
+    (c1: ISceneObject | QualifiedSceneObject | Point2DLike, c2: ISceneObject | QualifiedSceneObject | Point2DLike, diameter: number, mustTouch?: boolean): IGeometry;
+}
+declare const _default: TCircleFunction;
+export default _default;

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

@@ -0,0 +1,24 @@
+import { QualifiedSceneObject } from "../../features/2d/constraints/qualified-geometry.js";
+import { TwoObjectsTangentCircle } from "../../features/2d/tcircle-constrained.js";
+import { normalizePoint2D } from "../../helpers/normalize.js";
+import { registerBuilder } from "../../index.js";
+import { isPoint2DLike } from "../../math/point.js";
+function build(context) {
+    return function tCircle() {
+        if ((arguments.length === 3 || arguments.length === 4) && typeof arguments[2] === 'number') {
+            const o1 = isPoint2DLike(arguments[0]) ? normalizePoint2D(arguments[0]) : arguments[0];
+            const o2 = isPoint2DLike(arguments[1]) ? normalizePoint2D(arguments[1]) : arguments[1];
+            const c1 = QualifiedSceneObject.from(o1);
+            const c2 = QualifiedSceneObject.from(o2);
+            const diameter = arguments[2];
+            const mustTouch = typeof arguments[3] === 'boolean' ? arguments[3] : false;
+            const tangentCircle = new TwoObjectsTangentCircle(c1, c2, diameter, mustTouch);
+            context.addSceneObject(tangentCircle);
+            return tangentCircle;
+        }
+        else {
+            throw new Error('Invalid arguments for tCircle: expected (c1, c2, diameter) or (c1, c2, c3)');
+        }
+    };
+}
+export default registerBuilder(build);

package/lib/dist/core/2d/tline.d.ts

@@ -0,0 +1,24 @@
+import { QualifiedSceneObject } from "../../features/2d/constraints/qualified-geometry.js";
+import { IGeometry, ISceneObject, ITwoObjectsTangentLine } from "../interfaces.js";
+interface TLineFunction {
+    /**
+     * Draws a line tangent to the previous geometry with the given distance.
+     * @param distance - The tangent line length
+     */
+    (distance: number): IGeometry;
+    /**
+     * Draws a line tangent to two objects.
+     * @param c1 - The first constraint object
+     * @param c2 - The second constraint object
+     * @param mustTouch - Whether the line must touch both objects
+     */
+    (c1: ISceneObject | QualifiedSceneObject, c2: ISceneObject | QualifiedSceneObject, mustTouch?: boolean): ITwoObjectsTangentLine;
+    /**
+     * Draws a line tangent to one object.
+     * @param c1 - The constraint object
+     * @param mustTouch - Whether the line must touch the object
+     */
+    (c1: ISceneObject | QualifiedSceneObject, mustTouch?: boolean): IGeometry;
+}
+declare const _default: TLineFunction;
+export default _default;

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

@@ -0,0 +1,30 @@
+import { QualifiedSceneObject } from "../../features/2d/constraints/qualified-geometry.js";
+import { OneObjectTangentLine, TwoObjectsTangentLine } from "../../features/2d/tline-constrained.js";
+import { TangentLine } from "../../features/2d/tline.js";
+import { registerBuilder } from "../../index.js";
+function build(context) {
+    return function line() {
+        if (arguments.length === 1 && typeof arguments[0] === 'number') {
+            const distance = arguments[0];
+            const hline = new TangentLine(distance);
+            context.addSceneObject(hline);
+            return hline;
+        }
+        else if (arguments.length === 1 || (arguments.length === 2 && typeof arguments[1] === 'boolean')) {
+            const mustTouch = typeof arguments[1] === 'boolean' ? arguments[1] : false;
+            const constrainedLine = new OneObjectTangentLine(QualifiedSceneObject.from(arguments[0]), mustTouch);
+            context.addSceneObject(constrainedLine);
+            return constrainedLine;
+        }
+        else if (arguments.length >= 2) {
+            const mustTouch = typeof arguments[2] === 'boolean' ? arguments[2] : false;
+            const constrainedLine = new TwoObjectsTangentLine(QualifiedSceneObject.from(arguments[0]), QualifiedSceneObject.from(arguments[1]), mustTouch);
+            context.addSceneObject(constrainedLine);
+            return constrainedLine;
+        }
+        else {
+            throw new Error('Invalid number of arguments for line function');
+        }
+    };
+}
+export default registerBuilder(build);

package/lib/dist/core/2d/vline.d.ts

@@ -0,0 +1,33 @@
+import { Point2DLike } from "../../math/point.js";
+import { PlaneLike } from "../../math/plane.js";
+import { IGeometry, ISceneObject } from "../interfaces.js";
+interface VLineFunction {
+    /**
+     * Draws a vertical line of the given distance.
+     * @param distance - The line length
+     * @param centered - Whether to center the line on the current position
+     */
+    (distance: number, centered?: boolean): IGeometry;
+    /**
+     * Draws a vertical line from a start point.
+     * @param start - The start point
+     * @param distance - The line length
+     * @param centered - Whether to center the line on the start point
+     */
+    (start: Point2DLike, distance: number, centered?: boolean): IGeometry;
+    /**
+     * Draws a vertical line on a specific plane.
+     * @param distance - The line length
+     * @param targetPlane - The plane to draw on
+     */
+    (distance: number, targetPlane: PlaneLike | ISceneObject): IGeometry;
+    /**
+     * Draws a vertical line with centering on a specific plane.
+     * @param distance - The line length
+     * @param centered - Whether to center the line on the current position
+     * @param targetPlane - The plane to draw on
+     */
+    (distance: number, centered: boolean, targetPlane: PlaneLike | ISceneObject): IGeometry;
+}
+declare const _default: VLineFunction;
+export default _default;

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

@@ -0,0 +1,37 @@
+import { isPoint2DLike } from "../../math/point.js";
+import { Move } from "../../features/2d/move.js";
+import { VerticalLine } from "../../features/2d/vline.js";
+import { normalizePoint2D } from "../../helpers/normalize.js";
+import { registerBuilder } from "../../index.js";
+import { isPlaneLike } from "../../math/plane.js";
+import { SceneObject } from "../../common/scene-object.js";
+import { resolvePlane } from "../../helpers/resolve.js";
+function build(context) {
+    return function line() {
+        let planeObj = null;
+        let argCount = arguments.length;
+        // Detect plane as last argument
+        if (argCount > 0) {
+            const lastArg = arguments[argCount - 1];
+            if (isPlaneLike(lastArg) || (lastArg instanceof SceneObject && !isPoint2DLike(lastArg))) {
+                planeObj = resolvePlane(lastArg, context);
+                argCount--;
+            }
+        }
+        if (typeof arguments[0] !== 'number') {
+            // vline(start, distance) or vline(start, distance, centered)
+            const start = normalizePoint2D(arguments[0]);
+            const distance = arguments[1];
+            const centered = argCount >= 3 ? arguments[2] : false;
+            const vline = new VerticalLine(distance, centered, planeObj);
+            context.addSceneObjects([new Move(start), vline]);
+            return vline;
+        }
+        const distance = arguments[0];
+        const centered = argCount >= 2 ? arguments[1] : false;
+        const vline = new VerticalLine(distance, centered, planeObj);
+        context.addSceneObject(vline);
+        return vline;
+    };
+}
+export default registerBuilder(build);