fluidcad 0.0.2

package/lib/dist/core/revolve.js

@@ -0,0 +1,39 @@
+import { registerBuilder } from "../index.js";
+import { Revolve } from "../features/revolve.js";
+import { resolveAxis } from "../helpers/resolve.js";
+import { SceneObject } from "../common/scene-object.js";
+function isExtrudable(obj) {
+    return obj instanceof SceneObject && obj.isExtrudable();
+}
+function build(context) {
+    function doRevolve(params, extrudable) {
+        const defaultAngle = 360;
+        // (axis)
+        if (params.length === 1) {
+            const axis = resolveAxis(params[0], context);
+            return new Revolve(axis, defaultAngle, extrudable);
+        }
+        // (axis, angle)
+        if (params.length === 2) {
+            const axis = resolveAxis(params[0], context);
+            if (typeof params[1] === 'number') {
+                return new Revolve(axis, params[1], extrudable);
+            }
+        }
+        throw new Error("Invalid parameters for revolve function.");
+    }
+    return function revolve() {
+        const args = [...arguments];
+        let extrudable;
+        if (args.length > 0 && isExtrudable(args[args.length - 1])) {
+            extrudable = args.pop();
+        }
+        else {
+            extrudable = context.getLastExtrudable() || undefined;
+        }
+        const result = doRevolve(args, extrudable);
+        context.addSceneObject(result);
+        return result;
+    };
+}
+export default registerBuilder(build);

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

@@ -0,0 +1,34 @@
+import { AxisLike } from "../math/axis.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[]): 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[]): 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[]): ISceneObject;
+    /**
+     * [3D] Rotates objects around an axis by an angle, optionally making a copy.
+     * @param axis - The axis to rotate around
+     * @param angle - The rotation angle in degrees
+     * @param copy - Whether to copy instead of move
+     * @param targets - The objects to rotate (defaults to last object)
+     */
+    (axis: AxisLike, angle: number, copy: boolean, ...targets: ISceneObject[]): ISceneObject;
+}
+declare const _default: RotateFunction;
+export default _default;

package/lib/dist/core/rotate.js

@@ -0,0 +1,48 @@
+import { registerBuilder } from "../index.js";
+import { normalizeAxis } from "../helpers/normalize.js";
+import { Rotate } from "../features/rotate.js";
+import { SceneObject } from "../common/scene-object.js";
+import { AxisObjectBase } from "../features/axis-renderable-base.js";
+import { AxisObject } from "../features/axis.js";
+import { Rotate2D } from "../features/rotate2d.js";
+function build(context) {
+    return function rotate() {
+        const args = Array.from(arguments);
+        const activeSketch = context.getActiveSketch();
+        // Extract SceneObject targets from the end
+        const targets = [];
+        while (args.length > 0 && args[args.length - 1] instanceof SceneObject) {
+            targets.unshift(args.pop());
+        }
+        // Extract copy flag from the end (if boolean)
+        const copy = typeof args[args.length - 1] === 'boolean' ? args.pop() : false;
+        // 2D: rotate(angle, copy?, ...targets)
+        if (args.length === 1 && activeSketch) {
+            const angle = args[0];
+            const rotate = new Rotate2D(angle, copy, ...targets);
+            context.addSceneObject(rotate);
+            return rotate;
+        }
+        if (activeSketch && args.length !== 2) {
+            throw new Error("Cannot specify an axis for rotate inside a sketch. Use rotate(angle) instead.");
+        }
+        // 3D: rotate(axis, angle, copy?, ...targets)
+        if (args.length === 2) {
+            let axis = null;
+            if (args[0] instanceof AxisObjectBase) {
+                axis = args[0];
+            }
+            else {
+                const a = normalizeAxis(args[0]);
+                axis = new AxisObject(a);
+                context.addSceneObject(axis);
+            }
+            const angle = args[1];
+            const rotate = new Rotate(axis, angle, copy, ...targets);
+            context.addSceneObject(rotate);
+            return rotate;
+        }
+        throw new Error("Invalid arguments for rotate function");
+    };
+}
+export default registerBuilder(build);

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

