fluidcad 0.0.2

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

@@ -0,0 +1,9 @@
+interface VMoveFunction {
+    /**
+     * Moves the cursor vertically by the given distance.
+     * @param distance - The vertical distance to move
+     */
+    (distance: number): void;
+}
+declare const _default: VMoveFunction;
+export default _default;

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

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

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

@@ -0,0 +1,11 @@
+import { PlaneLike } from "../../math/plane.js";
+import { IExtrudableGeometry, IGeometry, ISceneObject } from "../interfaces.js";
+interface WireFunction {
+    /**
+     * Groups geometry segments into a closed wire for extrusion.
+     * @param args - The geometry segments to group, optionally ending with a target plane
+     */
+    (...args: (IGeometry | PlaneLike | ISceneObject)[]): IExtrudableGeometry;
+}
+declare const _default: WireFunction;
+export default _default;

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

@@ -0,0 +1,29 @@
+import { GeometrySceneObject } from "../../features/2d/geometry.js";
+import { WireObject } from "../../features/2d/wire.js";
+import { registerBuilder } from "../../index.js";
+import { isPlaneLike } from "../../math/plane.js";
+import { SceneObject } from "../../common/scene-object.js";
+import { resolvePlane } from "../../helpers/resolve.js";
+function build(context) {
+    return function wire() {
+        let planeObj = null;
+        let argCount = arguments.length;
+        // Check if last argument is a plane
+        if (argCount > 0) {
+            const lastArg = arguments[argCount - 1];
+            if (isPlaneLike(lastArg) || (lastArg instanceof SceneObject && !(lastArg instanceof GeometrySceneObject))) {
+                planeObj = resolvePlane(lastArg, context);
+                argCount--;
+            }
+        }
+        // Collect target objects from arguments
+        let targetObjects = [];
+        for (let i = 0; i < argCount; i++) {
+            targetObjects.push(arguments[i]);
+        }
+        const path = new WireObject(targetObjects.length > 0 ? targetObjects : null, planeObj);
+        context.addSceneObject(path);
+        return path;
+    };
+}
+export default registerBuilder(build);

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

@@ -0,0 +1,41 @@
+import { AxisLike, AxisTransformOptions } from "../math/axis.js";
+import { IAxis, ISceneObject } from "./interfaces.js";
+interface AxisFunction {
+    /**
+     * Creates an axis from a direction vector.
+     * @param axis - The direction vector or standard axis
+     */
+    (axis: AxisLike): IAxis;
+    /**
+     * Creates an axis from a direction vector with transform options.
+     * @param axis - The direction vector or standard axis
+     * @param options - Transform options (offset, flip, etc.)
+     */
+    (axis: AxisLike, options: AxisTransformOptions): IAxis;
+    /**
+     * Creates an axis from a scene object's edge.
+     * @param source - The scene object whose edge defines the axis
+     */
+    (source: ISceneObject): IAxis;
+    /**
+     * Creates an axis from a scene object's edge with transform options.
+     * @param source - The scene object whose edge defines the axis
+     * @param options - Transform options (offset, flip, etc.)
+     */
+    (source: ISceneObject, options: AxisTransformOptions): IAxis;
+    /**
+     * Transforms an existing axis with options.
+     * @param axis - The existing axis to transform
+     * @param options - Transform options (offset, flip, etc.)
+     */
+    (axis: IAxis, options: AxisTransformOptions): IAxis;
+    /**
+     * Creates an axis midway between two axes.
+     * @param a1 - The first axis
+     * @param a2 - The second axis
+     * @param options - Transform options (offset, flip, etc.)
+     */
+    (a1: AxisLike | IAxis, a2: AxisLike | IAxis, options?: AxisTransformOptions): IAxis;
+}
+declare const _default: AxisFunction;
+export default _default;

package/lib/dist/core/axis.js

