fluidcad 0.0.25 → 0.0.27

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

@@ -24,26 +24,28 @@ export interface ISceneObject {
      */
     reusable(): this;
 }
-export interface IFuseable extends ITransformable {
+export interface IBooleanOperation extends ISceneObject {
     /**
-     * Additive boolean operation — fuses the result with existing shapes.
-     * When called with no arguments, fuses with all intersecting scene objects.
-     * When called with specific objects, fuses only with those objects.
-     * @param objects - Optional target objects to fuse with.
+     * Additive boolean operation — fuses the result with all intersecting scene objects.
+     * Use `.scope()` to target specific objects.
      */
-    add(...objects: ISceneObject[]): this;
+    add(): this;
     /**
      * No boolean operation — keeps the result as a standalone shape,
      * separate from all other scene objects.
      */
     'new'(): this;
     /**
-     * Subtractive boolean operation — cuts the result from existing shapes.
-     * When called with no arguments, cuts from all intersecting scene objects.
-     * When called with specific objects, cuts only from those objects.
-     * @param objects - Optional target objects to cut from.
+     * Subtractive boolean operation — cuts the result from all intersecting scene objects.
+     * Use `.scope()` to target specific objects.
      */
-    remove(...objects: ISceneObject[]): this;
+    remove(): this;
+    /**
+     * Narrows the boolean operation scope to specific target objects.
+     * Must be chained after `.add()` or `.remove()`.
+     * @param objects - The target objects to operate on.
+     */
+    scope(...objects: ISceneObject[]): this;
 }
 /**
  * Scene objects that can be chained with world-space transformations.
@@ -98,13 +100,13 @@ export interface ITransformable extends ISceneObject {
      */
     mirror(axis: AxisLike): this;
 }
