fluidcad 0.0.14 → 0.0.15

package/lib/dist/common/scene-object.d.ts

@@ -27,6 +27,7 @@ export declare abstract class SceneObject implements Comparable<SceneObject>, Se
     private _id;
     private _order;
     private _transform;
+    private _cloneSource;
     private _parent;
     private _alwaysVisible;
     private _name;
@@ -60,6 +61,8 @@ export declare abstract class SceneObject implements Comparable<SceneObject>, Se
     clone(): SceneObject[];
     setTransform(matrix: Matrix4): void;
     getTransform(): Matrix4 | null;
+    setCloneSource(source: SceneObject): void;
+    getCloneSource(): SceneObject | null;
     getTransformMatrix(): Matrix4 | null;
     isExtrudable(): boolean;
     init(): void;

package/lib/dist/common/scene-object.js

@@ -5,6 +5,7 @@ export class SceneObject {
     _id;
     _order = 0;
     _transform = null;
+    _cloneSource = null;
     _parent = null;
     _alwaysVisible = false;
     _name = null;
@@ -161,6 +162,12 @@ export class SceneObject {
     getTransform() {
         return this._transform;
     }
+    setCloneSource(source) {
+        this._cloneSource = source;
+    }
+    getCloneSource() {
+        return this._cloneSource;
+    }
     getTransformMatrix() {
         return null;
     }

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

@@ -1,84 +1,42 @@
 import { Point2DLike } from "../../math/point.js";
 import { PlaneLike } from "../../math/plane.js";
-import { IGeometry, ISceneObject } from "../interfaces.js";
+import { IArcPoints, IArcAngles, ISceneObject } from "../interfaces.js";
 interface ArcFunction {
     /**
-     * Draws an arc to an end point with an optional bulge radius.
+     * Draws an arc to an end point from the current position.
+     * Chain `.radius(r)` to set bulge radius, or `.center(point)` to specify the circle center.
      * @param endPoint - The end point of the arc
-     * @param radius - The bulge radius (0 = auto)
      */
-    (endPoint: Point2DLike, radius?: number): IGeometry;
+    (endPoint: Point2DLike): IArcPoints;
     /**
-     * Draws an arc from a start point to an end point with an optional bulge radius.
+     * Draws an arc from a start point to an end point.
+     * By default, uses the current position as the arc center.
+     * Chain `.radius(r)` to use bulge radius instead, or `.center(point)` to specify an explicit center.
      * @param startPoint - The start point of the arc
      * @param endPoint - The end point of the arc
-     * @param radius - The bulge radius (0 = auto)
      */
-    (startPoint: Point2DLike, endPoint: Point2DLike, radius?: number): IGeometry;
+    (startPoint: Point2DLike, endPoint: Point2DLike): IArcPoints;
     /**
-     * Draws an arc by radius and angle range.
+     * Draws an arc by radius and angle range at the current position.
+     * Chain `.centered()` to center the arc symmetrically around the start angle.
      * @param radius - The arc radius
      * @param startAngle - The start angle in degrees (defaults to 0)
      * @param endAngle - The end angle in degrees (defaults to 180)
-     * @param centered - Whether to center the arc on the current position
      */
-    (radius: number, startAngle?: number, endAngle?: number, centered?: boolean): IGeometry;
-    /**
-     * Draws an arc from a start point to an end point around a center point.
-     * @param startPoint - The start point of the arc
-     * @param endPoint - The end point of the arc
-     * @param center - The center point of the arc
-     */
-    (startPoint: Point2DLike, endPoint: Point2DLike, center: Point2DLike): IGeometry;
+    (radius: number, startAngle?: number, endAngle?: number): IArcAngles;
     /**
      * Draws an arc to an end point on a specific plane.
      * @param endPoint - The end point of the arc
      * @param targetPlane - The plane to draw on
      */
-    (endPoint: Point2DLike, targetPlane: PlaneLike | ISceneObject): IGeometry;
-    /**
-     * Draws an arc to an end point with a bulge radius on a specific plane.
-     * @param endPoint - The end point of the arc
-     * @param radius - The bulge radius
-     * @param targetPlane - The plane to draw on
-     */
-    (endPoint: Point2DLike, radius: number, targetPlane: PlaneLike | ISceneObject): IGeometry;
+    (endPoint: Point2DLike, targetPlane: PlaneLike | ISceneObject): IArcPoints;
     /**
      * Draws an arc between two points on a specific plane.
      * @param startPoint - The start point of the arc
      * @param endPoint - The end point of the arc
      * @param targetPlane - The plane to draw on
      */
-    (startPoint: Point2DLike, endPoint: Point2DLike, targetPlane: PlaneLike | ISceneObject): IGeometry;
-    /**
-     * Draws an arc between two points with a bulge radius on a specific plane.
-     * @param startPoint - The start point of the arc
-     * @param endPoint - The end point of the arc
-     * @param radius - The bulge radius
-     * @param targetPlane - The plane to draw on
-     */
-    (startPoint: Point2DLike, endPoint: Point2DLike, radius: number, targetPlane: PlaneLike | ISceneObject): IGeometry;
-    /**
-     * Draws an arc from a start point to an end point around a center point on a specific plane.
-     * @param startPoint - The start point of the arc
-     * @param endPoint - The end point of the arc
-     * @param center - The center point of the arc
-     * @param targetPlane - The plane to draw on
-     */
-    (startPoint: Point2DLike, endPoint: Point2DLike, center: Point2DLike, targetPlane: PlaneLike | ISceneObject): IGeometry;
-    /**
-     * Draws an arc by radius on a specific plane.
-     * @param radius - The arc radius
-     * @param targetPlane - The plane to draw on
-     */
-    (radius: number, targetPlane: PlaneLike | ISceneObject): IGeometry;
-    /**
-     * Draws an arc by radius and start angle on a specific plane.
-     * @param radius - The arc radius
-     * @param startAngle - The start angle in degrees
-     * @param targetPlane - The plane to draw on
-     */
-    (radius: number, startAngle: number, targetPlane: PlaneLike | ISceneObject): IGeometry;
+    (startPoint: Point2DLike, endPoint: Point2DLike, targetPlane: PlaneLike | ISceneObject): IArcPoints;
     /**
      * Draws an arc by radius and angle range on a specific plane.
      * @param radius - The arc radius
@@ -86,7 +44,7 @@ interface ArcFunction {
      * @param endAngle - The end angle in degrees
      * @param targetPlane - The plane to draw on
      */
-    (radius: number, startAngle: number, endAngle: number, targetPlane: PlaneLike | ISceneObject): IGeometry;
+    (radius: number, startAngle: number, endAngle: number, targetPlane: PlaneLike | ISceneObject): IArcAngles;
 }
 declare const _default: ArcFunction;
 export default _default;

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

@@ -1,8 +1,5 @@
 import { isPoint2DLike } from "../../math/point.js";
-import { ArcFromTwoAngles } from "../../features/2d/arc.js";
-import { ArcToPoint } from "../../features/2d/arc-to-point.js";
-import { ArcThreePoints } from "../../features/2d/arc-three-points.js";
-import { Move } from "../../features/2d/move.js";
+import { Arc } from "../../features/2d/arc.js";
 import { normalizePoint2D } from "../../helpers/normalize.js";
 import { registerBuilder } from "../../index.js";
 import { isPlaneLike } from "../../math/plane.js";
@@ -20,38 +17,26 @@ function build(context) {
                 argCount--;
             }
         }
-        // (startPoint, endPoint, center) — three Point2DLike args
-        if (argCount >= 3 && isPoint2DLike(arguments[0]) && isPoint2DLike(arguments[1]) && isPoint2DLike(arguments[2])) {
-            const start = normalizePoint2D(arguments[0]);
-            const end = normalizePoint2D(arguments[1]);
-            const center = normalizePoint2D(arguments[2]);
-            const arcObj = new ArcThreePoints(start, end, center, planeObj);
-            context.addSceneObjects([new Move(start), arcObj]);
-            return arcObj;
-        }
-        // (startPoint, endPoint, radius?) — two Point2DLike args
+        // (startPoint, endPoint) — two Point2DLike args, default center = current position
         if (argCount >= 2 && isPoint2DLike(arguments[0]) && isPoint2DLike(arguments[1])) {
             const start = normalizePoint2D(arguments[0]);
             const end = normalizePoint2D(arguments[1]);
-            const radius = argCount >= 3 ? arguments[2] : 0;
-            const arcObj = new ArcToPoint(end, radius, planeObj);
-            context.addSceneObjects([new Move(start), arcObj]);
+            const arcObj = Arc.twoPoints(start, end, planeObj);
+            context.addSceneObject(arcObj);
             return arcObj;
         }
-        // (endPoint, radius?) — single Point2DLike arg
+        // (endPoint) — single Point2DLike arg
         if (isPoint2DLike(arguments[0])) {
             const end = normalizePoint2D(arguments[0]);
-            const radius = argCount >= 2 ? arguments[1] : 0;
-            const arcObj = new ArcToPoint(end, radius, planeObj);
+            const arcObj = Arc.toPoint(end, planeObj);
             context.addSceneObject(arcObj);
             return arcObj;
         }
-        // (radius, startAngle, endAngle?, centered?) — all numeric args
+        // (radius, startAngle?, endAngle?) — all numeric args
         const radius = arguments[0] || 100;
         const startAngle = arguments[1] || 0;
         const endAngle = argCount >= 3 ? arguments[2] : 180;
-        const centered = argCount >= 4 ? arguments[3] : false;
-        const arcObj = new ArcFromTwoAngles(radius, startAngle, endAngle, centered, planeObj);
+        const arcObj = Arc.fromAngles(radius, startAngle, endAngle, planeObj);
         context.addSceneObject(arcObj);
         return arcObj;
     };

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