@@ -0,0 +1,12 @@
+import { Shape } from "../common/shapes.js";
+import { FilterBuilderBase } from "../filters/filter-builder-base.js";
+import { ISelect } from "./interfaces.js";
+interface SelectFunction {
+    /**
+     * Selects faces or edges matching the given filters.
+     * @param filters - One or more filter builders to match against
+     */
+    (...filters: FilterBuilderBase<Shape>[]): ISelect;
+}
+declare const _default: SelectFunction;
+export default _default;

package/lib/dist/core/select.js

@@ -0,0 +1,21 @@
+import { registerBuilder } from "../index.js";
+import { SelectSceneObject } from "../features/select.js";
+function build(context) {
+    return function select() {
+        const params = Array.from(arguments);
+        let selectObject;
+        if (params.length === 0) {
+            throw new Error("At least one argument is required for select function");
+        }
+        else if (params.length >= 1) {
+            const actualFilters = params;
+            selectObject = new SelectSceneObject(actualFilters);
+        }
+        if (!selectObject) {
+            throw new Error("Invalid arguments for select function");
+        }
+        context.addSceneObject(selectObject);
+        return selectObject;
+    };
+}
+export default registerBuilder(build);

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

@@ -0,0 +1,16 @@
+import { ISceneObject, IShell } from "./interfaces.js";
+interface ShellFunction {
+    /**
+     * Hollows out a solid with the given wall thickness.
+     * @param thickness - The wall thickness (defaults to 2.5)
+     */
+    (thickness?: number): IShell;
+    /**
+     * Hollows out a solid, removing the selected faces.
+     * @param thickness - The wall thickness
+     * @param selections - The face selections to remove
+     */
+    (thickness: number, ...selections: ISceneObject[]): IShell;
+}
+declare const _default: ShellFunction;
+export default _default;

package/lib/dist/core/shell.js

@@ -0,0 +1,28 @@
+import { Shell } from "../features/shell.js";
+import { SceneObject } from "../common/scene-object.js";
+import { registerBuilder } from "../index.js";
+function build(context) {
+    return function shell() {
+        const args = Array.from(arguments);
+        const selections = [];
+        while (args.length > 0 && args[args.length - 1] instanceof SceneObject) {
+            selections.unshift(args.pop());
+        }
+        if (selections.length === 0) {
+            const implicit = context.getLastSelection() || undefined;
+            if (implicit) {
+                selections.push(implicit);
+            }
+        }
+        const thickness = (args.length >= 1 && typeof args[0] === 'number')
+            ? args[0]
+            : 2.5;
+        for (const sel of selections) {
+            context.addSceneObject(sel);
+        }
+        const shell = new Shell(thickness, selections.length > 0 ? selections : undefined);
+        context.addSceneObject(shell);
+        return shell;
+    };
+}
+export default registerBuilder(build);

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

@@ -0,0 +1,18 @@
+import { PlaneLike } from "../math/plane.js";
+import { IPlane, ISceneObject } from "./interfaces.js";
+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;
+    /**
+     * Draws 2D geometry on a face or plane object.
+     * @param face - The face or plane object to sketch on
+     * @param sketcher - Callback containing sketch operations
+     */
+    (face: ISceneObject | IPlane, sketcher: () => void): ISceneObject;
+}
+declare const _default: SketchFunction;
+export default _default;

package/lib/dist/core/sketch.js