@@ -0,0 +1,104 @@
+import { registerBuilder } from "../index.js";
+import { isAxisLike } from "../math/axis.js";
+import { AxisObject } from "../features/axis.js";
+import { normalizeAxis } from "../helpers/normalize.js";
+import { AxisFromEdge } from "../features/axis-from-edge.js";
+import { AxisObjectBase } from "../features/axis-renderable-base.js";
+import { AxisMiddle } from "../features/axis-mid.js";
+import { SceneObject } from "../common/scene-object.js";
+function build(context) {
+    return function axis() {
+        if (arguments.length === 1) {
+            if (arguments[0] instanceof SceneObject) {
+                context.addSceneObject(arguments[0]);
+                const a = new AxisFromEdge(arguments[0]);
+                context.addSceneObject(a);
+                return a;
+            }
+            else {
+                const axis = normalizeAxis(arguments[0]);
+                const a = new AxisObject(axis);
+                context.addSceneObject(a);
+                return a;
+            }
+        }
+        if (arguments.length === 2) {
+            if ((arguments[0] instanceof AxisObjectBase || isAxisLike(arguments[0])) &&
+                (arguments[1] instanceof AxisObjectBase || isAxisLike(arguments[1]))) {
+                // axis between two others
+                let a1;
+                let a2;
+                if (arguments[0] instanceof AxisObjectBase) {
+                    a1 = arguments[0];
+                }
+                else {
+                    const axis = normalizeAxis(arguments[0]);
+                    a1 = new AxisObject(axis);
+                }
+                if (arguments[1] instanceof AxisObjectBase) {
+                    a2 = arguments[1];
+                }
+                else {
+                    const axis = normalizeAxis(arguments[1]);
+                    a2 = new AxisObject(axis);
+                }
+                context.addSceneObject(a1);
+                context.addSceneObject(a2);
+                const a = new AxisMiddle(a1, a2);
+                context.addSceneObject(a);
+                return a;
+            }
+            if ((arguments[0] instanceof AxisObjectBase) && typeof arguments[1] === 'object') {
+                const axis = arguments[0];
+                const options = arguments[1];
+                context.addSceneObject(axis);
+                const a = new AxisFromEdge(axis, options);
+                context.addSceneObject(a);
+                return a;
+            }
+            if (arguments[0] instanceof SceneObject) {
+                context.addSceneObject(arguments[0]);
+                const a = new AxisFromEdge(arguments[0], arguments[1]);
+                context.addSceneObject(a);
+                return a;
+            }
+            if (isAxisLike(arguments[0])) {
+                const axis1 = normalizeAxis(arguments[0]);
+                const options = arguments[1];
+                const a = new AxisObject(axis1, options);
+                context.addSceneObject(a);
+                return a;
+            }
+        }
+        if (arguments.length === 3) {
+            if ((arguments[0] instanceof AxisObjectBase || isAxisLike((arguments[0]))) &&
+                (arguments[1] instanceof AxisObjectBase || isAxisLike((arguments[1])))) {
+                // axis between two others with options
+                let a1;
+                let a2;
+                if (arguments[0] instanceof AxisObjectBase) {
+                    a1 = arguments[0];
+                }
+                else {
+                    const axis = normalizeAxis(arguments[0]);
+                    a1 = new AxisObject(axis);
+                }
+                if (arguments[1] instanceof AxisObjectBase) {
+                    a2 = arguments[1];
+                }
+                else {
+                    const axis = normalizeAxis(arguments[1]);
+                    a2 = new AxisObject(axis);
+                }
+                const options = arguments[2];
+                context.addSceneObject(a1);
+                context.addSceneObject(a2);
+                const a = new AxisMiddle(a1, a2, options);
+                context.addSceneObject(a);
+                return a;
+            }
+        }
+        throw new Error("Invalid arguments for axis function");
+    };
+}
+export default registerBuilder(build);

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

