fluidcad 0.0.2

package/lib/dist/oc/wire-ops.js

@@ -0,0 +1,176 @@
+import { getOC } from "./init.js";
+import { Wire } from "../common/wire.js";
+import { Explorer } from "./explorer.js";
+import { Convert } from "./convert.js";
+export class WireOps {
+    static isCW(wire, normal) {
+        return WireOps.isCWRaw(wire.getShape(), normal);
+    }
+    static makeWireFromEdges(edges) {
+        return Wire.fromTopoDSWire(WireOps.makeWireFromEdgesRaw(edges.map(e => e.getShape())));
+    }
+    static reverseWire(wire) {
+        return Wire.fromTopoDSWire(WireOps.reverseWireRaw(wire.getShape()));
+    }
+    static buildWire(edges) {
+        return Wire.fromTopoDSWire(WireOps.buildWireRaw(edges.map(e => e.getShape())));
+    }
+    static offsetWire(shape, distance, isOpen) {
+        const wire = shape instanceof Wire ? shape : WireOps.makeWireFromEdges([shape]);
+        return Wire.fromTopoDSWire(WireOps.offsetWireRaw(wire.getShape(), distance, isOpen));
+    }
+    static isCWRaw(wire, normal) {
+        const oc = getOC();
+        const adaptor = new oc.BRepAdaptor_CompCurve(wire, false);
+        const u0 = adaptor.FirstParameter();
+        const u1 = adaptor.LastParameter();
+        const N = 64;
+        let signedArea = 0;
+        for (let i = 0; i < N; i++) {
+            const ua = u0 + (u1 - u0) * i / N;
+            const ub = u0 + (u1 - u0) * (i + 1) / N;
+            const a = adaptor.Value(ua);
+            const b = adaptor.Value(ub);
+            signedArea += (a.Y() * b.Z() - a.Z() * b.Y()) * normal.x
+                + (a.Z() * b.X() - a.X() * b.Z()) * normal.y
+                + (a.X() * b.Y() - a.Y() * b.X()) * normal.z;
+            a.delete();
+            b.delete();
+        }
+        adaptor.delete();
+        return signedArea < 0;
+    }
+    static makeWireFromEdgesRaw(edges) {
+        const oc = getOC();
+        const wireMaker = new oc.BRepBuilderAPI_MakeWire();
+        for (const edge of edges) {
+            wireMaker.Add(oc.TopoDS.Edge(edge));
+        }
+        if (!wireMaker.IsDone()) {
+            wireMaker.delete();
+            throw new Error("Failed to create wire from edges");
+        }
+        const wire = wireMaker.Wire();
+        wireMaker.delete();
+        return wire;
+    }
+    static reverseWireRaw(wire) {
+        const oc = getOC();
+        const wd = new oc.ShapeExtend_WireData(wire, true, true);
+        wd.Reverse();
+        const result = wd.Wire();
+        wd.delete();
+        return result;
+        // const oc = getOC();
+        // return oc.TopoDS.Wire(wire.Reversed());
+    }
+    static buildWireRaw(edges) {
+        const oc = getOC();
+        const wireMaker = new oc.BRepBuilderAPI_MakeWire();
+        for (const edge of edges) {
+            wireMaker.Add(edge);
+        }
+        if (!wireMaker.IsDone()) {
+            wireMaker.delete();
+            throw new Error("Failed to create Wire: " + wireMaker.Error());
+        }
+        const wire = wireMaker.Wire();
+        wireMaker.delete();
+        return wire;
+    }
+    static fixWire(wire, plane) {
+        const oc = getOC();
+        const [pln, disposePlane] = Convert.toGpPln(plane);
+        const faceMaker = new oc.BRepBuilderAPI_MakeFace(pln);
+        if (!faceMaker.IsDone()) {
+            faceMaker.delete();
+            disposePlane();
+            throw new Error("Failed to create face for wire fixing");
+        }
+        const face = faceMaker.Face();
+        faceMaker.delete();
+        const fixedWire = WireOps.fixWireRaw(wire.getShape(), face);
+        disposePlane();
+        return Wire.fromTopoDSWire(fixedWire);
+    }
+    static fixWireRaw(wire, face) {
+        const oc = getOC();
+        const fixer = new oc.ShapeFix_Wire(wire, face, oc.Precision.Confusion());
+        fixer.FixDegenerated();
+        fixer.FixGaps2d();
+        fixer.FixEdgeCurves();
+        fixer.FixConnected(oc.Precision.Confusion());
+        fixer.FixReorder();
+        fixer.Perform();
+        const fixed = fixer.Wire();
+        fixer.delete();
+        return oc.TopoDS.Wire(fixed);
+    }
+    static groupConnectedEdges(edges) {
+        if (edges.length === 0) {
+            return [];
+        }
+        const visited = new Set();
+        const groups = [];
+        for (let i = 0; i < edges.length; i++) {
+            if (visited.has(i)) {
+                continue;
+            }
+            const group = [];
+            const queue = [i];
+            visited.add(i);
+            while (queue.length > 0) {
+                const idx = queue.shift();
+                group.push(edges[idx]);
+                const v1 = edges[idx].getFirstVertex();
+                const v2 = edges[idx].getLastVertex();
+                for (let j = 0; j < edges.length; j++) {
+                    if (visited.has(j)) {
+                        continue;
+                    }
+                    const ov1 = edges[j].getFirstVertex();
+                    const ov2 = edges[j].getLastVertex();
+                    if (WireOps.verticesMatch(v1, ov1) || WireOps.verticesMatch(v1, ov2) ||
+                        WireOps.verticesMatch(v2, ov1) || WireOps.verticesMatch(v2, ov2)) {
+                        visited.add(j);
+                        queue.push(j);
+                    }
+                }
+            }
+            groups.push(group);
+        }
+        return groups;
+    }
+    static verticesMatch(v1, v2) {
+        if (v1.compareTo(v2)) {
+            return true;
+        }
+        const p1 = v1.toPoint();
+        const p2 = v2.toPoint();
+        const dx = p1.x - p2.x;
+        const dy = p1.y - p2.y;
+        const dz = p1.z - p2.z;
+        return (dx * dx + dy * dy + dz * dz) < 1e-14;
+    }
+    static offsetWireRaw(wire, distance, isOpen) {
+        const oc = getOC();
+        const maker = new oc.BRepOffsetAPI_MakeOffset();
+        maker.Init(oc.GeomAbs_JoinType.GeomAbs_Arc, isOpen);
+        maker.AddWire(wire);
+        maker.Perform(distance, 0);
+        if (!maker.IsDone()) {
+            maker.delete();
+            throw new Error("Failed to offset wire");
+        }
+        const result = maker.Shape();
+        maker.delete();
+        if (Explorer.isWire(result)) {
+            return oc.TopoDS.Wire(result);
+        }
+        const wires = Explorer.findShapes(result, oc.TopAbs_ShapeEnum.TopAbs_WIRE);
+        if (wires.length === 0) {
+            throw new Error("Offset produced no wires");
+        }
+        return oc.TopoDS.Wire(wires[0]);
+    }
+}