@@ -0,0 +1,34 @@
+import { registerBuilder } from "../index.js";
+import { normalizePlane } from "../helpers/normalize.js";
+import { PlaneObject } from "../features/plane.js";
+import { isPlaneLike } from "../math/plane.js";
+import { PlaneObjectBase } from "../features/plane-renderable-base.js";
+import { Sketch } from "../features/2d/sketch.js";
+import { SceneObject } from "../common/scene-object.js";
+import { PlaneFromObject } from "../features/plane-from-object.js";
+function build(context) {
+    return function sketch(p, sketcher) {
+        let planeObj;
+        if (p instanceof PlaneObjectBase) {
+            planeObj = p;
+        }
+        else if (isPlaneLike(p)) {
+            planeObj = new PlaneObject(normalizePlane(p));
+            context.addSceneObject(planeObj);
+        }
+        else if (p instanceof SceneObject) {
+            context.addSceneObject(p);
+            planeObj = new PlaneFromObject(p);
+            context.addSceneObject(planeObj);
+        }
+        else {
+            throw new Error('Invalid argument for sketch: expected a plane or a scene object');
+        }
+        const sketch = new Sketch(planeObj);
+        context.startProgressiveContainer(sketch);
+        sketcher();
+        context.endProgressiveContainer();
+        return sketch;
+    };
+}
+export default registerBuilder(build);

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

@@ -0,0 +1,16 @@
+import { ISceneObject } from "./interfaces.js";
+interface SphereFunction {
+    /**
+     * Creates a full sphere with the given radius.
+     * @param radius - The sphere radius
+     */
+    (radius: number): ISceneObject;
+    /**
+     * Creates a partial sphere with the given radius and sweep angle.
+     * @param radius - The sphere radius
+     * @param angle - The sweep angle in degrees
+     */
+    (radius: number, angle: number): ISceneObject;
+}
+declare const _default: SphereFunction;
+export default _default;

package/lib/dist/core/sphere.js

@@ -0,0 +1,11 @@
+import { Sphere } from "../features/sphere.js";
+import { rad } from "../helpers/math-helpers.js";
+import { registerBuilder } from "../index.js";
+function build(context) {
+    return function sphere(radius, angle = 360) {
+        const sphere = new Sphere(radius, rad(angle));
+        context.addSceneObject(sphere);
+        return sphere;
+    };
+}
+export default registerBuilder(build);

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

@@ -0,0 +1,12 @@
+import { ISceneObject } from "./interfaces.js";
+interface SplitFunction {
+    /** Splits all intersecting sketch geometries at their crossing points. */
+    (): ISceneObject;
+    /**
+     * Splits the given sketch geometries at their crossing points.
+     * @param objects - The geometries to split
+     */
+    (...objects: ISceneObject[]): ISceneObject;
+}
+declare const _default: SplitFunction;
+export default _default;

package/lib/dist/core/split.js

@@ -0,0 +1,26 @@
+import { registerBuilder } from "../index.js";
+import { Split2D } from "../features/split2d.js";
+function build(context) {
+    return function split(...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 split2d = new Split2D(...objects);
+            context.addSceneObject(split2d);
+            return split2d;
+        }
+        throw new Error("Split can only be used within a sketch");
+    };
+}
+export default registerBuilder(build);

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

@@ -0,0 +1,11 @@
+import { ISceneObject } from "./interfaces.js";
+interface SubtractFunction {
+    /**
+     * Subtracts the second solid from the first (boolean difference).
+     * @param solid1 - The base solid
+     * @param solid2 - The solid to subtract
+     */
+    (solid1: ISceneObject, solid2: ISceneObject): ISceneObject;
+}
+declare const _default: SubtractFunction;
+export default _default;

package/lib/dist/core/subtract.js

@@ -0,0 +1,10 @@
+import { registerBuilder } from "../index.js";
+import { Subtract } from "../features/subtract.js";
+function build(context) {
+    return function subtract(solid1, solid2) {
+        const subtract = new Subtract(solid1, solid2);
+        context.addSceneObject(subtract);
+        return subtract;
+    };
+}
+export default registerBuilder(build);

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