@@ -0,0 +1,31 @@
+import { ISceneObject } from "./interfaces.js";
+interface ChamferFunction {
+    /**
+     * Chamfers selected edges with the given distance.
+     * @param distance - The chamfer distance (defaults to 1)
+     */
+    (distance?: number): ISceneObject;
+    /**
+     * Chamfers the given edge selection with the given distance.
+     * @param distance - The chamfer distance
+     * @param selection - The edge selection to chamfer
+     */
+    (distance: number, selection: ISceneObject): ISceneObject;
+    /**
+     * Chamfers selected edges with two distances or a distance and angle.
+     * @param distance - The first chamfer distance
+     * @param distance2 - The second distance, or angle if `isAngle` is true
+     * @param isAngle - Whether `distance2` is an angle
+     */
+    (distance: number, distance2: number, isAngle?: boolean): ISceneObject;
+    /**
+     * Chamfers the given edge selection with two distances or a distance and angle.
+     * @param distance - The first chamfer distance
+     * @param distance2 - The second distance, or angle if `isAngle` is true
+     * @param isAngle - Whether `distance2` is an angle
+     * @param selection - The edge selection to chamfer
+     */
+    (distance: number, distance2: number, isAngle: boolean, selection: ISceneObject): ISceneObject;
+}
+declare const _default: ChamferFunction;
+export default _default;

package/lib/dist/core/chamfer.js

@@ -0,0 +1,32 @@
+import { Chamfer } from "../features/chamfer.js";
+import { SceneObject } from "../common/scene-object.js";
+import { registerBuilder } from "../index.js";
+function build(context) {
+    return function chamfer() {
+        const args = Array.from(arguments);
+        let selection;
+        if (args.length > 0 && args[args.length - 1] instanceof SceneObject) {
+            selection = args.pop();
+        }
+        else {
+            selection = context.getLastSelection() || undefined;
+        }
+        context.addSceneObject(selection); // Ensure lazy selections are added to the scene
+        let distance = 1;
+        let distance2 = undefined;
+        let isAngle = false;
+        if (args.length >= 1 && typeof args[0] === 'number') {
+            distance = args[0];
+        }
+        if (args.length >= 2 && typeof args[1] === 'number') {
+            distance2 = args[1];
+        }
+        if (args.length >= 3 && typeof args[2] === 'boolean') {
+            isAngle = args[2];
+        }
+        const chamfer = new Chamfer(distance, distance2, isAngle, selection);
+        context.addSceneObject(chamfer);
+        return chamfer;
+    };
+}
+export default registerBuilder(build);

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

@@ -0,0 +1,16 @@
+import { ISceneObject } from "./interfaces.js";
+interface ColorFunction {
+    /**
+     * Applies a color to the last selection.
+     * @param color - The color value (CSS color string)
+     */
+    (color: string): ISceneObject;
+    /**
+     * Applies a color to the given selection.
+     * @param color - The color value (CSS color string)
+     * @param selection - The face or edge selection to color
+     */
+    (color: string, selection: ISceneObject): ISceneObject;
+}
+declare const _default: ColorFunction;
+export default _default;

package/lib/dist/core/color.js

@@ -0,0 +1,19 @@
+import { registerBuilder } from "../index.js";
+import { SceneObject } from "../common/scene-object.js";
+import { Color } from "../features/color.js";
+function build(context) {
+    return function color() {
+        let selection;
+        if (arguments.length >= 2 && arguments[1] instanceof SceneObject) {
+            selection = arguments[1];
+        }
+        else {
+            selection = context.getLastSelection() || undefined;
+        }
+        context.addSceneObject(selection);
+        const obj = new Color(arguments[0], selection);
+        context.addSceneObject(obj);
+        return obj;
+    };
+}
+export default registerBuilder(build);

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

@@ -0,0 +1,12 @@
+import { ICommon, ISceneObject } from "./interfaces.js";
+interface CommonFunction {
+    /** Computes the common (intersection) of all shapes or 2D geometries in the current context. */
+    (): ICommon;
+    /**
+     * Computes the common (intersection) of the given shapes or 2D geometries.
+     * @param objects - The objects to intersect
+     */
+    (...objects: ISceneObject[]): ICommon;
+}
+declare const _default: CommonFunction;
+export default _default;