package/lib/dist/rendering/builder-context.d.ts

@@ -0,0 +1,16 @@
+import { SceneObject } from "../common/scene-object.js";
+import { Shape, ShapeFilter } from "../common/shape.js";
+import { SelectSceneObject } from "../features/select.js";
+import { Extrudable } from "../helpers/types.js";
+export declare class SceneBuilderContext {
+    private sceneObjects;
+    constructor(sceneObjects: SceneObject[]);
+    getSceneObjects(): SceneObject[];
+    getObjectShapesMap(filter?: ShapeFilter): Map<SceneObject, Shape<import("occjs-wrapper").TopoDS_Shape>[]>;
+    getActiveSceneObjects(): SceneObject[];
+    getSceneObjectsFromTo(from: SceneObject, to: SceneObject): SceneObject[];
+    getLastExtrudable(): Extrudable;
+    getLastSelections(): any[];
+    getLastSelection(): SelectSceneObject;
+    addObject(obj: SceneObject): void;
+}

package/lib/dist/rendering/builder-context.js

@@ -0,0 +1,63 @@
+import { SelectSceneObject } from "../features/select.js";
+export class SceneBuilderContext {
+    sceneObjects;
+    constructor(sceneObjects) {
+        this.sceneObjects = sceneObjects;
+    }
+    getSceneObjects() {
+        return this.sceneObjects;
+    }
+    getObjectShapesMap(filter) {
+        const map = new Map();
+        for (const obj of this.sceneObjects) {
+            const shapes = obj.getShapes(filter, 'solid');
+            if (shapes.length === 0) {
+                continue;
+            }
+            map.set(obj, shapes);
+        }
+        return map;
+    }
+    getActiveSceneObjects() {
+        return this.sceneObjects.filter(f => f.hasShapes());
+    }
+    getSceneObjectsFromTo(from, to) {
+        const fromIndex = this.sceneObjects.findIndex(f => f === from);
+        const toIndex = this.sceneObjects.findIndex(f => f === to);
+        return this.sceneObjects.slice(fromIndex, toIndex);
+    }
+    getLastExtrudable() {
+        let count = this.sceneObjects.length;
+        while (count--) {
+            const object = this.sceneObjects[count];
+            if (object.isExtrudable() && !object.parentId) {
+                return object;
+            }
+        }
+        return null;
+    }
+    getLastSelections() {
+        let count = this.sceneObjects.length;
+        const selections = [];
+        while (count--) {
+            const obj = this.sceneObjects[count];
+            if (obj instanceof SelectSceneObject) {
+                selections.push(obj);
+            }
+        }
+        return selections;
+    }
+    getLastSelection() {
+        let count = this.sceneObjects.length;
+        while (count--) {
+            const obj = this.sceneObjects[count];
+            if (obj instanceof SelectSceneObject) {
+                return obj;
+            }
+        }
+        return null;
+    }
+    addObject(obj) {
+        this.sceneObjects.push(obj);
+    }
+}

