Updated some-message-channel_en.md

problem/some-message-channel_en.md

@@ -1,4 +1,64 @@
+# Explanation of the Code
 
-There is no solution yet.
+## Introduction
 
-Would you like to [contribute to the solution](https://github.com/BFEdev/BFE.dev-solutions/blob/main/problem/some-message-channel_en.md)? [Contribute guideline](https://github.com/BFEdev/BFE.dev-solutions#how-to-contribute)
+In this JavaScript code, we utilize the concept of a mixin to enhance the functionality of `SomePort` instances, which are properties of the `SomeChannel` class. We then create a new class called `BetterChannel` that leverages this mixin to add additional methods to these port objects.
+
+## Key Concepts
+
+### Mixins
+
+Mixins are a way to add properties and methods to objects or classes without using inheritance. They allow for the composition of behaviors and can be mixed into any object.
+
+### SomeChannel and SomePort
+
+- `SomeChannel` is a class with two properties: `port1` and `port2`, both of which are instances of `SomePort`.
+- `SomePort` has a `postMessage` method and an optional `onmessage` method.
+
+## Code Explanation
+
+### The `portMixin` Object
+
+The `portMixin` object contains methods that we want to add to instances of `SomePort`:
+
+```javascript
+const portMixin = {
+  postMessage(message, handler) {
+    console.log(this.oppositePort);
+    if(this.oppositePort.onmessage) {
+      this.oppositePort.onmessage(message, this.callingOnceOnly(handler))
+    }
+  },
+  callingOnceOnly(cb) {
+    let alreadyCalled = false;
+    return function(...args) {
+      if(!alreadyCalled){
+        cb(...args);
+        alreadyCalled = true;
+        return;
+      }
+      else return;
+    }
+  }
+}
+
+1. **`postMessage(message, handler)`**:
+   - This method logs the `oppositePort` and checks if the `oppositePort` has an `onmessage` handler.
+   - If the `onmessage` handler exists, it calls the handler with the message and ensures the handler is called only once using `callingOnceOnly`.
+
+2. **`callingOnceOnly(cb)`**:
+   - This method takes a callback function `cb` and returns a new function that ensures `cb` is called only once.
+   - It uses a flag (`alreadyCalled`) to track whether `cb` has been called before.
+
+### Enhancing `SomeChannel` with the Mixin
+
+We then enhance the `SomeChannel` class using the mixin:
+
+```javascript
+class BetterChannel {
+  constructor() {
+    const {port1, port2} = new SomeChannel();
+    this.port1 = Object.assign(port1, portMixin, {oppositePort: port2});
+    this.port2 = Object.assign(port2, portMixin, {oppositePort: port1});
+  }
+}