fluidcad 0.0.13 → 0.0.15

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

@@ -3,35 +3,233 @@ 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) {
+import { normalizePoint2D } from "../../helpers/normalize.js";
+export class Arc extends GeometrySceneObject {
+    // Two-point mode state (set by factory)
+    _startPoint = null;
+    _endPoint = null;
+    // Angle mode state (set by factory)
+    _arcRadius = 0;
+    _startAngle = 0;
+    _endAngle = 180;
+    // Chainable state
+    _bulgeRadius = 0;
+    _centerPoint = null;
+    _centered = false;
+    _targetPlane;
+    constructor(targetPlane = null) {
         super();
-        this.radius = radius;
-        this.startAngle = startAngle;
-        this.endAngle = endAngle;
-        this.centered = centered;
-        this.targetPlane = targetPlane;
+        this._targetPlane = targetPlane;
+    }
+    static toPoint(endPoint, targetPlane = null) {
+        const arc = new Arc(targetPlane);
+        arc._endPoint = endPoint;
+        return arc;
+    }
+    static twoPoints(startPoint, endPoint, targetPlane = null) {
+        const arc = new Arc(targetPlane);
+        arc._startPoint = startPoint;
+        arc._endPoint = endPoint;
+        return arc;
+    }
+    static fromAngles(arcRadius, startAngle, endAngle, targetPlane = null) {
+        const arc = new Arc(targetPlane);
+        arc._arcRadius = arcRadius;
+        arc._startAngle = startAngle;
+        arc._endAngle = endAngle;
+        return arc;
+    }
+    // Chainable methods (IArc)
+    radius(value) {
+        this._bulgeRadius = value;
+        return this;
+    }
+    center(value) {
+        this._centerPoint = normalizePoint2D(value);
+        return this;
+    }
+    centered() {
+        this._centered = true;
+        return this;
     }
     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())
+        if (this._startPoint && this._endPoint) {
+            // Two explicit points: default center = current position
+            if (this._bulgeRadius !== 0) {
+                this.buildTwoPointsBulge();
+            }
+            else {
+                this.buildTwoPointsCenter();
+            }
+        }
+        else if (this._endPoint) {
+            // From current position to endpoint
+            if (this._centerPoint) {
+                this.buildWithCenter();
+            }
+            else {
+                this.buildToPoint();
+            }
+        }
+        else {
+            this.buildFromAngles();
+        }
+    }
+    buildTwoPointsCenter() {
+        const plane = this._targetPlane?.getPlane() || this.sketch.getPlane();
+        const startPt = this._startPoint.asPoint2D();
+        const endPt = this._endPoint.asPoint2D();
+        const centerPt = this._centerPoint
+            ? this._centerPoint.asPoint2D()
             : 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);