package/lib/dist/rendering/mesh-builder.d.ts

@@ -0,0 +1,5 @@
+import { Shape } from "../common/shape.js";
+import { SceneObjectMesh } from "./scene.js";
+export declare class MeshBuilder {
+    build(shapeObj: Shape): SceneObjectMesh[];
+}

package/lib/dist/rendering/mesh-builder.js

@@ -0,0 +1,43 @@
+import { Explorer } from "../oc/explorer.js";
+import { renderSolid } from "./render-solid.js";
+import { renderFace } from "./render-face.js";
+import { renderWire } from "./render-wire.js";
+import { renderEdge } from "./render-edge.js";
+export class MeshBuilder {
+    build(shapeObj) {
+        const shape = shapeObj.getShape();
+        let result = null;
+        if (Explorer.isSolid(shape)) {
+            result = renderSolid(shapeObj);
+        }
+        else if (Explorer.isFace(shape)) {
+            result = renderFace(shapeObj);
+        }
+        else if (Explorer.isWire(shape)) {
+            result = renderWire(shapeObj);
+        }
+        else if (Explorer.isEdge(shape)) {
+            result = renderEdge(shapeObj);
+        }
+        else if (Explorer.isCompound(shape)) {
+            console.warn("Compound shapes are not supported yet.");
+        }
+        else if (Explorer.isCompoundSolid(shape)) {
+            console.warn("CompSolid shapes are not supported yet.");
+        }
+        else if (Explorer.isShell(shape)) {
+            console.warn("Shell shapes are not supported yet.");
+        }
+        else if (Explorer.isVertex(shape)) {
+            console.warn("Vertex shapes are not supported yet.");
+        }
+        else {
+            console.warn("Shape is not a valid TopoDS_Shape.");
+        }
+        if (result) {
+            const meshes = Array.isArray(result) ? result : [result];
+            return meshes;
+        }
+        return null;
+    }
+}

package/lib/dist/rendering/render-edge.d.ts

@@ -0,0 +1,3 @@
+import { Shape } from "../common/shape.js";
+import type { SceneObjectMesh } from "./scene.js";
+export declare function renderEdge(edgeObj: Shape): SceneObjectMesh;

package/lib/dist/rendering/render-edge.js

@@ -0,0 +1,4 @@
+import { Mesh } from "../oc/mesh.js";
+export function renderEdge(edgeObj) {
+    return Mesh.discretizeEdge(edgeObj);
+}

package/lib/dist/rendering/render-face.d.ts

@@ -0,0 +1,2 @@
+import { Shape } from "../common/shape.js";
+export declare function renderFace(faceObj: Shape, vertexOffset?: number): import("../oc/mesh.js").MeshData;

package/lib/dist/rendering/render-face.js

@@ -0,0 +1,5 @@
+import { Mesh } from "../oc/mesh.js";
+export function renderFace(faceObj, vertexOffset = 0) {
+    const face = faceObj.getShape();
+    return Mesh.triangulateFaceRaw(face, vertexOffset);
+}