@@ -0,0 +1,9 @@
+import { IGeometry } from "../interfaces.js";
+interface CenterFunction {
+    /**
+     * Move the current position to the center of the sketch plane.
+     */
+    (): IGeometry;
+}
+declare const _default: CenterFunction;
+export default _default;

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

@@ -0,0 +1,10 @@
+import { PlaneCenter } from "../../features/2d/plane-center.js";
+import { registerBuilder } from "../../index.js";
+function build(context) {
+    return function center() {
+        const planeCenter = new PlaneCenter();
+        context.addSceneObject(planeCenter);
+        return planeCenter;
+    };
+}
+export default registerBuilder(build);

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

@@ -18,4 +18,6 @@ export { default as connect } from './connect.js';
 export { default as polygon } from './polygon.js';
 export { default as offset } from './offset.js';
 export { default as project } from './project.js';
+export { default as intersect } from './intersect.js';
 export { default as bezier } from './bezier.js';
+export { default as center } from './center.js';

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

@@ -18,4 +18,6 @@ export { default as connect } from './connect.js';
 export { default as polygon } from './polygon.js';
 export { default as offset } from './offset.js';
 export { default as project } from './project.js';
+export { default as intersect } from './intersect.js';
 export { default as bezier } from './bezier.js';
+export { default as center } from './center.js';

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

