Refactor EventProperties component to utilize new state management for selected event data and asset selection; implement action handling based on asset type and improve action rendering logic.

Enhance Simulations component to support adding and removing events from products; integrate new asset selection store for better state management.

Fix import paths in Design component and related files to ensure correct module resolution.

Update Tools component to correct import paths for template saving functionality.

Refactor EditWidgetOption component to simplify option handling and remove unnecessary state management.

Add new mechanics components for various asset types (Conveyor, Machine, Robotic Arm, Storage, Vehicle) as placeholders for future implementation.

Implement Trigger and TriggerConnector components to manage right-click interactions and asset selection in the simulation environment.

Enhance product store with new helper functions for event and action retrieval based on UUIDs.

Introduce new selected event data and asset state management in the simulation store for improved event handling.

Update simulation types to include new action types and improve type definitions for better type safety.

Remove obsolete temp markdown file from triggers directory.

app/src/store/simulation/useProductStore.ts

@@ -55,6 +55,11 @@ type ProductsStore = {
 
     // Helper functions
     getProductById: (productId: string) => { productName: string; productId: string; eventsData: EventsSchema[] } | undefined;
+    getEventByModelUuid: (productId: string, modelUuid: string) => EventsSchema | undefined;
+    getPointByUuid: (productId: string, modelUuid: string, pointUuid: string) => ConveyorPointSchema | VehiclePointSchema | RoboticArmPointSchema | MachinePointSchema | StoragePointSchema | undefined;
+    getActionByUuid: (productId: string, actionUuid: string) => (ConveyorPointSchema['action'] | VehiclePointSchema['action'] | RoboticArmPointSchema['actions'][0] | MachinePointSchema['action'] | StoragePointSchema['action']) | undefined;
+    getTriggerByUuid: (productId: string, triggerUuid: string) => TriggerSchema | undefined;
+    getIsEventInProduct: (productId: string, modelUuid: string) => boolean;
 };
 
 export const useProductStore = create<ProductsStore>()(
@@ -417,6 +422,89 @@ export const useProductStore = create<ProductsStore>()(
         // Helper functions
         getProductById: (productId) => {
             return get().products.find(p => p.productId === productId);
+        },
+
+        getEventByModelUuid: (productId, modelUuid) => {
+            const product = get().getProductById(productId);
+            if (!product) return undefined;
+            return product.eventsData.find(e => 'modelUuid' in e && e.modelUuid === modelUuid);
+        },
+
+        getPointByUuid: (productId, modelUuid, pointUuid) => {
+            const event = get().getEventByModelUuid(productId, modelUuid);
+            if (!event) return undefined;
+            
+            if ('points' in event) {
+                return (event as ConveyorEventSchema).points.find(p => p.uuid === pointUuid);
+            } else if ('point' in event && (event as any).point.uuid === pointUuid) {
+                return (event as VehicleEventSchema | RoboticArmEventSchema | MachineEventSchema | StorageEventSchema).point;
+            }
+            return undefined;
+        },
+
+        getActionByUuid: (productId, actionUuid) => {
+            const product = get().products.find(p => p.productId === productId);
+            if (!product) return undefined;
+
+            for (const event of product.eventsData) {
+                if ('points' in event) {
+                    for (const point of (event as ConveyorEventSchema).points) {
+                        if (point.action?.actionUuid === actionUuid) {
+                            return point.action;
+                        }
+                    }
+                } else if ('point' in event) {
+                    const point = (event as any).point;
+                    if ('action' in point && point.action?.actionUuid === actionUuid) {
+                        return point.action;
+                    } else if ('actions' in point) {
+                        const action = point.actions.find((a: any) => a.actionUuid === actionUuid);
+                        if (action) return action;
+                    }
+                }
+            }
+            return undefined;
+        },
+
+        getTriggerByUuid: (productId, triggerUuid) => {
+            const product = get().products.find(p => p.productId === productId);
+            if (!product) return undefined;
+
+            for (const event of product.eventsData) {
+                if ('points' in event) {
+                    for (const point of (event as ConveyorEventSchema).points) {
+                        for (const trigger of point.action?.triggers || []) {
+                            if (trigger.triggerUuid === triggerUuid) {
+                                return trigger;
+                            }
+                        }
+                    }
+                } else if ('point' in event) {
+                    const point = (event as any).point;
+                    if ('action' in point) {
+                        for (const trigger of point.action?.triggers || []) {
+                            if (trigger.triggerUuid === triggerUuid) {
+                                return trigger;
+                            }
+                        }
+                    } else if ('actions' in point) {
+                        for (const action of point.actions) {
+                            for (const trigger of action.triggers || []) {
+                                if (trigger.triggerUuid === triggerUuid) {
+                                    return trigger;
+                                }
+                            }
+                        }
+                    }
+                }
+            }
+            return undefined;
+        },
+
+        getIsEventInProduct: (productId, modelUuid) => {
+            const product = get().getProductById(productId);
+            if (!product) return false;
+            return product.eventsData.some(e => 'modelUuid' in e && e.modelUuid === modelUuid);
         }
     }))
 );

app/src/store/simulation/useSimulationStore.ts

@@ -24,6 +24,50 @@ export const useSelectedEventSphere = create<SelectedEventSphereState>()(
     }))
 );
 
+interface SelectedEventDataState {
+    selectedEventData: { data: EventsSchema; selectedPoint: string } | undefined;
+    setSelectedEventData: (data: EventsSchema, selectedPoint: string) => void;
+    clearSelectedEventData: () => void;
+}
+
+export const useSelectedEventData = create<SelectedEventDataState>()(
+    immer((set) => ({
+        selectedEventData: undefined,
+        setSelectedEventData: (data, selectedPoint) => {
+            set((state) => {
+                state.selectedEventData = { data, selectedPoint };
+            });
+        },
+        clearSelectedEventData: () => {
+            set((state) => {
+                state.selectedEventData = undefined;
+            });
+        },
+    }))
+);
+
+interface SelectedAssetState {
+    selectedAsset: EventsSchema | undefined;
+    setSelectedAsset: (EventData: EventsSchema) => void;
+    clearSelectedAsset: () => void;
+}
+
+export const useSelectedAsset = create<SelectedAssetState>()(
+    immer((set) => ({
+        selectedAsset: undefined,
+        setSelectedAsset: (EventData) => {
+            set((state) => {
+                state.selectedAsset = EventData;
+            });
+        },
+        clearSelectedAsset: () => {
+            set((state) => {
+                state.selectedAsset = undefined;
+            });
+        },
+    }))
+);
+
 interface SelectedProductState {
     selectedProduct: { productId: string; productName: string };
     setSelectedProduct: (productId: string, productName: string) => void;

app/src/store/useModuleStore.ts

@@ -13,14 +13,17 @@ const useModuleStore = create<ModuleStore>((set) => ({
 export default useModuleStore;
 
 // New store for subModule
+
+type SubModule = 'properties' | 'simulations' | 'mechanics' | 'analysis' | 'zoneProperties';
+
 interface SubModuleStore {
-  subModule: string;
-  setSubModule: (subModule: string) => void;
+  subModule: SubModule;
+  setSubModule: (subModule: SubModule) => void;
 }
 
 const useSubModuleStore = create<SubModuleStore>((set) => ({
   subModule: "properties", // Initial subModule state
-  setSubModule: (subModule) => set({ subModule }), // Update subModule state
+  setSubModule: (value) => set({ subModule: value }), // Update subModule state
 }));
 
 export { useSubModuleStore };