package/lib/dist/core/common.js

@@ -0,0 +1,36 @@
+import { registerBuilder } from "../index.js";
+import { Common } from "../features/common.js";
+import { Common2D } from "../features/common2d.js";
+function build(context) {
+    return function common(...args) {
+        const activeSketch = context.getActiveSketch();
+        if (activeSketch) {
+            let objects;
+            if (args.length > 0) {
+                if (args.length === 1 && Array.isArray(args[0])) {
+                    objects = args[0];
+                }
+                else {
+                    objects = args;
+                }
+            }
+            else {
+                objects = [];
+            }
+            const common2d = new Common2D(...objects);
+            context.addSceneObject(common2d);
+            return common2d;
+        }
+        let solids;
+        if (args.length === 1 && Array.isArray(args[0])) {
+            solids = args[0];
+        }
+        else {
+            solids = args;
+        }
+        const common = new Common(...solids);
+        context.addSceneObject(common);
+        return common;
+    };
+}
+export default registerBuilder(build);

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

@@ -0,0 +1,58 @@
+import { AxisLike } from "../math/axis.js";
+import { Point2DLike } from "../math/point.js";
+import { LinearCopyOptions } from "../features/copy-linear.js";
+import { CircularCopyOptions } from "../features/copy-circular.js";
+import { ISceneObject } from "./interfaces.js";
+export type CopyType = 'linear' | 'circular';
+interface CopyFunction {
+    /**
+     * [2D] Creates linear copies along an axis inside a sketch.
+     * @param type - Must be `'linear'`
+     * @param axis - The axis to copy along
+     * @param options - Copy count, spacing, etc.
+     * @param objects - The objects to copy (defaults to last object)
+     */
+    (type: 'linear', axis: AxisLike, options: LinearCopyOptions, ...objects: ISceneObject[]): ISceneObject;
+    /**
+     * [2D] Creates linear copies along multiple axes inside a sketch.
+     * @param type - Must be `'linear'`
+     * @param axis - The axes to copy along
+     * @param options - Copy count, spacing, etc.
+     * @param objects - The objects to copy (defaults to last object)
+     */
+    (type: 'linear', axis: AxisLike[], options: LinearCopyOptions, ...objects: ISceneObject[]): ISceneObject;
+    /**
+     * [3D] Creates linear copies along an axis.
+     * @param type - Must be `'linear'`
+     * @param axis - The axis to copy along
+     * @param options - Copy count, spacing, etc.
+     * @param objects - The objects to copy (defaults to last object)
+     */
+    (type: 'linear', axis: AxisLike, options: LinearCopyOptions, ...objects: ISceneObject[]): ISceneObject;
+    /**
+     * [3D] Creates linear copies along multiple axes.
+     * @param type - Must be `'linear'`
+     * @param axis - The axes to copy along
+     * @param options - Copy count, spacing, etc.
+     * @param objects - The objects to copy (defaults to last object)
+     */
+    (type: 'linear', axis: AxisLike[], options: LinearCopyOptions, ...objects: ISceneObject[]): ISceneObject;
+    /**
+     * [2D] Creates circular copies around a center point inside a sketch.
+     * @param type - Must be `'circular'`
+     * @param center - The center point to copy around
+     * @param options - Copy count, angle, etc.
+     * @param objects - The objects to copy (defaults to last object)
+     */
+    (type: 'circular', center: Point2DLike, options: CircularCopyOptions, ...objects: ISceneObject[]): ISceneObject;
+    /**
+     * [3D] Creates circular copies around an axis.
+     * @param type - Must be `'circular'`
+     * @param axis - The axis to copy around
+     * @param options - Copy count, angle, etc.
+     * @param objects - The objects to copy (defaults to last object)
+     */
+    (type: 'circular', axis: AxisLike, options: CircularCopyOptions, ...objects: ISceneObject[]): ISceneObject;
+}
+declare const _default: CopyFunction;
+export default _default;

package/lib/dist/core/copy.js