@@ -0,0 +1,16 @@
+import { ISweep, ISceneObject } from "./interfaces.js";
+interface SweepFunction {
+    /**
+     * Sweeps the last sketch along a path.
+     * @param path - The path to sweep along (edges/wire)
+     */
+    (path: ISceneObject): ISweep;
+    /**
+     * Sweeps the given sketch along a path.
+     * @param path - The path to sweep along (edges/wire)
+     * @param target - The sketch to sweep
+     */
+    (path: ISceneObject, target?: ISceneObject): ISweep;
+}
+declare const _default: SweepFunction;
+export default _default;

package/lib/dist/core/sweep.js

@@ -0,0 +1,29 @@
+import { SceneObject } from "../common/scene-object.js";
+import { registerBuilder } from "../index.js";
+import { Sweep } from "../features/sweep.js";
+function isExtrudable(obj) {
+    return obj instanceof SceneObject && obj.isExtrudable();
+}
+function build(context) {
+    //@ts-ignore
+    return function sweep() {
+        const args = [...arguments];
+        if (args.length === 0) {
+            throw new Error("sweep() requires at least a path argument.");
+        }
+        // Last argument may be the target extrudable
+        let extrudable;
+        if (args.length > 1 && isExtrudable(args[args.length - 1])) {
+            extrudable = args.pop();
+        }
+        else {
+            extrudable = context.getLastExtrudable() || undefined;
+        }
+        const path = args[0];
+        context.addSceneObject(path);
+        const result = new Sweep(path, extrudable);
+        context.addSceneObject(result);
+        return result;
+    };
+}
+export default registerBuilder(build);

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

@@ -0,0 +1,64 @@
+import { PointLike } from "../math/point.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[]): 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[]): 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[]): ISceneObject;
+    /**
+     * Translates objects along the X and Y axes, optionally making a copy.
+     * @param x - The X distance
+     * @param y - The Y distance
+     * @param copy - Whether to copy instead of move
+     * @param targets - The objects to translate (defaults to last object)
+     */
+    (x: number, y: number, copy: boolean, ...targets: ISceneObject[]): ISceneObject;
+    /**
+     * Translates objects along all three axes.
+     * @param x - The X distance
+     * @param y - The Y distance
+     * @param z - The Z distance
+     * @param targets - The objects to translate (defaults to last object)
+     */
+    (x: number, y: number, z: number, ...targets: ISceneObject[]): ISceneObject;
+    /**
+     * Translates objects along all three axes, optionally making a copy.
+     * @param x - The X distance
+     * @param y - The Y distance
+     * @param z - The Z distance
+     * @param copy - Whether to copy instead of move
+     * @param targets - The objects to translate (defaults to last object)
+     */
+    (x: number, y: number, z: number, copy: boolean, ...targets: ISceneObject[]): ISceneObject;
+    /**
+     * Translates objects by a point-like offset.
+     * @param distance - The offset as a point
+     * @param targets - The objects to translate (defaults to last object)
+     */
+    (distance: PointLike, ...targets: ISceneObject[]): ISceneObject;
+    /**
+     * Translates objects by a point-like offset, optionally making a copy.
+     * @param distance - The offset as a point
+     * @param copy - Whether to copy instead of move
+     * @param targets - The objects to translate (defaults to last object)
+     */
+    (distance: PointLike, copy: boolean, ...targets: ISceneObject[]): ISceneObject;
+}
+declare const _default: TranslateFunction;
+export default _default;

package/lib/dist/core/translate.js

