<!-- wrapper-layout.component.html -->

 <div class="container">
    <div class="row">
        <div>
            <left-side></left-side>
        </div>
        <div>
            <router-outlet 
                name="showright"
            ></router-outlet>
        </div>
    </div>
</div>

/** routing.module.ts */

{
    path: 'connect',
    component: WrapperLayoutComponent,
    children: [
       { 
           path: '', 
           component: RightSideComponent,
           outlet: 'showright'
       },
    ]
 },

// component navigation action

this.router.navigate([
    '/connect', 
    { outlets: { showright: ['user-info'] } }
]);

PubSub is one of the most commonly used and fundamental reactivity patterns. The Publisher is responsible for notifying Subscribers about the updates and the Subscriber receives those updates and can react in response.

One popular example of its usage is Redux. This popular state management library is based on this pattern (or more specifically, the Flux architecture). Things work pretty simple in the context of Redux:

— Publisher: The store acts as the publisher. When an action is dispatched, the store notifies all the subscribed components about the state change.

— Subscriber: UI Components in the application are the subscribers. They subscribe to the Redux store and receive updates whenever the state changes.

If you prefer not to dispatch events globally on the window object, you can create your own event target.

By extending the native EventTarget class, you can dispatch events to a new instance of it. This ensures that your events are triggered only on the new class itself, avoiding global propagation. Moreover, you have the flexibility to attach handlers directly to this specific instance.

The Observer pattern is really similar to PubSub. You subscribe to the Subject and then it notifies its subscribers (Observers) about changes, allowing them to react accordingly. This pattern plays a significant role in building decoupled and flexible architecture.

If you want to react to changes in objects, Proxy is the way to go. It lets us achieve reactivity when setting or getting values of object fields.

If you don’t need to track all the fields in the objects, you can choose the specific one using Object.defineProperty or group of them with Object.defineProperties.

One way to achieve reactivity in the DOM is by using MutationObserver. Its API allows us to observe changes in attributes and also in the text content of the target element and its children.

The browser offers an API for triggering and subscribing to custom events through the CustomEvent class and the dispatchEvent method. The latter provides us with the ability not only to trigger an event but also to attach any desired data to it.

The IntersectionObserver API enables reacting to the intersection of a target element with another element or the viewport area.