fluidcad 0.0.25 → 0.0.26

package/lib/dist/core/mirror.js

@@ -4,84 +4,69 @@ import { SceneObject } from "../common/scene-object.js";
 import { MirrorShape } from "../features/mirror-shape.js";
 import { PlaneObjectBase } from "../features/plane-renderable-base.js";
 import { PlaneObject } from "../features/plane.js";
-import { isAxisLike } from "../math/axis.js";
+import { isAxisLike, isStandardAxis } from "../math/axis.js";
 import { MirrorShape2D } from "../features/mirror-shape2d.js";
 import { AxisObjectBase } from "../features/axis-renderable-base.js";
 import { AxisObject } from "../features/axis.js";
 import { AxisFromEdge } from "../features/axis-from-edge.js";
+const axisToPlaneName = { x: "yz", y: "xz", z: "xy" };
+function resolveAxis(arg, context) {
+    if (arg instanceof AxisObjectBase) {
+        return arg;
+    }
+    if (arg instanceof SceneObject) {
+        const axis = new AxisFromEdge(arg);
+        context.addSceneObject(axis);
+        return axis;
+    }
+    const a = normalizeAxis(arg);
+    const axis = new AxisObject(a);
+    context.addSceneObject(axis);
+    return axis;
+}
+function resolvePlane(arg, context) {
+    if (arg instanceof PlaneObjectBase) {
+        return arg;
+    }
+    const normalizedPlane = normalizePlane(arg);
+    const planeObj = new PlaneObject(normalizedPlane);
+    context.addSceneObject(planeObj);
+    return planeObj;
+}
 function build(context) {
     return function mirror() {
+        const activeSketch = context.getActiveSketch();
         if (arguments.length === 1) {
-            if (isAxisLike(arguments[0] || arguments[0] instanceof SceneObject)) {
-                let axis = null;
-                if (arguments[0] instanceof AxisObjectBase) {
-                    axis = arguments[0];
-                }
-                else if (arguments[0] instanceof SceneObject) {
-                    const line = arguments[0];
-                    axis = new AxisFromEdge(line);
-                    context.addSceneObject(axis);
-                }
-                else {
-                    const a = normalizeAxis(arguments[0]);
-                    axis = new AxisObject(a);
-                    context.addSceneObject(axis);
-                }
+            if (activeSketch && (isAxisLike(arguments[0]) || arguments[0] instanceof SceneObject)) {
+                const axis = resolveAxis(arguments[0], context);
                 const mirror = new MirrorShape2D(axis);
                 context.addSceneObject(mirror);
                 return mirror;
             }
-            else {
-                const pln = arguments[0];
-                let planeObj;
-                if (!(pln instanceof PlaneObjectBase)) {
-                    const normalizedPlane = normalizePlane(arguments[0]);
-                    planeObj = new PlaneObject(normalizedPlane);
-                    context.addSceneObject(planeObj);
-                }
-                else {
-                    planeObj = pln;
-                    ;
-                }
-                const mirror = new MirrorShape(planeObj);
-                context.addSceneObject(mirror);
-                return mirror;
+            let planeArg = arguments[0];
+            if (isStandardAxis(planeArg)) {
+                planeArg = axisToPlaneName[planeArg];
             }
+            const planeObj = resolvePlane(planeArg, context);
+            const mirror = new MirrorShape(planeObj);
+            context.addSceneObject(mirror);
+            return mirror;
         }
         if (arguments.length >= 2) {
             const args = Array.from(arguments);
-            // 2D mirror with target objects: mirror(axis/line, geometries[])
-            if (isAxisLike(args[0]) || args[0] instanceof SceneObject) {
-                let axis = null;
-                if (args[0] instanceof AxisObjectBase) {
-                    axis = args[0];
-                }
-                else if (args[0] instanceof SceneObject) {
-                    const line = args[0];
-                    axis = new AxisFromEdge(line);
-                    context.addSceneObject(axis);
-                }
-                else {
-                    const a = normalizeAxis(args[0]);
-                    axis = new AxisObject(a);
-                    context.addSceneObject(axis);
-                }
+            if (activeSketch && (isAxisLike(args[0]) || args[0] instanceof SceneObject)) {
+                const axis = resolveAxis(args[0], context);
                 const targetObjects = args.slice(1);
                 const mirror = new MirrorShape2D(axis, targetObjects);
                 context.addSceneObject(mirror);
                 return mirror;
             }
-            // 3D shape mirror: mirror(plane, ...objects)
-            const targetObjects = args.slice(1);
-            let planeObj;
-            if (!(args[0] instanceof PlaneObjectBase)) {
-                const normalizedPlane = normalizePlane(args[0]);
-                planeObj = new PlaneObject(normalizedPlane);
-                context.addSceneObject(planeObj);
-            }
-            else {
-                planeObj = args[0];
+            let planeArg = args[0];
+            if (isStandardAxis(planeArg)) {
+                planeArg = axisToPlaneName[planeArg];
             }
+            const planeObj = resolvePlane(planeArg, context);
+            const targetObjects = args.slice(1);
             const mirror = new MirrorShape(planeObj, targetObjects);
             context.addSceneObject(mirror);
             return mirror;

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

@@ -1,8 +1,6 @@
 import { PlaneLike, PlaneTransformOptions } from "../math/plane.js";
 import { IPlane, ISceneObject } from "./interfaces.js";
-export type PlaneRenderableOptions = PlaneTransformOptions & {
-    sticky?: boolean;
-};
+export type PlaneRenderableOptions = PlaneTransformOptions;
 interface PlaneFunction {
     /**
      * Creates a plane from a standard plane or normal vector.
@@ -12,7 +10,7 @@ interface PlaneFunction {
     /**
      * Creates a plane with transform options.
      * @param plane - The standard plane or normal vector
-     * @param options - Transform options (offset, flip, sticky, etc.)
+     * @param options - Transform options (offset, rotate, etc.)
      */
     (plane: PlaneLike, options: PlaneRenderableOptions): IPlane;
     /**
@@ -29,7 +27,7 @@ interface PlaneFunction {
     /**
      * Creates a plane from a face selection with transform options.
      * @param selection - The selected face to create a plane from
-     * @param options - Transform options (offset, flip, sticky, etc.)
+     * @param options - Transform options (offset, rotate, etc.)
      */
     (selection: ISceneObject, options: PlaneRenderableOptions): IPlane;
     /**
@@ -41,14 +39,14 @@ interface PlaneFunction {
     /**
      * Transforms an existing plane with options.
      * @param plane - The existing plane to transform
-     * @param options - Transform options (offset, flip, sticky, etc.)
+     * @param options - Transform options (offset, rotate, etc.)
      */
     (plane: IPlane, options: PlaneRenderableOptions): IPlane;
     /**
      * Creates a plane midway between two standard planes or normal vectors.
      * @param p1 - The first standard plane or normal vector
      * @param p2 - The second standard plane or normal vector
-     * @param options - Transform options (offset, flip, sticky, etc.)
+     * @param options - Transform options (offset, rotate, etc.)
      */
     (p1: PlaneLike, p2: PlaneLike, options?: PlaneRenderableOptions): IPlane;
     /**

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

@@ -1,10 +1,10 @@
-import { ISceneObject, ITransformable } from "./interfaces.js";
+import { ISceneObject } from "./interfaces.js";
 interface RemoveFunction {
     /**
      * Removes the given objects from the scene.
      * @param objects - The objects to remove
      */
-    (...objects: ISceneObject[]): ITransformable;
+    (...objects: ISceneObject[]): ISceneObject;
 }
 declare const _default: RemoveFunction;
 export default _default;

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

@@ -1,26 +1,26 @@
 import { AxisLike } from "../math/axis.js";
-import { ISceneObject, ITransformable } from "./interfaces.js";
+import { 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[]): ITransformable;
+    (angle: number, ...targets: ISceneObject[]): ISceneObject;
     /**
      * [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[]): ITransformable;
+    (angle: number, copy: boolean, ...targets: ISceneObject[]): ISceneObject;
     /**
      * [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[]): ITransformable;
+    (axis: AxisLike, angle: number, ...targets: ISceneObject[]): ISceneObject;
     /**
      * [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[]): ITransformable;
+    (axis: AxisLike, angle: number, copy: boolean, ...targets: ISceneObject[]): ISceneObject;
 }
 declare const _default: RotateFunction;
 export default _default;

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

@@ -1,4 +1,4 @@
-import { ISceneObject, ITransformable } from "./interfaces.js";
+import { ISceneObject } from "./interfaces.js";
 interface SubtractFunction {
     /**
      * Subtracts the second shape from the first (boolean difference).
@@ -6,7 +6,7 @@ interface SubtractFunction {
      * @param object1 - The base shape
      * @param object2 - The shape to subtract
      */
-    (object1: ISceneObject, object2: ISceneObject): ITransformable;
+    (object1: ISceneObject, object2: ISceneObject): ISceneObject;
 }
 declare const _default: SubtractFunction;
 export default _default;

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

@@ -1,26 +1,26 @@
 import { PointLike } from "../math/point.js";
-import { ISceneObject, ITransformable } from "./interfaces.js";
+import { ISceneObject } 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[]): ITransformable;
+    (x: number, ...targets: ISceneObject[]): ISceneObject;
     /**
      * 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[]): ITransformable;
+    (x: number, copy: boolean, ...targets: ISceneObject[]): ISceneObject;
     /**
      * 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[]): ITransformable;
+    (x: number, y: number, ...targets: ISceneObject[]): ISceneObject;
     /**
      * 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[]): ITransformable;
+    (x: number, y: number, copy: boolean, ...targets: ISceneObject[]): ISceneObject;
     /**
      * 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[]): ITransformable;
+    (x: number, y: number, z: number, ...targets: ISceneObject[]): ISceneObject;
     /**
      * 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[]): ITransformable;
+    (x: number, y: number, z: number, copy: boolean, ...targets: ISceneObject[]): ISceneObject;
     /**
      * 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[]): ITransformable;
+    (distance: PointLike, ...targets: ISceneObject[]): ISceneObject;
     /**
      * 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[]): ITransformable;
+    (distance: PointLike, copy: boolean, ...targets: ISceneObject[]): ISceneObject;
 }
 declare const _default: TranslateFunction;
 export default _default;

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

@@ -6,8 +6,10 @@ export declare class Slot extends ExtrudableGeometryBase implements ISlot {
     distance: number;
     radius: number;
     private _center;
+    private _angle;
     constructor(distance: number, radius: number, targetPlane?: PlaneObjectBase);
     centered(value?: boolean): this;
+    rotate(angle: number): this;
     build(): void;
     getType(): string;
     getDependencies(): SceneObject[];
@@ -17,5 +19,6 @@ export declare class Slot extends ExtrudableGeometryBase implements ISlot {
         distance: number;
         radius: number;
         centered: boolean;
+        angle: number;
     };
 }

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

@@ -1,10 +1,12 @@
 import { Point2D } from "../../math/point.js";
 import { Geometry } from "../../oc/geometry.js";
+import { rad } from "../../helpers/math-helpers.js";
 import { ExtrudableGeometryBase } from "./extrudable-base.js";
 export class Slot extends ExtrudableGeometryBase {
     distance;
     radius;
     _center = false;
+    _angle = 0;
     constructor(distance, radius, targetPlane = null) {
         super(targetPlane);
         this.distance = distance;
@@ -14,6 +16,10 @@ export class Slot extends ExtrudableGeometryBase {
         this._center = value;
         return this;
     }
+    rotate(angle) {
+        this._angle = angle;
+        return this;
+    }
     build() {
         if (this.distance < 0) {
             throw new Error("Slot distance must be positive");
@@ -24,14 +30,26 @@ export class Slot extends ExtrudableGeometryBase {
             ? plane.worldToLocal(this.targetPlane.getPlaneCenter())
             : this.getCurrentPosition();
         if (this._center) {
-            leftCenter = leftCenter.translate(-this.distance / 2, 0);
+            const angleRad = rad(this._angle);
+            const cos = Math.cos(angleRad);
+            const sin = Math.sin(angleRad);
+            leftCenter = leftCenter.translate(-this.distance / 2 * cos, -this.distance / 2 * sin);
         }
-        const rightCenter = new Point2D(leftCenter.x + this.distance, leftCenter.y);
+        const angleRad = rad(this._angle);
+        const cos = Math.cos(angleRad);
+        const sin = Math.sin(angleRad);
+        // Direction along the slot axis
+        const dirX = cos;
+        const dirY = sin;
+        // Perpendicular direction (90 degrees CCW)
+        const perpX = -sin;
+        const perpY = cos;
+        const rightCenter = new Point2D(leftCenter.x + this.distance * dirX, leftCenter.y + this.distance * dirY);
         // Four key points where lines meet arcs
-        const topLeft = new Point2D(leftCenter.x, leftCenter.y + this.radius);
-        const topRight = new Point2D(rightCenter.x, rightCenter.y + this.radius);
-        const bottomRight = new Point2D(rightCenter.x, rightCenter.y - this.radius);
-        const bottomLeft = new Point2D(leftCenter.x, leftCenter.y - this.radius);
+        const topLeft = new Point2D(leftCenter.x + this.radius * perpX, leftCenter.y + this.radius * perpY);
+        const topRight = new Point2D(rightCenter.x + this.radius * perpX, rightCenter.y + this.radius * perpY);
+        const bottomRight = new Point2D(rightCenter.x - this.radius * perpX, rightCenter.y - this.radius * perpY);
+        const bottomLeft = new Point2D(leftCenter.x - this.radius * perpX, leftCenter.y - this.radius * perpY);
         // Top line: topLeft -> topRight
         const topSegment = Geometry.makeSegment(localToWorld(topLeft), localToWorld(topRight));
         // Right arc: topRight -> bottomRight (CW semicircle around rightCenter)
@@ -69,6 +87,7 @@ export class Slot extends ExtrudableGeometryBase {
         const targetPlane = this.targetPlane ? (remap.get(this.targetPlane) || this.targetPlane) : null;
         const s = new Slot(this.distance, this.radius, targetPlane);
         s.centered(this._center);
+        s.rotate(this._angle);
         return s;
     }
     compareTo(other) {
@@ -86,13 +105,15 @@ export class Slot extends ExtrudableGeometryBase {
         }
         return this.distance === other.distance &&
             this.radius === other.radius &&
-            this._center === other._center;
+            this._center === other._center &&
+            this._angle === other._angle;
     }
     serialize() {
         return {
             distance: this.distance,
             radius: this.radius,
             centered: this._center,
+            angle: this._angle,
         };
     }
 }

package/lib/dist/features/cylinder.d.ts

@@ -1,5 +1,5 @@
-import { SceneObject } from "../common/scene-object.js";
-export declare class Cylinder extends SceneObject {
+import { TransformablePrimitive } from "../common/transformable-primitive.js";
+export declare class Cylinder extends TransformablePrimitive {
     radius: number;
     height: number;
     constructor(radius: number, height: number);

package/lib/dist/features/cylinder.js

@@ -1,6 +1,6 @@
-import { SceneObject } from "../common/scene-object.js";
+import { TransformablePrimitive } from "../common/transformable-primitive.js";
 import { Primitives } from "../oc/primitives.js";
-export class Cylinder extends SceneObject {
+export class Cylinder extends TransformablePrimitive {
     radius;
     height;
     constructor(radius, height) {

package/lib/dist/features/plane-from-object.d.ts

@@ -23,7 +23,7 @@ export declare class PlaneFromObject extends PlaneObjectBase {
         xDirection: import("../math/vector3d.js").Vector3d;
         yDirection: import("../math/vector3d.js").Vector3d;
         normal: import("../math/vector3d.js").Vector3d;
-        options: PlaneRenderableOptions;
+        options: import("../math/plane.js").PlaneTransformOptions;
         center: any;
     };
 }

package/lib/dist/features/plane-from-object.js

@@ -24,24 +24,29 @@ export class PlaneFromObject extends PlaneObjectBase {
             sourceFace = extract.sourceFace;
         }
         this.sourceObject.removeShapes(this);
-        if (this.options) {
-            plane = plane.transform(this.options);
-        }
         if (sourceFace) {
             const bbox = ShapeOps.getBoundingBox(sourceFace.getShape());
             center = new Point(bbox.centerX, bbox.centerY, bbox.centerZ);
         }
-        if (center) {
-            this.setState('plane-center', center);
+        if (this.options) {
+            // Apply the same transform to the center so the preview face stays on
+            // the rotated plane instead of floating at its pre-rotation position.
+            const matrix = plane.getTransformMatrix(this.options);
+            plane = plane.applyMatrix(matrix);
+            if (center) {
+                center = center.transform(matrix);
+            }
         }
         const transform = context?.getTransform() ?? null;
         if (transform) {
             plane = plane.applyMatrix(transform);
             if (center) {
                 center = center.transform(transform);
-                this.setState('plane-center', center);
             }
         }
+        if (center) {
+            this.setState('plane-center', center);
+        }
         this.setState('plane', plane);
         const face = FaceOps.planeToFace(plane, center);
         face.markAsMetaShape();

package/lib/dist/features/plane-mid.d.ts

@@ -13,6 +13,6 @@ export declare class PlaneMiddleRenderable extends PlaneObjectBase {
         yDirection: import("../math/vector3d.js").Vector3d;
         normal: import("../math/vector3d.js").Vector3d;
         center: import("../math/point.js").Point;
-        options: PlaneRenderableOptions;
+        options: import("../math/plane.js").PlaneTransformOptions;
     };
 }

package/lib/dist/features/plane.d.ts

@@ -16,6 +16,6 @@ export declare class PlaneObject extends PlaneObjectBase {
         yDirection: import("../math/vector3d.js").Vector3d;
         normal: import("../math/vector3d.js").Vector3d;
         center: import("../math/point.js").Point;
-        options: PlaneRenderableOptions;
+        options: import("../math/plane.js").PlaneTransformOptions;
     };
 }

package/lib/dist/features/select.d.ts

@@ -14,7 +14,7 @@ export declare class SelectSceneObject extends SceneObject implements ISelect {
     private getAllShapes;
     getDependencies(): SceneObject[];
     createCopy(remap: Map<SceneObject, SceneObject>): SceneObject;
-    withTransformedFilters(matrix: Matrix4): SelectSceneObject;
+    transform(matrix: Matrix4): SelectSceneObject;
     private injectScopeFaces;
     applyFilters(shapes: Shape[], filters: FilterBuilderBase<Shape>[]): Shape[];
     compareTo(other: SelectSceneObject): boolean;

package/lib/dist/features/select.js

@@ -63,7 +63,7 @@ export class SelectSceneObject extends SceneObject {
             : undefined;
         return new SelectSceneObject(this.filters, remappedConstraint);
     }
-    withTransformedFilters(matrix) {
+    transform(matrix) {
         const mirroredFilters = this.filters.map(f => f.transform(matrix));
         return new SelectSceneObject(mirroredFilters, this.constraintObject);
     }

package/lib/dist/features/sphere.d.ts

@@ -1,5 +1,5 @@
-import { SceneObject } from "../common/scene-object.js";
-export declare class Sphere extends SceneObject {
+import { TransformablePrimitive } from "../common/transformable-primitive.js";
+export declare class Sphere extends TransformablePrimitive {
     radius: number;
     angle: number;
     constructor(radius: number, angle: number);

package/lib/dist/features/sphere.js

@@ -1,6 +1,6 @@
-import { SceneObject } from "../common/scene-object.js";
+import { TransformablePrimitive } from "../common/transformable-primitive.js";
 import { Primitives } from "../oc/primitives.js";
-export class Sphere extends SceneObject {
+export class Sphere extends TransformablePrimitive {
     radius;
     angle;
     constructor(radius, angle) {

package/lib/dist/math/index.d.ts

@@ -3,6 +3,6 @@ export { Point, Point2D, PointLike, Point2DLike, isPointLike, isPoint2DLike } fr
 export { Quaternion } from "./quaternion.js";
 export { Matrix4 } from "./matrix4.js";
 export { Axis, AxisLike, StandardAxis, AxisTransformOptions, isAxisLike, isStandardAxis, toAxis } from "./axis.js";
-export { Plane, PlaneLike, StandardPlane, PlaneTransformOptions, RotationSpace, isPlaneLike, toPlane } from "./plane.js";
+export { Plane, PlaneLike, StandardPlane, PlaneTransformOptions, isPlaneLike, toPlane } from "./plane.js";
 export { CoordinateSystem } from "./coordinate-system.js";
 export { Convert } from "./convert.js";

package/lib/dist/math/plane.d.ts

@@ -4,13 +4,11 @@ import { Axis, AxisLike } from "./axis.js";
 import { Matrix4 } from "./matrix4.js";
 import { PlaneObjectBase } from "../features/plane-renderable-base.js";
 import { IPlane } from "../core/interfaces.js";
-export type RotationSpace = 'local' | 'global';
 export interface PlaneTransformOptions {
     offset?: number;
     rotateX?: number;
     rotateY?: number;
     rotateZ?: number;
-    rotationSpace?: RotationSpace;
 }
 export declare class Plane {
     readonly origin: Point;
@@ -25,6 +23,7 @@ export declare class Plane {
     localToWorld(point: Point2D): Point;
     offset(distance: number): Plane;
     transform(options: PlaneTransformOptions): Plane;
+    getTransformMatrix(options: PlaneTransformOptions): Matrix4;
     applyMatrix(matrix: Matrix4): Plane;
     translateAlongNormal(distance: number): Plane;
     translate(dx: number, dy: number, dz: number): Plane;

package/lib/dist/math/plane.js

@@ -36,36 +36,37 @@ export class Plane {
         return new Plane(newOrigin, this.xDirection, this.normal);
     }
     transform(options) {
-        let result = this;
-        if (options.offset) {
-            result = result.offset(options.offset);
-        }
+        return this.applyMatrix(this.getTransformMatrix(options));
+    }
+    getTransformMatrix(options) {
+        const offset = options.offset || 0;
+        const offsetVec = this.normal.multiply(offset);
+        const offsetMatrix = offset
+            ? Matrix4.fromTranslation(offsetVec.x, offsetVec.y, offsetVec.z)
+            : Matrix4.identity();
         const hasRotation = options.rotateX || options.rotateY || options.rotateZ;
         if (!hasRotation) {
-            return result;
+            return offsetMatrix;
         }
-        const useGlobal = options.rotationSpace === 'global';
-        // Determine rotation axes based on rotation space
-        const xAxis = useGlobal ? Vector3d.unitX() : result.xDirection;
-        const yAxis = useGlobal ? Vector3d.unitY() : result.yDirection;
-        const zAxis = useGlobal ? Vector3d.unitZ() : result.normal;
-        // Compose all rotations into a single quaternion to avoid gimbal lock
+        // Compose all rotations into a single quaternion to avoid gimbal lock.
+        // Axes are taken from the current plane (offset doesn't change orientation).
         let q = Quaternion.identity();
         if (options.rotateX) {
-            q = q.multiply(Quaternion.fromAxisAngle(xAxis, rad(options.rotateX)));
+            q = q.multiply(Quaternion.fromAxisAngle(this.xDirection, rad(options.rotateX)));
         }
         if (options.rotateY) {
-            q = q.multiply(Quaternion.fromAxisAngle(yAxis, rad(options.rotateY)));
+            q = q.multiply(Quaternion.fromAxisAngle(this.yDirection, rad(options.rotateY)));
         }
         if (options.rotateZ) {
-            q = q.multiply(Quaternion.fromAxisAngle(zAxis, rad(options.rotateZ)));
+            q = q.multiply(Quaternion.fromAxisAngle(this.normal, rad(options.rotateZ)));
         }
-        // Apply the composed rotation around the plane's origin
-        const toOrigin = Matrix4.fromTranslation(-result.origin.x, -result.origin.y, -result.origin.z);
+        // Rotate around the offset-applied origin (the plane's origin after offset).
+        const pivot = this.origin.add(offsetVec);
+        const toOrigin = Matrix4.fromTranslation(-pivot.x, -pivot.y, -pivot.z);
         const rotation = Matrix4.fromQuaternion(q);
-        const fromOrigin = Matrix4.fromTranslation(result.origin.x, result.origin.y, result.origin.z);
-        const matrix = fromOrigin.multiply(rotation).multiply(toOrigin);
-        return result.applyMatrix(matrix);
+        const fromOrigin = Matrix4.fromTranslation(pivot.x, pivot.y, pivot.z);
+        const rotationMatrix = fromOrigin.multiply(rotation).multiply(toOrigin);
+        return rotationMatrix.multiply(offsetMatrix);
     }
     applyMatrix(matrix) {
         return new Plane(matrix.transformPoint(this.origin), matrix.transformDirection(this.xDirection), matrix.transformDirection(this.normal), matrix.transformDirection(this.yDirection));

package/lib/dist/tests/features/cut-two-distances.test.js

@@ -97,7 +97,7 @@ describe("cut two distances", () => {
                 move([25, 25]);
                 rect(50, 50);
             });
-            cut(20, 10).remove(e1);
+            cut(20, 10).scope(e1);
             const scene = render();
             // First box is cut, second box is untouched — 2 shapes
             expect(countShapes(scene)).toBe(2);

package/lib/dist/tests/features/cut.test.js

@@ -154,7 +154,7 @@ describe("cut", () => {
                 move([25, 25]);
                 rect(50, 50);
             });
-            cut(20).remove(e1);
+            cut(20).scope(e1);
             const scene = render();
             // First box is cut (modified), second box is untouched — 2 shapes
             expect(countShapes(scene)).toBe(2);