+        const dx = startPt.x - centerPt.x;
+        const dy = startPt.y - centerPt.y;
+        const radius = Math.sqrt(dx * dx + dy * dy);
+        const endAngle = Math.atan2(endPt.y - centerPt.y, endPt.x - centerPt.x);
+        const center = plane.localToWorld(centerPt);
+        const start = plane.localToWorld(startPt);
+        const end = plane.localToWorld(endPt);
+        const arc = Geometry.makeArc(center, radius, plane.normal, start, end);
+        const edge = Geometry.makeEdgeFromCurve(arc);
+        const tx = -Math.sin(endAngle);
+        const ty = Math.cos(endAngle);
+        this.setTangent(new Point2D(tx, ty));
+        this.setState('start', Vertex.fromPoint2D(startPt));
+        this.setState('end', Vertex.fromPoint2D(endPt));
+        this.addShape(edge);
+        if (this.sketch) {
+            this.setCurrentPosition(endPt);
+        }
+        if (this._targetPlane) {
+            this._targetPlane.removeShapes(this);
+        }
+    }
+    buildTwoPointsBulge() {
+        const plane = this._targetPlane?.getPlane() || this.sketch.getPlane();
+        const startPoint = this._startPoint.asPoint2D();
+        const targetPoint = this._endPoint.asPoint2D();
+        const dx = targetPoint.x - startPoint.x;
+        const dy = targetPoint.y - startPoint.y;
+        const chordLen = Math.sqrt(dx * dx + dy * dy);
+        let r = this._bulgeRadius;
+        const cw = r < 0;
+        r = Math.abs(r);
+        if (r < chordLen / 2) {
+            r = chordLen / 2;
+        }
+        const mx = (startPoint.x + targetPoint.x) / 2;
+        const my = (startPoint.y + targetPoint.y) / 2;
+        const px = -dy / chordLen;
+        const py = dx / chordLen;
+        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 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);
+        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);
+        }
+    }
+    buildToPoint() {
+        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);
+        let r = this._bulgeRadius || (chordLen / 2);
+        const cw = r < 0;
+        r = Math.abs(r);
+        if (r < chordLen / 2) {
+            r = chordLen / 2;
+        }
+        const mx = (startPoint.x + targetPoint.x) / 2;
+        const my = (startPoint.y + targetPoint.y) / 2;
+        const px = -dy / chordLen;
+        const py = dx / chordLen;
+        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);
+        const start = plane.localToWorld(startPoint);
+        const end = plane.localToWorld(targetPoint);
+        const arc = Geometry.makeArc(center, r, normal, start, end);
+        const edge = Geometry.makeEdgeFromCurve(arc);
+        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);
+        }
+    }
+    buildWithCenter() {
+        const plane = this._targetPlane?.getPlane() || this.sketch.getPlane();
+        const startPt = this._targetPlane
+            ? plane.worldToLocal(this._targetPlane.getPlaneCenter())
+            : this.getCurrentPosition();
+        const endPt = this._endPoint.asPoint2D();
+        const centerPt = this._centerPoint.asPoint2D();
+        const dx = startPt.x - centerPt.x;
+        const dy = startPt.y - centerPt.y;
+        const radius = Math.sqrt(dx * dx + dy * dy);
+        const endAngle = Math.atan2(endPt.y - centerPt.y, endPt.x - centerPt.x);
+        const center = plane.localToWorld(centerPt);
+        const start = plane.localToWorld(startPt);
+        const end = plane.localToWorld(endPt);
+        const arc = Geometry.makeArc(center, radius, plane.normal, start, end);
+        const edge = Geometry.makeEdgeFromCurve(arc);
+        const tx = -Math.sin(endAngle);
+        const ty = Math.cos(endAngle);
+        this.setTangent(new Point2D(tx, ty));
+        this.setState('start', Vertex.fromPoint2D(startPt));
+        this.setState('end', Vertex.fromPoint2D(endPt));
+        this.addShape(edge);
+        if (this.sketch) {
+            this.setCurrentPosition(endPt);
+        }
+        if (this._targetPlane) {
+            this._targetPlane.removeShapes(this);
+        }
+    }
+    buildFromAngles() {
+        const plane = this._targetPlane?.getPlane() || this.sketch.getPlane();
+        const radius = this._arcRadius;
+        const centerPoint = this._targetPlane
+            ? plane.worldToLocal(this._targetPlane.getPlaneCenter())
+            : this.getCurrentPosition();
+        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
+        if (this._centered) {
             const halfSweep = rad(absEndAngle) / 2;
             const midAngle = rad(absStartAngle);
             startAngleRad = midAngle - halfSweep;
@@ -51,44 +249,77 @@ export class ArcFromTwoAngles extends GeometrySceneObject {
         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);
+        if (this._targetPlane) {
+            this._targetPlane.removeShapes(this);
         }
     }
     getType() {
         return 'arc';
     }
     compareTo(other) {
-        if (!(other instanceof ArcFromTwoAngles)) {
+        if (!(other instanceof Arc)) {
             return false;
         }
         if (!super.compareTo(other)) {
             return false;
         }
-        if (this.targetPlane?.constructor !== other.targetPlane?.constructor) {
+        if (this._targetPlane?.constructor !== other._targetPlane?.constructor) {
             return false;
         }
-        if (this.targetPlane && other.targetPlane && !this.targetPlane.compareTo(other.targetPlane)) {
+        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;
+        if (this._endPoint && other._endPoint) {
+            if (!this._endPoint.compareTo(other._endPoint)) {
+                return false;
+            }
+            if (this._startPoint && other._startPoint) {
+                if (!this._startPoint.compareTo(other._startPoint)) {
+                    return false;
+                }
+            }
+            else if (this._startPoint !== other._startPoint) {
+                return false;
+            }
+            if (this._centerPoint && other._centerPoint) {
+                return this._centerPoint.compareTo(other._centerPoint);
+            }
+            return this._bulgeRadius === other._bulgeRadius;
+        }
+        if (!this._endPoint && !other._endPoint) {
+            return this._arcRadius === other._arcRadius &&
+                this._startAngle === other._startAngle &&
+                this._endAngle === other._endAngle &&
+                this._centered === other._centered;
+        }
+        return false;
     }
     serialize() {
+        if (this._endPoint) {
+            const base = {
+                endPoint: this._endPoint.serialize(),
+            };
+            if (this._startPoint) {
+                base.startPoint = this._startPoint.serialize();
+            }
+            if (this._centerPoint) {
+                base.center = this._centerPoint.serialize();
+            }
+            if (this._bulgeRadius !== 0) {
+                base.radius = this._bulgeRadius;
+            }
+            return base;
+        }
         return {
-            radius: this.radius,
-            startAngle: this.startAngle,
-            endAngle: this.endAngle,
-            centered: this.centered,
+            radius: this._arcRadius,
+            startAngle: this._startAngle,
+            endAngle: this._endAngle,
+            centered: this._centered
         };
     }
 }

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

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

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

@@ -0,0 +1,83 @@
+import { Vertex } from "../../common/vertex.js";
+import { SectionOps } from "../../oc/section-ops.js";
+import { ExtrudableGeometryBase } from "./extrudable-base.js";
+export class Intersect extends ExtrudableGeometryBase {
+    sourceObjects;
+    constructor(sourceObjects, targetPlane = null) {
+        super(targetPlane);
+        this.sourceObjects = sourceObjects;
+    }
+    build(context) {
+        const plane = this.targetPlane?.getPlane() || this.sketch.getPlane();
+        const shapes = this.sourceObjects.flatMap(obj => obj.getShapes());
+        const transform = context?.getTransform() ?? null;
+        let lastEdge = null;
+        for (let shape of shapes) {
+            const edges = SectionOps.sectionShapeWithPlane(plane, shape);
+            for (const edge of edges) {
+                lastEdge = edge;
+            }
+            this.addShapes(edges);
+        }
+        if (lastEdge) {
+            const localStart = plane.worldToLocal(lastEdge.getFirstVertex().toPoint());
+            const localEnd = plane.worldToLocal(lastEdge.getLastVertex().toPoint());
+            this.setState('start', Vertex.fromPoint2D(localStart));
+            this.setState('end', Vertex.fromPoint2D(localEnd));
+        }
+        for (const obj of this.sourceObjects) {
+            obj.removeShapes(this);
+        }
+        if (this.targetPlane) {
+            this.targetPlane.removeShapes(this);
+        }
+        if (this.sketch) {
+            this.setCurrentPosition(this.getCurrentPosition());
+        }
+    }
+    getDependencies() {
+        const deps = [...this.sourceObjects];
+        if (this.targetPlane) {
+            deps.push(this.targetPlane);
+        }
+        return deps;
+    }
+    createCopy(remap) {
+        const objects = this.sourceObjects.map(obj => remap.get(obj) || obj);
+        const targetPlane = this.targetPlane ? (remap.get(this.targetPlane) || this.targetPlane) : null;
+        return new Intersect(objects, targetPlane);
+    }
+    compareTo(other) {
+        if (!(other instanceof Intersect)) {
+            return false;
+        }
+        if (!super.compareTo(other)) {
+            return false;
+        }
+        if (this.targetPlane?.constructor !== other.targetPlane?.constructor) {
+            return false;
+        }
+        if (this.targetPlane && other.targetPlane && !this.targetPlane.compareTo(other.targetPlane)) {
+            return false;
+        }
+        const thisObjects = this.sourceObjects || [];
+        const otherObjects = other.sourceObjects || [];
+        if (thisObjects.length !== otherObjects.length) {
+            return false;
+        }
+        for (let i = 0; i < thisObjects.length; i++) {
+            if (!thisObjects[i].compareTo(otherObjects[i])) {
+                return false;
+            }
+        }
+        return true;
+    }
+    getType() {
+        return 'intersect';
+    }
+    serialize() {
+        return {
+            objectIds: this.sourceObjects.map(o => o.id)
+        };
+    }
+}

package/lib/dist/features/2d/plane-center.d.ts

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

package/lib/dist/features/2d/plane-center.js

@@ -0,0 +1,40 @@
+import { GeometrySceneObject } from "./geometry.js";
+import { LazyVertex } from "../lazy-vertex.js";
+export class PlaneCenter extends GeometrySceneObject {
+    constructor() {
+        super();
+    }
+    getType() {
+        return 'plane-center';
+    }
+    build() {
+        const plane = this.sketch.getPlane();
+        const centerPoint = this.sketch.planeObj.getPlaneCenter();
+        const local = plane.worldToLocal(centerPoint);
+        this.setCurrentPosition(local);
+    }
+    center() {
+        return new LazyVertex(this.generateUniqueName('center'), () => {
+            const vertex = this.getState('center-vertex');
+            if (vertex) {
+                return [vertex];
+            }
+            return [];
+        });
+    }
+    getDependencies() {
+        return [];
+    }
+    createCopy(remap) {
+        return new PlaneCenter();
+    }
+    compareTo(other) {
+        if (!(other instanceof PlaneCenter)) {
+            return false;
+        }
+        return super.compareTo(other);
+    }
+    serialize() {
+        return {};
+    }
+}

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

@@ -1,5 +1,4 @@
 import { Face } from "../../common/face.js";
-import { ShapeOps } from "../../oc/shape-ops.js";
 import { Edge } from "../../common/edge.js";
 import { Vertex } from "../../common/vertex.js";
 import { ProjectionOps } from "../../oc/intersection.js";
@@ -18,9 +17,9 @@ export class Projection extends ExtrudableGeometryBase {
         let lastWire = null;
         console.log('Projection: building with shapes:', shapes.length);
         for (let shape of shapes) {
-            if (transform) {
-                shape = ShapeOps.transform(shape, transform);
-            }
+            // if (transform) {
+            //   shape = ShapeOps.transform(shape, transform);
+            // }
             let wires = [];
             if (shape instanceof Face) {
                 wires = ProjectionOps.projectFaceOntoPlane(plane, shape);

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

@@ -34,12 +34,12 @@ export declare class Rect extends ExtrudableGeometryBase implements IRect {
     bottomLeft(): LazyVertex;
     bottomRight(): LazyVertex;
     radius(...r: number[]): this;
-    center(value?: CenteringOptions): this;
+    centered(value?: CenteringOptions): this;
     serialize(): {
         width: number;
         height: number;
         radius: number | number[];
-        center: CenteringOptions;
+        centered: CenteringOptions;
     };
 }
 export {};

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

@@ -152,7 +152,7 @@ export class Rect extends ExtrudableGeometryBase {
         if (this._radius) {
             rect.radius(...(Array.isArray(this._radius) ? this._radius : [this._radius]));
         }
-        rect.center(this._center);
+        rect.centered(this._center);
         return rect;
     }
     compareTo(other) {
@@ -250,7 +250,7 @@ export class Rect extends ExtrudableGeometryBase {
         }
         return this;
     }
-    center(value = true) {
+    centered(value = true) {
         this._center = value;
         return this;
     }
@@ -259,7 +259,7 @@ export class Rect extends ExtrudableGeometryBase {
             width: this.width,
             height: this.height,
             radius: this._radius,
-            center: this._center
+            centered: this._center
         };
     }
 }

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

@@ -2,7 +2,7 @@ import { Plane } from "../../math/plane.js";
 import { Point2D } from "../../math/point.js";
 import { GeometrySceneObject } from "./geometry.js";
 import { PlaneObjectBase } from "../plane-renderable-base.js";
-import { SceneObject } from "../../common/scene-object.js";
+import { BuildSceneObjectContext, SceneObject } from "../../common/scene-object.js";
 import { Edge } from "../../common/edge.js";
 import { Extrudable } from "../../helpers/types.js";
 export declare class Sketch extends SceneObject implements Extrudable {
@@ -15,7 +15,7 @@ export declare class Sketch extends SceneObject implements Extrudable {
     getTangentAt(currentObj: GeometrySceneObject): Point2D | null;
     getPositionAt(currentObj: GeometrySceneObject): Point2D;
     getLastPosition(scope?: Set<SceneObject>): Point2D;
-    build(): void;
+    build(context?: BuildSceneObjectContext): void;
     getEdges(): Edge[];
     getEdgesWithOwner(): Map<Edge, GeometrySceneObject>;
     getGeometriesWithOwner(): Map<Edge, GeometrySceneObject>;

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

@@ -3,6 +3,7 @@ import { GeometrySceneObject } from "./geometry.js";
 import { SceneObject } from "../../common/scene-object.js";
 import { Edge } from "../../common/edge.js";
 import { Wire } from "../../common/wire.js";
+import { ShapeOps } from "../../oc/shape-ops.js";
 export class Sketch extends SceneObject {
     planeObj;
     constructor(planeObj) {
@@ -77,10 +78,21 @@ export class Sketch extends SceneObject {
             children.pop();
         }
     }
-    build() {
+    build(context) {
         this.planeObj.removeShapes(this);
+        const source = this.getCloneSource();
+        const transform = context?.getTransform();
+        if (source instanceof Sketch && transform) {
+            const originalEdges = source.getEdges();
+            const transformedEdges = originalEdges.map(edge => ShapeOps.transform(edge, transform));
+            this.setState('cloned-edges', transformedEdges);
+        }
     }
     getEdges() {
+        const clonedEdges = this.getState('cloned-edges');
+        if (clonedEdges) {
+            return clonedEdges;
+        }
         return [...this.getEdgesWithOwner().keys()];
     }
     getEdgesWithOwner() {

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

@@ -8,7 +8,7 @@ export declare class Slot extends ExtrudableGeometryBase implements ISlot {
     private _center;
     private _angle;
     constructor(distance: number, radius: number, targetPlane?: PlaneObjectBase);
-    center(value?: boolean): this;
+    centered(value?: boolean): this;
     rotate(angle: number): this;
     build(): void;
     getType(): string;
@@ -18,7 +18,7 @@ export declare class Slot extends ExtrudableGeometryBase implements ISlot {
     serialize(): {
         distance: number;
         radius: number;
-        center: boolean;
+        centered: boolean;
         angle: number;
     };
 }

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

@@ -12,7 +12,7 @@ export class Slot extends ExtrudableGeometryBase {
         this.distance = distance;
         this.radius = radius;
     }
-    center(value = true) {
+    centered(value = true) {
         this._center = value;
         return this;
     }
@@ -86,7 +86,7 @@ export class Slot extends ExtrudableGeometryBase {
     createCopy(remap) {
         const targetPlane = this.targetPlane ? (remap.get(this.targetPlane) || this.targetPlane) : null;
         const s = new Slot(this.distance, this.radius, targetPlane);
-        s.center(this._center);
+        s.centered(this._center);
         s.rotate(this._angle);
         return s;
     }
@@ -112,7 +112,7 @@ export class Slot extends ExtrudableGeometryBase {
         return {
             distance: this.distance,
             radius: this.radius,
-            center: this._center,
+            centered: this._center,
             angle: this._angle,
         };
     }