fluidcad 0.0.12 → 0.0.14

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

@@ -12,7 +12,7 @@ export interface Comparable<T> {
     compareTo(other: T): boolean;
 }
 export interface Serializable {
-    serialize(): any;
+    serialize(scope?: Set<SceneObject>): any;
 }
 export type BuildSceneObjectContext = {
     getSceneObjects(): SceneObject[];
@@ -51,7 +51,7 @@ export declare abstract class SceneObject implements Comparable<SceneObject>, Se
     isContainer(): boolean;
     saveShapesSnapshot(context: BuildSceneObjectContext): void;
     getSnapshot(): Map<SceneObject, Shape[]>;
-    abstract serialize(): any;
+    abstract serialize(scope?: Set<SceneObject>): any;
     abstract getType(): string;
     abstract build(context?: BuildSceneObjectContext): void;
     compareTo(other: SceneObject): boolean;

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

@@ -7,7 +7,7 @@ export class SceneObject {
     _transform = null;
     _parent = null;
     _alwaysVisible = false;
-    _name = '';
+    _name = null;
     _guide = false;
     _sourceLocation = null;
     _error = null;
@@ -19,7 +19,6 @@ export class SceneObject {
         this.state.set('addedShapes', []);
         this.state.set('removedShapes', []);
         this._id = randomUUID().toString();
-        this._name = this.getType();
     }
     get id() {
         return this._id;
@@ -287,7 +286,7 @@ export class SceneObject {
         return this._order;
     }
     getName() {
-        return this._name;
+        return this._name ?? this.getType();
     }
     name(value) {
         this._name = value;

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

@@ -14,7 +14,7 @@ export declare class Sketch extends SceneObject implements Extrudable {
     getStartPoint(): Point2D;
     getTangentAt(currentObj: GeometrySceneObject): Point2D | null;
     getPositionAt(currentObj: GeometrySceneObject): Point2D;
-    getLastPosition(): Point2D;
+    getLastPosition(scope?: Set<SceneObject>): Point2D;
     build(): void;
     getEdges(): Edge[];
     getEdgesWithOwner(): Map<Edge, GeometrySceneObject>;
@@ -23,9 +23,9 @@ export declare class Sketch extends SceneObject implements Extrudable {
     getDependencies(): SceneObject[];
     createCopy(remap: Map<SceneObject, SceneObject>): SceneObject;
     compareTo(other: Sketch): boolean;
-    getTangent(): Point2D | null;
+    getTangent(scope?: Set<SceneObject>): Point2D | null;
     getType(): string;
-    serialize(): {
+    serialize(scope?: Set<SceneObject>): {
         currentPosition: import("../../math/point.js").Point;
         currentTangent: import("../../math/point.js").Point;
         plane: any;

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

@@ -57,8 +57,11 @@ export class Sketch extends SceneObject {
         }
         return this.getStartPoint();
     }
-    getLastPosition() {
-        const children = this.getChildren().slice();
+    getLastPosition(scope) {
+        let children = this.getChildren().slice();
+        if (scope) {
+            children = children.filter(c => scope.has(c));
+        }
         if (children.length === 0) {
             return this.getStartPoint();
         }
@@ -132,8 +135,11 @@ export class Sketch extends SceneObject {
         }
         return true;
     }
-    getTangent() {
+    getTangent(scope) {
         let children = this.getChildren()?.slice();
+        if (scope) {
+            children = children.filter(c => scope.has(c));
+        }
         if (children.length === 0) {
             return null;
         }
@@ -156,11 +162,11 @@ export class Sketch extends SceneObject {
     getType() {
         return "sketch";
     }
-    serialize() {
+    serialize(scope) {
         const plane = this.getPlane();
-        const tangent = this.getTangent();
+        const tangent = this.getTangent(scope);
         return {
-            currentPosition: plane.localToWorld(this.getLastPosition()),
+            currentPosition: plane.localToWorld(this.getLastPosition(scope)),
             currentTangent: tangent ? plane.localToWorld(tangent) : null,
             plane: this.planeObj.serialize(),
         };

package/lib/dist/features/extrude-base.d.ts

@@ -35,6 +35,17 @@ export declare abstract class ExtrudeBase extends SceneObject implements IExtrud
     draft(value: number | [number, number]): this;
     endOffset(value: number): this;
     drill(value?: boolean): this;
+    protected serializePickFields(): {
+        picking: true;
+        pickPoints: number[][];
+        trigger: "region-picking";
+        pickPlane: {
+            origin: import("../math/point.js").Point;
+            xDirection: import("../math/vector3d.js").Vector3d;
+            yDirection: import("../math/vector3d.js").Vector3d;
+            normal: import("../math/vector3d.js").Vector3d;
+        };
+    };
     pick(...points: Point2DLike[]): this;
     isPicking(): boolean;
     getPickPoints(): LazyVertex[];

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

@@ -198,6 +198,22 @@ export class ExtrudeBase extends SceneObject {
         this._drill = value;
         return this;
     }
+    serializePickFields() {
+        const plane = this._extrudable?.getPlane();
+        return {
+            picking: this.isPicking() || undefined,
+            pickPoints: this.isPicking()
+                ? this._pickPoints.map(p => { const pt = p.asPoint2D(); return [pt.x, pt.y]; })
+                : undefined,
+            trigger: 'region-picking',
+            pickPlane: plane ? {
+                origin: plane.origin,
+                xDirection: plane.xDirection,
+                yDirection: plane.yDirection,
+                normal: plane.normal,
+            } : undefined,
+        };
+    }
     pick(...points) {
         this._picking = true;
         this._pickPoints = points.map(p => normalizePoint2D(p));
@@ -219,13 +235,8 @@ export class ExtrudeBase extends SceneObject {
         if (!this.isPicking()) {
             return null;
         }
-        let cells = this.extrudable.getState('pick-region-cells');
-        if (!cells) {
-            console.log(':::::::: No cached cells found, computing cells for the first time');
-            const sketchShapes = this.extrudable.getGeometries();
-            cells = FaceMaker2.getRegions(sketchShapes, plane, false);
-            this.extrudable.setState('pick-region-cells', cells);
-        }
+        const sketchShapes = this.extrudable.getGeometries();
+        const cells = FaceMaker2.getRegions(sketchShapes, plane, false);
         if (cells.length === 0) {
             return [];
         }
@@ -327,6 +338,6 @@ export class ExtrudeBase extends SceneObject {
         return true;
     }
     getType() {
-        return "extrude";
+        return this._operationMode === "remove" ? "cut" : "extrude";
     }
 }

package/lib/dist/features/extrude-to-face.d.ts

@@ -1,6 +1,7 @@
 import { BuildSceneObjectContext, SceneObject } from "../common/scene-object.js";
 import { ExtrudeBase } from "./extrude-base.js";
 import { Extrudable } from "../helpers/types.js";
+import { Point } from "../math/point.js";
 export declare class ExtrudeToFace extends ExtrudeBase {
     face: SceneObject | 'first-face' | 'last-face';
     constructor(face: SceneObject | 'first-face' | 'last-face', extrudable?: Extrudable);
@@ -24,12 +25,19 @@ export declare class ExtrudeToFace extends ExtrudeBase {
     compareTo(other: ExtrudeToFace): boolean;
     getUniqueType(): string;
     serialize(): {
+        picking: true;
+        pickPoints: number[][];
+        trigger: "region-picking";
+        pickPlane: {
+            origin: Point;
+            xDirection: import("../math/vector3d.js").Vector3d;
+            yDirection: import("../math/vector3d.js").Vector3d;
+            normal: import("../math/vector3d.js").Vector3d;
+        };
         sheptType: string;
         extrudable: any;
         draft: [number, number];
         endOffset: number;
         face: string;
-        picking: true;
-        pickPoints: number[][];
     };
 }

package/lib/dist/features/extrude-to-face.js

@@ -257,6 +257,9 @@ export class ExtrudeToFace extends ExtrudeBase {
         return true;
     }
     getUniqueType() {
+        if (this._operationMode === 'remove') {
+            return 'cut';
+        }
         return 'extrude-to-face';
     }
     serialize() {
@@ -266,10 +269,7 @@ export class ExtrudeToFace extends ExtrudeBase {
             draft: this.getDraft(),
             endOffset: this.getEndOffset(),
             face: typeof (this.face) === 'string' ? this.face : 'selection',
-            picking: this.isPicking() || undefined,
-            pickPoints: this.isPicking()
-                ? this._pickPoints.map(p => { const pt = p.asPoint2D(); return [pt.x, pt.y]; })
-                : undefined,
+            ...this.serializePickFields(),
         };
     }
 }

package/lib/dist/features/extrude-two-distances.d.ts

@@ -11,11 +11,18 @@ export declare class ExtrudeTwoDistances extends ExtrudeBase {
     compareTo(other: ExtrudeTwoDistances): boolean;
     getUniqueType(): string;
     serialize(): {
+        picking: true;
+        pickPoints: number[][];
+        trigger: "region-picking";
+        pickPlane: {
+            origin: import("../math/point.js").Point;
+            xDirection: import("../math/vector3d.js").Vector3d;
+            yDirection: import("../math/vector3d.js").Vector3d;
+            normal: import("../math/vector3d.js").Vector3d;
+        };
         extrudable: any;
         distance1: number;
         distance2: number;
         operationMode: "new" | "remove";
-        picking: true;
-        pickPoints: number[][];
     };
 }

package/lib/dist/features/extrude-two-distances.js

@@ -99,6 +99,9 @@ export class ExtrudeTwoDistances extends ExtrudeBase {
         return true;
     }
     getUniqueType() {
+        if (this._operationMode === 'remove') {
+            return 'cut';
+        }
         return 'extrude-by-two-distance';
     }
     serialize() {
@@ -107,10 +110,7 @@ export class ExtrudeTwoDistances extends ExtrudeBase {
             distance1: this.distance1,
             distance2: this.distance2,
             operationMode: this._operationMode !== 'add' ? this._operationMode : undefined,
-            picking: this.isPicking() || undefined,
-            pickPoints: this.isPicking()
-                ? this._pickPoints.map(p => { const pt = p.asPoint2D(); return [pt.x, pt.y]; })
-                : undefined,
+            ...this.serializePickFields(),
         };
     }
 }

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

@@ -13,13 +13,20 @@ export declare class Extrude extends ExtrudeBase {
     compareTo(other: Extrude): boolean;
     getUniqueType(): string;
     serialize(): {
+        picking: true;
+        pickPoints: number[][];
+        trigger: "region-picking";
+        pickPlane: {
+            origin: import("../math/point.js").Point;
+            xDirection: import("../math/vector3d.js").Vector3d;
+            yDirection: import("../math/vector3d.js").Vector3d;
+            normal: import("../math/vector3d.js").Vector3d;
+        };
         extrudable: any;
         distance: number;
         operationMode: "new" | "remove";
         symmetric: true;
         draft: [number, number];
         endOffset: number;
-        picking: true;
-        pickPoints: number[][];
     };
 }

package/lib/dist/features/extrude.js

@@ -107,7 +107,7 @@ export class Extrude extends ExtrudeBase {
         if (this._symmetric) {
             // Symmetric cut: create tool centered on sketch plane
             if (isThroughAll) {
-                const extrudeThroughAll = new ExtrudeThroughAll(this.extrudable, true, true);
+                const extrudeThroughAll = new ExtrudeThroughAll(this.extrudable, true, true, faces);
                 toolShapes = extrudeThroughAll.build();
             }
             else {
@@ -121,7 +121,7 @@ export class Extrude extends ExtrudeBase {
             }
         }
         else if (isThroughAll) {
-            const extrudeThroughAll = new ExtrudeThroughAll(this.extrudable, false, true);
+            const extrudeThroughAll = new ExtrudeThroughAll(this.extrudable, false, true, faces);
             toolShapes = extrudeThroughAll.build();
         }
         else {
@@ -157,12 +157,15 @@ export class Extrude extends ExtrudeBase {
         return true;
     }
     getUniqueType() {
+        if (this._operationMode === 'remove') {
+            if (this._symmetric) {
+                return 'cut-symmetric';
+            }
+            return 'cut';
+        }
         if (this._symmetric) {
             return 'extrude-symmetric';
         }
-        if (this._operationMode === 'remove') {
-            return 'cut-by-distance';
-        }
         return 'extrude-by-distance';
     }
     serialize() {
@@ -173,10 +176,7 @@ export class Extrude extends ExtrudeBase {
             symmetric: this._symmetric || undefined,
             draft: this.getDraft(),
             endOffset: this.getEndOffset(),
-            picking: this.isPicking() || undefined,
-            pickPoints: this.isPicking()
-                ? this._pickPoints.map(p => { const pt = p.asPoint2D(); return [pt.x, pt.y]; })
-                : undefined,
+            ...this.serializePickFields(),
         };
     }
 }

package/lib/dist/features/infinite-extrude.d.ts

@@ -1,10 +1,12 @@
 import { Solid } from "../common/shapes.js";
+import { Face } from "../common/face.js";
 import { Extrudable } from "../helpers/types.js";
 export declare class ExtrudeThroughAll {
     extrudable: Extrudable;
     symmetric: boolean;
     reversed: boolean;
+    pickedFaces?: Face[];
     private shapes;
-    constructor(extrudable: Extrudable, symmetric: boolean, reversed: boolean);
+    constructor(extrudable: Extrudable, symmetric: boolean, reversed: boolean, pickedFaces?: Face[]);
     build(): Solid[];
 }

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

@@ -4,30 +4,34 @@ export class ExtrudeThroughAll {
     extrudable;
     symmetric;
     reversed;
+    pickedFaces;
     shapes = null;
-    constructor(extrudable, symmetric, reversed) {
+    constructor(extrudable, symmetric, reversed, pickedFaces) {
         this.extrudable = extrudable;
         this.symmetric = symmetric;
         this.reversed = reversed;
+        this.pickedFaces = pickedFaces;
     }
     build() {
         if (this.shapes) {
             return this.shapes;
         }
         const solids = [];
-        const wires = this.extrudable.getGeometries();
         const plane = this.extrudable.getPlane();
-        const faces = FaceMaker2.getRegions(wires, plane);
+        const faces = this.pickedFaces ?? FaceMaker2.getRegions(this.extrudable.getGeometries(), plane);
         console.log("Extruding faces:", faces);
         let dir = plane.normal;
         if (this.reversed) {
             dir = dir.multiply(-1);
         }
+        const shouldDispose = !this.pickedFaces;
         if (this.symmetric) {
             for (const face of faces) {
                 const solid = ExtrudeOps.makePrismSymmetric(face, dir);
                 solids.push(solid);
-                face.dispose();
+                if (shouldDispose) {
+                    face.dispose();
+                }
             }
         }
         else {
@@ -35,7 +39,9 @@ export class ExtrudeThroughAll {
             for (const face of faces) {
                 const solid = ExtrudeOps.makePrism(face, dir, 1);
                 solids.push(solid);
-                face.dispose();
+                if (shouldDispose) {
+                    face.dispose();
+                }
             }
         }
         this.shapes = solids;

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

@@ -13,11 +13,18 @@ export declare class Revolve extends ExtrudeBase implements IRevolve {
     compareTo(other: Revolve): boolean;
     getType(): string;
     serialize(): {
+        picking: true;
+        pickPoints: number[][];
+        trigger: "region-picking";
+        pickPlane: {
+            origin: import("../math/point.js").Point;
+            xDirection: import("../math/vector3d.js").Vector3d;
+            yDirection: import("../math/vector3d.js").Vector3d;
+            normal: import("../math/vector3d.js").Vector3d;
+        };
         angle: number;
         axis: any;
         operationMode: "new" | "remove";
         symmetric: true;
-        picking: true;
-        pickPoints: number[][];
     };
 }

package/lib/dist/features/revolve.js

@@ -141,10 +141,7 @@ export class Revolve extends ExtrudeBase {
             axis: this.axis.serialize(),
             operationMode: this._operationMode !== 'add' ? this._operationMode : undefined,
             symmetric: this._symmetric || undefined,
-            picking: this.isPicking() || undefined,
-            pickPoints: this.isPicking()
-                ? this._pickPoints.map(p => { const pt = p.asPoint2D(); return [pt.x, pt.y]; })
-                : undefined,
+            ...this.serializePickFields(),
         };
     }
 }

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

@@ -13,10 +13,17 @@ export declare class Sweep extends ExtrudeBase implements ISweep {
     compareTo(other: Sweep): boolean;
     getType(): string;
     serialize(): {
+        picking: true;
+        pickPoints: number[][];
+        trigger: "region-picking";
+        pickPlane: {
+            origin: import("../math/point.js").Point;
+            xDirection: import("../math/vector3d.js").Vector3d;
+            yDirection: import("../math/vector3d.js").Vector3d;
+            normal: import("../math/vector3d.js").Vector3d;
+        };
         path: any;
         extrudable: any;
         operationMode: "new" | "remove";
-        picking: true;
-        pickPoints: number[][];
     };
 }

package/lib/dist/features/sweep.js

@@ -120,10 +120,7 @@ export class Sweep extends ExtrudeBase {
             path: this._path.serialize(),
             extrudable: this.extrudable.serialize(),
             operationMode: this._operationMode !== 'add' ? this._operationMode : undefined,
-            picking: this.isPicking() || undefined,
-            pickPoints: this.isPicking()
-                ? this._pickPoints.map(p => { const pt = p.asPoint2D(); return [pt.x, pt.y]; })
-                : undefined,
+            ...this.serializePickFields(),
         };
     }
 }

package/lib/dist/rendering/render.js

@@ -78,6 +78,8 @@ export function renderSceneRollback(scene, rollbackIndex) {
                     shapeType: shape.getType(),
                     isMetaShape: shape.isMetaShape() || undefined,
                     isGuide: shape.isGuideShape() || undefined,
+                    metaType: shape.metaType || undefined,
+                    metaData: shape.metaData || undefined,
                 });
             }
             let isVisible = !!sceneShapes.length;
@@ -97,7 +99,7 @@ export function renderSceneRollback(scene, rollbackIndex) {
                 id: obj.id,
                 name: obj.getName(),
                 parentId: obj.parentId,
-                object: obj.serialize(),
+                object: obj.serialize(scope),
                 sceneShapes: renderedSceneShapes,
                 type: obj.getType(),
                 uniqueType: obj.getUniqueType(),
@@ -113,7 +115,7 @@ export function renderSceneRollback(scene, rollbackIndex) {
                 id: obj.id,
                 name: obj.getName(),
                 parentId: obj.parentId,
-                object: obj.serialize(),
+                object: obj.serialize(scope),
                 sceneShapes: [],
                 type: obj.getType(),
                 uniqueType: obj.getUniqueType(),