package/lib/dist/rendering/render-solid.d.ts

@@ -0,0 +1,3 @@
+import { Shape } from "../common/shape.js";
+import { SceneObjectMesh } from "./scene.js";
+export declare function renderSolid(shapeObj: Shape): SceneObjectMesh[];

package/lib/dist/rendering/render-solid.js

@@ -0,0 +1,61 @@
+import { renderFace } from "./render-face.js";
+import { renderEdge } from "./render-edge.js";
+import { Explorer } from "../oc/explorer.js";
+export function renderSolid(shapeObj) {
+    const facesMeshes = getFacesMesh(shapeObj);
+    const edgesMesh = getEdgesMesh(shapeObj);
+    return [...facesMeshes, ...edgesMesh];
+}
+function getEdgesMesh(shapeObj) {
+    const result = [];
+    const edges = Explorer.findEdgesWrapped(shapeObj);
+    for (let edgeIdx = 0; edgeIdx < edges.length; edgeIdx++) {
+        const edgeResult = renderEdge(edges[edgeIdx]);
+        if (edgeResult) {
+            edgeResult.label = 'solid-edges';
+            edgeResult.edgeIndex = edgeIdx;
+            result.push(edgeResult);
+        }
+    }
+    return result;
+}
+function getFacesMesh(shapeObj) {
+    const faces = Explorer.findFacesWrapped(shapeObj);
+    const groups = new Map();
+    for (let faceIdx = 0; faceIdx < faces.length; faceIdx++) {
+        const face = faces[faceIdx];
+        const color = shapeObj.getColor(face.getShape());
+        const faceResult = renderFace(face, 0);
+        if (faceResult) {
+            if (!groups.has(color)) {
+                groups.set(color, { vertices: [], normals: [], indices: [], faceMapping: [], vertexOffset: 0 });
+            }
+            const group = groups.get(color);
+            const triangleCount = faceResult.indices.length / 3;
+            for (let t = 0; t < triangleCount; t++) {
+                group.faceMapping.push(faceIdx);
+            }
+            group.vertices.push(...faceResult.vertices);
+            group.normals.push(...faceResult.normals);
+            for (const idx of faceResult.indices) {
+                group.indices.push(group.vertexOffset + idx);
+            }
+            group.vertexOffset += faceResult.count;
+        }
+    }
+    const result = [];
+    for (const [color, group] of groups) {
+        const mesh = {
+            vertices: group.vertices,
+            normals: group.normals,
+            indices: group.indices,
+            faceMapping: group.faceMapping,
+            label: "solid-faces",
+        };
+        if (color) {
+            mesh.color = color;
+        }
+        result.push(mesh);
+    }
+    return result;
+}

package/lib/dist/rendering/render-wire.d.ts

@@ -0,0 +1,6 @@
+import { Shape } from "../common/shape.js";
+export declare function renderWire(shapeObj: Shape): {
+    vertices: number[];
+    normals: number[];
+    indices: number[];
+};

package/lib/dist/rendering/render-wire.js

@@ -0,0 +1,27 @@
+import { renderEdge } from "./render-edge.js";
+import { Edge } from "../common/edge.js";
+import { Explorer } from "../oc/explorer.js";
+export function renderWire(shapeObj) {
+    const shape = shapeObj.getShape();
+    const edges = Explorer.findShapes(shape, Explorer.getOcShapeType("edge"));
+    const allVertices = [];
+    const allNormals = [];
+    const allIndices = [];
+    for (const current of edges) {
+        const edge = Explorer.toEdge(current);
+        const edgeResult = renderEdge(Edge.fromTopoDSEdge(edge));
+        if (edgeResult) {
+            const vertexOffset = allVertices.length / 3;
+            allVertices.push(...edgeResult.vertices);
+            allNormals.push(...edgeResult.normals);
+            for (let i = 0; i < edgeResult.indices.length; i++) {
+                allIndices.push(edgeResult.indices[i] + vertexOffset);
+            }
+        }
+    }
+    return {
+        vertices: allVertices,
+        normals: allNormals,
+        indices: allIndices
+    };
+}

package/lib/dist/rendering/render.d.ts

@@ -0,0 +1,3 @@
+import { Scene } from "./scene.js";
+export declare function renderSceneRollback(scene: Scene, rollbackIndex: number): Scene;
+export declare function renderScene(scene: Scene): Scene;

