feat: Refactor simulation components and enhance product management with new features

app/src/store/simulation/useArmBotStore.ts

@@ -17,6 +17,9 @@ interface ArmBotStore {
     addAction: (modelUuid: string, action: RoboticArmPointSchema['actions'][number]) => void;
     removeAction: (modelUuid: string, actionUuid: string) => void;
 
+    updateStartPoint: (modelUuid: string, actionUuid: string, startPoint: [number, number, number] | null) => void;
+    updateEndPoint: (modelUuid: string, actionUuid: string, endPoint: [number, number, number] | null) => void;
+
     setArmBotActive: (modelUuid: string, isActive: boolean) => void;
 
     incrementActiveTime: (modelUuid: string, incrementBy: number) => void;
@@ -106,6 +109,30 @@ export const useArmBotStore = create<ArmBotStore>()(
             });
         },
 
+        updateStartPoint: (modelUuid, actionUuid, startPoint) => {
+            set((state) => {
+                const armBot = state.armBots.find(a => a.modelUuid === modelUuid);
+                if (armBot) {
+                    const action = armBot.point.actions.find(a => a.actionUuid === actionUuid);
+                    if (action) {
+                        action.process.startPoint = startPoint;
+                    }
+                }
+            });
+        },
+
+        updateEndPoint: (modelUuid, actionUuid, endPoint) => {
+            set((state) => {
+                const armBot = state.armBots.find(a => a.modelUuid === modelUuid);
+                if (armBot) {
+                    const action = armBot.point.actions.find(a => a.actionUuid === actionUuid);
+                    if (action) {
+                        action.process.endPoint = endPoint;
+                    }
+                }
+            });
+        },
+
         setArmBotActive: (modelUuid, isActive) => {
             set((state) => {
                 const armBot = state.armBots.find(a => a.modelUuid === modelUuid);

app/src/store/simulation/useProductStore.ts

@@ -48,6 +48,11 @@ type ProductsStore = {
         updates: Partial<TriggerSchema>
     ) => void;
 
+    // Renaming functions
+    renameProduct: (productId: string, newName: string) => void;
+    renameAction: (actionUuid: string, newName: string) => void;
+    renameTrigger: (triggerUuid: string, newName: string) => void;
+
     // Helper functions
     getProductById: (productId: string) => { productName: string; productId: string; eventsData: EventsSchema[] } | undefined;
 };
@@ -331,6 +336,84 @@ export const useProductStore = create<ProductsStore>()(
             });
         },
 
+        // Renaming functions
+        renameProduct: (productId, newName) => {
+            set((state) => {
+                const product = state.products.find(p => p.productId === productId);
+                if (product) {
+                    product.productName = newName;
+                }
+            });
+        },
+
+        renameAction: (actionUuid, newName) => {
+            set((state) => {
+                for (const product of state.products) {
+                    for (const event of product.eventsData) {
+                        if ('points' in event) {
+                            for (const point of (event as ConveyorEventSchema).points) {
+                                if (point.action && point.action.actionUuid === actionUuid) {
+                                    point.action.actionName = newName;
+                                    return;
+                                }
+                            }
+                        } else if ('point' in event) {
+                            const point = (event as any).point;
+                            if ('action' in point && point.action.actionUuid === actionUuid) {
+                                point.action.actionName = newName;
+                                return;
+                            } else if ('actions' in point) {
+                                const action = point.actions.find((a: any) => a.actionUuid === actionUuid);
+                                if (action) {
+                                    action.actionName = newName;
+                                    return;
+                                }
+                            }
+                        }
+                    }
+                }
+            });
+        },
+
+        renameTrigger: (triggerUuid, newName) => {
+            set((state) => {
+                for (const product of state.products) {
+                    for (const event of product.eventsData) {
+                        if ('points' in event) {
+                            for (const point of (event as ConveyorEventSchema).points) {
+                                if (point.action && 'triggers' in point.action) {
+                                    const trigger = point.action.triggers.find(t => t.triggerUuid === triggerUuid);
+                                    if (trigger) {
+                                        trigger.triggerName = newName;
+                                        return;
+                                    }
+                                }
+                            }
+                        } else if ('point' in event) {
+                            const point = (event as any).point;
+                            if ('action' in point && 'triggers' in point.action) {
+                                const trigger = point.action.triggers.find((t: any) => t.triggerUuid === triggerUuid);
+                                if (trigger) {
+                                    trigger.triggerName = newName;
+                                    return;
+                                }
+                            } else if ('actions' in point) {
+                                for (const action of point.actions) {
+                                    if ('triggers' in action) {
+                                        const trigger = action.triggers.find((t: any) => t.triggerUuid === triggerUuid);
+                                        if (trigger) {
+                                            trigger.triggerName = newName;
+                                            return;
+                                        }
+                                    }
+                                }
+                            }
+                        }
+                    }
+                }
+            });
+        },
+
         // Helper functions
         getProductById: (productId) => {
             return get().products.find(p => p.productId === productId);

app/src/store/simulation/useSimulationStore.ts

@@ -22,4 +22,28 @@ export const useSelectedEventSphere = create<SelectedEventSphereState>()(
             });
         },
     }))
+);
+
+interface SelectedProductState {
+    selectedProduct: { productId: string; productName: string };
+    setSelectedProduct: (productId: string, productName: string) => void;
+    clearSelectedProduct: () => void;
+}
+
+export const useSelectedProduct = create<SelectedProductState>()(
+    immer((set) => ({
+        selectedProduct: { productId: '', productName: '' },
+        setSelectedProduct: (productId, productName) => {
+            set((state) => {
+                state.selectedProduct.productId = productId;
+                state.selectedProduct.productName = productName;
+            });
+        },
+        clearSelectedProduct: () => {
+            set((state) => {
+                state.selectedProduct.productId = '';
+                state.selectedProduct.productName = '';
+            });
+        },
+    }))
 );