@@ -0,0 +1,17 @@
+import { PlaneLike } from "../../math/plane.js";
+import { IExtrudableGeometry, ISceneObject } from "../interfaces.js";
+interface IntersectFunction {
+    /**
+     * Intersects 3D objects with the current sketch plane, producing cross-section edges.
+     * @param sourceObjects - The 3D objects to intersect
+     */
+    (...sourceObjects: ISceneObject[]): IExtrudableGeometry;
+    /**
+     * Intersects 3D objects with a target plane, producing cross-section edges.
+     * @param sourceObjects - The 3D objects to intersect
+     * @param targetPlane - The plane to intersect with
+     */
+    (sourceObjects: ISceneObject[], targetPlane: PlaneLike | ISceneObject): IExtrudableGeometry;
+}
+declare const _default: IntersectFunction;
+export default _default;

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

@@ -0,0 +1,20 @@
+import { Intersect } from "../../features/2d/intersect.js";
+import { resolvePlane } from "../../helpers/resolve.js";
+import { registerBuilder } from "../../index.js";
+function build(context) {
+    return function intersect(...args) {
+        if (Array.isArray(args[0])) {
+            const sourceObjects = args[0];
+            context.addSceneObjects(sourceObjects);
+            const planeObj = resolvePlane(args[1], context);
+            const result = new Intersect(sourceObjects, planeObj);
+            context.addSceneObject(result);
+            return result;
+        }
+        const result = new Intersect(args);
+        context.addSceneObjects(args);
+        context.addSceneObject(result);
+        return result;
+    };
+}
+export default registerBuilder(build);

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