package/lib/dist/rendering/render.js

@@ -0,0 +1,183 @@
+import { MeshBuilder } from "./mesh-builder.js";
+import { PlaneObjectBase } from "../features/plane-renderable-base.js";
+import { AxisObjectBase } from "../features/axis-renderable-base.js";
+const meshBuilder = new MeshBuilder();
+function renderSceneObject(obj, scene) {
+    const hasError = !!obj.getError();
+    const sceneShapes = obj.getOwnShapes({ excludeMeta: false, excludeGuide: false });
+    const renderedSceneShapes = [];
+    if (sceneShapes.length) {
+        console.log(` - Scene shapes: ${sceneShapes.length}`);
+        for (const shape of sceneShapes) {
+            let meshes = shape.getMeshes();
+            if (!meshes) {
+                meshes = meshBuilder.build(shape);
+                shape.setMeshes(meshes);
+            }
+            const shapeType = shape.getType();
+            renderedSceneShapes.push({
+                shapeId: shape.id,
+                meshes,
+                shapeType,
+                isMetaShape: shape.isMetaShape() || undefined,
+                isGuide: shape.isGuideShape() || undefined,
+                metaType: shape.metaType || undefined,
+                metaData: shape.metaData || undefined,
+            });
+        }
+    }
+    let isVisible = !!sceneShapes.length;
+    if (obj.isAlwaysVisible()) {
+        isVisible = true;
+    }
+    else if (obj.isContainer()) {
+        const children = scene.getChildren(obj);
+        isVisible = children.some(child => {
+            const shapes = child.getOwnShapes();
+            return shapes.length > 0;
+        });
+    }
+    scene.addRenderedObject(obj, {
+        id: obj.id,
+        name: obj.getName(),
+        parentId: obj.parentId,
+        object: obj.serialize(),
+        sceneShapes: renderedSceneShapes,
+        type: obj.getType(),
+        uniqueType: obj.getUniqueType(),
+        fromCache: scene.isCached(obj),
+        visible: isVisible,
+        isContainer: obj.isContainer(),
+        hasError,
+        errorMessage: obj.getError() || undefined,
+        sourceLocation: obj.getSourceLocation() || undefined,
+    });
+}
+export function renderSceneRollback(scene, rollbackIndex) {
+    console.log("============ Rollback Rendering ==============", rollbackIndex);
+    const scope = new Set();
+    const allObjects = scene.getAllSceneObjects();
+    for (let i = 0; i <= rollbackIndex && i < allObjects.length; i++) {
+        scope.add(allObjects[i]);
+    }
+    scene.clearRenderedObjects();
+    for (const obj of allObjects) {
+        const inScope = scope.has(obj);
+        if (inScope) {
+            const sceneShapes = obj.getOwnShapes({ excludeMeta: false }, scope);
+            const renderedSceneShapes = [];
+            for (const shape of sceneShapes) {
+                let meshes = shape.getMeshes();
+                if (!meshes) {
+                    meshes = meshBuilder.build(shape);
+                    shape.setMeshes(meshes);
+                }
+                renderedSceneShapes.push({
+                    shapeId: shape.id,
+                    meshes,
+                    shapeType: shape.getType(),
+                    isMetaShape: shape.isMetaShape() || undefined,
+                    isGuide: shape.isGuideShape() || undefined,
+                });
+            }
+            let isVisible = !!sceneShapes.length;
+            if (obj.isAlwaysVisible()) {
+                isVisible = true;
+            }
+            else if (obj.isContainer()) {
+                const children = scene.getChildren(obj);
+                isVisible = children.some(child => {
+                    if (!scope.has(child))
+                        return false;
+                    const shapes = child.getOwnShapes({ excludeMeta: true }, scope);
+                    return shapes.length > 0;
+                });
+            }
+            scene.addRenderedObject(obj, {
+                id: obj.id,
+                name: obj.getName(),
+                parentId: obj.parentId,
+                object: obj.serialize(),
+                sceneShapes: renderedSceneShapes,
+                type: obj.getType(),
+                uniqueType: obj.getUniqueType(),
+                fromCache: scene.isCached(obj),
+                visible: isVisible,
+                isContainer: obj.isContainer(),
+                hasError: false,
+                sourceLocation: obj.getSourceLocation() || undefined,
+            });
+        }
+        else {
+            scene.addRenderedObject(obj, {
+                id: obj.id,
+                name: obj.getName(),
+                parentId: obj.parentId,
+                object: obj.serialize(),
+                sceneShapes: [],
+                type: obj.getType(),
+                uniqueType: obj.getUniqueType(),
+                fromCache: scene.isCached(obj),
+                visible: false,
+                isContainer: obj.isContainer(),
+                hasError: false,
+                sourceLocation: obj.getSourceLocation() || undefined,
+            });
+        }
+    }
+    const result = scene.getRenderedObjects();
+    console.table(result);
+    return scene;
+}
+export function renderScene(scene) {
+    const sceneObjects = scene.getAllSceneObjects();
+    console.log("============ Rendering ==============", sceneObjects.length);
+    for (const object of sceneObjects) {
+        console.log("Rendering object:", object.getUniqueType());
+        const isCached = scene.isCached(object);
+        if (!isCached) {
+            object.clearError();
+            try {
+                object.build({
+                    getSceneObjects() {
+                        return scene.getPartScopedObjectsUpTo(object);
+                    },
+                    getActiveSceneObjects() {
+                        return scene.getPartScopedActiveObjectsUpTo(object);
+                    },
+                    getSceneObjectsFromTo(from, to) {
+                        return scene.getSceneObjectsFromTo(from, to);
+                    },
+                    getTransform() {
+                        return object.getTransform();
+                    },
+                    getLastObject() {
+                        const objects = scene.getSceneObjectsUpTo(object);
+                        for (let i = objects.length - 1; i >= 0; i--) {
+                            const obj = objects[i];
+                            if (!(obj instanceof PlaneObjectBase) && !(obj instanceof AxisObjectBase)) {
+                                return obj;
+                            }
+                        }
+                        return null;
+                    },
+                });
+            }
+            catch (error) {
+                const message = error instanceof Error ? error.message : String(error);
+                console.error(`Error building object ${object.getUniqueType()}:`, error);
+                object.setError(message);
+            }
+        }
+    }
+    // Cleanup pass — let objects adjust based on final scene state
+    for (const object of sceneObjects) {
+        object.clean(scene.getPartScopedAllObjects(object));
+    }
+    for (const object of sceneObjects) {
+        renderSceneObject(object, scene);
+    }
+    const result = scene.getRenderedObjects();
+    console.table(result);
+    return scene;
+}

