fluidcad 0.0.26 → 0.0.28

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

@@ -1,4 +1,6 @@
 import { Shape, ShapeFilter } from "./shape.js";
+import { Face } from "./face.js";
+import { Edge } from "./edge.js";
 import { Matrix4 } from "../math/matrix4.js";
 import { ISceneObject } from "../core/interfaces.js";
 import { FusionScope, OperationMode } from "../features/extrude-options.js";
@@ -8,6 +10,19 @@ export type SourceLocation = {
     line: number;
     column: number;
 };
+export type AdditionRecord<T> = {
+    shape: T;
+    addedBy: SceneObject;
+};
+export type RemovalRecord<T> = {
+    shape: T;
+    removedBy: SceneObject;
+};
+export type ModificationRecord<T> = {
+    sources: T[];
+    results: T[];
+    modifiedBy: SceneObject;
+};
 export interface Comparable<T> {
     compareTo(other: T): boolean;
 }
@@ -74,11 +89,41 @@ export declare abstract class SceneObject implements Comparable<SceneObject>, Se
     private set addedShapes(value);
     private get removedShapes();
     private set removedShapes(value);
+    private get addedFaces();
+    private set addedFaces(value);
+    private get modifiedFaces();
+    private set modifiedFaces(value);
+    private get removedFaces();
+    private set removedFaces(value);
+    private get addedEdges();
+    private set addedEdges(value);
+    private get modifiedEdges();
+    private set modifiedEdges(value);
+    private get removedEdges();
+    private set removedEdges(value);
+    private get finalShapes();
+    private set finalShapes(value);
     getUniqueType(): string;
     addShape(shape: Shape): void;
     addShapes(shapes: Shape[]): void;
     removeShape(shape: Shape, removedBy: SceneObject): void;
     removeShapes(removedBy: SceneObject, force?: boolean): void;
+    recordAddedFace(face: Face, addedBy: SceneObject): void;
+    recordAddedEdge(edge: Edge, addedBy: SceneObject): void;
+    recordModifiedFaces(sources: Face[], results: Face[], modifiedBy: SceneObject): void;
+    recordModifiedEdges(sources: Edge[], results: Edge[], modifiedBy: SceneObject): void;
+    recordRemovedFace(face: Face, removedBy: SceneObject): void;
+    recordRemovedEdge(edge: Edge, removedBy: SceneObject): void;
+    private ownsFace;
+    private ownsEdge;
+    getAddedFaces(scope?: Set<SceneObject>): Face[];
+    getModifiedFaces(scope?: Set<SceneObject>): ModificationRecord<Face>[];
+    getRemovedFaces(scope?: Set<SceneObject>): Face[];
+    getAddedEdges(scope?: Set<SceneObject>): Edge[];
+    getModifiedEdges(scope?: Set<SceneObject>): ModificationRecord<Edge>[];
+    getRemovedEdges(scope?: Set<SceneObject>): Edge[];
+    setFinalShapes(shapes: Shape[]): void;
+    getFinalShapes(): Shape[];
     getOwnShapes(filter?: ShapeFilter, scope?: Set<SceneObject>): Shape[];
     getChildShapes(filter?: ShapeFilter, type?: ShapeType): Shape[];
     getShapes(filter?: ShapeFilter, type?: ShapeType): Shape[];

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

