fluidcad 0.0.21 → 0.0.23

package/README.md

@@ -71,7 +71,7 @@ Re-apply modeling features based on matrix transformations. Move, rotate, or mir
 
 ```javascript
 sketch("xy", () => {
-    rect(200, 100).center()
+    rect(200, 100).centered()
 })
 
 const e1 = extrude(20)
@@ -155,7 +155,12 @@ Step-by-step tutorials from simple shapes to exam-level parts. [Browse all tutor
         <strong>CSWP Sample Exam</strong>
       </a>
     </td>
-    <td width="33%"></td>
+    <td align="center" width="33%">
+      <a href="https://fluidcad.io/docs/tutorials/hinge-bracket">
+        <img src="https://fluidcad.io/assets/images/hinge-bracket-final-137547b475db21736d78b5b13f8db48b.png" alt="Hinge Bracket" height="180" /><br />
+        <strong>Hinge Bracket</strong>
+      </a>
+    </td>
   </tr>
 </table>
 

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

@@ -1,6 +1,7 @@
 import type { TopoDS_Shape } from "occjs-wrapper";
 import { ShapeType } from "./shape-type.js";
 import { SceneObjectMesh } from "../rendering/scene.js";
+import { Matrix4 } from "../math/matrix4.js";
 export interface ShapeFilter {
     excludeMeta?: boolean;
     excludeGuide?: boolean;
@@ -17,6 +18,7 @@ export declare abstract class Shape<T extends TopoDS_Shape = TopoDS_Shape> {
         color: string;
     }>;
     private meshes;
+    private _meshSource;
     constructor(shape: T);
     abstract getType(): ShapeType;
     getShape(): T;
@@ -36,6 +38,11 @@ export declare abstract class Shape<T extends TopoDS_Shape = TopoDS_Shape> {
     isGuideShape(): boolean;
     getMeshes(): SceneObjectMesh[];
     setMeshes(meshes: SceneObjectMesh[]): void;
+    setMeshSource(source: Shape, matrix: Matrix4): void;
+    getMeshSource(): {
+        shape: Shape;
+        matrix: Matrix4;
+    } | null;
     setColor(face: TopoDS_Shape, color: string): void;
     getColor(face: TopoDS_Shape): string | undefined;
     hasColors(): boolean;

package/lib/dist/common/shape.js

@@ -8,6 +8,7 @@ export class Shape {
     id;
     colorMap = [];
     meshes;
+    _meshSource = null;
     constructor(shape) {
         this.shape = shape;
         this.id = randomUUID();
@@ -70,6 +71,12 @@ export class Shape {
     setMeshes(meshes) {
         this.meshes = meshes;
     }
+    setMeshSource(source, matrix) {
+        this._meshSource = { shape: source, matrix };
+    }
+    getMeshSource() {
+        return this._meshSource;
+    }
     setColor(face, color) {
         if (this.isEdge()) {
             throw new Error("Cannot set color on edge shape");

package/lib/dist/core/copy.js

@@ -16,7 +16,7 @@ function build(context) {
         const restObjects = args.slice(3);
         const objects = restObjects.length > 0
             ? restObjects
-            : [context.getSceneObjects().at(-1)];
+            : null;
         if (type === 'linear') {
             const axisArg = args[1];
             const axes = Array.isArray(axisArg)

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

@@ -0,0 +1,16 @@
+import { ISceneObject, IDraft } from "./interfaces.js";
+interface DraftFunction {
+    /**
+     * Applies a draft angle to the last selected faces.
+     * @param angle - The draft angle in degrees
+     */
+    (angle: number): IDraft;
+    /**
+     * Applies a draft angle to the given face selections.
+     * @param angle - The draft angle in degrees
+     * @param selections - The face selections to draft
+     */
+    (angle: number, ...selections: ISceneObject[]): IDraft;
+}
+declare const _default: DraftFunction;
+export default _default;

package/lib/dist/core/draft.js

@@ -0,0 +1,29 @@
+import { Draft } from "../features/draft.js";
+import { SceneObject } from "../common/scene-object.js";
+import { registerBuilder } from "../index.js";
+import { rad } from "../helpers/math-helpers.js";
+function build(context) {
+    return function draft() {
+        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 angleDeg = (args.length >= 1 && typeof args[0] === 'number')
+            ? args[0]
+            : 5;
+        for (const sel of selections) {
+            context.addSceneObject(sel);
+        }
+        const draft = new Draft(rad(angleDeg), selections);
+        context.addSceneObject(draft);
+        return draft;
+    };
+}
+export default registerBuilder(build);

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

@@ -1,4 +1,4 @@
-export type { ISceneObject, IFuseable, IPlane, IAxis, ISelect, IGeometry, IExtrudableGeometry, IRect, ISlot, IPolygon, ITwoObjectsTangentLine, ITangentArcTwoObjects, IExtrude, ICut, ICommon, ISweep, ILoft, IRevolve } from "./interfaces.js";
+export type { ISceneObject, IFuseable, IPlane, IAxis, ISelect, IGeometry, IExtrudableGeometry, IRect, ISlot, IPolygon, ITwoObjectsTangentLine, ITangentArcTwoObjects, IExtrude, ICut, ICommon, ISweep, ILoft, IRevolve, IDraft } from "./interfaces.js";
 export { default as axis } from "./axis.js";
 export { default as plane } from "./plane.js";
 export { default as sketch } from "./sketch.js";
@@ -23,11 +23,10 @@ export { default as load } from "./load.js";
 export { default as loft } from "./loft.js";
 export { default as sweep } from "./sweep.js";
 export { default as color } from "./color.js";
+export { default as draft } from "./draft.js";
 export { default as remove } from "./remove.js";
 export { default as split } from "./split.js";
 export { default as trim } from "./trim.js";
 export { default as part } from "./part.js";
-export { default as use } from "./use.js";
-export type { PartHandle } from "./part.js";
 export * from "./2d/index.js";
 export { breakpoint } from "./breakpoint.js";

package/lib/dist/core/index.js

@@ -22,10 +22,10 @@ export { default as load } from "./load.js";
 export { default as loft } from "./loft.js";
 export { default as sweep } from "./sweep.js";
 export { default as color } from "./color.js";
+export { default as draft } from "./draft.js";
 export { default as remove } from "./remove.js";
 export { default as split } from "./split.js";
 export { default as trim } from "./trim.js";
 export { default as part } from "./part.js";
-export { default as use } from "./use.js";
 export * from "./2d/index.js";
 export { breakpoint } from "./breakpoint.js";

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

@@ -562,6 +562,8 @@ export interface ISweep extends IFuseable {
      */
     capEdges(...args: (number | EdgeFilterBuilder)[]): ISceneObject;
 }
+export interface IDraft extends ISceneObject {
+}
 export interface IShell extends ISceneObject {
     /**
      * Selects the inner wall faces created by the shell operation (from thickness removal).

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

@@ -1,7 +1,3 @@
-export type PartHandle<T = any> = {
-    __fluidcad_part: true;
-    name: string;
-    _callback: (options: T) => void;
-};
-declare function part<T = any>(name: string, callback: (options: T) => void): PartHandle<T>;
+import { ISceneObject } from "./interfaces.js";
+declare function part(name: string, callback: () => void): ISceneObject;
 export default part;

package/lib/dist/core/part.js

@@ -1,29 +1,19 @@
 import { captureSourceLocation } from "../index.js";
-import { getCurrentScene, getCurrentFile } from "../scene-manager.js";
+import { getCurrentScene } from "../scene-manager.js";
 import { Part } from "../features/part.js";
 function part(name, callback) {
-    const handle = {
-        __fluidcad_part: true,
-        name,
-        _callback: callback,
-    };
+    const scene = getCurrentScene();
+    if (!scene) {
+        throw new Error("part() must be called within a scene context");
+    }
     const sourceLocation = captureSourceLocation();
-    const currentFile = getCurrentFile();
-    const isDirectEdit = sourceLocation
-        && currentFile
-        && sourceLocation.filePath === currentFile;
-    if (isDirectEdit) {
-        const scene = getCurrentScene();
-        if (scene) {
-            const partObj = new Part(name);
-            if (sourceLocation) {
-                partObj.setSourceLocation(sourceLocation);
-            }
-            scene.startProgressiveContainer(partObj);
-            callback(undefined);
-            scene.endProgressiveContainer();
-        }
+    const partObj = new Part(name);
+    if (sourceLocation) {
+        partObj.setSourceLocation(sourceLocation);
     }
-    return handle;
+    scene.startProgressiveContainer(partObj);
+    callback();
+    scene.endProgressiveContainer();
+    return partObj;
 }
 export default part;

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

@@ -1,13 +1,20 @@
 import { Point2DLike } from "../math/point.js";
-import { ISceneObject } from "./interfaces.js";
+import { EdgeFilterBuilder } from "../filters/edge/edge-filter.js";
+interface ITrim {
+    /**
+     * Enters interactive trimming mode, optionally trimming edges at the given points.
+     * @param points - Points where geometry should be trimmed; the nearest edge segment to each point is removed.
+     */
+    pick(...points: Point2DLike[]): ITrim;
+}
 interface TrimFunction {
     /** Trims all sketch geometry segments. */
-    (): ISceneObject;
+    (): ITrim;
     /**
-     * Trims sketch geometry segments at the given points.
-     * @param points - The points where geometry should be trimmed
+     * Trims sketch geometry segments matching the given edge filters.
+     * @param filters - Edge filters that select which edges to remove
      */
-    (...points: Point2DLike[]): ISceneObject;
+    (...filters: EdgeFilterBuilder[]): ITrim;
 }
 declare const _default: TrimFunction;
 export default _default;

package/lib/dist/core/trim.js

@@ -9,10 +9,15 @@ function build(context) {
         }
         const trim2d = new Trim2D();
         if (args.length > 0) {
-            trim2d.points(...args.map(p => normalizePoint2D(p)));
+            trim2d.setFilters(...args);
         }
         context.addSceneObject(trim2d);
-        return trim2d;
+        return {
+            pick(...points) {
+                trim2d.pick(...points.map(p => normalizePoint2D(p)));
+                return this;
+            },
+        };
     };
 }
 export default registerBuilder(build);

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

@@ -83,33 +83,39 @@ export class Sketch extends SceneObject {
         const source = this.getCloneSource();
         const transform = context?.getTransform();
         if (source instanceof Sketch && transform) {
-            const originalEdges = source.getEdges();
-            const transformedEdges = originalEdges.map(edge => ShapeOps.transform(edge, transform));
-            this.setState('cloned-edges', transformedEdges);
+            const sourceChildren = source.getChildren();
+            const clonedChildren = this.getChildren();
+            for (let i = 0; i < sourceChildren.length; i++) {
+                const sourceChild = sourceChildren[i];
+                const clonedChild = clonedChildren[i];
+                if (!clonedChild) {
+                    continue;
+                }
+                const shapes = sourceChild.getAddedShapes();
+                const removedShapes = sourceChild.getRemovedShapes();
+                for (const shape of shapes) {
+                    if (shape.isMetaShape() || shape.isGuideShape()) {
+                        continue;
+                    }
+                    const isRemovedBySibling = removedShapes.some(s => s.shape === shape && s.removedBy?.parentId === source.id);
+                    if (isRemovedBySibling) {
+                        continue;
+                    }
+                    const transformed = ShapeOps.transform(shape, transform);
+                    clonedChild.addShape(transformed);
+                }
+            }
         }
     }
     getEdges() {
-        const clonedEdges = this.getState('cloned-edges');
-        if (clonedEdges) {
-            return clonedEdges;
-        }
         return [...this.getEdgesWithOwner().keys()];
     }
     getEdgesWithOwner() {
         const children = this.getChildren();
         const result = new Map();
-        // get edges and filter out the ones that were removed by non-siblings
         for (const child of children) {
-            const shapes = child.getAddedShapes();
-            const removedShapes = child.getRemovedShapes();
+            const shapes = child.getShapes();
             for (const shape of shapes) {
-                if (shape.isMetaShape() || shape.isGuideShape()) {
-                    continue;
-                }
-                const isRemovedBySibling = removedShapes.some(s => s.shape === shape && s.removedBy?.parentId === this.id);
-                if (isRemovedBySibling) {
-                    continue;
-                }
                 if (shape instanceof Edge) {
                     result.set(shape, child);
                 }

package/lib/dist/features/copy-circular.js

@@ -34,6 +34,7 @@ export class CopyCircular extends SceneObject {
             for (const obj of objects) {
                 for (const shape of obj.getShapes()) {
                     const transformed = ShapeOps.transform(shape, matrix);
+                    transformed.setMeshSource(shape, matrix);
                     this.addShape(transformed);
                 }
             }

package/lib/dist/features/copy-circular2d.js

@@ -41,6 +41,7 @@ export class CopyCircular2D extends GeometrySceneObject {
             for (const obj of objects) {
                 for (const shape of obj.getShapes()) {
                     const transformed = ShapeOps.transform(shape, matrix);
+                    transformed.setMeshSource(shape, matrix);
                     this.addShape(transformed);
                 }
             }

package/lib/dist/features/copy-linear.js

@@ -34,6 +34,7 @@ export class CopyLinear extends SceneObject {
             const axisCount = counts[a];
             return axisCount > 1 ? len / (axisCount - 1) : 0;
         });
+        const centerIndices = this.axes.map((_, a) => centered ? Math.floor(counts[a] / 2) : 0);
         // Build grid positions as cartesian product of per-axis indices (0..counts[a]-1)
         let positions = [[]];
         for (let a = 0; a < this.axes.length; a++) {
@@ -46,23 +47,21 @@ export class CopyLinear extends SceneObject {
             positions = next;
         }
         for (const pos of positions) {
-            if (pos.every(idx => idx === 0))
+            if (pos.every((idx, a) => idx === centerIndices[a]))
                 continue;
             if (skip?.some(coord => coord.every((v, a) => v === pos[a]))) {
                 continue;
             }
             let matrix = Matrix4.identity();
             for (let a = 0; a < this.axes.length; a++) {
-                const axisCount = counts[a];
-                const axisOffset = axisOffsets[a];
-                const startOffset = centered ? -(axisCount * axisOffset) / 2 : 0;
-                const distance = startOffset + axisOffset * pos[a];
+                const distance = (pos[a] - centerIndices[a]) * axisOffsets[a];
                 const translation = this.axes[a].direction.multiply(distance);
                 matrix = matrix.multiply(Matrix4.fromTranslationVector(translation));
             }
             for (const obj of objects) {
                 for (const shape of obj.getShapes()) {
                     const transformed = ShapeOps.transform(shape, matrix);
+                    transformed.setMeshSource(shape, matrix);
                     this.addShape(transformed);
                 }
             }

package/lib/dist/features/copy-linear2d.js

@@ -38,6 +38,7 @@ export class CopyLinear2D extends GeometrySceneObject {
             const axisCount = counts[a];
             return axisCount > 1 ? len / (axisCount - 1) : 0;
         });
+        const centerIndices = this.axes.map((_, a) => centered ? Math.floor(counts[a] / 2) : 0);
         // Build grid positions as cartesian product of per-axis indices (0..counts[a]-1)
         let positions = [[]];
         for (let a = 0; a < this.axes.length; a++) {
@@ -50,23 +51,21 @@ export class CopyLinear2D extends GeometrySceneObject {
             positions = next;
         }
         for (const pos of positions) {
-            if (pos.every(idx => idx === 0))
+            if (pos.every((idx, a) => idx === centerIndices[a]))
                 continue;
             if (skip?.some(coord => coord.every((v, a) => v === pos[a]))) {
                 continue;
             }
             let matrix = Matrix4.identity();
             for (let a = 0; a < this.axes.length; a++) {
-                const axisCount = counts[a];
-                const axisOffset = axisOffsets[a];
-                const startOffset = centered ? -(axisCount * axisOffset) / 2 : 0;
-                const distance = startOffset + axisOffset * pos[a];
+                const distance = (pos[a] - centerIndices[a]) * axisOffsets[a];
                 const translation = this.axes[a].direction.multiply(distance);
                 matrix = matrix.multiply(Matrix4.fromTranslationVector(translation));
             }
             for (const obj of objects) {
                 for (const shape of obj.getShapes()) {
                     const transformed = ShapeOps.transform(shape, matrix);
+                    transformed.setMeshSource(shape, matrix);
                     this.addShape(transformed);
                 }
             }

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

@@ -0,0 +1,15 @@
+import { BuildSceneObjectContext, SceneObject } from "../common/scene-object.js";
+import { IDraft } from "../core/interfaces.js";
+export declare class Draft extends SceneObject implements IDraft {
+    private angle;
+    private _selections;
+    constructor(angle: number, selections: SceneObject[]);
+    build(context: BuildSceneObjectContext): void;
+    compareTo(other: SceneObject): boolean;
+    getDependencies(): SceneObject[];
+    createCopy(remap: Map<SceneObject, SceneObject>): SceneObject;
+    getType(): string;
+    serialize(): {
+        angle: number;
+    };
+}

package/lib/dist/features/draft.js

@@ -0,0 +1,88 @@
+import { SceneObject } from "../common/scene-object.js";
+import { DraftOps } from "../oc/draft-ops.js";
+export class Draft extends SceneObject {
+    angle;
+    _selections = [];
+    constructor(angle, selections) {
+        super();
+        this.angle = angle;
+        this._selections = selections;
+    }
+    build(context) {
+        const shapeObjMap = new Map();
+        for (const obj of context.getSceneObjects()) {
+            if (obj.id === this.parentId) {
+                continue;
+            }
+            const shapes = obj.getShapes({ excludeMeta: false }, 'solid');
+            for (const shape of shapes) {
+                shapeObjMap.set(shape, obj);
+            }
+        }
+        if (!shapeObjMap.size) {
+            return;
+        }
+        const allFaceShapes = [];
+        for (const sel of this._selections) {
+            allFaceShapes.push(...sel.getShapes());
+        }
+        const selectionFaces = allFaceShapes;
+        const selectionFaceRaws = selectionFaces.map(f => f.getShape());
+        const newShapes = [];
+        const allTargetShapes = Array.from(shapeObjMap.keys());
+        for (const shape of allTargetShapes) {
+            try {
+                const result = DraftOps.applyDraft(shape, selectionFaceRaws, this.angle);
+                if (!result) {
+                    continue;
+                }
+                newShapes.push(result);
+                const originalObj = shapeObjMap.get(shape);
+                originalObj.removeShape(shape, this);
+            }
+            catch (e) {
+                newShapes.push(shape);
+                console.warn("Draft: Failed to apply draft angle.", e);
+            }
+        }
+        for (const sel of this._selections) {
+            sel.removeShapes(this);
+        }
+        this.addShapes(newShapes);
+    }
+    compareTo(other) {
+        if (!(other instanceof Draft)) {
+            return false;
+        }
+        if (!super.compareTo(other)) {
+            return false;
+        }
+        if (this.angle !== other.angle) {
+            return false;
+        }
+        if (this._selections.length !== other._selections.length) {
+            return false;
+        }
+        for (let i = 0; i < this._selections.length; i++) {
+            if (!this._selections[i].compareTo(other._selections[i])) {
+                return false;
+            }
+        }
+        return true;
+    }
+    getDependencies() {
+        return [...this._selections];
+    }
+    createCopy(remap) {
+        const selections = this._selections.map(sel => remap.get(sel) || sel);
+        return new Draft(this.angle, selections);
+    }
+    getType() {
+        return 'draft';
+    }
+    serialize() {
+        return {
+            angle: this.angle
+        };
+    }
+}

package/lib/dist/features/extrude-base.js

@@ -339,6 +339,7 @@ export class ExtrudeBase extends SceneObject {
         this._picking = other._picking;
         this._pickPoints = other._pickPoints;
         this._thin = other._thin;
+        this._drill = other._drill;
         return this;
     }
     /**

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

@@ -4,6 +4,8 @@ export declare class Remove extends SceneObject {
     constructor(objects: SceneObject[]);
     build(): void;
     compareTo(other: Remove): boolean;
+    getDependencies(): SceneObject[];
+    createCopy(remap: Map<SceneObject, SceneObject>): SceneObject;
     getType(): string;
     serialize(): {};
 }

package/lib/dist/features/remove.js

@@ -24,6 +24,13 @@ export class Remove extends SceneObject {
         }
         return true;
     }
+    getDependencies() {
+        return this.objects;
+    }
+    createCopy(remap) {
+        const remappedObjects = this.objects.map(obj => remap.get(obj) || obj);
+        return new Remove(remappedObjects);
+    }
     getType() {
         return 'remove';
     }

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

@@ -1,15 +1,27 @@
 import { SceneObject } from "../common/scene-object.js";
 import { GeometrySceneObject } from "./2d/geometry.js";
 import { LazyVertex } from "./lazy-vertex.js";
+import { EdgeFilterBuilder } from "../filters/edge/edge-filter.js";
 export declare class Trim2D extends GeometrySceneObject {
-    private _points;
+    private _filters;
+    private _picking;
+    private _pickPoints;
     constructor();
-    points(...ps: LazyVertex[]): this;
-    get trimPoints(): LazyVertex[];
+    setFilters(...fs: EdgeFilterBuilder[]): this;
+    pick(...ps: LazyVertex[]): this;
+    isPicking(): boolean;
+    getPickPoints(): LazyVertex[];
+    get filters(): EdgeFilterBuilder[];
     build(): void;
+    private buildWithFilters;
+    private buildWithPicking;
     getDependencies(): SceneObject[];
     createCopy(remap: Map<SceneObject, SceneObject>): SceneObject;
     compareTo(other: Trim2D): boolean;
     getType(): string;
-    serialize(): {};
+    serialize(): {
+        trigger: "trim-picking";
+        picking: true;
+        pickPoints: number[][];
+    };
 }