package/lib/dist/rendering/scene-compare.d.ts

@@ -0,0 +1,4 @@
+import { Scene } from "./scene.js";
+export declare class SceneCompare {
+    static compare(oldScene: Scene, newScene: Scene): Scene;
+}

package/lib/dist/rendering/scene-compare.js

@@ -0,0 +1,41 @@
+export class SceneCompare {
+    static compare(oldScene, newScene) {
+        const map = new Map();
+        for (let i = 0; i < newScene.getSceneObjects().length; i++) {
+            const newObj = newScene.getSceneObjectAt(i);
+            const oldObj = oldScene.getSceneObjectAt(i);
+            console.log('Checking:', newObj?.getUniqueType());
+            let oldMatch = null;
+            if (!oldObj || oldObj.getUniqueType() !== newObj.getUniqueType() || !oldObj.compareTo(newObj)) {
+                console.log('NO MATCH:', newObj.getUniqueType());
+                break;
+            }
+            console.log('MATCHED:', oldObj.getUniqueType());
+            oldMatch = oldObj;
+            newScene.markCached(newObj);
+            map.set(oldMatch, newObj);
+        }
+        // copy state from old to new
+        for (const [oldObj, newObj] of map.entries()) {
+            const oldSttate = oldObj.getFullState();
+            const oldRemovedShapes = oldSttate.get('removedShapes');
+            const newRemovedShapes = [];
+            for (const r of oldRemovedShapes) {
+                const removedByNewObj = map.get(r.removedBy);
+                if (removedByNewObj) {
+                    newRemovedShapes.push({
+                        shape: r.shape,
+                        removedBy: removedByNewObj,
+                    });
+                }
+            }
+            oldSttate.set('removedShapes', newRemovedShapes);
+            newObj.restoreState(oldSttate);
+            const oldError = oldObj.getError();
+            if (oldError) {
+                newObj.setError(oldError);
+            }
+        }
+        return newScene;
+    }
+}