@@ -21,6 +21,13 @@ export class SceneObject {
         this.state = new Map();
         this.state.set('addedShapes', []);
         this.state.set('removedShapes', []);
+        this.state.set('addedFaces', []);
+        this.state.set('modifiedFaces', []);
+        this.state.set('removedFaces', []);
+        this.state.set('addedEdges', []);
+        this.state.set('modifiedEdges', []);
+        this.state.set('removedEdges', []);
+        this.state.set('finalShapes', []);
         this._id = randomUUID().toString();
     }
     get id() {
@@ -208,6 +215,48 @@ export class SceneObject {
     set removedShapes(shapes) {
         this.state.set('removedShapes', shapes);
     }
+    get addedFaces() {
+        return this.state.get('addedFaces');
+    }
+    set addedFaces(records) {
+        this.state.set('addedFaces', records);
+    }
+    get modifiedFaces() {
+        return this.state.get('modifiedFaces');
+    }
+    set modifiedFaces(records) {
+        this.state.set('modifiedFaces', records);
+    }
+    get removedFaces() {
+        return this.state.get('removedFaces');
+    }
+    set removedFaces(records) {
+        this.state.set('removedFaces', records);
+    }
+    get addedEdges() {
+        return this.state.get('addedEdges');
+    }
+    set addedEdges(records) {
+        this.state.set('addedEdges', records);
+    }
+    get modifiedEdges() {
+        return this.state.get('modifiedEdges');
+    }
+    set modifiedEdges(records) {
+        this.state.set('modifiedEdges', records);
+    }
+    get removedEdges() {
+        return this.state.get('removedEdges');
+    }
+    set removedEdges(records) {
+        this.state.set('removedEdges', records);
+    }
+    get finalShapes() {
+        return this.state.get('finalShapes');
+    }
+    set finalShapes(shapes) {
+        this.state.set('finalShapes', shapes);
+    }
     getUniqueType() {
         return this.getType();
     }
@@ -251,6 +300,78 @@ export class SceneObject {
             this.removeShape(shape, removedBy);
         }
     }
+    recordAddedFace(face, addedBy) {
+        this.addedFaces.push({ shape: face, addedBy });
+    }
+    recordAddedEdge(edge, addedBy) {
+        this.addedEdges.push({ shape: edge, addedBy });
+    }
+    recordModifiedFaces(sources, results, modifiedBy) {
+        this.modifiedFaces.push({ sources, results, modifiedBy });
+    }
+    recordModifiedEdges(sources, results, modifiedBy) {
+        this.modifiedEdges.push({ sources, results, modifiedBy });
+    }
+    recordRemovedFace(face, removedBy) {
+        if (this.isContainer()) {
+            for (const child of this.children) {
+                if (child.ownsFace(face)) {
+                    child.recordRemovedFace(face, removedBy);
+                }
+            }
+            return;
+        }
+        this.removedFaces.push({ shape: face, removedBy });
+    }
+    recordRemovedEdge(edge, removedBy) {
+        if (this.isContainer()) {
+            for (const child of this.children) {
+                if (child.ownsEdge(edge)) {
+                    child.recordRemovedEdge(edge, removedBy);
+                }
+            }
+            return;
+        }
+        this.removedEdges.push({ shape: edge, removedBy });
+    }
+    ownsFace(face) {
+        return this.addedFaces.some(r => r.shape === face);
+    }
+    ownsEdge(edge) {
+        return this.addedEdges.some(r => r.shape === edge);
+    }
+    getAddedFaces(scope) {
+        return this.addedFaces
+            .filter(r => !scope || scope.has(r.addedBy))
+            .map(r => r.shape);
+    }
+    getModifiedFaces(scope) {
+        return this.modifiedFaces.filter(r => !scope || scope.has(r.modifiedBy));
+    }
+    getRemovedFaces(scope) {
+        return this.removedFaces
+            .filter(r => !scope || scope.has(r.removedBy))
+            .map(r => r.shape);
+    }
+    getAddedEdges(scope) {
+        return this.addedEdges
+            .filter(r => !scope || scope.has(r.addedBy))
+            .map(r => r.shape);
+    }
+    getModifiedEdges(scope) {
+        return this.modifiedEdges.filter(r => !scope || scope.has(r.modifiedBy));
+    }
+    getRemovedEdges(scope) {
+        return this.removedEdges
+            .filter(r => !scope || scope.has(r.removedBy))
+            .map(r => r.shape);
+    }
+    setFinalShapes(shapes) {
+        this.finalShapes = shapes;
+    }
+    getFinalShapes() {
+        return this.finalShapes;
+    }
     getOwnShapes(filter, scope) {
         filter = {
             excludeMeta: filter?.excludeMeta ?? true,

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

@@ -4,5 +4,5 @@ import { Wire } from "./wire.js";
 import { Face } from "./face.js";
 import { Edge } from "./edge.js";
 export declare class ShapeFactory {
-    static fromShape(shape: TopoDS_Shape): Wire | Edge | Solid | Face;
+    static fromShape(shape: TopoDS_Shape): Solid | Face | Edge | Wire;
 }

package/lib/dist/common/shape-history-tracker.d.ts

@@ -0,0 +1,35 @@
+import type { BRepBuilderAPI_MakeShape } from "occjs-wrapper";
+import { Face } from "./face.js";
+import { Edge } from "./edge.js";
+import { Shape } from "./shape.js";
+export type ShapeHistoryRecord<T> = {
+    sources: T[];
+    results: T[];
+};
+export type ShapeHistory = {
+    addedFaces: Face[];
+    modifiedFaces: ShapeHistoryRecord<Face>[];
+    generatedFaces: ShapeHistoryRecord<Face>[];
+    removedFaces: Face[];
+    addedEdges: Edge[];
+    modifiedEdges: ShapeHistoryRecord<Edge>[];
+    generatedEdges: ShapeHistoryRecord<Edge>[];
+    removedEdges: Edge[];
+};
+export declare class ShapeHistoryTracker {
+    /**
+     * Remap a list of pre-operation faces through a `ShapeHistory`'s
+     * modifications. For each input face:
+     *   - If it appears as a source in `modifiedFaces`, emit the corresponding
+     *     result faces (1:N).
+     *   - Otherwise, pass it through unchanged (it survived the operation with
+     *     the same TShape pointer).
+     *
+     * Use this to keep classification arrays (start/end/side/…) valid after a
+     * fusion has modified some of their faces.
+     */
+    static remapFaces(faces: Face[], history: ShapeHistory): Face[];
+    static remapEdges(edges: Edge[], history: ShapeHistory): Edge[];
+    static collect(maker: BRepBuilderAPI_MakeShape, inputs: Shape[]): ShapeHistory;
+    private static collectForType;
+}

package/lib/dist/common/shape-history-tracker.js

@@ -0,0 +1,114 @@
+import { getOC } from "../oc/init.js";
+import { Explorer } from "../oc/explorer.js";
+import { ShapeOps } from "../oc/shape-ops.js";
+import { Face } from "./face.js";
+import { Edge } from "./edge.js";
+export class ShapeHistoryTracker {
+    /**
+     * Remap a list of pre-operation faces through a `ShapeHistory`'s
+     * modifications. For each input face:
+     *   - If it appears as a source in `modifiedFaces`, emit the corresponding
+     *     result faces (1:N).
+     *   - Otherwise, pass it through unchanged (it survived the operation with
+     *     the same TShape pointer).
+     *
+     * Use this to keep classification arrays (start/end/side/…) valid after a
+     * fusion has modified some of their faces.
+     */
+    static remapFaces(faces, history) {
+        const result = [];
+        for (const face of faces) {
+            const record = history.modifiedFaces.find(m => m.sources.some(s => s.getShape().IsSame(face.getShape())));
+            if (record) {
+                result.push(...record.results);
+            }
+            else {
+                result.push(face);
+            }
+        }
+        return result;
+    }
+    static remapEdges(edges, history) {
+        const result = [];
+        for (const edge of edges) {
+            const record = history.modifiedEdges.find(m => m.sources.some(s => s.getShape().IsSame(edge.getShape())));
+            if (record) {
+                result.push(...record.results);
+            }
+            else {
+                result.push(edge);
+            }
+        }
+        return result;
+    }
+    static collect(maker, inputs) {
+        const oc = getOC();
+        const FACE = oc.TopAbs_ShapeEnum.TopAbs_FACE;
+        const EDGE = oc.TopAbs_ShapeEnum.TopAbs_EDGE;
+        const output = maker.Shape();
+        const outputFaces = Explorer.findShapes(output, FACE);
+        const outputEdges = Explorer.findShapes(output, EDGE);
+        const faces = ShapeHistoryTracker.collectForType(maker, inputs, FACE, outputFaces, (raw) => Face.fromTopoDSFace(Explorer.toFace(raw)));
+        const edges = ShapeHistoryTracker.collectForType(maker, inputs, EDGE, outputEdges, (raw) => Edge.fromTopoDSEdge(Explorer.toEdge(raw)));
+        return {
+            addedFaces: faces.added,
+            modifiedFaces: faces.modified,
+            generatedFaces: faces.generated,
+            removedFaces: faces.removed,
+            addedEdges: edges.added,
+            modifiedEdges: edges.modified,
+            generatedEdges: edges.generated,
+            removedEdges: edges.removed,
+        };
+    }
+    static collectForType(maker, inputs, type, outputRaws, wrap) {
+        const oc = getOC();
+        const modified = [];
+        const generated = [];
+        const removed = [];
+        // Collect every output raw that was either Modified or Generated from an input,
+        // so we can later classify the remaining outputs as pure additions.
+        const claimed = new oc.TopTools_MapOfShape();
+        const isOfType = (raw) => raw.ShapeType() === type;
+        for (const input of inputs) {
+            const inputRaws = Explorer.findShapes(input.getShape(), type);
+            for (const inputRaw of inputRaws) {
+                const modifiedRaws = ShapeOps.shapeListToArray(maker.Modified(inputRaw)).filter(isOfType);
+                const generatedRaws = ShapeOps.shapeListToArray(maker.Generated(inputRaw)).filter(isOfType);
+                const isDeleted = maker.IsDeleted(inputRaw);
+                if (modifiedRaws.length > 0) {
+                    modified.push({
+                        sources: [wrap(inputRaw)],
+                        results: modifiedRaws.map(wrap),
+                    });
+                    for (const r of modifiedRaws) {
+                        claimed.Add(r);
+                    }
+                }
+                if (generatedRaws.length > 0) {
+                    generated.push({
+                        sources: [wrap(inputRaw)],
+                        results: generatedRaws.map(wrap),
+                    });
+                    for (const r of generatedRaws) {
+                        claimed.Add(r);
+                    }
+                }
+                // An input that is deleted with no successor is a removal. If it was
+                // Modified into something, the modification record already captures
+                // its fate — don't double-count as removed.
+                if (isDeleted && modifiedRaws.length === 0 && generatedRaws.length === 0) {
+                    removed.push(wrap(inputRaw));
+                }
+            }
+        }
+        const added = [];
+        for (const raw of outputRaws) {
+            if (!claimed.Contains(raw)) {
+                added.push(wrap(raw));
+            }
+        }
+        claimed.delete();
+        return { added, modified, generated, removed };
+    }
+}

package/lib/dist/common/shape.js

@@ -87,7 +87,13 @@ export class Shape {
         if (this.isVertex()) {
             throw new Error("Cannot set color on vertex shape");
         }
-        this.colorMap.push({ shape: face, color });
+        const existing = this.colorMap.findIndex(c => c.shape.IsSame(face));
+        if (existing >= 0) {
+            this.colorMap[existing] = { shape: face, color };
+        }
+        else {
+            this.colorMap.push({ shape: face, color });
+        }
     }
     getColor(face) {
         const entry = this.colorMap.find(c => c.shape.IsSame(face));

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

@@ -3,4 +3,3 @@ export { Edge } from "./edge.js";
 export { Vertex } from "./vertex.js";
 export { Face } from "./face.js";
 export { Solid } from "./solid.js";
-export { SolidFace } from "./solid-face.js";

package/lib/dist/common/shapes.js

@@ -3,4 +3,3 @@ export { Edge } from "./edge.js";
 export { Vertex } from "./vertex.js";
 export { Face } from "./face.js";
 export { Solid } from "./solid.js";
-export { SolidFace } from "./solid-face.js";

package/lib/dist/common/solid.js

@@ -60,7 +60,11 @@ export class Solid extends Shape {
         return null;
     }
     copy() {
-        return new Solid(this.getShape());
+        const copied = new Solid(this.getShape());
+        for (const entry of this.colorMap) {
+            copied.colorMap.push({ shape: entry.shape, color: entry.color });
+        }
+        return copied;
     }
     static fromTopoDSSolid(solid) {
         return new Solid(solid);

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

@@ -2,45 +2,44 @@ import { IExtrude, ISceneObject } from "./interfaces.js";
 interface ExtrudeFunction {
     /**
      * Extrudes the last sketch with a default distance.
-     * @param target - The sketch to extrude
+     * @param target - The sketch or face-bearing scene object to extrude
      */
     (target?: ISceneObject): IExtrude;
     /**
-     * Extrudes the last sketch by a given distance.
+     * Extrudes by a given distance.
      * @param distance - The extrusion distance
-     * @param target - The sketch to extrude
+     * @param target - The sketch or face-bearing scene object to extrude
      */
     (distance: number, target?: ISceneObject): IExtrude;
     /**
-     * Extrudes the last sketch between two distances.
+     * Extrudes 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.
+     * Extrudes between two distances.
      * @param distance1 - The first extrusion distance
      * @param distance2 - The second extrusion distance
-     * @param target - The sketch to extrude
+     * @param target - The sketch or face-bearing scene object to extrude
      */
     (distance1: number, distance2: number, target: ISceneObject): IExtrude;
     /**
-     * Extrudes the last sketch up to a specific face.
+     * Extrudes up to a specific face.
      * @param face - A face selection to extrude up to
-     * @param target - The sketch to extrude
+     * @param target - The sketch or face-bearing scene object to extrude
      */
     (face: ISceneObject, target?: ISceneObject): IExtrude;
     /**
-     * Extrudes the last sketch up to the first intersecting face.
+     * Extrudes up to the first intersecting face.
      * @param face - The literal `'first-face'`
-     * @param target - The sketch to extrude
+     * @param target - The sketch or face-bearing scene object to extrude
      */
     (face: 'first-face', target?: ISceneObject): IExtrude;
     /**
-     * Extrudes the last sketch up to the last intersecting face.
+     * Extrudes up to the last intersecting face.
      * @param face - The literal `'last-face'`
-     * @param target - The sketch to extrude
+     * @param target - The sketch or face-bearing scene object to extrude
      */
     (face: 'last-face', target?: ISceneObject): IExtrude;
 }

package/lib/dist/core/extrude.js

@@ -3,9 +3,22 @@ import { registerBuilder } from "../index.js";
 import { Extrude } from "../features/extrude.js";
 import { ExtrudeTwoDistances } from "../features/extrude-two-distances.js";
 import { ExtrudeToFace } from "../features/extrude-to-face.js";
+import { SelectSceneObject } from "../features/select.js";
 function isExtrudable(obj) {
     return obj instanceof SceneObject && obj.isExtrudable();
 }
+function isFaceSource(obj) {
+    if (!(obj instanceof SceneObject)) {
+        return false;
+    }
+    if (isExtrudable(obj)) {
+        return false;
+    }
+    if (obj instanceof SelectSceneObject) {
+        return obj.shapeType() === 'face';
+    }
+    return true;
+}
 function build(context) {
     function doExtrude(params, extrudable) {
         const defaultDistance = 25;
@@ -41,8 +54,13 @@ function build(context) {
     return function extrude() {
         const args = [...arguments];
         let extrudable;
-        if (args.length > 0 && isExtrudable(args[args.length - 1])) {
+        const last = args.length > 0 ? args[args.length - 1] : undefined;
+        if (last !== undefined && isExtrudable(last)) {
+            extrudable = args.pop();
+        }
+        else if (last !== undefined && args.length >= 2 && isFaceSource(last)) {
             extrudable = args.pop();
+            context.addSceneObject(extrudable);
         }
         else {
             extrudable = context.getLastExtrudable() || undefined;

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

@@ -1,3 +1,4 @@
 import { ISceneObject } from "./interfaces.js";
-declare function part(name: string, callback: () => void): ISceneObject;
+type Extend<T> = T extends object ? T : {};
+declare function part<T>(name: string, callback: () => T): ISceneObject & Extend<T>;
 export default part;

package/lib/dist/core/part.js

@@ -12,8 +12,11 @@ function part(name, callback) {
         partObj.setSourceLocation(sourceLocation);
     }
     scene.startProgressiveContainer(partObj);
-    callback();
+    const extensions = callback();
     scene.endProgressiveContainer();
+    if (extensions && typeof extensions === 'object') {
+        Object.assign(partObj, extensions);
+    }
     return partObj;
 }
 export default part;

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

@@ -1,24 +1,25 @@
 import { PlaneLike } from "../math/plane.js";
 import { IPlane, ISceneObject } from "./interfaces.js";
+type Extend<T> = T extends object ? T : {};
 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;
+    <T>(plane: PlaneLike, sketcher: () => T): ISceneObject & Extend<T>;
     /**
      * Draws 2D geometry on a face selection.
      * @param face - The face to sketch on
      * @param sketcher - Callback containing sketch operations
      */
-    (face: ISceneObject, sketcher: () => void): ISceneObject;
+    <T>(face: ISceneObject, sketcher: () => T): ISceneObject & Extend<T>;
     /**
      * Draws 2D geometry on an existing Plane object.
      * @param plane - The Plane object to sketch on
      * @param sketcher - Callback containing sketch operations
      */
-    (plane: IPlane, sketcher: () => void): ISceneObject;
+    <T>(plane: IPlane, sketcher: () => T): ISceneObject & Extend<T>;
 }
 declare const _default: SketchFunction;
 export default _default;

package/lib/dist/core/sketch.js

@@ -26,8 +26,11 @@ function build(context) {
         }
         const sketch = new Sketch(planeObj);
         context.startProgressiveContainer(sketch);
-        sketcher();
+        const extensions = sketcher();
         context.endProgressiveContainer();
+        if (extensions && typeof extensions === 'object') {
+            Object.assign(sketch, extensions);
+        }
         return sketch;
     };
 }

package/lib/dist/features/chamfer.js

@@ -2,6 +2,7 @@ import { SceneObject } from "../common/scene-object.js";
 import { FilletOps } from "../oc/fillet-ops.js";
 import { Explorer } from "../oc/explorer.js";
 import { ShapeOps } from "../oc/shape-ops.js";
+import { ColorTransfer } from "../oc/color-transfer.js";
 export class Chamfer extends SceneObject {
     distance;
     distance2;
@@ -62,9 +63,9 @@ export class Chamfer extends SceneObject {
             }
             edges = edges.filter(e => !targetEdges.includes(e));
             try {
-                let newShape;
+                let preCleanSolids;
                 if (!this.distance2) {
-                    newShape = FilletOps.makeChamfer(solid, targetEdges, this.distance);
+                    preCleanSolids = FilletOps.makeChamfer(solid, targetEdges, this.distance);
                 }
                 else {
                     const faces = solid.getFaces();
@@ -78,13 +79,18 @@ export class Chamfer extends SceneObject {
                         }
                         commonFaces.push(firstCommonFace);
                     }
-                    newShape = FilletOps.makeChamferTwoDistances(solid, targetEdges, this.distance, this.distance2, commonFaces, this.isAngle);
+                    preCleanSolids = FilletOps.makeChamferTwoDistances(solid, targetEdges, this.distance, this.distance2, commonFaces, this.isAngle);
                 }
                 const obj = shapeObjectMap.get(shape);
                 obj.removeShape(shape, this);
-                const subShapes = Explorer.findSolidsWrapped(ShapeOps.cleanShape(newShape));
-                for (const subShape of subShapes) {
-                    newShapes.push(subShape);
+                // Clean each chamfer result and chain colors through the cleanup's
+                // UnifySameDomain history so any merged faces keep their colors.
+                for (const preClean of preCleanSolids) {
+                    const cleanup = ShapeOps.cleanShapeWithLineage(preClean);
+                    ColorTransfer.applyThroughCleanup(preClean, cleanup);
+                    const cleaned = cleanup.shape;
+                    cleanup.dispose();
+                    newShapes.push(cleaned);
                 }
             }
             catch {