@@ -0,0 +1,49 @@
+import { registerBuilder } from "../index.js";
+import { normalizeAxis, normalizePoint2D } from "../helpers/normalize.js";
+import { CopyLinear } from "../features/copy-linear.js";
+import { CopyCircular } from "../features/copy-circular.js";
+import { CopyLinear2D } from "../features/copy-linear2d.js";
+import { CopyCircular2D } from "../features/copy-circular2d.js";
+function build(context) {
+    return function copy() {
+        const args = Array.from(arguments);
+        if (args.length < 3) {
+            throw new Error("Invalid arguments for copy function: expected at least (type, axis, options)");
+        }
+        const type = args[0];
+        const activeSketch = context.getActiveSketch();
+        const options = args[2];
+        const restObjects = args.slice(3);
+        const objects = restObjects.length > 0
+            ? restObjects
+            : [context.getSceneObjects().at(-1)];
+        if (type === 'linear') {
+            const axisArg = args[1];
+            const axes = Array.isArray(axisArg)
+                ? axisArg.map(a => normalizeAxis(a))
+                : [normalizeAxis(axisArg)];
+            if (activeSketch) {
+                const copy = new CopyLinear2D(axes, options, restObjects.length > 0 ? restObjects : null);
+                context.addSceneObject(copy);
+                return copy;
+            }
+            const copy = new CopyLinear(axes, options, objects);
+            context.addSceneObject(copy);
+            return copy;
+        }
+        if (type === 'circular') {
+            if (activeSketch) {
+                const center = normalizePoint2D(args[1]);
+                const copy = new CopyCircular2D(center, options, restObjects.length > 0 ? restObjects : null);
+                context.addSceneObject(copy);
+                return copy;
+            }
+            const axis = normalizeAxis(args[1]);
+            const copy = new CopyCircular(axis, options, objects);
+            context.addSceneObject(copy);
+            return copy;
+        }
+        throw new Error(`Invalid copy type: ${type}`);
+    };
+}
+export default registerBuilder(build);

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

@@ -0,0 +1,46 @@
+import { ICut, ISceneObject } from "./interfaces.js";
+interface CutFunction {
+    /**
+     * Cuts through all using the last sketch
+     * @param target - The sketch to cut with
+     */
+    (): ICut;
+    /**
+     * Cuts using the given sketch with a default distance.
+     * @param target - The sketch to cut with
+     */
+    (target: ISceneObject): ICut;
+    /**
+     * Cuts using the given sketch by a given distance.
+     * @param distance - The cut depth
+     * @param target - The sketch to cut with
+     */
+    (distance: number, target?: ISceneObject): ICut;
+    /**
+     * Cuts by two distances using the last sketch.
+     * @param distance1 - The first cut distance
+     * @param distance2 - The second cut distance
+     */
+    (distance1: number, distance2: number): ICut;
+    /**
+     * Cuts by two distances using the given sketch.
+     * @param distance1 - The first cut distance
+     * @param distance2 - The second cut distance
+     * @param target - The sketch to cut with
+     */
+    (distance1: number, distance2: number, target: ISceneObject): ICut;
+    /**
+     * Cuts up to face using the last sketch.
+     * @param face - The face to cut up to, or `'first-face'`/`'last-face'`
+     * @param target - The sketch to cut with
+     */
+    (face: ISceneObject | 'first-face' | 'last-face'): ICut;
+    /**
+     * Cuts up to face using the given sketch.
+     * @param face - The face to cut up to, or `'first-face'`/`'last-face'`
+     * @param target - The sketch to cut with
+     */
+    (face: ISceneObject | 'first-face' | 'last-face', target: ISceneObject): ICut;
+}
+declare const _default: CutFunction;
+export default _default;

package/lib/dist/core/cut.js

