diff --git a/.github/workflows/Pharo12CI.yml b/.github/workflows/Pharo12CI.yml
index 7d768024..cceb5a95 100644
--- a/.github/workflows/Pharo12CI.yml
+++ b/.github/workflows/Pharo12CI.yml
@@ -9,8 +9,6 @@ on:
       - 'main'
   pull_request:
     types: [assigned, opened, synchronize, reopened]
-  schedule:
-    - cron:  '0 12 * * 0'
 
 jobs:
   build:
diff --git a/README.md b/README.md
index 51d4c9a1..240bda4c 100644
--- a/README.md
+++ b/README.md
@@ -102,6 +102,26 @@ This menu provides `metrics` to have statistics on the Molecule code in selected
 This menu provides actions and tools depending on the selected classes.
 With this menu you can force to `define` a Component, specially if you have deactivated the Molecule dynamic update or if you have a bug when a Component contract changed.
 
+### See Component implementations
+![contextual menu see component implementations](https://github.com/Eliott-Guevel/Molecule-various-fixes/assets/76944457/a4221985-0578-4e95-a133-831548e0f5ef) \
+When right-clicking a Trait that uses the `MolComponentType` Trait, a new option appears in the `Molecule` sub-menu (as shown above):
+
+![see component implementations github](https://github.com/Eliott-Guevel/Molecule-various-fixes/assets/76944457/68a94948-d6a0-4dce-9c67-2d1974b78fdf) \
+Clicking this option opens this window, showing all the Component implementations of a Type Trait. \
+The title of the window indicates the name of the Type Trait. \
+Clicking an implementation activates the Browse button, which is used to open it in the **System Browser** of Pharo (double-clicking also works). \
+Typing in the filtering list (above the two window buttons) filters the implementations' list.
+
+### See Component users
+![contextual menu see component users](https://github.com/Eliott-Guevel/Molecule-various-fixes/assets/76944457/8a9aaa63-33f8-46ea-a638-fc896fc2a60c) \
+When right-clicking a interface (that is, a Trait that uses the `MolComponentEvents`, `MolComponentParameters` or `MolComponentServices` Traits), a new option appears in the `Molecule` sub-menu (as shown above):
+
+![See component users github](https://github.com/Eliott-Guevel/Molecule-various-fixes/assets/76944457/682f388b-78a6-41d4-a3c4-2377fb7e9cf5) \
+The title of the window indicates the name of the Type Trait as well as the type of interfaces it is about (events, parameters or services). \
+In columns are shown the Type Trait requiring and offering this interface. \
+Clicking a Type Trait activates the Browse button, which is used to open it in the **System Browser** of Pharo (double-clicking also works). \
+Typing in a filtering list (below the columns) filters the relevant Type Traits' list.
+
 ## <img src="/resources/puce.svg" width="32" height="32" align="bottom"> Using Components
 
 ### Start and stop method
diff --git a/documentation/Create and connect Components.md b/documentation/Create and connect Components.md
index b5594ad5..40d49767 100644
--- a/documentation/Create and connect Components.md	
+++ b/documentation/Create and connect Components.md	
@@ -5,14 +5,14 @@ They're directly linked, in the sense that a change detected in the first Compon
 ![gps molecule without figure](https://github.com/Eliott-Guevel/Molecule-various-fixes/assets/76944457/a949d2f8-c460-40be-985d-273881e5b3da) \
 GPS (Global Positioning System) is the american subsystem of GNSS (Global Navigation Satellite Systems).
 
-The complete GNSS example is present in the **Molecule-Examples** package, but if it's your first time using Molecule, you should follow this tutorial step-by-step in order to understand how Molecule works. \
+The complete GNSS example is present in the [Molecule-Examples](https://github.com/OpenSmock/Molecule/tree/main/src/Molecule-Examples) package, but if it's your first time using Molecule, you should follow this tutorial step-by-step in order to understand how Molecule works. \
 A graphical form of the example is available in the [Molecule-Geographical-Position-Example](https://github.com/OpenSmock/Molecule-Geographical-Position-Example) repository.
 
 # Contents
 [STATIC PART: declaration](https://github.com/OpenSmock/Molecule/blob/documentation/documentation/Create%20and%20connect%20Components.md#static-part-declaration)
 * [Define Component Types](https://github.com/OpenSmock/Molecule/blob/documentation/documentation/Create%20and%20connect%20Components.md#define-component-types)
 	- [Adding Component contract with a Component Type](https://github.com/OpenSmock/Molecule/blob/documentation/documentation/Create%20and%20connect%20Components.md#adding-component-contract-with-a-component-type)
-	  	+ [Define first Component Type MolGNSSData](https://github.com/OpenSmock/Molecule/blob/documentation/documentation/Create%20and%20connect%20Components.md#define-the-first-component-type-molgnssdata)
+	  	+ [Define the first Component Type MolGNSSData](https://github.com/OpenSmock/Molecule/blob/documentation/documentation/Create%20and%20connect%20Components.md#define-the-first-component-type-molgnssdata)
 	     + [Define the second Component Type MolGNSSMap](https://github.com/OpenSmock/Molecule/blob/documentation/documentation/Create%20and%20connect%20Components.md#define-the-second-component-type-molgnssmap)
 * [Define Services and Events](https://github.com/OpenSmock/Molecule/blob/documentation/documentation/Create%20and%20connect%20Components.md#define-services-and-events)
 * [Create a Component implementation of a Type](https://github.com/OpenSmock/Molecule/blob/documentation/documentation/Create%20and%20connect%20Components.md#create-a-component-implementation-of-a-type)
@@ -100,8 +100,8 @@ This Event trait produces the `currentPositionChanged: aGeoPosition` Event
 
 ## Create a Component implementation of a Type
 There are two ways to create a new Molecule Component :
-- Create a new Component from scratch : write a new Class inheriting from the Component hierarchy
-- Re-using an existing Class : augmenting that class with Component behavior
+- Create a new Component from scratch: write a new Class inheriting from the Component hierarchy
+- Re-using an existing Class: augmenting that class with Component behavior
 
 ### Create a new Component from scratch
 To develop a new Component from scratch, a class needs to be created that must subclass the `MolAbstractComponentImpl` abstract Class.
@@ -118,7 +118,7 @@ We must use the Molecule Component interface `MolComponentImpl`, which is a Trai
 For this tutorial, the GNSS needs to send its geographical data to the Map. \
 In order to do that, its contract needs to be redefined to indicate which Services and Events are produced and provided by it.
 ![implementation contrat molecule](https://github.com/Eliott-Guevel/Molecule-various-fixes/assets/76944457/a9c14388-0abe-4f09-8ac5-578054f98ad1) \
-Redefining a Component's contract is done on the **Class side** of Pharo (in the **System Browser**, accessible through the **Browse** tab of Pharo, click on the radio button located left to the Class side text, which is located in the middle of the **System Browser** window). \
+Redefining a Component's contract is done on the **Class side** of Pharo (in the **System Browser** which is accessible through the **Browse** tab of Pharo, click on the radio button located left to the Class side text which is located in the middle of the **System Browser** window). \
 ![system browser red](https://github.com/Eliott-Guevel/Molecule-various-fixes/assets/76944457/7fa84d1d-45b4-4fe1-b524-6193fc7d6fec)
 ![class side red](https://github.com/Eliott-Guevel/Molecule-various-fixes/assets/76944457/7b189b8a-1552-46df-a69d-44f78bb73848)
 
@@ -181,7 +181,7 @@ MolGNSSDataImpl>>increaseAccuracy
 		self accuracy: nextAccuracy ]
 ```
 
-Then, override the `getAccuracyRadiusInMeters` Service (which will simply return `accuracy`). The override is done since the `getAccuracyRadiusInMeters` Service is declared in the `providedComponentServices` part of `MolGNSSData`'s contract. And since `MolGNSSDataImpl` is an implemmentation of `MolGNSSData`, the `getAccuracyRadiusInMeters` is implemented here.
+Then, override the `getAccuracyRadiusInMeters` Service (which will simply return `accuracy`). The override is done since the `getAccuracyRadiusInMeters` Service is declared in the `providedComponentServices` part of `MolGNSSData`'s contract. And since `MolGNSSDataImpl` is an implementation of `MolGNSSData`, the `getAccuracyRadiusInMeters` is implemented here.
 ```smalltalk
 MolGNSSDataImpl>>getAccuracyRadiusInMeters
 	"Get and return the accuracy of the GNSS depending quality of signal and quantity of connected satellites"
@@ -229,9 +229,9 @@ To quickly detail this method, we first need to examine `getMolGNSSDataEventsNot
 To return to `componentActivate`, after every 50 milliseconds, a random geographical position is generated which is sent through the `currentPositionChanged: aGeoPosition` Event.
 
 Generated methods take the following forms:
-- get[componentName]EventsNotifier
-- get[componentName]EventsSubscriber
-- get[componentName]ServicesProvider
+- `get[componentName]EventsNotifier`
+- `get[componentName]EventsSubscriber`
+- `get[componentName]ServicesProvider`
 
 There is no need to manually type them.
 
@@ -247,7 +247,7 @@ MolGNSSDataImpl>>componentPassivate
 ```
 
 ## Create the Component implementation for MolGNSSMap
-Same way as `MolGNSSDataImpl`, we can move on to create the Map Component, being `MolGNSSMapImpl`. This component uses the `MolGNSSMap` Trait, used to define the Component's contract, as well as the `MolGNSSDataEvents` interface, which needs to be specified in order for the Component to consume its Service.
+Same way as `MolGNSSDataImpl`, we can move on to create the Map Component, being `MolGNSSMapImpl`. This component uses the `MolGNSSMap` Trait, used to define the Component's contract, as well as the `MolGNSSDataEvents` interface which needs to be specified in order for the Component to consume its Service.
 ```smalltalk
 MolAbstractComponentImpl subclass: #MolGNSSMapImpl
 	uses: MolGNSSMap + MolGNSSDataEvents
@@ -338,7 +338,7 @@ The Pharo **Transcript** (also located in the **Browse** tab of Pharo) will star
 
 ### Starting a Component with a name
 It's also possible to create a component with a name by using the `MolComponentImpl class>>start: #[name]` method.
-This will be useful for [Producers](https://github.com/OpenSmock/Molecule/blob/main/documentation/Creating%20Producers.md), which determine which component of a given Type A receives events from which component of a given Type B, if multiple components of the same Type exist.
+This will be useful for [Producers](https://github.com/OpenSmock/Molecule/blob/main/documentation/Creating%20Producers.md), which determine which component of a given Type A receives events from which component of a given Type B if multiple components of the same Type exist.
 
 ## Stopping a Component
 Components are stopped using the `MolComponentImpl class>>stop` instruction. \
diff --git a/documentation/Producers.md b/documentation/Producers.md
index 50b63e4e..8da97a80 100644
--- a/documentation/Producers.md
+++ b/documentation/Producers.md
@@ -1,8 +1,8 @@
 # Producers
-Producers are used to specify the sender of the Events created by components.
-Producers are created using the following syntax:
-`self forEvents: [componentName]Events useProducer: #[instanceName]`
-with [instanceName] being the name you chose for starting a component (see [Create and connect Components](https://github.com/OpenSmock/Molecule/blob/main/documentation/Create%20and%20connect%20Components)), `default` if no name was used.
+Producers are used to specify the sender of the Events created by components. \
+Producers are created using the following syntax: \
+`self forEvents: [componentName]Events useProducer: #[instanceName]` \
+with [instanceName] being the name you chose for starting a component (see [Create and connect Components](https://github.com/OpenSmock/Molecule/blob/main/documentation/Create%20and%20connect%20Components)), `default` if no name was used. \
 Producers are created in the `componentInitialize` method.
 
 For multiple Producers (multiple named launched components of the same Type), the syntax is
diff --git a/documentation/Table of contents.md b/documentation/Table of contents.md
index c3ae27b1..b1dd2400 100644
--- a/documentation/Table of contents.md	
+++ b/documentation/Table of contents.md	
@@ -4,11 +4,10 @@ Welcome to the Molecule wiki!
 [Principles](https://github.com/OpenSmock/Molecule/blob/main/documentation/Principles.md)
 
 # Tutorials
-Step-by-step example describing an example between two Components interacting:
-
+## Step-by-step example describing two Components interacting between one another
 [Create and connect Components](https://github.com/OpenSmock/Molecule/blob/main/documentation/Create%20and%20connect%20Components.md)
 
-Other tutorials focused on one specific part of Molecule:
+## Other tutorials focused on one specific part of Molecule
 
 [Connecting two Components](https://github.com/OpenSmock/Molecule/blob/main/documentation/Connecting%20two%20Components.md)
 
diff --git a/documentation/Tests.md b/documentation/Tests.md
index baa54b9d..1456ae42 100644
--- a/documentation/Tests.md
+++ b/documentation/Tests.md
@@ -1,5 +1,5 @@
 # Tests
-To create quick tests for your Components, you can create a package named [yourPackageName]-Examples or [yourPackageName]-Tests, then create an Object subclass named [yourPackageName]Examples, 
+To create quick tests for your Components, you can create a package named `[yourPackageName]-Examples` or `[yourPackageName]-Tests`, then create an Object subclass named `[yourPackageName]Examples`,
 ```smalltalk
 Object subclass: #MolGPS-Examples
 	instanceVariableNames: ''
@@ -7,7 +7,7 @@ Object subclass: #MolGPS-Examples
 	package: 'Molecule-Tutorial'
 ```
 then display the **Class side** of this class.
-This then allows the creation of methods for different test cases.
+This allows the creation of methods for different test cases.
 
 One practical thing is putting a `<script>` tag at the start of your methods. This will create a small icon next to your method in order to launch it without the use of a Playground.
 ```smalltalk
@@ -37,8 +37,8 @@ MolGPS-Examples>>stop
 
 ## Switching Components on the fly
 This test space can be useful for switching Components on the fly, stopping a component to start another having the same Type. 
-Make sure that they have a different name or that the current launched Component is stopped before the other of the same Type is launched.
-See the Molecule-Examples package for more examples on this.
+Make sure that they have a different name or that the current launched Component is stopped before the other of the same Type is launched. \
+See the [Molecule-Examples](https://github.com/OpenSmock/Molecule/tree/main/src/Molecule-Examples) package for more examples on this.
 
 ## Calling another script
 To call another script, you simply have to call it like a regular function with `self [script]` since the `self` here represents the current class (for methods located in the class side).
diff --git a/src/.properties b/src/.properties
index bb800cdb..28edcab8 100644
--- a/src/.properties
+++ b/src/.properties
@@ -1,3 +1,4 @@
 {
-	#format : #tonel
+	#format : #tonel,
+	#version: #'1.0'
 }
\ No newline at end of file
diff --git a/src/Molecule-IDE-Tests/MolImplementationsPresenterTest.class.st b/src/Molecule-IDE-Tests/MolImplementationsPresenterTest.class.st
new file mode 100644
index 00000000..2e0a9fee
--- /dev/null
+++ b/src/Molecule-IDE-Tests/MolImplementationsPresenterTest.class.st
@@ -0,0 +1,68 @@
+Class {
+	#name : #MolImplementationsPresenterTest,
+	#superclass : #TestCase,
+	#instVars : [
+		'clockImplementations',
+		'geoPosImplementations'
+	],
+	#category : #'Molecule-IDE-Tests-Cases'
+}
+
+{ #category : #running }
+MolImplementationsPresenterTest >> setUp [
+
+	super setUp.
+	MolComponentManager cleanUp.
+
+	"Put here a common initialization logic for tests"
+	clockImplementations := MolImplementationsPresenter new.
+	clockImplementations type: MolMyClockComponent.
+
+	geoPosImplementations := MolImplementationsPresenter new.
+	geoPosImplementations type: MolGeoPosEquipmentType.
+]
+
+{ #category : #running }
+MolImplementationsPresenterTest >> tearDown [ 
+
+	MolComponentManager cleanUp.
+	super tearDown
+]
+
+{ #category : #running }
+MolImplementationsPresenterTest >> testBrowseButtonActivated [
+
+	| enabled |
+	clockImplementations implementationList selectItem:
+		MolMyClockComponentImpl.
+	enabled := clockImplementations buttonBrowse isEnabled.
+
+	self assert: [ enabled ]
+]
+
+{ #category : #running }
+MolImplementationsPresenterTest >> testFilter [
+
+	| implementations |
+	geoPosImplementations implementationList filterListItems: 'gps'.
+	implementations := geoPosImplementations implementationList items.
+
+	self assert: [ implementations size = 2 ]
+]
+
+{ #category : #running }
+MolImplementationsPresenterTest >> testSelectingImplementation [
+
+	clockImplementations implementationList selectItem: MolMyClockComponentImpl.
+
+	self assert: [
+		clockImplementations implementationList selectedItem
+		= MolMyClockComponentImpl ]
+]
+
+{ #category : #running }
+MolImplementationsPresenterTest >> testTitle [
+
+	self assert: [
+		clockImplementations title = 'MolMyClockComponent Implementations' ]
+]
diff --git a/src/Molecule-IDE-Tests/MolInterfacesPresenterTest.class.st b/src/Molecule-IDE-Tests/MolInterfacesPresenterTest.class.st
new file mode 100644
index 00000000..a9d4eb80
--- /dev/null
+++ b/src/Molecule-IDE-Tests/MolInterfacesPresenterTest.class.st
@@ -0,0 +1,62 @@
+Class {
+	#name : #MolInterfacesPresenterTest,
+	#superclass : #TestCase,
+	#instVars : [
+		'localTimeEvents'
+	],
+	#category : #'Molecule-IDE-Tests-Cases'
+}
+
+{ #category : #running }
+MolInterfacesPresenterTest >> setUp [
+
+	super setUp.
+	MolComponentManager cleanUp.
+
+	"Put here a common initialization logic for tests"
+	localTimeEvents := MolInterfacesPresenter new.
+	localTimeEvents interface: MolMyLocalTimeEvents.
+]
+
+{ #category : #running }
+MolInterfacesPresenterTest >> tearDown [ 
+
+	MolComponentManager cleanUp.
+	super tearDown
+]
+
+{ #category : #running }
+MolInterfacesPresenterTest >> testBrowseButtonActivated [
+
+	| enabled |
+	localTimeEvents requiredList selectItem: MolMyAlarmComponent.
+	enabled := localTimeEvents buttonBrowse isEnabled.
+	self assert: [ enabled ]
+]
+
+{ #category : #running }
+MolInterfacesPresenterTest >> testRequiredAnd [
+
+	localTimeEvents dropList selectItem: 'Required AND Offered'.
+	self assert: [ localTimeEvents requiredList items size = 0 ]
+]
+
+{ #category : #running }
+MolInterfacesPresenterTest >> testRequiredOr [
+	"no need to select an option since OR is selected by default"
+
+	self assert: [ localTimeEvents requiredList items size = 2 ]
+]
+
+{ #category : #running }
+MolInterfacesPresenterTest >> testRequiredXor [
+
+	localTimeEvents dropList selectItem: 'Required XOR Offered'.
+	self assert: [ localTimeEvents requiredList items size = 2 ]
+]
+
+{ #category : #running }
+MolInterfacesPresenterTest >> testTitle [
+
+	self assert: [ localTimeEvents title = 'MolMyLocalTimeEvents events' ]
+]
diff --git a/src/Molecule-IDE/MolCmdCommand.class.st b/src/Molecule-IDE/MolCmdCommand.class.st
index 72bea109..e4f868e4 100644
--- a/src/Molecule-IDE/MolCmdCommand.class.st
+++ b/src/Molecule-IDE/MolCmdCommand.class.st
@@ -6,7 +6,6 @@ Class {
 	#superclass : #CmdCommand,
 	#instVars : [
 		'selectedItems',
-		'items',
 		'executionResult'
 	],
 	#category : #'Molecule-IDE-Menus'
diff --git a/src/Molecule-IDE/MolImplementationsPresenter.class.st b/src/Molecule-IDE/MolImplementationsPresenter.class.st
new file mode 100644
index 00000000..013920a8
--- /dev/null
+++ b/src/Molecule-IDE/MolImplementationsPresenter.class.st
@@ -0,0 +1,63 @@
+Class {
+	#name : #MolImplementationsPresenter,
+	#superclass : #MolOptionsPresenter,
+	#instVars : [
+		'selectedType'
+	],
+	#category : #'Molecule-IDE-Tools'
+}
+
+{ #category : #initialization }
+MolImplementationsPresenter >> buttonBrowseAction [
+	"an implementation needs to be selected in order to browse it"
+
+	| item |
+	item := implementationList selectedItem.
+
+	item ifNotNil: [
+		buttonBrowse enable.
+		item browse ]
+]
+
+{ #category : #initialization }
+MolImplementationsPresenter >> connectPresenters [
+	"enables the Browse button if an implementation is selected"
+
+	implementationList whenSelectionChangedDo: [
+		implementationList selectedItem ifNotNil: [ buttonBrowse enable ] ]
+]
+
+{ #category : #initialization }
+MolImplementationsPresenter >> defaultLayout [
+
+	^ SpBoxLayout newVertical
+		  add: implementationList;
+		  addLast: actionBar;
+		  yourself
+]
+
+{ #category : #initialization }
+MolImplementationsPresenter >> initializePresenters [
+
+	super initializePresenters.
+
+	implementationList := MolSpFilteringListDoubleClickPresenter new.
+	implementationList displayIcon: [ :elem |
+		self iconNamed: elem systemIconName ]
+]
+
+{ #category : #initialization }
+MolImplementationsPresenter >> title [
+
+	^ selectedType asString , ' Implementations'
+]
+
+{ #category : #initialization }
+MolImplementationsPresenter >> type: aType [
+	"when the Type Trait is given, loads the list"
+
+	"only one Type can be selected in the System Browser at a time"
+
+	selectedType := aType.
+	implementationList items: (self listImplementations: selectedType)
+]
diff --git a/src/Molecule-IDE/MolInspectInterfacesImplementationsCmdCommand.class.st b/src/Molecule-IDE/MolInspectInterfacesImplementationsCmdCommand.class.st
new file mode 100644
index 00000000..92981739
--- /dev/null
+++ b/src/Molecule-IDE/MolInspectInterfacesImplementationsCmdCommand.class.st
@@ -0,0 +1,47 @@
+Class {
+	#name : #MolInspectInterfacesImplementationsCmdCommand,
+	#superclass : #MolInterfaceCmdCommand,
+	#category : #'Molecule-IDE-Tools'
+}
+
+{ #category : #activation }
+MolInspectInterfacesImplementationsCmdCommand class >> browserMenuActivation [
+	<classAnnotation>
+	^CmdContextMenuActivation byItemOf: MolCmdMenuGroup for: ClyFullBrowserClassContext.
+]
+
+{ #category : #accessing }
+MolInspectInterfacesImplementationsCmdCommand >> defaultMenuIconName [
+
+	^ 'glamorousInspect'
+]
+
+{ #category : #accessing }
+MolInspectInterfacesImplementationsCmdCommand >> defaultMenuItemName [
+
+	^ 'See Component users'
+]
+
+{ #category : #accessing }
+MolInspectInterfacesImplementationsCmdCommand >> description [
+
+	^ 'Shows in a window users of the selected interface (Events, Parameters or Services)'
+]
+
+{ #category : #accessing }
+MolInspectInterfacesImplementationsCmdCommand >> execute [
+
+	| selectedInterface emptyArray interface |
+	selectedInterface := self selectedInterfaceClass.
+
+	interface := MolInterfacesPresenter new.
+	emptyArray := Array new: 0.
+
+	"condition and ifTrue: are executed only if multiple Traits were/are selected in the System Browser, since this option only supports one Type selected at a time"
+	selectedInterface = emptyArray
+		ifFalse: [ selectedInterface := selectedInterface at: 1 ]
+		ifTrue: [
+		selectedInterface := (selectedItems at: 1) browserItem actualObject ].
+	interface interface: selectedInterface.
+	interface open
+]
diff --git a/src/Molecule-IDE/MolInspectTypeImplementationsCmdCommand.class.st b/src/Molecule-IDE/MolInspectTypeImplementationsCmdCommand.class.st
new file mode 100644
index 00000000..051ddfc7
--- /dev/null
+++ b/src/Molecule-IDE/MolInspectTypeImplementationsCmdCommand.class.st
@@ -0,0 +1,47 @@
+Class {
+	#name : #MolInspectTypeImplementationsCmdCommand,
+	#superclass : #MolTypeCmdCommand,
+	#category : #'Molecule-IDE-Tools'
+}
+
+{ #category : #activation }
+MolInspectTypeImplementationsCmdCommand class >> browserMenuActivation [
+	<classAnnotation>
+	^CmdContextMenuActivation byItemOf: MolCmdMenuGroup for: ClyFullBrowserClassContext.
+]
+
+{ #category : #accessing }
+MolInspectTypeImplementationsCmdCommand >> defaultMenuIconName [
+
+	^ 'glamorousInspect'
+]
+
+{ #category : #accessing }
+MolInspectTypeImplementationsCmdCommand >> defaultMenuItemName [
+
+	^ 'See Component Implementations'
+]
+
+{ #category : #accessing }
+MolInspectTypeImplementationsCmdCommand >> description [
+
+	^ 'Shows implementations of this Molecule Type'
+]
+
+{ #category : #accessing }
+MolInspectTypeImplementationsCmdCommand >> execute [
+
+	| selectedType implem emptyArray |
+	selectedType := self selectedTypeClass.
+
+	implem := MolImplementationsPresenter new.
+	emptyArray := Array new: 0.
+
+	"condition and ifTrue: are executed only if multiple Traits were/are selected in the System Browser, since this option only supports one Type selected at a time"
+	selectedType = emptyArray
+		ifFalse: [ selectedType := selectedType at: 1 ]
+		ifTrue: [
+		selectedType := (selectedItems at: 1) browserItem actualObject ].
+	implem type: selectedType.
+	implem open
+]
diff --git a/src/Molecule-IDE/MolInterfaceCmdCommand.class.st b/src/Molecule-IDE/MolInterfaceCmdCommand.class.st
new file mode 100644
index 00000000..9e270e5d
--- /dev/null
+++ b/src/Molecule-IDE/MolInterfaceCmdCommand.class.st
@@ -0,0 +1,40 @@
+Class {
+	#name : #MolInterfaceCmdCommand,
+	#superclass : #MolCmdCommand,
+	#category : #'Molecule-IDE-Tools'
+}
+
+{ #category : #testing }
+MolInterfaceCmdCommand class >> canBeExecutedInContext: aToolContext [
+
+	| list selectedItem selected |
+	(super canBeExecutedInContext: aToolContext) ifFalse: [ ^ false ].
+	aToolContext selectedItems ifEmpty: [ ^ false ].
+
+	selectedItem := aToolContext selectedItems at: 1.
+	selected := selectedItem browserItem actualObject name.
+
+	"find all interfaces"
+	list := SystemNavigation default allClasses select: [ :c |
+		        c isTrait and: [
+			        c isComponentEvents or:
+				        (c isComponentParameters or: c isComponentServices) ] ].
+
+	"return if selected object is in list of component"
+	^ list includes: (self class environment at: selected asSymbol)
+]
+
+{ #category : #'api - accessing' }
+MolInterfaceCmdCommand >> selectedClass [
+
+	^ (selectedItems collect: [ :p | p browserItem actualObject ])
+]
+
+{ #category : #'as yet unclassified' }
+MolInterfaceCmdCommand >> selectedInterfaceClass [
+	"this method returns the class in the System Browser that is an interface (Events/Parameters/Services)"
+
+	^ self selectedClass select: [ :c |
+		  c isComponentEvents or:
+			  (c isComponentParameters or: c isComponentServices) ]
+]
diff --git a/src/Molecule-IDE/MolInterfacesPresenter.class.st b/src/Molecule-IDE/MolInterfacesPresenter.class.st
new file mode 100644
index 00000000..7f68e7c0
--- /dev/null
+++ b/src/Molecule-IDE/MolInterfacesPresenter.class.st
@@ -0,0 +1,408 @@
+Class {
+	#name : #MolInterfacesPresenter,
+	#superclass : #MolOptionsPresenter,
+	#instVars : [
+		'selectedInterface',
+		'requiredList',
+		'offeredList',
+		'dropList',
+		'typeInterface',
+		'servicesProvidedList',
+		'eventsConsumedList',
+		'parametersUsedList',
+		'servicesUsedList',
+		'eventsProducedList',
+		'parametersProvidedList',
+		'listImplementationBoth',
+		'eventsConsumed',
+		'parametersUsed',
+		'servicesUsed',
+		'eventsProduced',
+		'parametersProvided',
+		'servicesProvided',
+		'implemList'
+	],
+	#category : #'Molecule-IDE-Tools'
+}
+
+{ #category : #initialization }
+MolInterfacesPresenter >> addTrait: trait IfInterfaceCorrespondsIn: interfaceList forList: interfaceForScreenList [
+	"adds the interfaces that appear in the relevant parts of the component contract to lists in order to show them after using requiredList and offeredList"
+
+	interfaceList ifNotNil: [
+		interfaceList do: [ :interface |
+			interface = selectedInterface ifTrue: [
+				interfaceForScreenList add: trait ] ] ]
+]
+
+{ #category : #adding }
+MolInterfacesPresenter >> addTypesInInterfaceList: trait [
+	"add a Trait to the lists if it corresponds to a part of their component contract"
+
+	typeInterface = 'Events' ifTrue: [
+		eventsConsumed := trait allConsumedEvents.
+		self
+			addTrait: trait
+			IfInterfaceCorrespondsIn: eventsConsumed
+			forList: eventsConsumedList.
+
+		eventsProduced := trait allProducedEvents.
+		self
+			addTrait: trait
+			IfInterfaceCorrespondsIn: eventsProduced
+			forList: eventsProducedList ].
+
+	typeInterface = 'Parameters' ifTrue: [
+		parametersUsed := trait allUsedParameters.
+		self
+			addTrait: trait
+			IfInterfaceCorrespondsIn: parametersUsed
+			forList: parametersUsedList.
+
+		parametersProvided := trait allProvidedParameters.
+		self
+			addTrait: trait
+			IfInterfaceCorrespondsIn: parametersProvided
+			forList: parametersProvidedList ].
+
+	typeInterface = 'Services' ifTrue: [
+		servicesUsed := trait allUsedServices.
+		self
+			addTrait: trait
+			IfInterfaceCorrespondsIn: servicesUsed
+			forList: servicesUsedList.
+
+		servicesProvided := trait allProvidedServices.
+		self
+			addTrait: trait
+			IfInterfaceCorrespondsIn: servicesProvided
+			forList: servicesProvidedList ]
+]
+
+{ #category : #adding }
+MolInterfacesPresenter >> addTypesInInterfaceLists [
+
+	selectedInterface = '' ifTrue: [ ^ self ].
+	
+	(MolUtils requiredTypes: selectedInterface) do: [ :trait |
+		self addTypesInInterfaceList: trait ].
+
+	(MolUtils offeredTypes: selectedInterface) do: [ :trait |
+		self addTypesInInterfaceList: trait ]
+]
+
+{ #category : #'as yet unclassified' }
+MolInterfacesPresenter >> andMode [
+	"if a Type appears in both columns (is both required and offered), show it in both columns"
+	"doesn't show it in either if it only appears once"
+
+	self emptyLists.
+
+	self addTypesInInterfaceLists.
+
+	self require: eventsConsumedList andOffer: eventsProducedList.
+	self require: parametersUsedList andOffer: parametersProvidedList.
+	self require: servicesUsedList andOffer: servicesProvidedList.
+
+	self fillRequiredAndOfferedLists.
+
+	self applyFilter
+]
+
+{ #category : #initialization }
+MolInterfacesPresenter >> applyFilter [
+	"used when changing boolean operator modes in order to conserve the filters typed, for both the required and offered interfaces"
+
+	| requiredListFilter offeredListFilter |
+	requiredList ifNotNil: [
+		requiredListFilter := requiredList filterText.
+		offeredListFilter := offeredList filterText.
+
+		requiredList applyFilter: requiredListFilter.
+		offeredList applyFilter: offeredListFilter ]
+]
+
+{ #category : #initialization }
+MolInterfacesPresenter >> browseLastSelectedElement [
+	"the Browse button always browses the last selected Trait, no matter in which list it is. However, selecting an element in a list, selecting another element in the other list then selecting again the first element opens the one in the other list since the selection of the first list isn't emptied. This method is here to remedy to this problem"
+
+	"see https://github.com/OpenSmock/Molecule/pull/168#issuecomment-2020688480"
+
+	requiredList whenSelectionChangedDo: [ offeredList selectItem: nil ].
+	offeredList whenSelectionChangedDo: [ requiredList selectItem: nil ]
+]
+
+{ #category : #initialization }
+MolInterfacesPresenter >> buttonBrowseAction [
+	"an implementation needs to be selected in order to browse it. The last selected one (for both lists) being the one browsed"
+
+	| item |
+	item := implementationList selectedItem.
+	item ifNotNil: [ item browse ]
+]
+
+{ #category : #initialization }
+MolInterfacesPresenter >> connectPresenters [
+	"enables the Browse button if a Type is selected, disables it if another mode is chosen since the lists are reset and the selection could point to nothing in particular"
+
+	dropList whenSelectionChangedDo: [ buttonBrowse disable ].
+	
+	self browseLastSelectedElement.
+
+	self enableBrowseButton: requiredList.
+	self enableBrowseButton: offeredList
+]
+
+{ #category : #initialization }
+MolInterfacesPresenter >> defaultLayout [
+
+	^ SpBoxLayout newVertical
+		  add: 'Component Types which are using this interface:'
+		  expand: false;
+		  add: dropList expand: false;
+		  add: (SpBoxLayout newLeftToRight
+				   add: (SpBoxLayout newVertical
+						    add: 'Required' expand: false;
+						    add: requiredList;
+						    yourself);
+				   add: SpBoxLayout newLeftToRight width: 5 yourself;
+				   add: (SpBoxLayout newVertical
+						    add: 'Offered' expand: false;
+						    add: offeredList;
+						    yourself);
+				   yourself);
+		  addLast: actionBar;
+		  yourself
+]
+
+{ #category : #initialization }
+MolInterfacesPresenter >> determineTypeInterface [
+	"determines the type of the selected interface (Events, Parameters or Services) using the relevant Molecule methods (isComponent[Events/Parameters/Services])"
+
+	| events parameters services |
+	events := 'Events'.
+	parameters := 'Parameters'.
+	services := 'Services'.
+
+	selectedInterface isComponentEvents ifTrue: [
+		typeInterface := events ].
+	selectedInterface isComponentParameters ifTrue: [
+		typeInterface := parameters ].
+	selectedInterface isComponentServices ifTrue: [
+		typeInterface := services ]
+]
+
+{ #category : #initialization }
+MolInterfacesPresenter >> dropList [
+	"used for test purposes"
+
+	^ dropList
+]
+
+{ #category : #initialization }
+MolInterfacesPresenter >> emptyLists [
+	"since the implementations change when switching from one boolean operator to another, the lists of implementations need to be reset"
+
+	"is also used to initialize them since this method is called at the start of required[And/Or/Xor]OfferedMode"
+
+	eventsConsumedList := OrderedCollection new.
+	parametersUsedList := OrderedCollection new.
+	servicesUsedList := OrderedCollection new.
+
+	eventsProducedList := OrderedCollection new.
+	parametersProvidedList := OrderedCollection new.
+	servicesProvidedList := OrderedCollection new.
+
+	listImplementationBoth := OrderedCollection new
+]
+
+{ #category : #initialization }
+MolInterfacesPresenter >> enableBrowseButton: listOnScreen [
+	"determines which list was the last one selected, necessary for using the Browse button"
+
+	listOnScreen whenSelectionChangedDo: [
+		implementationList := listOnScreen.
+		listOnScreen selectedItem ifNotNil: [ buttonBrowse enable ] ]
+]
+
+{ #category : #'as yet unclassified' }
+MolInterfacesPresenter >> fillRequiredAndOfferedLists [
+	"used for the and mode"
+
+	requiredList items: listImplementationBoth.
+	offeredList items: listImplementationBoth
+]
+
+{ #category : #initialization }
+MolInterfacesPresenter >> initializePresenters [
+
+	"Required OR Offered selected by default in the drop down list"
+
+	super initializePresenters.
+
+		"set to a placeholder value since the name of the interface is given after in execute: in the contextual menu side of things (MolInspectInterfaceImplementationsCmdCommand)"
+	selectedInterface := ''.
+
+	eventsConsumedList := OrderedCollection new.
+	parametersUsedList := OrderedCollection new.
+	servicesUsedList := OrderedCollection new.
+
+	eventsProducedList := OrderedCollection new.
+	parametersProvidedList := OrderedCollection new.
+	servicesProvidedList := OrderedCollection new.
+
+	"drop list, no width property"
+	dropList := self newDropList
+		            help: 'Component Types which are using this interface:';
+		            addItemLabeled: 'Required OR Offered'
+		            do: [ self orMode ];
+		            addItemLabeled: 'Required AND Offered'
+		            do: [ self andMode ];
+		            addItemLabeled: 'Required XOR Offered'
+		            do: [ self xorMode ].
+
+	requiredList := MolSpFilteringListDoubleClickPresenter new.
+	requiredList
+		displayIcon: [ :elem | self iconNamed: elem systemIconName ];
+		contextMenu: [ self listMenu ].
+
+	offeredList := MolSpFilteringListDoubleClickPresenter new.
+	offeredList
+		displayIcon: [ :elem | self iconNamed: elem systemIconName ];
+		contextMenu: [ self listMenu ]
+]
+
+{ #category : #initialization }
+MolInterfacesPresenter >> interface: anInterface [
+	"when an interface is given, loads the filtering lists"
+
+	"only one interface can be selected at a time"
+
+	selectedInterface := anInterface.
+	self determineTypeInterface.
+	implemList := self listImplementations: anInterface.
+
+	self orMode
+]
+
+{ #category : #initialization }
+MolInterfacesPresenter >> interfaceListAssignment: interfaceList for: listOnScreen [
+	"adds the Types to a list if they are required or offered by the selected interface"
+
+	listOnScreen ifNotNil: [
+		interfaceList = OrderedCollection new ifFalse: [
+			listOnScreen items: interfaceList ] ]
+]
+
+{ #category : #initialization }
+MolInterfacesPresenter >> listMenu [
+
+	^ self newMenu addItem: [ :item |
+		  item
+			  name: 'See Component Implementations';
+			  icon: (self iconNamed: #package);
+			  help: 'Shows implementations of this Molecule Type';
+			  action: [ self seeComponentImplementations ] ]
+]
+
+{ #category : #initialization }
+MolInterfacesPresenter >> offeredList [
+	"used for test purposes"
+
+	^ offeredList
+]
+
+{ #category : #'as yet unclassified' }
+MolInterfacesPresenter >> orMode [
+	"if an implementation requires or provides the selected interface, make it appear in the correct column"
+
+	"is selected by default"
+
+	self emptyLists.
+
+	self addTypesInInterfaceLists.
+
+	self requireOrOffer.
+
+	self applyFilter
+]
+
+{ #category : #'as yet unclassified' }
+MolInterfacesPresenter >> require: listRequired andOffer: listOffered [
+		"adds the items in the lists shown on screen if the interface is both required and offered by an implementation"
+
+	listRequired do: [ :interfaceRequired |
+		listOffered do: [ :interfaceOffered |
+			interfaceRequired = interfaceOffered ifTrue: [
+				listImplementationBoth add: interfaceRequired ] ] ]
+]
+
+{ #category : #'as yet unclassified' }
+MolInterfacesPresenter >> require: listRequired xorOffer: listOffered [
+	"removes the items in the lists shown on screen if the interface is both required and offered by an implementation"
+
+	listRequired do: [ :interfaceRequired |
+		listOffered do: [ :interfaceOffered |
+			interfaceRequired = interfaceOffered ifTrue: [
+				listRequired remove: interfaceRequired.
+				listOffered remove: interfaceRequired ] ] ]
+]
+
+{ #category : #'as yet unclassified' }
+MolInterfacesPresenter >> requireOrOffer [
+	"adds the items in the lists shown on screen if the interface is required or offered by a Type"
+
+	self interfaceListAssignment: eventsConsumedList for: requiredList.
+	self interfaceListAssignment: parametersUsedList for: requiredList.
+	self interfaceListAssignment: servicesUsedList for: requiredList.
+
+	self interfaceListAssignment: eventsProducedList for: offeredList.
+	self interfaceListAssignment: parametersProvidedList for: offeredList.
+	self interfaceListAssignment: servicesProvidedList for: offeredList
+]
+
+{ #category : #initialization }
+MolInterfacesPresenter >> requiredList [
+	"used for test purposes"
+
+	^ requiredList
+]
+
+{ #category : #initialization }
+MolInterfacesPresenter >> seeComponentImplementations [
+	"code based on the execute method in MolInspectTypeImplementationsCmdCommand without the multiple selection part since multiple elements can't be chosen at the same time in requiredList and offeredList"
+
+	| selectedType implem |
+	selectedType := implementationList selectedItem.
+	implem := MolImplementationsPresenter new.
+
+	selectedType isComponentType ifTrue: [
+		implem type: selectedType.
+		implem open ]
+]
+
+{ #category : #initialization }
+MolInterfacesPresenter >> title [
+
+	^ selectedInterface asString , ' ' , typeInterface asLowercase
+]
+
+{ #category : #'as yet unclassified' }
+MolInterfacesPresenter >> xorMode [
+	"boolean operator equivalent to OR minus AND, show a Type only if it exists and doesn't appear in both columns (requires or offers the interface, but not both)"
+
+	self emptyLists.
+
+	"adds the interfaces"
+	self addTypesInInterfaceLists.
+
+	"removes implementations that both require and offer this interface"
+	self require: eventsConsumedList xorOffer: eventsProducedList.
+	self require: servicesUsedList xorOffer: servicesProvidedList.
+	self require: parametersUsedList xorOffer: parametersProvidedList.
+
+	"adds the interfaces in requiredList and offeredList"
+	self requireOrOffer.
+
+	self applyFilter
+]
diff --git a/src/Molecule-IDE/MolOptionsPresenter.class.st b/src/Molecule-IDE/MolOptionsPresenter.class.st
new file mode 100644
index 00000000..83343284
--- /dev/null
+++ b/src/Molecule-IDE/MolOptionsPresenter.class.st
@@ -0,0 +1,64 @@
+Class {
+	#name : #MolOptionsPresenter,
+	#superclass : #SpPresenter,
+	#instVars : [
+		'implementationList',
+		'actionBar',
+		'buttonBrowse',
+		'buttonClose'
+	],
+	#category : #'Molecule-IDE-Tools'
+}
+
+{ #category : #tests }
+MolOptionsPresenter >> buttonBrowse [
+	"used for test purposes"
+
+	^ buttonBrowse
+]
+
+{ #category : #tests }
+MolOptionsPresenter >> buttonBrowseAction [ 
+]
+
+{ #category : #tests }
+MolOptionsPresenter >> implementationList [
+	"used for test purposes"
+
+	^ implementationList
+]
+
+{ #category : #tests }
+MolOptionsPresenter >> initializePresenters [
+	"buttons"
+
+	buttonBrowse := self newButton
+		                label: 'Browse';
+		                icon: (self iconNamed: #package);
+		                help: 'Browse the selected implementation';
+		                action: [ self buttonBrowseAction ];
+		                disable;
+		                yourself.
+
+	buttonClose := self newButton
+		               label: 'Close';
+		               icon: (self iconNamed: #smallCancel);
+		               help: 'Close the window';
+		               action: [ self delete ];
+		               yourself.
+		
+"action bar"
+	actionBar := self newActionBar
+		             addLast: buttonBrowse;
+		             addLast: buttonClose;
+		             yourself
+]
+
+{ #category : #tests }
+MolOptionsPresenter >> listImplementations: selectedClass [
+	"necessary to use a Collection or one of its subclasses (Array in this case) to retrieve implementations of the selected Type Trait"
+
+	(selectedClass = '' or: selectedClass = OrderedCollection new)
+		ifFalse: [
+			^ selectedClass users asArray ]
+]
diff --git a/src/Molecule-IDE/MolSpFilteringListDoubleClickPresenter.class.st b/src/Molecule-IDE/MolSpFilteringListDoubleClickPresenter.class.st
new file mode 100644
index 00000000..1496eb52
--- /dev/null
+++ b/src/Molecule-IDE/MolSpFilteringListDoubleClickPresenter.class.st
@@ -0,0 +1,30 @@
+Class {
+	#name : #MolSpFilteringListDoubleClickPresenter,
+	#superclass : #SpFilteringListPresenter,
+	#category : #'Molecule-IDE-Tools'
+}
+
+{ #category : #simulation }
+MolSpFilteringListDoubleClickPresenter >> connectPresenters [
+
+	super connectPresenters.
+	self doubleClickActivated
+]
+
+{ #category : #simulation }
+MolSpFilteringListDoubleClickPresenter >> doubleClickActivated [
+	"activates the Browse functionality by double-clicking an element"
+
+	| item |
+	listPresenter whenActivatedDo: [
+		item := listPresenter selectedItem.
+		item browse ]
+]
+
+{ #category : #simulation }
+MolSpFilteringListDoubleClickPresenter >> initializePresenters [
+	"changes the original 'Filter...' placeholder text to 'Hit return to accept'"
+
+	super initializePresenters.
+	filterInputPresenter placeholder: 'Hit return to accept'
+]
diff --git a/src/Molecule-IDE/MolTypeCmdCommand.class.st b/src/Molecule-IDE/MolTypeCmdCommand.class.st
new file mode 100644
index 00000000..329d5c6b
--- /dev/null
+++ b/src/Molecule-IDE/MolTypeCmdCommand.class.st
@@ -0,0 +1,39 @@
+Class {
+	#name : #MolTypeCmdCommand,
+	#superclass : #MolCmdCommand,
+	#instVars : [
+		'typeName'
+	],
+	#category : #'Molecule-IDE-Tools'
+}
+
+{ #category : #testing }
+MolTypeCmdCommand class >> canBeExecutedInContext: aToolContext [
+
+	| list selectedItem selected |
+	(super canBeExecutedInContext: aToolContext) ifFalse: [ ^ false ].
+	aToolContext selectedItems ifEmpty: [ ^ false ].
+
+	selectedItem := aToolContext selectedItems at: 1.
+	selected := selectedItem browserItem actualObject name.
+
+	"find all Types"
+	list := SystemNavigation default allClasses select: [ :c |
+		        c isTrait and: [ c isComponentType ] ].
+
+	"return if selected object is in list of component"
+	^ list includes: (self class environment at: selected asSymbol)
+]
+
+{ #category : #'as yet unclassified' }
+MolTypeCmdCommand >> selectedClass [
+
+	^ selectedItems collect: [ :p | p browserItem actualObject ]
+]
+
+{ #category : #'as yet unclassified' }
+MolTypeCmdCommand >> selectedTypeClass [
+	"this method returns the class selected in the System Browser that is a Type"
+
+	^ self selectedClass select: [ :c | c isComponentType ]
+]
diff --git a/src/Molecule-IDE/MolWorld.class.st b/src/Molecule-IDE/MolWorld.class.st
index 18cb0912..dc9029e3 100644
--- a/src/Molecule-IDE/MolWorld.class.st
+++ b/src/Molecule-IDE/MolWorld.class.st
@@ -215,20 +215,25 @@ MolWorld class >> toolsMenu10DefineComponentOn: aBuilder [
 
 { #category : #'menu - tools' }
 MolWorld class >> toolsMenu110DeepCleanUp: aBuilder [
+
 	<worldMenu>
 	(aBuilder item: #MoleculeClearComponent)
 		parent: #MoleculeDebug;
 		order: 11.0;
 		icon: (self iconNamed: #stop);
-		action: [| result |
+		action: [
+			| result |
 			"Confirmation window"
-			result := UIManager default confirm: 'Do you want to scan and clean all the Molecule Components of your Pharo image ? 
-This action may be necessary if your system is broken.' 
-				label: 'Molecule - Confirmation'.
-			result ifTrue:[ MolComponentManager deepCleanUp]. 
-		];
+			result := UIManager default
+				          confirm:
+					          'Do you want to scan and clean all the Molecule Components of your Pharo image ? 
+This action may be necessary if your system is broken.'
+				          label: 'Molecule - Confirmation'.
+			result ifTrue: [ MolComponentManager deepCleanUp ] ];
 		label: 'Garbage, cleanup and release all components';
-		help: 'Cleanup all Molecule system instances and components of the image'
+		help:
+			'Cleanup all Molecule system instances and components of the image';
+				withSeparatorAfter
 ]
 
 { #category : #'menu - tools' }
diff --git a/src/Molecule-Tests/MolComponentAnnouncementTest.class.st b/src/Molecule-Tests/MolComponentAnnouncementTest.class.st
new file mode 100644
index 00000000..7f1ef813
--- /dev/null
+++ b/src/Molecule-Tests/MolComponentAnnouncementTest.class.st
@@ -0,0 +1,130 @@
+"
+A MolComponentInstanciatedTest is a test class for testing the behavior of MolComponentInstanciated
+"
+Class {
+	#name : #MolComponentAnnouncementTest,
+	#superclass : #TestCase,
+	#category : #'Molecule-Tests-Announcements'
+}
+
+{ #category : #running }
+MolComponentAnnouncementTest >> setUp [
+
+	super setUp.
+	MolComponentManager cleanUp
+]
+
+{ #category : #running }
+MolComponentAnnouncementTest >> tearDown [
+
+	MolComponentManager cleanUp.
+	super tearDown
+]
+
+{ #category : #tests }
+MolComponentAnnouncementTest >> testAnnounceActivated [
+
+	| announcement component component2 |
+	announcement := nil.
+	SystemAnnouncer uniqueInstance when: MolComponentActivated do:[ :a | announcement := a ].
+
+	"test by standard instanciation"
+	MolMyUserComponentImpl deploy.
+	component := MolMyUserComponentImpl instantiate.
+	self assert: announcement isNil.
+	
+	MolMyUserComponentImpl activate.
+	self assert: announcement notNil.
+	self assert: announcement component equals: component.
+	self assert: announcement componentName equals: MolUtils defaultComponentName.
+	announcement := nil.
+	
+	"test by named instanciation"
+	component2 := MolMyUserComponentImpl instantiate: #myComponent.
+	MolMyUserComponentImpl activate: #myComponent.
+	self assert: announcement notNil.
+	self assert: announcement component equals: component2.
+	self assert: announcement componentName equals: #myComponent.
+]
+
+{ #category : #tests }
+MolComponentAnnouncementTest >> testAnnounceInstanciated [
+
+	| announcement component component2 |
+	announcement := nil.
+	SystemAnnouncer uniqueInstance when: MolComponentInstanciated do:[ :a | announcement := a ].
+
+	"test by standard instanciation"
+	MolMyUserComponentImpl deploy.
+	component := MolMyUserComponentImpl instantiate.
+	self assert: announcement notNil.
+	self assert: announcement component equals: component.
+	self assert: announcement componentName equals: MolUtils defaultComponentName.
+	announcement := nil.
+	
+	"test by named instanciation"
+	component2 := MolMyUserComponentImpl instantiate: #myComponent.
+	self assert: announcement notNil.
+	self assert: announcement component equals: component2.
+	self assert: announcement componentName equals: #myComponent.
+]
+
+{ #category : #tests }
+MolComponentAnnouncementTest >> testAnnouncePassivated [
+
+	| announcement component component2 |
+	announcement := nil.
+	SystemAnnouncer uniqueInstance when: MolComponentPassivated do:[ :a | announcement := a ].
+
+	"test by standard instanciation"
+	MolMyUserComponentImpl deploy.
+	component := MolMyUserComponentImpl instantiate.
+	MolMyUserComponentImpl activate.
+	self assert: announcement isNil.
+	
+	MolMyUserComponentImpl passivate.
+	self assert: announcement notNil.
+	self assert: announcement component equals: component.
+	self assert: announcement componentName equals: MolUtils defaultComponentName.
+	announcement := nil.
+	
+	"test by named instanciation"
+	component2 := MolMyUserComponentImpl instantiate: #myComponent.
+	MolMyUserComponentImpl activate: #myComponent.
+	MolMyUserComponentImpl passivate: #myComponent.
+	self assert: announcement notNil.
+	self assert: announcement component equals: component2.
+	self assert: announcement componentName equals: #myComponent.
+]
+
+{ #category : #tests }
+MolComponentAnnouncementTest >> testAnnounceRemoved [
+
+	| announcement component component2 |
+	announcement := nil.
+	SystemAnnouncer uniqueInstance when: MolComponentRemoved do:[ :a | announcement := a ].
+
+	"test by standard instanciation"
+	MolMyUserComponentImpl deploy.
+	component := MolMyUserComponentImpl instantiate.
+	MolMyUserComponentImpl activate.
+	MolMyUserComponentImpl passivate.
+	self assert: announcement isNil.
+	
+	MolMyUserComponentImpl remove.
+	self assert: announcement notNil.
+	self assert: announcement component equals: component.
+	self assert: announcement componentName equals: MolUtils defaultComponentName.
+	announcement := nil.
+	
+	"test by named instanciation"
+	component2 := MolMyUserComponentImpl instantiate: #myComponent.
+	MolMyUserComponentImpl activate: #myComponent.
+	MolMyUserComponentImpl passivate: #myComponent.
+	self assert: announcement isNil.
+	
+	MolMyUserComponentImpl remove: #myComponent.
+	self assert: announcement notNil.
+	self assert: announcement component equals: component2.
+	self assert: announcement componentName equals: #myComponent.
+]
diff --git a/src/Molecule-Tests/MolComponentManagerTest.class.st b/src/Molecule-Tests/MolComponentManagerTest.class.st
index b45e5348..07d92965 100644
--- a/src/Molecule-Tests/MolComponentManagerTest.class.st
+++ b/src/Molecule-Tests/MolComponentManagerTest.class.st
@@ -9,13 +9,19 @@ Class {
 
 { #category : #'setUp - tearDown' }
 MolComponentManagerTest >> setUp [
+
 	super setUp.
-	MolComponentManager cleanUp
+	MolComponentManager cleanUp.
+	Smalltalk garbageCollect.
+	Smalltalk garbageCollectMost.
 ]
 
 { #category : #'setUp - tearDown' }
 MolComponentManagerTest >> tearDown [
+
 	MolComponentManager cleanUp.
+	Smalltalk garbageCollect.
+	Smalltalk garbageCollectMost.
 	super tearDown
 ]
 
@@ -32,6 +38,22 @@ MolComponentManagerTest >> testCleanUp [
 	
 ]
 
+{ #category : #tests }
+MolComponentManagerTest >> testCleanUpAnnouncements [
+| announcement list selection |
+announcement := nil.
+	SystemAnnouncer uniqueInstance when: MolComponentInstanciated do:[ :a | announcement := a ].
+	SystemAnnouncer uniqueInstance when: MolComponentPassivated do:[ :a | announcement := a ].
+	SystemAnnouncer uniqueInstance when: MolComponentInstanciated do:[ :a | announcement := a ].
+	list := MolAnnouncement withAllSubclasses.
+	selection := SystemAnnouncer uniqueInstance subscriptions subscriptions select: [  :e | list includes: e announcementClass] .
+	self assert: (selection size > 0).
+	MolComponentManager cleanupMolAnnouncements.
+	selection := SystemAnnouncer uniqueInstance subscriptions subscriptions select: [  :e | list includes: e announcementClass] .
+	self assert: (selection size = 0).
+	
+]
+
 { #category : #'tests - general' }
 MolComponentManagerTest >> testCleanUpIgnoreErrors [
 	"Start a manuel tree of components and clean up, components are removed during the cleanUp but some componentRemove methods should remove again an already removed component : a error is reach but ignored during a cleanUp"
@@ -80,21 +102,6 @@ MolComponentManagerTest >> testDeepCleanUp [
 	self assert: factory == MolComponentFactory default equals: false.
 ]
 
-{ #category : #tests }
-MolComponentManagerTest >> testDeepCleanUpGarbageCollect [
-
-	1 to: 10 do: [ :i | 
-		MolCompleteComponentImpl start: ('test' , i printString) asSymbol ].
-
-	"Check created instances"
-	self assert: MolCompleteComponentImpl allInstances size equals: 10.
-	
-	MolComponentManager deepCleanUp.
-	
-	"Check created instances"
-	self assert: MolCompleteComponentImpl allInstances size equals: 0.
-]
-
 { #category : #tests }
 MolComponentManagerTest >> testDefault [
 	self assert: (MolComponentManager default isKindOf: MolComponentManager).
@@ -108,44 +115,6 @@ MolComponentManagerTest >> testDeploymentServices [
 	self assert: (manager deploymentServices isKindOf: MolDeploymentServices).
 ]
 
-{ #category : #tests }
-MolComponentManagerTest >> testFlushComponents [
-	| nb |
-	
-	"Create some classics components to flush"
-	1 to: 10 do:[ :i | MolCompleteComponentImpl new ].
-	"Create some augmented class as components to flush"
-	1 to: 10 do:[ :i | MolAugmentedClassToAComponent new ].
-	"Check created instances"
-	self assert: MolCompleteComponentImpl allInstances size equals: 10.
-	self assert: MolAugmentedClassToAComponent allInstances size equals: 10.
-	
-	nb := MolComponentManager flushComponents.
-	self assert: nb equals: 20.
-	self assert: MolCompleteComponentImpl allInstances size equals: 0.
-	self assert: MolAugmentedClassToAComponent allInstances size equals: 0.
-]
-
-{ #category : #'setUp - tearDown' }
-MolComponentManagerTest >> testGarbageCollect [
-
-	"Create some classics components to clean"
-
-	1 to: 10 do: [ :i | 
-		MolCompleteComponentImpl start: ('test' , i printString) asSymbol ].
-
-	"Check created instances"
-	self assert: MolCompleteComponentImpl allInstances size equals: 10.
-
-
-	1 to: 10 do: [ :i | 
-		MolCompleteComponentImpl stop: ('test' , i printString) asSymbol ].
-	
-	Smalltalk garbageCollect.
-
-	self assert: MolCompleteComponentImpl allInstances size equals: 0
-]
-
 { #category : #tests }
 MolComponentManagerTest >> testHomeServices [
 	| manager |
diff --git a/src/Molecule-Tests/MolUtilsTest.class.st b/src/Molecule-Tests/MolUtilsTest.class.st
index f4a53d02..bc061b86 100644
--- a/src/Molecule-Tests/MolUtilsTest.class.st
+++ b/src/Molecule-Tests/MolUtilsTest.class.st
@@ -239,6 +239,34 @@ MolUtilsTest >> testLog2 [
 	MolUtils  isLogActive: (activate).
 ]
 
+{ #category : #tests }
+MolUtilsTest >> testOfferedTypes [
+
+	"Not used services"
+	| types |
+	self assert: (MolUtils offeredTypes: nil) isEmpty. "test with nil"
+	self assert: (MolUtils offeredTypes: Trait) isEmpty. "test with no component interface object"
+	self assert: (MolUtils offeredTypes: MolUnusedServices) isEmpty. "test with unused interface"
+	
+	"Type used services"
+	types := MolUtils offeredTypes: MolUsedServices.
+	self assert: types size equals: 2.
+	self assert: (types includes: MolCompleteComponent).
+	self assert: (types includes: MolCompleteComponent2).
+	
+	"Type provide events"
+	types := MolUtils offeredTypes: MolUsedEvents.
+	self assert: types size equals: 2.
+	self assert: (types includes: MolCompleteComponent).
+	self assert: (types includes: MolCompleteComponent2).
+	
+	"Type used parameters"
+	types := MolUtils offeredTypes: MolUsedParameters.
+	self assert: types size equals: 2.
+	self assert: (types includes: MolCompleteComponent).
+	self assert: (types includes: MolCompleteComponent2).
+]
+
 { #category : #tests }
 MolUtilsTest >> testPassivateComponentNamed [
 
@@ -395,6 +423,34 @@ MolUtilsTest >> testRemoveComponents [
 		equals: false
 ]
 
+{ #category : #tests }
+MolUtilsTest >> testRequiredTypes [
+
+	"Not used services"
+	| types |
+	self assert: (MolUtils requiredTypes: nil) isEmpty. "test with nil"
+	self assert: (MolUtils requiredTypes: Trait) isEmpty. "test with no component interface object"
+	self assert: (MolUtils requiredTypes: MolUnusedServices) isEmpty. "test with unused interface"
+	
+	"Type used services"
+	types := MolUtils requiredTypes: MolUsedServices.
+	self assert: types size equals: 2.
+	self assert: (types includes: MolCompleteComponent).
+	self assert: (types includes: MolCompleteComponent2).
+	
+	"Type provide events"
+	types := MolUtils requiredTypes: MolUsedEvents.
+	self assert: types size equals: 2.
+	self assert: (types includes: MolCompleteComponent).
+	self assert: (types includes: MolCompleteComponent2).
+	
+	"Type used parameters"
+	types := MolUtils requiredTypes: MolUsedParameters.
+	self assert: types size equals: 2.
+	self assert: (types includes: MolCompleteComponent).
+	self assert: (types includes: MolCompleteComponent2).
+]
+
 { #category : #tests }
 MolUtilsTest >> testShowInformation [
 	MolUtils showInformation: nil.
diff --git a/src/Molecule/MolAnnouncement.class.st b/src/Molecule/MolAnnouncement.class.st
new file mode 100644
index 00000000..c0596f2e
--- /dev/null
+++ b/src/Molecule/MolAnnouncement.class.st
@@ -0,0 +1,5 @@
+Class {
+	#name : #MolAnnouncement,
+	#superclass : #Announcement,
+	#category : #'Molecule-Announcements'
+}
diff --git a/src/Molecule/MolComponentActivated.class.st b/src/Molecule/MolComponentActivated.class.st
new file mode 100644
index 00000000..1fe41e2f
--- /dev/null
+++ b/src/Molecule/MolComponentActivated.class.st
@@ -0,0 +1,5 @@
+Class {
+	#name : #MolComponentActivated,
+	#superclass : #MolComponentAnnouncement,
+	#category : #'Molecule-Announcements'
+}
diff --git a/src/Molecule/MolComponentAnnouncement.class.st b/src/Molecule/MolComponentAnnouncement.class.st
new file mode 100644
index 00000000..0bd772f8
--- /dev/null
+++ b/src/Molecule/MolComponentAnnouncement.class.st
@@ -0,0 +1,33 @@
+Class {
+	#name : #MolComponentAnnouncement,
+	#superclass : #MolAnnouncement,
+	#instVars : [
+		'component',
+		'componentName'
+	],
+	#category : #'Molecule-Announcements'
+}
+
+{ #category : #accessing }
+MolComponentAnnouncement >> component [
+
+	^ component
+]
+
+{ #category : #accessing }
+MolComponentAnnouncement >> component: anObject [
+
+	component := anObject
+]
+
+{ #category : #accessing }
+MolComponentAnnouncement >> componentName [
+
+	^ componentName
+]
+
+{ #category : #accessing }
+MolComponentAnnouncement >> componentName: anObject [
+
+	componentName := anObject
+]
diff --git a/src/Molecule/MolComponentInstanciated.class.st b/src/Molecule/MolComponentInstanciated.class.st
new file mode 100644
index 00000000..9c98bba0
--- /dev/null
+++ b/src/Molecule/MolComponentInstanciated.class.st
@@ -0,0 +1,8 @@
+"
+Announcement when a component is instanciated by the ComponentManager.
+"
+Class {
+	#name : #MolComponentInstanciated,
+	#superclass : #MolComponentAnnouncement,
+	#category : #'Molecule-Announcements'
+}
diff --git a/src/Molecule/MolComponentManager.class.st b/src/Molecule/MolComponentManager.class.st
index 2eba83e5..2eff3e05 100644
--- a/src/Molecule/MolComponentManager.class.st
+++ b/src/Molecule/MolComponentManager.class.st
@@ -47,6 +47,8 @@ MolComponentManager class >> cleanUp [
 	notifiers do: [ :n | n release ].
 	subscribers do: [ :n | n release ].
 	
+	self cleanupMolAnnouncements.
+	
 	MolUtils log: 'End of the cleanUp.'
 ]
 
@@ -57,38 +59,55 @@ MolComponentManager class >> cleanUp: aBoolean [
 	self deepCleanUp.
 ]
 
+{ #category : #cleanup }
+MolComponentManager class >> cleanupMolAnnouncements [
+<script>
+| registeredList |
+registeredList := SystemAnnouncer uniqueInstance subscriptions subscriptions select: [  :e | self isMolAnnoucement: e announcementClass ].
+registeredList do: [ :r | SystemAnnouncer uniqueInstance subscriptions remove: r].
+]
+
 { #category : #cleanup }
 MolComponentManager class >> deepCleanUp [
+
 	<script: 'self deepCleanUp'>
 	| i j |
-	
 	"Try to remove non garbaged component instances"
 	Smalltalk garbageCollect.
-	
+	Smalltalk garbageCollectMost.
+
 	self cleanUp.
 	MolUtils log: 'Starting a deep cleanUp.'.
-	MolComponentFactory allInstancesDo: [ :factory | (factory == MolComponentFactory default) ifFalse:[factory release]].
+	MolComponentFactory allInstancesDo: [ :factory |
+		factory == MolComponentFactory default ifFalse: [ factory release ] ].
 	i := self flushComponents.
 	j := i.
-	
+
 	"Try to reflush"
-	i > 0 ifTrue:[
+	i > 0 ifTrue: [
+		
+		Smalltalk garbageCollect.
+		Smalltalk garbageCollectMost.
+		
 		(Delay forMilliseconds: 500) wait.
-		j := self flushComponents.
-	].
-	
-	MolUtils log: 'Deep Cleanup: ',i printString,' lost component(s) found and released.'.
-	i <= 0 ifFalse:[
-		j <= 0 ifFalse:[
-			MolUtils showInformation: 'Warning : Cannot release ',i printString,' component(s) after two clean pass, please try again to confirm correct cleanup.'.
-		] ifTrue:[
-			MolUtils showInformation: 'Clean success : ',i printString,' lost component(s) found and released.'.
-		].
-	] ifTrue:[
-		MolUtils showInformation: 'No problem : image was clean.'.
-	].
-
-	MolUtils log: 'End of the deep cleanUp.'.
+		j := self flushComponents ].
+
+	MolUtils log: 'Deep Cleanup: ' , i printString
+		, ' lost component(s) found and released.'.
+	i <= 0
+		ifFalse: [
+			j <= 0
+				ifFalse: [
+					MolUtils showInformation:
+						'Warning : Cannot release ' , i printString
+						,
+						' component(s) after two clean pass, please try again to confirm correct cleanup.' ]
+				ifTrue: [
+					MolUtils showInformation: 'Clean success : ' , i printString
+						, ' lost component(s) found and released.' ] ]
+		ifTrue: [ MolUtils showInformation: 'No problem : image was clean.' ].
+
+	MolUtils log: 'End of the deep cleanUp.'
 ]
 
 { #category : #singleton }
@@ -104,23 +123,25 @@ MolComponentManager class >> default [
 
 { #category : #'initialize-release' }
 MolComponentManager class >> flushComponents [
-	"Flush all components : detect all component class instances of the Pharo image and disconnect each componentconnector, return number of flushed components"
+	"Flush all components : detect all component class instances of the Pharo image and disconnect each component connector, return number of flushed components"
+
 	| i |
 	i := 0.
 	"First : search direct component class subinstances (inheritance from MolAbstractComponentImpl class)"
-	MolAbstractComponentImpl allSubInstancesDo:[ :component | 
-		component componentConnector: nil. i := i + 1.
-	].
-	"Second : search augmented class as a component instances (using the MolComponentImpl trait)"
-	MolComponentImpl users do: [ :impl | 
-		impl allInstances do: [:component | component componentConnector: nil. i := i + 1].
-	].	
-	
+	MolAbstractComponentImpl allSubInstancesDo: [ :component |
+		component componentConnector: nil.
+		i := i + 1 ].
+	"Second : search augmented class component instances (using the MolComponentImpl trait)"
+	MolComponentImpl users do: [ :impl |
+		impl allInstances do: [ :component |
+			component componentConnector: nil.
+			i := i + 1 ] ].
+
 	SmalltalkImage cleanUp.
 	Smalltalk garbageCollect.
 	Smalltalk garbageCollectMost.
-	
-	^i
+
+	^ i
 ]
 
 { #category : #'initialize-release' }
@@ -131,6 +152,14 @@ MolComponentManager class >> isInitialized [
 	^ Default notNil
 ]
 
+{ #category : #cleanup }
+MolComponentManager class >> isMolAnnoucement: aClass [
+
+	MolAnnouncement withAllSubclasses do: [ :a |
+		a = aClass ifTrue: [ ^ true ] ].
+	^ false
+]
+
 { #category : #'initialize-release' }
 MolComponentManager class >> isRunningComponents [
 	<script:'self isRunningComponents inspect'>
diff --git a/src/Molecule/MolComponentPassivated.class.st b/src/Molecule/MolComponentPassivated.class.st
new file mode 100644
index 00000000..97e09a49
--- /dev/null
+++ b/src/Molecule/MolComponentPassivated.class.st
@@ -0,0 +1,5 @@
+Class {
+	#name : #MolComponentPassivated,
+	#superclass : #MolComponentAnnouncement,
+	#category : #'Molecule-Announcements'
+}
diff --git a/src/Molecule/MolComponentRemoved.class.st b/src/Molecule/MolComponentRemoved.class.st
new file mode 100644
index 00000000..90ca1157
--- /dev/null
+++ b/src/Molecule/MolComponentRemoved.class.st
@@ -0,0 +1,5 @@
+Class {
+	#name : #MolComponentRemoved,
+	#superclass : #MolComponentAnnouncement,
+	#category : #'Molecule-Announcements'
+}
diff --git a/src/Molecule/MolHomeServices.class.st b/src/Molecule/MolHomeServices.class.st
index 663adc0a..5331545c 100644
--- a/src/Molecule/MolHomeServices.class.st
+++ b/src/Molecule/MolHomeServices.class.st
@@ -56,7 +56,8 @@ MolHomeServices >> activateComponent: aComponentClass named: aName [
 	MolComponentManager default locatorServices resolveWaitingSubscriptions: component.
 	
 	component componentActivate.
-	component triggerEvent: #activateComponent with: component.
+	self announcer announce: (MolComponentActivated new 
+		component: component; componentName: aName; yourself).
 	
 	MolUtils log: aComponentClass printString , ' named: ' , aName printString , ' is activated.'.
 	
@@ -68,6 +69,12 @@ MolHomeServices >> addDeployedComponent: aComponentClass [
 	self deployedComponents at: aComponentClass ifAbsentPut: [Dictionary new]
 ]
 
+{ #category : #announcer }
+MolHomeServices >> announcer [
+
+	^ SystemAnnouncer uniqueInstance
+]
+
 { #category : #private }
 MolHomeServices >> checkComponentInstantiationPermission: aComponentClass named: aComponentName [
 
@@ -135,9 +142,10 @@ MolHomeServices >> deployedComponents [
 
 { #category : #'initialize-release' }
 MolHomeServices >> initialize [
+
 	super initialize.
 	deployedComponents := Dictionary new.
-	waitingForActivation := Set new.
+	waitingForActivation := Set new
 ]
 
 { #category : #accessing }
@@ -191,11 +199,6 @@ MolHomeServices >> instantiateComponent: aComponentClass named: aName [
 	error ifNotNil: [ error signal. ^ nil ].
 
 	component := aComponentClass new componentName: aName; yourself.
-	
-	MolUtils log:
-		aComponentClass printString , ' named: ' , aName printString
-		, ' is instantiated.'.
-
 	deployed := self deployedComponents at: aComponentClass.
 	deployed at: component componentName put: component.
 
@@ -203,7 +206,12 @@ MolHomeServices >> instantiateComponent: aComponentClass named: aName [
 	connector := MolComponentConnector new.
 	component componentConnector: connector.
 	component componentInitialize.
-	component triggerEvent: #instantiateComponent with: component.
+	self announcer announce: (MolComponentInstanciated new 
+		component: component; componentName: aName; yourself).
+
+	MolUtils log:
+		aComponentClass printString , ' named: ' , aName printString
+		, ' is instantiated.'.
 
 	"add the component to waiting activation list"
 	waitingForActivation add: component.
@@ -266,8 +274,9 @@ MolHomeServices >> passivateComponent: aComponentClass named: aName [
 
 	component componentPassivate.
 	component componentConnector passivateComponent.
-	component triggerEvent: #passivateComponent with: component.
-	
+	self announcer announce: (MolComponentPassivated new 
+		component: component; componentName: aName; yourself).
+		
 	MolUtils log: aComponentClass printString , ' named: ' , aName printString, ' is passivated.'.
 
 	"add in waiting activation list"
@@ -278,10 +287,11 @@ MolHomeServices >> passivateComponent: aComponentClass named: aName [
 
 { #category : #'initialize-release' }
 MolHomeServices >> release [
+
 	self removeAllComponents.
 	deployedComponents := nil.
 	waitingForActivation := nil.
-	super release.
+	super release
 ]
 
 { #category : #'life cycle' }
@@ -333,10 +343,7 @@ MolHomeServices >> removeComponent: aComponentClass named: aName ifAbsent: aBloc
 	"Remove the component"
 	removedComponent componentRemove.
 	removedComponent componentConnector: nil.
-	removedComponent
-		triggerEvent: #removeComponent
-		with: removedComponent.
-
+	
 	"Get deployed component instances of this component class"
 	deployedComponentsOfThisClass := self deployedComponents
 		                                 at: aComponentClass
@@ -368,9 +375,14 @@ MolHomeServices >> removeComponent: aComponentClass named: aName ifAbsent: aBloc
 
 	"Finish release of the component life-cycle"
 	removedComponent componentName: nil.
+
+	self announcer announce: (MolComponentRemoved new 
+		component: removedComponent; componentName: aName; yourself).
+	
 	MolUtils log:
 		aComponentClass printString , ' named: ' , aName printString
 		, ' is removed.'.
+		
 	^ removedComponent
 ]
 
diff --git a/src/Molecule/MolUtils.class.st b/src/Molecule/MolUtils.class.st
index 36ada385..6f8761a2 100644
--- a/src/Molecule/MolUtils.class.st
+++ b/src/Molecule/MolUtils.class.st
@@ -200,6 +200,32 @@ MolUtils class >> log: aString [
 	self traceCr: '[Molecule] ' , string
 ]
 
+{ #category : #'component contract' }
+MolUtils class >> offeredTypes: aComponentContractInterface [
+	"Get types that are part of a component contract offered as Services, Events, or Parameters interface"
+
+	| list |
+	list := Set new.
+	aComponentContractInterface ifNil:[ ^ list asOrderedCollection ].
+	aComponentContractInterface isTrait ifFalse:[ ^ list asOrderedCollection ].
+	(aComponentContractInterface isComponentServices not and:[aComponentContractInterface isComponentEvents not and:[aComponentContractInterface isComponentParameters not]]) ifTrue:[ ^ list asOrderedCollection ].
+	
+	"Collect all required"
+	MolComponentType users do:[ :type | 
+		aComponentContractInterface isComponentServices ifTrue:[ 
+			(type isProvideServices: aComponentContractInterface) ifTrue:[ list add: type ].
+		] ifFalse:[
+			aComponentContractInterface isComponentEvents ifTrue:[ 
+				(type isProduceEvents: aComponentContractInterface) ifTrue:[ list add: type ].
+			] ifFalse:[
+				(type isProvideParameters: aComponentContractInterface) ifTrue:[ list add: type ].
+			].
+		].
+	].
+
+	^ list asOrderedCollection  
+]
+
 { #category : #'quick lifecycle' }
 MolUtils class >> passivateComponent: aComponentClass named: aName [
 	"passivate quickly a component"
@@ -274,6 +300,32 @@ MolUtils class >> removeComponents: aComponentClassList [
 	].
 ]
 
+{ #category : #'component contract' }
+MolUtils class >> requiredTypes: aComponentContractInterface [
+	"Get types that are part of a component contract required as Services, Events, or Parameters interface"
+
+	| list |
+	list := Set new.
+	aComponentContractInterface ifNil:[ ^ list asOrderedCollection ].
+	aComponentContractInterface isTrait ifFalse:[ ^ list asOrderedCollection ].
+	(aComponentContractInterface isComponentServices not and:[aComponentContractInterface isComponentEvents not and:[aComponentContractInterface isComponentParameters not]]) ifTrue:[ ^ list asOrderedCollection ].
+	
+	"Collect all required"
+	MolComponentType users do:[ :type | 
+		aComponentContractInterface isComponentServices ifTrue:[ 
+			(type isUseServices: aComponentContractInterface) ifTrue:[ list add: type ].
+		] ifFalse:[
+			aComponentContractInterface isComponentEvents ifTrue:[ 
+				(type isConsumeEvents: aComponentContractInterface) ifTrue:[ list add: type ].
+			] ifFalse:[
+				(type isUseParameters: aComponentContractInterface) ifTrue:[ list add: type ].
+			].
+		].
+	].
+
+	^ list asOrderedCollection  
+]
+
 { #category : #log }
 MolUtils class >> showInformation: aString [
 	"Inform the user with a message into the Pharo UI"