@@ -58,6 +58,26 @@ export interface IGeometry extends ISceneObject {
 }
 export interface IExtrudableGeometry extends IGeometry {
 }
+export interface IArcPoints extends IExtrudableGeometry {
+    /**
+     * Sets the bulge radius for point-to-point arcs.
+     * Positive = CCW, negative = CW.
+     * @param value - The bulge radius.
+     */
+    radius(value: number): this;
+    /**
+     * Specifies the circle center point for the arc.
+     * Mutually exclusive with `.radius()`.
+     * @param value - The center point of the arc's circle.
+     */
+    center(value: Point2DLike): this;
+}
+export interface IArcAngles extends IExtrudableGeometry {
+    /**
+     * Centers the arc symmetrically around the start angle.
+     */
+    centered(): this;
+}
 export interface IRect extends IExtrudableGeometry {
     /**
      * Sets corner radii for a rounded rectangle. Accepts 1–4 values
@@ -71,7 +91,7 @@ export interface IRect extends IExtrudableGeometry {
      * @param value - `true` centers on both axes, `'horizontal'` or `'vertical'` centers
      *   on one axis, `false` (default) keeps the current point as the origin corner.
      */
-    center(value?: boolean | 'horizontal' | 'vertical'): this;
+    centered(value?: boolean | 'horizontal' | 'vertical'): this;
     /**
      * Returns the top straight edge of the rectangle.
      */
@@ -127,7 +147,7 @@ export interface ISlot extends IExtrudableGeometry {
      * When `true`, the slot is offset backward by half its length.
      * @param value - `true` to center, `false` (default) to start from the current position.
      */
-    center(value?: boolean): this;
+    centered(value?: boolean): this;
     /**
      * Sets the rotation angle of the slot's primary axis.
      * @param angle - Rotation in degrees.
@@ -244,6 +264,20 @@ export interface IExtrude extends IFuseable {
      * @param points - 2D points in the sketch plane identifying regions to extrude.
      */
     pick(...points: Point2DLike[]): this;
+    /**
+     * Enables thin extrude mode — offsets the profile edges to create a thin-walled solid
+     * instead of extruding filled faces. Positive values offset outward, negative values offset inward.
+     * @param offset - The wall offset distance. Positive = outward, negative = inward.
+     */
+    thin(offset: number): this;
+    /**
+     * Enables thin extrude mode with two offset directions.
+     * The two offsets must go in opposite directions. If both have the same sign,
+     * the second offset is automatically flipped.
+     * @param offset1 - The first wall offset distance. Positive = outward, negative = inward.
+     * @param offset2 - The second wall offset distance, in the opposite direction of offset1.
+     */
+    thin(offset1: number, offset2: number): this;
 }
 export interface ICut extends ISceneObject {
     /**
@@ -290,6 +324,20 @@ export interface ICut extends ISceneObject {
      * @param points - 2D points in the sketch plane identifying regions to cut.
      */
     pick(...points: Point2DLike[]): this;
+    /**
+     * Enables thin cut mode — offsets the profile edges to cut a thin-walled shape
+     * instead of cutting filled faces. Positive values offset outward, negative values offset inward.
+     * @param offset - The wall offset distance. Positive = outward, negative = inward.
+     */
+    thin(offset: number): this;
+    /**
+     * Enables thin cut mode with two offset directions.
+     * The two offsets must go in opposite directions. If both have the same sign,
+     * the second offset is automatically flipped.
+     * @param offset1 - The first wall offset distance. Positive = outward, negative = inward.
+     * @param offset2 - The second wall offset distance, in the opposite direction of offset1.
+     */
+    thin(offset1: number, offset2: number): this;
 }
 export interface IRevolve extends IFuseable {
     /**

package/lib/dist/core/repeat.js

@@ -73,9 +73,16 @@ function build(context) {
                     indexCombinations.push(...newCombinations);
                 }
                 for (const indices of indexCombinations) {
-                    // Skip the origin instance (all zeros)
-                    if (indices.every(i => i === 0)) {
-                        continue;
+                    // Skip the origin instance
+                    if (options.centered) {
+                        if (indices.every((idx, a) => idx === Math.floor(axisOffsets[a].count / 2))) {
+                            continue;
+                        }
+                    }
+                    else {
+                        if (indices.every(i => i === 0)) {
+                            continue;
+                        }
                     }
                     // Skip if in the skip list
                     if (options.skip?.some(s => s.length === indices.length && s.every((v, i) => v === indices[i]))) {

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

@@ -1,19 +1,32 @@
+import { Point2DLike } from "../../math/point.js";
 import { PlaneObjectBase } from "../plane-renderable-base.js";
 import { GeometrySceneObject } from "./geometry.js";
-export declare class ArcFromTwoAngles extends GeometrySceneObject {
-    radius: number;
-    startAngle: number;
-    endAngle: number;
-    centered: boolean;
-    private targetPlane;
-    constructor(radius: number, startAngle: number, endAngle: number, centered?: boolean, targetPlane?: PlaneObjectBase);
+import { LazyVertex } from "../lazy-vertex.js";
+import { IArcPoints, IArcAngles } from "../../core/interfaces.js";
+export declare class Arc extends GeometrySceneObject implements IArcPoints, IArcAngles {
+    private _startPoint;
+    private _endPoint;
+    private _arcRadius;
+    private _startAngle;
+    private _endAngle;
+    private _bulgeRadius;
+    private _centerPoint;
+    private _centered;
+    private _targetPlane;
+    constructor(targetPlane?: PlaneObjectBase | null);
+    static toPoint(endPoint: LazyVertex, targetPlane?: PlaneObjectBase | null): Arc;
+    static twoPoints(startPoint: LazyVertex, endPoint: LazyVertex, targetPlane?: PlaneObjectBase | null): Arc;
+    static fromAngles(arcRadius: number, startAngle: number, endAngle: number, targetPlane?: PlaneObjectBase | null): Arc;
+    radius(value: number): this;
+    center(value: Point2DLike): this;
+    centered(): this;
     build(): void;
+    private buildTwoPointsCenter;
+    private buildTwoPointsBulge;
+    private buildToPoint;
+    private buildWithCenter;
+    private buildFromAngles;
     getType(): string;
-    compareTo(other: ArcFromTwoAngles): boolean;
-    serialize(): {
-        radius: number;
-        startAngle: number;
-        endAngle: number;
-        centered: boolean;
-    };
+    compareTo(other: Arc): boolean;
+    serialize(): Record<string, unknown>;
 }