4.9.0

pubkey · Dec 23, 2021 · 1f05a0f · 1f05a0f
1 parent c872596
commit 1f05a0f
Show file tree

Hide file tree

Showing 13 changed files with 155 additions and 36 deletions.
diff --git a/CHANGELOG.md b/CHANGELOG.md
@@ -1,6 +1,6 @@
 # CHANGELOG
 
-## X.X.X (comming soon)
+## 4.9.0 (23 December 2021)
 
 Bugfixes:
   - When listening to messages directly, responses that where send directly after `addEventListener()` where missing because of inaccurate JavaScript timing.

diff --git a/dist/es5node/broadcast-channel.js b/dist/es5node/broadcast-channel.js
@@ -260,9 +260,21 @@ function _startListening(channel) {
   if (!channel._iL && _hasMessageListeners(channel)) {
     // someone is listening, start subscribing
     var listenerFn = function listenerFn(msgObj) {
-      channel._addEL[msgObj.type].forEach(function (obj) {
-        if (msgObj.time >= obj.time) {
-          obj.fn(msgObj.data);
+      channel._addEL[msgObj.type].forEach(function (listenerObject) {
+        /**
+         * Getting the current time in JavaScript has no good precision.
+         * So instead of only listening to events that happend 'after' the listener
+         * was added, we also listen to events that happended 100ms before it.
+         * This ensures that when another process, like a WebWorker, sends events
+         * we do not miss them out because their timestamp is a bit off compared to the main process.
+         * Not doing this would make messages missing when we send data directly after subscribing and awaiting a response.
+         * @link https://johnresig.com/blog/accuracy-of-javascript-time/
+         */
+        var hundredMsInMicro = 100 * 1000;
+        var minMessageTime = listenerObject.time - hundredMsInMicro;
+
+        if (msgObj.time >= minMessageTime) {
+          listenerObject.fn(msgObj.data);
         }
       });
     };

diff --git a/dist/esbrowser/broadcast-channel.js b/dist/esbrowser/broadcast-channel.js
@@ -242,9 +242,21 @@ function _startListening(channel) {
   if (!channel._iL && _hasMessageListeners(channel)) {
     // someone is listening, start subscribing
     var listenerFn = function listenerFn(msgObj) {
-      channel._addEL[msgObj.type].forEach(function (obj) {
-        if (msgObj.time >= obj.time) {
-          obj.fn(msgObj.data);
+      channel._addEL[msgObj.type].forEach(function (listenerObject) {
+        /**
+         * Getting the current time in JavaScript has no good precision.
+         * So instead of only listening to events that happend 'after' the listener
+         * was added, we also listen to events that happended 100ms before it.
+         * This ensures that when another process, like a WebWorker, sends events
+         * we do not miss them out because their timestamp is a bit off compared to the main process.
+         * Not doing this would make messages missing when we send data directly after subscribing and awaiting a response.
+         * @link https://johnresig.com/blog/accuracy-of-javascript-time/
+         */
+        var hundredMsInMicro = 100 * 1000;
+        var minMessageTime = listenerObject.time - hundredMsInMicro;
+
+        if (msgObj.time >= minMessageTime) {
+          listenerObject.fn(msgObj.data);
         }
       });
     };

diff --git a/dist/esnode/broadcast-channel.js b/dist/esnode/broadcast-channel.js
@@ -242,9 +242,21 @@ function _startListening(channel) {
   if (!channel._iL && _hasMessageListeners(channel)) {
     // someone is listening, start subscribing
     var listenerFn = function listenerFn(msgObj) {
-      channel._addEL[msgObj.type].forEach(function (obj) {
-        if (msgObj.time >= obj.time) {
-          obj.fn(msgObj.data);
+      channel._addEL[msgObj.type].forEach(function (listenerObject) {
+        /**
+         * Getting the current time in JavaScript has no good precision.
+         * So instead of only listening to events that happend 'after' the listener
+         * was added, we also listen to events that happended 100ms before it.
+         * This ensures that when another process, like a WebWorker, sends events
+         * we do not miss them out because their timestamp is a bit off compared to the main process.
+         * Not doing this would make messages missing when we send data directly after subscribing and awaiting a response.
+         * @link https://johnresig.com/blog/accuracy-of-javascript-time/
+         */
+        var hundredMsInMicro = 100 * 1000;
+        var minMessageTime = listenerObject.time - hundredMsInMicro;
+
+        if (msgObj.time >= minMessageTime) {
+          listenerObject.fn(msgObj.data);
         }
       });
     };

diff --git a/dist/lib/broadcast-channel.js b/dist/lib/broadcast-channel.js
@@ -260,9 +260,21 @@ function _startListening(channel) {
   if (!channel._iL && _hasMessageListeners(channel)) {
     // someone is listening, start subscribing
     var listenerFn = function listenerFn(msgObj) {
-      channel._addEL[msgObj.type].forEach(function (obj) {
-        if (msgObj.time >= obj.time) {
-          obj.fn(msgObj.data);
+      channel._addEL[msgObj.type].forEach(function (listenerObject) {
+        /**
+         * Getting the current time in JavaScript has no good precision.
+         * So instead of only listening to events that happend 'after' the listener
+         * was added, we also listen to events that happended 100ms before it.
+         * This ensures that when another process, like a WebWorker, sends events
+         * we do not miss them out because their timestamp is a bit off compared to the main process.
+         * Not doing this would make messages missing when we send data directly after subscribing and awaiting a response.
+         * @link https://johnresig.com/blog/accuracy-of-javascript-time/
+         */
+        var hundredMsInMicro = 100 * 1000;
+        var minMessageTime = listenerObject.time - hundredMsInMicro;
+
+        if (msgObj.time >= minMessageTime) {
+          listenerObject.fn(msgObj.data);
         }
       });
     };

diff --git a/dist/lib/browser.js b/dist/lib/browser.js
@@ -261,9 +261,21 @@ function _startListening(channel) {
   if (!channel._iL && _hasMessageListeners(channel)) {
     // someone is listening, start subscribing
     var listenerFn = function listenerFn(msgObj) {
-      channel._addEL[msgObj.type].forEach(function (obj) {
-        if (msgObj.time >= obj.time) {
-          obj.fn(msgObj.data);
+      channel._addEL[msgObj.type].forEach(function (listenerObject) {
+        /**
+         * Getting the current time in JavaScript has no good precision.
+         * So instead of only listening to events that happend 'after' the listener
+         * was added, we also listen to events that happended 100ms before it.
+         * This ensures that when another process, like a WebWorker, sends events
+         * we do not miss them out because their timestamp is a bit off compared to the main process.
+         * Not doing this would make messages missing when we send data directly after subscribing and awaiting a response.
+         * @link https://johnresig.com/blog/accuracy-of-javascript-time/
+         */
+        var hundredMsInMicro = 100 * 1000;
+        var minMessageTime = listenerObject.time - hundredMsInMicro;
+
+        if (msgObj.time >= minMessageTime) {
+          listenerObject.fn(msgObj.data);
         }
       });
     };

diff --git a/dist/lib/browser.min.js b/dist/lib/browser.min.js
diff --git a/docs/e2e.js b/docs/e2e.js
@@ -261,9 +261,21 @@ function _startListening(channel) {
   if (!channel._iL && _hasMessageListeners(channel)) {
     // someone is listening, start subscribing
     var listenerFn = function listenerFn(msgObj) {
-      channel._addEL[msgObj.type].forEach(function (obj) {
-        if (msgObj.time >= obj.time) {
-          obj.fn(msgObj.data);
+      channel._addEL[msgObj.type].forEach(function (listenerObject) {
+        /**
+         * Getting the current time in JavaScript has no good precision.
+         * So instead of only listening to events that happend 'after' the listener
+         * was added, we also listen to events that happended 100ms before it.
+         * This ensures that when another process, like a WebWorker, sends events
+         * we do not miss them out because their timestamp is a bit off compared to the main process.
+         * Not doing this would make messages missing when we send data directly after subscribing and awaiting a response.
+         * @link https://johnresig.com/blog/accuracy-of-javascript-time/
+         */
+        var hundredMsInMicro = 100 * 1000;
+        var minMessageTime = listenerObject.time - hundredMsInMicro;
+
+        if (msgObj.time >= minMessageTime) {
+          listenerObject.fn(msgObj.data);
         }
       });
     };
@@ -12374,7 +12386,6 @@ function run() {
             rand = new Date().getTime();
 
             channel.onmessage = function (msg) {
-              console.log('main: recieved msg' + JSON.stringify(msg));
               answerPool[msg.from] = msg;
               var textnode = document.createTextNode(JSON.stringify(msg) + '</br>');
               msgContainer.appendChild(textnode);
@@ -12670,7 +12681,9 @@ function run() {
                         return true;
                       })]).then(function (errored) {
                         if (errored) {
-                          throw new Error('timed out for msgId ' + msgId);
+                          var errorMessage = 'ERROR startWorkerTest() timed out for msgId ' + msgId;
+                          console.error(errorMessage);
+                          throw new Error(errorMessage);
                         }
                       });
 

diff --git a/docs/iframe.js b/docs/iframe.js
@@ -261,9 +261,21 @@ function _startListening(channel) {
   if (!channel._iL && _hasMessageListeners(channel)) {
     // someone is listening, start subscribing
     var listenerFn = function listenerFn(msgObj) {
-      channel._addEL[msgObj.type].forEach(function (obj) {
-        if (msgObj.time >= obj.time) {
-          obj.fn(msgObj.data);
+      channel._addEL[msgObj.type].forEach(function (listenerObject) {
+        /**
+         * Getting the current time in JavaScript has no good precision.
+         * So instead of only listening to events that happend 'after' the listener
+         * was added, we also listen to events that happended 100ms before it.
+         * This ensures that when another process, like a WebWorker, sends events
+         * we do not miss them out because their timestamp is a bit off compared to the main process.
+         * Not doing this would make messages missing when we send data directly after subscribing and awaiting a response.
+         * @link https://johnresig.com/blog/accuracy-of-javascript-time/
+         */
+        var hundredMsInMicro = 100 * 1000;
+        var minMessageTime = listenerObject.time - hundredMsInMicro;
+
+        if (msgObj.time >= minMessageTime) {
+          listenerObject.fn(msgObj.data);
         }
       });
     };

diff --git a/docs/index.js b/docs/index.js
@@ -261,9 +261,21 @@ function _startListening(channel) {
   if (!channel._iL && _hasMessageListeners(channel)) {
     // someone is listening, start subscribing
     var listenerFn = function listenerFn(msgObj) {
-      channel._addEL[msgObj.type].forEach(function (obj) {
-        if (msgObj.time >= obj.time) {
-          obj.fn(msgObj.data);
+      channel._addEL[msgObj.type].forEach(function (listenerObject) {
+        /**
+         * Getting the current time in JavaScript has no good precision.
+         * So instead of only listening to events that happend 'after' the listener
+         * was added, we also listen to events that happended 100ms before it.
+         * This ensures that when another process, like a WebWorker, sends events
+         * we do not miss them out because their timestamp is a bit off compared to the main process.
+         * Not doing this would make messages missing when we send data directly after subscribing and awaiting a response.
+         * @link https://johnresig.com/blog/accuracy-of-javascript-time/
+         */
+        var hundredMsInMicro = 100 * 1000;
+        var minMessageTime = listenerObject.time - hundredMsInMicro;
+
+        if (msgObj.time >= minMessageTime) {
+          listenerObject.fn(msgObj.data);
         }
       });
     };

diff --git a/docs/leader-iframe.js b/docs/leader-iframe.js
@@ -261,9 +261,21 @@ function _startListening(channel) {
   if (!channel._iL && _hasMessageListeners(channel)) {
     // someone is listening, start subscribing
     var listenerFn = function listenerFn(msgObj) {
-      channel._addEL[msgObj.type].forEach(function (obj) {
-        if (msgObj.time >= obj.time) {
-          obj.fn(msgObj.data);
+      channel._addEL[msgObj.type].forEach(function (listenerObject) {
+        /**
+         * Getting the current time in JavaScript has no good precision.
+         * So instead of only listening to events that happend 'after' the listener
+         * was added, we also listen to events that happended 100ms before it.
+         * This ensures that when another process, like a WebWorker, sends events
+         * we do not miss them out because their timestamp is a bit off compared to the main process.
+         * Not doing this would make messages missing when we send data directly after subscribing and awaiting a response.
+         * @link https://johnresig.com/blog/accuracy-of-javascript-time/
+         */
+        var hundredMsInMicro = 100 * 1000;
+        var minMessageTime = listenerObject.time - hundredMsInMicro;
+
+        if (msgObj.time >= minMessageTime) {
+          listenerObject.fn(msgObj.data);
         }
       });
     };

diff --git a/docs/worker.js b/docs/worker.js
@@ -261,9 +261,21 @@ function _startListening(channel) {
   if (!channel._iL && _hasMessageListeners(channel)) {
     // someone is listening, start subscribing
     var listenerFn = function listenerFn(msgObj) {
-      channel._addEL[msgObj.type].forEach(function (obj) {
-        if (msgObj.time >= obj.time) {
-          obj.fn(msgObj.data);
+      channel._addEL[msgObj.type].forEach(function (listenerObject) {
+        /**
+         * Getting the current time in JavaScript has no good precision.
+         * So instead of only listening to events that happend 'after' the listener
+         * was added, we also listen to events that happended 100ms before it.
+         * This ensures that when another process, like a WebWorker, sends events
+         * we do not miss them out because their timestamp is a bit off compared to the main process.
+         * Not doing this would make messages missing when we send data directly after subscribing and awaiting a response.
+         * @link https://johnresig.com/blog/accuracy-of-javascript-time/
+         */
+        var hundredMsInMicro = 100 * 1000;
+        var minMessageTime = listenerObject.time - hundredMsInMicro;
+
+        if (msgObj.time >= minMessageTime) {
+          listenerObject.fn(msgObj.data);
         }
       });
     };

diff --git a/test/scripts/e2e.js b/test/scripts/e2e.js
@@ -79,8 +79,6 @@ function run() {
         const rand = new Date().getTime();
 
         channel.onmessage = function (msg) {
-            console.log('main: recieved msg' + JSON.stringify(msg));
-
             answerPool[msg.from] = msg;
             var textnode = document.createTextNode(JSON.stringify(msg) + '</br>');
             msgContainer.appendChild(textnode);