-export interface IPlane extends ITransformable {
+export interface IPlane extends ISceneObject {
 }
-export interface IAxis extends ITransformable {
+export interface IAxis extends ISceneObject {
 }
 export interface ISelect extends ISceneObject {
 }
-export interface IGeometry extends ITransformable {
+export interface IGeometry extends ISceneObject {
     /**
      * Returns a lazy-evaluated vertex at the start point of this geometry element.
      */
@@ -211,6 +213,11 @@ export interface ISlot extends IExtrudableGeometry {
      * @param value - `true` to center, `false` (default) to start from the current position.
      */
     centered(value?: boolean): this;
+    /**
+     * Sets the rotation angle of the slot's primary axis.
+     * @param angle - Rotation in degrees.
+     */
+    rotate(angle: number): this;
 }
 export interface IPolygon extends IExtrudableGeometry {
     /**
@@ -248,7 +255,7 @@ export interface ITangentArcTwoObjects extends IGeometry {
      */
     end(index?: number): LazyVertex;
 }
-export interface ICommon extends ITransformable {
+export interface ICommon extends ISceneObject {
     /**
      * Controls whether the original objects involved in the boolean intersection
      * are retained or removed after the operation.
@@ -256,7 +263,7 @@ export interface ICommon extends ITransformable {
      */
     keepOriginal(value?: boolean): this;
 }
-export interface IExtrude extends IFuseable {
+export interface IExtrude extends IBooleanOperation {
     /**
      * Enables symmetric mode — extrudes equally in both directions from the sketch plane.
      */
@@ -348,16 +355,17 @@ export interface IExtrude extends IFuseable {
      */
     thin(offset1: number, offset2: number): this;
 }
-export interface ICut extends ITransformable {
+export interface ICut extends ISceneObject {
     /**
      * Enables symmetric mode — cuts equally in both directions from the sketch plane.
      */
     symmetric(): this;
     /**
-     * Narrows the cut scope to specific objects instead of all scene objects.
+     * Narrows the cut scope to specific target objects.
+     * Must be chained after `.remove()`.
      * @param objects - The target objects to cut from.
      */
-    remove(...objects: ISceneObject[]): this;
+    scope(...objects: ISceneObject[]): this;
     /**
      * Applies a draft (taper) angle to the cut walls.
      * @param value - A single angle for uniform draft, or a `[start, end]` tuple for asymmetric draft.
@@ -408,7 +416,7 @@ export interface ICut extends ITransformable {
      */
     thin(offset1: number, offset2: number): this;
 }
-export interface IRevolve extends IFuseable {
+export interface IRevolve extends IBooleanOperation {
     /**
      * Enables symmetric mode — revolves equally in both directions from the sketch plane.
      */
@@ -456,7 +464,7 @@ export interface IRevolve extends IFuseable {
      */
     capEdges(...args: (number | EdgeFilterBuilder)[]): ISceneObject;
 }
-export interface ILoft extends IFuseable {
+export interface ILoft extends IBooleanOperation {
     /**
      * Selects faces on the first profile plane of the loft.
      * @param args - Numeric indices or {@link FaceFilterBuilder} instances to filter the selection.
@@ -525,7 +533,7 @@ export interface ILoft extends IFuseable {
      */
     capEdges(...args: (number | EdgeFilterBuilder)[]): ISceneObject;
 }
-export interface ISweep extends IFuseable {
+export interface ISweep extends IBooleanOperation {
     /**
      * Selects faces at the start (profile plane) of the sweep.
      * @param args - Numeric indices or {@link FaceFilterBuilder} instances to filter the selection.
@@ -613,9 +621,9 @@ export interface ISweep extends IFuseable {
      */
     capEdges(...args: (number | EdgeFilterBuilder)[]): ISceneObject;
 }
-export interface IDraft extends ITransformable {
+export interface IDraft extends ISceneObject {
 }
-export interface IShell extends ITransformable {
+export interface IShell extends ISceneObject {
     /**
      * Selects the inner wall faces created by the shell operation (from thickness removal).
      * @param args - Numeric indices or {@link FaceFilterBuilder} instances to filter the selection.

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

@@ -1,10 +1,10 @@
-import { ITransformable } from "./interfaces.js";
+import { ISceneObject } from "./interfaces.js";
 interface LoadFunction {
     /**
      * Loads a 3D model file (STEP, STL, etc.) by filename.
      * @param fileName - The path to the model file
      */
-    (fileName: string): ITransformable;
+    (fileName: string): ISceneObject;
 }
 declare const _default: LoadFunction;
 export default _default;

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

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/part.d.ts

@@ -1,3 +1,4 @@
 import { ISceneObject } from "./interfaces.js";
-declare function part(name: string, callback: () => void): ISceneObject;
+type Extend<T> = T extends object ? T : {};
+declare function part<T>(name: string, callback: () => T): ISceneObject & Extend<T>;
 export default part;

package/lib/dist/core/part.js

@@ -12,8 +12,11 @@ function part(name, callback) {
         partObj.setSourceLocation(sourceLocation);
     }
     scene.startProgressiveContainer(partObj);
-    callback();
+    const extensions = callback();
     scene.endProgressiveContainer();
+    if (extensions && typeof extensions === 'object') {
+        Object.assign(partObj, extensions);
+    }
     return partObj;
 }
 export default part;

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/sketch.d.ts

@@ -1,24 +1,25 @@
 import { PlaneLike } from "../math/plane.js";
 import { IPlane, ISceneObject } from "./interfaces.js";
+type Extend<T> = T extends object ? T : {};
 interface SketchFunction {
     /**
      * Draws 2D geometry on a standard plane.
      * @param plane - The plane to sketch on
      * @param sketcher - Callback containing sketch operations
      */
-    (plane: PlaneLike, sketcher: () => void): ISceneObject;
+    <T>(plane: PlaneLike, sketcher: () => T): ISceneObject & Extend<T>;
     /**
      * Draws 2D geometry on a face selection.
      * @param face - The face to sketch on
      * @param sketcher - Callback containing sketch operations
      */
-    (face: ISceneObject, sketcher: () => void): ISceneObject;
+    <T>(face: ISceneObject, sketcher: () => T): ISceneObject & Extend<T>;
     /**
      * Draws 2D geometry on an existing Plane object.
      * @param plane - The Plane object to sketch on
      * @param sketcher - Callback containing sketch operations
      */
-    (plane: IPlane, sketcher: () => void): ISceneObject;
+    <T>(plane: IPlane, sketcher: () => T): ISceneObject & Extend<T>;
 }
 declare const _default: SketchFunction;
 export default _default;

package/lib/dist/core/sketch.js

@@ -26,8 +26,11 @@ function build(context) {
         }
         const sketch = new Sketch(planeObj);
         context.startProgressiveContainer(sketch);
-        sketcher();
+        const extensions = sketcher();
         context.endProgressiveContainer();
+        if (extensions && typeof extensions === 'object') {
+            Object.assign(sketch, extensions);
+        }
         return sketch;
     };
 }

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;
     };
 }