@@ -0,0 +1,53 @@
+import { SceneObject } from "../common/scene-object.js";
+import { registerBuilder } from "../index.js";
+import { Extrude } from "../features/extrude.js";
+import { ExtrudeToFace } from "../features/extrude-to-face.js";
+import { ExtrudeTwoDistances } from "../features/extrude-two-distances.js";
+function isExtrudable(obj) {
+    return obj instanceof SceneObject && obj.isExtrudable();
+}
+function build(context) {
+    function doCut(params, extrudable) {
+        if (params.length === 0) {
+            return new Extrude(0, extrudable).remove();
+        }
+        else if (params.length === 1) {
+            if (typeof params[0] === 'number') {
+                return new Extrude(params[0], extrudable).remove();
+            }
+            else if (params[0] === 'first-face') {
+                return new ExtrudeToFace('first-face', extrudable).remove();
+            }
+            else if (params[0] === 'last-face') {
+                return new ExtrudeToFace('last-face', extrudable).remove();
+            }
+            else if (params[0] instanceof SceneObject) {
+                context.addSceneObject(params[0]);
+                return new ExtrudeToFace(params[0], extrudable).remove();
+            }
+            else {
+                throw new Error("Invalid parameter for cut function.");
+            }
+        }
+        else if (params.length === 2) {
+            if (typeof params[0] === 'number' && typeof params[1] === 'number') {
+                return new ExtrudeTwoDistances(params[0], params[1], extrudable).remove();
+            }
+        }
+        throw new Error("Invalid parameters for cut function.");
+    }
+    return function cut() {
+        const args = [...arguments];
+        let extrudable;
+        if (args.length > 0 && isExtrudable(args[args.length - 1])) {
+            extrudable = args.pop();
+        }
+        else {
+            extrudable = context.getLastExtrudable() || undefined;
+        }
+        const result = doCut(args, extrudable);
+        context.addSceneObject(result);
+        return result;
+    };
+}
+export default registerBuilder(build);

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

@@ -0,0 +1,11 @@
+import { ISceneObject } from "./interfaces.js";
+interface CylinderFunction {
+    /**
+     * Creates a cylinder with the given radius and height.
+     * @param radius - The cylinder radius
+     * @param height - The cylinder height
+     */
+    (radius: number, height: number): ISceneObject;
+}
+declare const _default: CylinderFunction;
+export default _default;

package/lib/dist/core/cylinder.js

@@ -0,0 +1,10 @@
+import { Cylinder } from "../features/cylinder.js";
+import { registerBuilder } from "../index.js";
+function build(context) {
+    return function cylinder(radius, height) {
+        const cylinder = new Cylinder(radius, height);
+        context.addSceneObject(cylinder);
+        return cylinder;
+    };
+}
+export default registerBuilder(build);

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

@@ -0,0 +1,36 @@
+import { IExtrude, ISceneObject } from "./interfaces.js";
+interface ExtrudeFunction {
+    /**
+     * Extrudes the last sketch with a default distance.
+     * @param target - The sketch to extrude
+     */
+    (target?: ISceneObject): IExtrude;
+    /**
+     * Extrudes the last sketch by a given distance.
+     * @param distance - The extrusion distance
+     * @param target - The sketch to extrude
+     */
+    (distance: number, target?: ISceneObject): IExtrude;
+    /**
+     * Extrudes the last sketch between two distances.
+     * @param distance1 - The first extrusion distance
+     * @param distance2 - The second extrusion distance
+     * @param target - The sketch to extrude
+     */
+    (distance1: number, distance2: number): IExtrude;
+    /**
+     * Extrudes the given sketch between two distances.
+     * @param distance1 - The first extrusion distance
+     * @param distance2 - The second extrusion distance
+     * @param target - The sketch to extrude
+     */
+    (distance1: number, distance2: number, target: ISceneObject): IExtrude;
+    /**
+     * Extrudes the last sketch up to a face.
+     * @param face - The face to extrude up to, or `'first-face'`/`'last-face'`
+     * @param target - The sketch to extrude
+     */
+    (face: ISceneObject | 'first-face' | 'last-face', target?: ISceneObject): IExtrude;
+}
+declare const _default: ExtrudeFunction;
+export default _default;