@@ -0,0 +1,39 @@
+import { registerBuilder } from "../index.js";
+import { normalizePoint } from "../helpers/normalize.js";
+import { Translate } from "../features/translate.js";
+import { Point } from "../math/point.js";
+import { SceneObject } from "../common/scene-object.js";
+import { Vertex } from "../common/vertex.js";
+import { LazyVertex } from "../features/lazy-vertex.js";
+function build(context) {
+    return function translate() {
+        const args = Array.from(arguments);
+        // Extract SceneObject targets from the end
+        const targets = [];
+        while (args.length > 0 && args[args.length - 1] instanceof SceneObject) {
+            targets.unshift(args.pop());
+        }
+        // Extract copy flag from the end (if boolean)
+        const copy = typeof args[args.length - 1] === 'boolean' ? args.pop() : false;
+        // translate(x, y?, z?)
+        if (typeof args[0] === 'number') {
+            const x = args[0];
+            const y = args[1] ?? 0;
+            const z = args[2] ?? 0;
+            const vertex = Vertex.fromPoint(new Point(x, y, z));
+            const lazyVertex = LazyVertex.fromVertex(vertex);
+            const translate = new Translate(lazyVertex, copy, ...targets);
+            context.addSceneObject(translate);
+            return translate;
+        }
+        // translate(distance: PointLike, copy?, ...targets)
+        if (args.length === 1) {
+            const normalizedDistance = normalizePoint(args[0]);
+            const translate = new Translate(normalizedDistance, copy, ...targets);
+            context.addSceneObject(translate);
+            return translate;
+        }
+        throw new Error("Invalid arguments for translate function");
+    };
+}
+export default registerBuilder(build);

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

@@ -0,0 +1,13 @@
+import { Point2DLike } from "../math/point.js";
+import { ISceneObject } from "./interfaces.js";
+interface TrimFunction {
+    /** Trims all sketch geometry segments. */
+    (): ISceneObject;
+    /**
+     * Trims sketch geometry segments at the given points.
+     * @param points - The points where geometry should be trimmed
+     */
+    (...points: Point2DLike[]): ISceneObject;
+}
+declare const _default: TrimFunction;
+export default _default;

package/lib/dist/core/trim.js

@@ -0,0 +1,18 @@
+import { normalizePoint2D } from "../helpers/normalize.js";
+import { registerBuilder } from "../index.js";
+import { Trim2D } from "../features/trim2d.js";
+function build(context) {
+    return function trim(...args) {
+        const activeSketch = context.getActiveSketch();
+        if (!activeSketch) {
+            throw new Error("Trim can only be used within a sketch");
+        }
+        const trim2d = new Trim2D();
+        if (args.length > 0) {
+            trim2d.points(...args.map(p => normalizePoint2D(p)));
+        }
+        context.addSceneObject(trim2d);
+        return trim2d;
+    };
+}
+export default registerBuilder(build);

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

@@ -0,0 +1,5 @@
+import { PartHandle } from "./part.js";
+import { ISceneObject } from "./interfaces.js";
+declare function use(handle: PartHandle): ISceneObject;
+declare function use<T>(handle: PartHandle<T>, options: T): ISceneObject;
+export default use;

package/lib/dist/core/use.js

@@ -0,0 +1,22 @@
+import { captureSourceLocation } from "../index.js";
+import { getCurrentScene } from "../scene-manager.js";
+import { Part } from "../features/part.js";
+function use(handle, options) {
+    if (!handle || !handle.__fluidcad_part) {
+        throw new Error("use() expects a PartHandle created by part()");
+    }
+    const scene = getCurrentScene();
+    if (!scene) {
+        throw new Error("use() must be called within a scene context");
+    }
+    const sourceLocation = captureSourceLocation();
+    const partObj = new Part(handle.name);
+    if (sourceLocation) {
+        partObj.setSourceLocation(sourceLocation);
+    }
+    scene.startProgressiveContainer(partObj);
+    handle._callback(options);
+    scene.endProgressiveContainer();
+    return partObj;
+}
+export default use;

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

@@ -0,0 +1,18 @@
+import { PlaneObjectBase } from "../plane-renderable-base.js";
+import { GeometrySceneObject } from "./geometry.js";
+export declare class AngledLine extends GeometrySceneObject {
+    length: number;
+    angle: number;
+    centered: boolean;
+    private targetPlane;
+    constructor(length: number, angle: number, centered?: boolean, targetPlane?: PlaneObjectBase);
+    build(): void;
+    compareTo(other: AngledLine): boolean;
+    getType(): string;
+    getUniqueType(): string;
+    serialize(): {
+        length: number;
+        angle: number;
+        centered: boolean;
+    };
+}