Fix node decomposing at drop time

packages/dev/sharedUiComponents/src/nodeGraphSystem/frameNodePort.ts

@@ -50,7 +50,7 @@ export class FrameNodePort extends NodePort {
         framePortId: number,
         parentFrameId: number
     ) {
-        super(portContainer, portData.data, node, stateManager);
+        super(portContainer, portData, node, stateManager);
 
         this._parentFrameId = parentFrameId;
         this._isInput = isInput;

packages/dev/sharedUiComponents/src/nodeGraphSystem/graphCanvas.tsx

@@ -307,15 +307,13 @@ export class GraphCanvasComponent extends React.Component<IGraphCanvasComponentP
             return this.nodes.filter((n) => n.content.data === nodeData.data)[0];
         }
 
-        this._nodeDataContentList.push(nodeData.data);
-
         onNodeCreated(nodeData.data);
 
         // Connections
         if (nodeData.inputs.length) {
             for (const input of nodeData.inputs) {
                 if (input.connectedPort && recursion) {
-                    this.createNodeFromObject(TypeLedger.NodeDataBuilder(input.connectedPort, this), onNodeCreated);
+                    this.createNodeFromObject(TypeLedger.NodeDataBuilder(input.connectedPort.ownerData, this), onNodeCreated);
                 }
             }
         }
@@ -440,12 +438,13 @@ export class GraphCanvasComponent extends React.Component<IGraphCanvasComponentP
         link.dispose();
     }
 
-    appendNode(data: INodeData) {
-        const newNode = new GraphNode(data, this.props.stateManager);
+    appendNode(nodeData: INodeData) {
+        const newNode = new GraphNode(nodeData, this.props.stateManager);
 
         newNode.appendVisual(this._graphCanvas, this);
 
         this._nodes.push(newNode);
+        this._nodeDataContentList.push(nodeData.data);
 
         return newNode;
     }

packages/dev/sharedUiComponents/src/nodeGraphSystem/graphFrame.ts

@@ -156,11 +156,13 @@ export class GraphFrame {
         for (let i = 0; i < this._exposedOutPorts.length; ) {
             // Output
             const port = this._exposedOutPorts[i];
-            if (port.node === null || port.node.enclosingFrameId != this.id) {
-                if (this._removePortFromExposedWithNode(port, this._exposedOutPorts)) continue;
-            } else {
-                if (!this._createOutputPorts(port, port.node) && this._removePortFromExposedWithNode(port, this._exposedOutPorts)) {
-                    continue;
+            if (port) {
+                if (port.node === null || port.node.enclosingFrameId != this.id) {
+                    if (this._removePortFromExposedWithNode(port, this._exposedOutPorts)) continue;
+                } else {
+                    if (!this._createOutputPorts(port, port.node) && this._removePortFromExposedWithNode(port, this._exposedOutPorts)) {
+                        continue;
+                    }
                 }
             }
             ++i;

packages/dev/sharedUiComponents/src/nodeGraphSystem/interfaces/nodeContainer.ts

@@ -1,5 +1,7 @@
 import type { GraphNode } from "../graphNode";
+import type { INodeData } from "./nodeData";
 
 export interface INodeContainer {
     nodes: GraphNode[];
+    appendNode(data: INodeData): GraphNode;
 }

packages/tools/nodeEditor/src/graphSystem/blockNodeData.ts

@@ -68,12 +68,16 @@ export class BlockNodeData implements INodeData {
     }
 
     public constructor(public data: NodeMaterialBlock, nodeContainer: INodeContainer) {
-        this.data.inputs.forEach((input) => {
-            this._inputs.push(new ConnectionPointPortData(input, nodeContainer));
-        });
+        if (data.inputs) {
+            this.data.inputs.forEach((input) => {
+                this._inputs.push(new ConnectionPointPortData(input, nodeContainer));
+            });
+        }
 
-        this.data.outputs.forEach((output) => {
-            this._outputs.push(new ConnectionPointPortData(output, nodeContainer));
-        });
+        if (data.outputs) {
+            this.data.outputs.forEach((output) => {
+                this._outputs.push(new ConnectionPointPortData(output, nodeContainer));
+            });
+        }
     }
 }

packages/tools/nodeEditor/src/graphSystem/connectionPointPortData.ts

@@ -6,6 +6,7 @@ import type { GraphNode } from "shared-ui-components/nodeGraphSystem/graphNode";
 import type { INodeContainer } from "shared-ui-components/nodeGraphSystem/interfaces/nodeContainer";
 import type { IPortData } from "shared-ui-components/nodeGraphSystem/interfaces/portData";
 import { PortDataDirection } from "shared-ui-components/nodeGraphSystem/interfaces/portData";
+import { TypeLedger } from "shared-ui-components/nodeGraphSystem/typeLedger";
 
 export class ConnectionPointPortData implements IPortData {
     private _connectedPort: Nullable<IPortData> = null;
@@ -53,11 +54,13 @@ export class ConnectionPointPortData implements IPortData {
         }
         if (!this._connectedPort) {
             const otherBlock = this.data.connectedPoint!.ownerBlock;
-            const otherNode = this._nodeContainer.nodes.find((n) => n.content.data === otherBlock);
+            let otherNode = this._nodeContainer.nodes.find((n) => n.content.data === otherBlock);
 
-            if (otherNode) {
-                this._connectedPort = otherNode.getPortDataForPortDataContent(this.data.connectedPoint!);
+            if (!otherNode) {
+                otherNode = this._nodeContainer.appendNode(TypeLedger.NodeDataBuilder(otherBlock, this._nodeContainer));
             }
+
+            this._connectedPort = otherNode.getPortDataForPortDataContent(this.data.connectedPoint!);
         }
 
         return this._connectedPort;

packages/tools/nodeEditor/src/graphSystem/registerToTypeLedger.ts

@@ -1,5 +1,4 @@
 import type { NodeMaterialConnectionPoint } from "core/Materials/Node/nodeMaterialBlockConnectionPoint";
-import type { INodeContainer } from "shared-ui-components/nodeGraphSystem/interfaces/nodeContainer";
 import { TypeLedger } from "shared-ui-components/nodeGraphSystem/typeLedger";
 import { BlockNodeData } from "./blockNodeData";
 import { ConnectionPointPortData } from "./connectionPointPortData";
@@ -9,7 +8,7 @@ export const RegisterTypeLedger = () => {
         return new ConnectionPointPortData(data.portData.data as NodeMaterialConnectionPoint, nodeContainer);
     };
 
-    TypeLedger.NodeDataBuilder = (data, nodeContainer: INodeContainer) => {
+    TypeLedger.NodeDataBuilder = (data, nodeContainer) => {
         return new BlockNodeData(data, nodeContainer);
     };
 };