fluidcad 0.0.29 → 0.0.30

package/lib/dist/common/scene-object.d.ts

@@ -69,6 +69,7 @@ export declare abstract class SceneObject implements Comparable<SceneObject>, Se
     getPreviousSibling(obj: SceneObject): SceneObject | null;
     getPreviousSiblings(obj: SceneObject): SceneObject[];
     isContainer(): boolean;
+    isLazy(): boolean;
     saveShapesSnapshot(context: BuildSceneObjectContext): void;
     getSnapshot(): Map<SceneObject, Shape[]>;
     abstract serialize(scope?: Set<SceneObject>): any;

package/lib/dist/common/scene-object.js

@@ -85,6 +85,9 @@ export class SceneObject {
     isContainer() {
         return false;
     }
+    isLazy() {
+        return false;
+    }
     // called by containers to save the shapes state up to this object
     saveShapesSnapshot(context) {
         const upToHere = context.getSceneObjects();

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

@@ -1,28 +1,28 @@
 import { PlaneLike } from "../../math/plane.js";
-import { IGeometry, ISceneObject } from "../interfaces.js";
+import { IALine, ISceneObject } from "../interfaces.js";
 interface ALineFunction {
     /**
      * Draws a line at the given angle with the given length.
-     * @param length - The line length
+     * Chain `.centered()` to center the line on the current position.
      * @param angle - The angle in degrees
-     * @param centered - Whether to center the line on the current position
+     * @param length - The line length
      */
-    (length: number, angle: number, centered?: boolean): IGeometry;
+    (angle: number, length: number): IALine;
     /**
-     * Draws a line at the given angle on a specific plane.
-     * @param targetPlane - The plane to draw on
-     * @param length - The line length
+     * Draws a line at the given angle that ends where it intersects the target
+     * geometry. The nearest intersection along the line's direction (in either
+     * sign) is used.
      * @param angle - The angle in degrees
+     * @param target - The geometry to intersect with
      */
-    (targetPlane: PlaneLike | ISceneObject, length: number, angle: number): IGeometry;
+    (angle: number, target: ISceneObject): IALine;
     /**
-     * Draws a centered line at the given angle on a specific plane.
+     * Draws a line at the given angle on a specific plane.
      * @param targetPlane - The plane to draw on
-     * @param length - The line length
      * @param angle - The angle in degrees
-     * @param centered - Whether to center the line on the current position
+     * @param length - The line length
      */
-    (targetPlane: PlaneLike | ISceneObject, length: number, angle: number, centered: boolean): IGeometry;
+    (targetPlane: PlaneLike | ISceneObject, angle: number, length: number): IALine;
 }
 declare const _default: ALineFunction;
 export default _default;

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

@@ -7,22 +7,27 @@ function build(context) {
     return function line() {
         let planeObj = null;
         let argOffset = 0;
-        // Detect plane as first argument (only valid outside a sketch)
+        const inSketch = context.getActiveSketch() !== null;
         if (arguments.length > 0) {
             const firstArg = arguments[0];
-            if (isPlaneLike(firstArg) || firstArg instanceof SceneObject) {
-                if (context.getActiveSketch() !== null) {
+            if (isPlaneLike(firstArg)) {
+                if (inSketch) {
                     throw new Error("aLine(plane, ...) cannot be used inside a sketch. Use aLine(...) instead.");
                 }
                 planeObj = resolvePlane(firstArg, context);
                 argOffset = 1;
             }
+            else if (!inSketch && firstArg instanceof SceneObject) {
+                planeObj = resolvePlane(firstArg, context);
+                argOffset = 1;
+            }
         }
-        const argCount = arguments.length - argOffset;
-        const length = arguments[argOffset];
-        const angle = arguments[argOffset + 1];
-        const centered = argCount >= 3 ? arguments[argOffset + 2] : false;
-        const aline = new AngledLine(length, angle, centered, planeObj);
+        const angle = arguments[argOffset];
+        const second = arguments[argOffset + 1];
+        const lengthOrTarget = second instanceof SceneObject
+            ? second
+            : second;
+        const aline = new AngledLine(angle, lengthOrTarget, planeObj);
         context.addSceneObject(aline);
         return aline;
     };

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

@@ -0,0 +1,12 @@
+import { IGeometry } from "../interfaces.js";
+interface BackFunction {
+    /** Reverts the cursor to the previous position. */
+    (): IGeometry;
+    /**
+     * Reverts the cursor `count` position-changes back.
+     * @param count - How many prior cursor changes to undo (default 1).
+     */
+    (count: number): IGeometry;
+}
+declare const _default: BackFunction;
+export default _default;

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

@@ -0,0 +1,11 @@
+import { Back } from "../../features/2d/back.js";
+import { registerBuilder } from "../../index.js";
+function build(context) {
+    return function back() {
+        const count = arguments[0] ?? 1;
+        const obj = new Back(count);
+        context.addSceneObject(obj);
+        return obj;
+    };
+}
+export default registerBuilder(build);

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

@@ -1,33 +1,40 @@
 import { Point2DLike } from "../../math/point.js";
 import { PlaneLike } from "../../math/plane.js";
-import { IGeometry, ISceneObject } from "../interfaces.js";
+import { IHLine, ISceneObject } from "../interfaces.js";
 interface HLineFunction {
     /**
      * Draws a horizontal line of the given distance.
+     * Chain `.centered()` to center the line on the current position.
      * @param distance - The line length
-     * @param centered - Whether to center the line on the current position
      */
-    (distance: number, centered?: boolean): IGeometry;
+    (distance: number): IHLine;
+    /**
+     * Draws a horizontal line that ends where it intersects the target geometry.
+     * The nearest intersection (in either direction along the X axis) is used.
+     * @param target - The geometry to intersect with
+     */
+    (target: ISceneObject): IHLine;
     /**
      * Draws a horizontal line from a start point.
+     * Chain `.centered()` to center the line on the 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;
+    (start: Point2DLike, distance: number): IHLine;
     /**
-     * Draws a horizontal line on a specific plane.
-     * @param targetPlane - The plane to draw on
-     * @param distance - The line length
+     * Draws a horizontal line from a start point that ends where it intersects
+     * the target geometry. The nearest intersection (in either direction along
+     * the X axis) is used.
+     * @param start - The start point
+     * @param target - The geometry to intersect with
      */
-    (targetPlane: PlaneLike | ISceneObject, distance: number): IGeometry;
+    (start: Point2DLike, target: ISceneObject): IHLine;
     /**
-     * Draws a horizontal line with centering on a specific plane.
+     * Draws a horizontal line on a specific plane.
      * @param targetPlane - The plane to draw on
      * @param distance - The line length
-     * @param centered - Whether to center the line on the current position
      */
-    (targetPlane: PlaneLike | ISceneObject, distance: number, centered: boolean): IGeometry;
+    (targetPlane: PlaneLike | ISceneObject, distance: number): IHLine;
 }
 declare const _default: HLineFunction;
 export default _default;

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

@@ -10,30 +10,44 @@ function build(context) {
     return function line() {
         let planeObj = null;
         let argOffset = 0;
-        // Detect plane as first argument (only valid outside a sketch)
+        const inSketch = context.getActiveSketch() !== null;
+        // Detect plane as first argument (only valid outside a sketch).
+        // Inside a sketch, a SceneObject in the first position is a target geometry,
+        // and a true PlaneLike is an error since drawing on another plane mid-sketch
+        // is not supported.
         if (arguments.length > 0) {
             const firstArg = arguments[0];
-            if (isPlaneLike(firstArg) || (firstArg instanceof SceneObject && !isPoint2DLike(firstArg))) {
-                if (context.getActiveSketch() !== null) {
+            if (isPlaneLike(firstArg)) {
+                if (inSketch) {
                     throw new Error("hLine(plane, ...) cannot be used inside a sketch. Use hLine(...) instead.");
                 }
                 planeObj = resolvePlane(firstArg, context);
                 argOffset = 1;
             }
+            else if (!inSketch && firstArg instanceof SceneObject && !isPoint2DLike(firstArg)) {
+                planeObj = resolvePlane(firstArg, context);
+                argOffset = 1;
+            }
+        }
+        if (argOffset === 0 && inSketch && arguments[0] instanceof SceneObject && !isPoint2DLike(arguments[0])) {
+            // hLine(target)
+            const hline = new HorizontalLine(arguments[0], null);
+            context.addSceneObject(hline);
+            return hline;
         }
-        const argCount = arguments.length - argOffset;
         if (argOffset === 0 && typeof arguments[0] !== 'number') {
-            // hline(start, distance) or hline(start, distance, centered)
+            // hLine(start, distance) or hLine(start, target)
             const start = normalizePoint2D(arguments[0]);
-            const distance = arguments[1];
-            const centered = argCount >= 3 ? arguments[2] : false;
-            const hline = new HorizontalLine(distance, centered, planeObj);
+            const second = arguments[1];
+            const distanceOrTarget = second instanceof SceneObject
+                ? second
+                : second;
+            const hline = new HorizontalLine(distanceOrTarget, planeObj);
             context.addSceneObjects([new Move(start), hline]);
             return hline;
         }
         const distance = arguments[argOffset];
-        const centered = argCount >= 2 ? arguments[argOffset + 1] : false;
-        const hline = new HorizontalLine(distance, centered, planeObj);
+        const hline = new HorizontalLine(distance, planeObj);
         context.addSceneObject(hline);
         return hline;
     };

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

@@ -22,3 +22,4 @@ export { default as project } from './project.js';
 export { default as intersect } from './intersect.js';
 export { default as bezier } from './bezier.js';
 export { default as center } from './center.js';
+export { default as back } from './back.js';

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

@@ -22,3 +22,4 @@ export { default as project } from './project.js';
 export { default as intersect } from './intersect.js';
 export { default as bezier } from './bezier.js';
 export { default as center } from './center.js';
+export { default as back } from './back.js';

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

@@ -1,33 +1,40 @@
 import { Point2DLike } from "../../math/point.js";
 import { PlaneLike } from "../../math/plane.js";
-import { IGeometry, ISceneObject } from "../interfaces.js";
+import { IVLine, ISceneObject } from "../interfaces.js";
 interface VLineFunction {
     /**
      * Draws a vertical line of the given distance.
+     * Chain `.centered()` to center the line on the current position.
      * @param distance - The line length
-     * @param centered - Whether to center the line on the current position
      */
-    (distance: number, centered?: boolean): IGeometry;
+    (distance: number): IVLine;
+    /**
+     * Draws a vertical line that ends where it intersects the target geometry.
+     * The nearest intersection (in either direction along the Y axis) is used.
+     * @param target - The geometry to intersect with
+     */
+    (target: ISceneObject): IVLine;
     /**
      * Draws a vertical line from a start point.
+     * Chain `.centered()` to center the line on the 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;
+    (start: Point2DLike, distance: number): IVLine;
     /**
-     * Draws a vertical line on a specific plane.
-     * @param targetPlane - The plane to draw on
-     * @param distance - The line length
+     * Draws a vertical line from a start point that ends where it intersects
+     * the target geometry. The nearest intersection (in either direction along
+     * the Y axis) is used.
+     * @param start - The start point
+     * @param target - The geometry to intersect with
      */
-    (targetPlane: PlaneLike | ISceneObject, distance: number): IGeometry;
+    (start: Point2DLike, target: ISceneObject): IVLine;
     /**
-     * Draws a vertical line with centering on a specific plane.
+     * Draws a vertical line on a specific plane.
      * @param targetPlane - The plane to draw on
      * @param distance - The line length
-     * @param centered - Whether to center the line on the current position
      */
-    (targetPlane: PlaneLike | ISceneObject, distance: number, centered: boolean): IGeometry;
+    (targetPlane: PlaneLike | ISceneObject, distance: number): IVLine;
 }
 declare const _default: VLineFunction;
 export default _default;

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

@@ -10,30 +10,40 @@ function build(context) {
     return function line() {
         let planeObj = null;
         let argOffset = 0;
-        // Detect plane as first argument (only valid outside a sketch)
+        const inSketch = context.getActiveSketch() !== null;
         if (arguments.length > 0) {
             const firstArg = arguments[0];
-            if (isPlaneLike(firstArg) || (firstArg instanceof SceneObject && !isPoint2DLike(firstArg))) {
-                if (context.getActiveSketch() !== null) {
+            if (isPlaneLike(firstArg)) {
+                if (inSketch) {
                     throw new Error("vLine(plane, ...) cannot be used inside a sketch. Use vLine(...) instead.");
                 }
                 planeObj = resolvePlane(firstArg, context);
                 argOffset = 1;
             }
+            else if (!inSketch && firstArg instanceof SceneObject && !isPoint2DLike(firstArg)) {
+                planeObj = resolvePlane(firstArg, context);
+                argOffset = 1;
+            }
+        }
+        if (argOffset === 0 && inSketch && arguments[0] instanceof SceneObject && !isPoint2DLike(arguments[0])) {
+            // vLine(target)
+            const vline = new VerticalLine(arguments[0], null);
+            context.addSceneObject(vline);
+            return vline;
         }
-        const argCount = arguments.length - argOffset;
         if (argOffset === 0 && typeof arguments[0] !== 'number') {
-            // vline(start, distance) or vline(start, distance, centered)
+            // vLine(start, distance) or vLine(start, target)
             const start = normalizePoint2D(arguments[0]);
-            const distance = arguments[1];
-            const centered = argCount >= 3 ? arguments[2] : false;
-            const vline = new VerticalLine(distance, centered, planeObj);
+            const second = arguments[1];
+            const distanceOrTarget = second instanceof SceneObject
+                ? second
+                : second;
+            const vline = new VerticalLine(distanceOrTarget, planeObj);
             context.addSceneObjects([new Move(start), vline]);
             return vline;
         }
         const distance = arguments[argOffset];
-        const centered = argCount >= 2 ? arguments[argOffset + 1] : false;
-        const vline = new VerticalLine(distance, centered, planeObj);
+        const vline = new VerticalLine(distance, planeObj);
         context.addSceneObject(vline);
         return vline;
     };

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 ISceneObject {
+    /**
+     * 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;
     };
 }