refactor(shared-worker): reorganize SharedWorker code

Decouple and re-organize `SharedWorker` code for better maintainability.

perf(shared-worker): improved subscription state refresh logic

Additional query parameter (removed before sending) is added for requests triggered by user and
state will be updated only for these requests.

refactor(logger): avoid similar timestamp in sequential lines

Log entry timestamp will be altered on millisecond if multiple log entries have similar
timestamp (logged in fraction of nanoseconds).

Author: parfeon

dist/web/pubnub.js

@@ -134,6 +134,10 @@ const makeConfiguration = (base, setupCryptoModule) => {
         getUseRandomIVs() {
             return base.useRandomIVs;
         },
+        isSharedWorkerEnabled() {
+            // @ts-expect-error: Access field from web-based SDK configuration.
+            return base.sdkFamily === 'Web' && base['subscriptionWorkerUrl'];
+        },
         getKeepPresenceChannelsInPresenceRequests() {
             // @ts-expect-error: Access field from web-based SDK configuration.
             return base.sdkFamily === 'Web' && base['subscriptionWorkerUrl'];

dist/web/pubnub.min.js

@@ -18,6 +18,15 @@ class LoggerManager {
      * @internal
      */
     constructor(pubNubId, minLogLevel, loggers) {
+        /**
+         * Keeping track of previous entry timestamp.
+         *
+         * This information will be used to make sure that multiple sequential entries doesn't have same timestamp. Adjustment
+         * on .001 will be done to make it possible to properly stort entries.
+         *
+         * @internal
+         */
+        this.previousEntryTimestamp = 0;
         this.pubNubId = pubNubId;
         this.minLogLevel = minLogLevel;
         this.loggers = loggers;
@@ -100,8 +109,15 @@ class LoggerManager {
         // Check whether a log message should be handled at all or not.
         if (logLevel < this.minLogLevel || this.loggers.length === 0)
             return;
+        const date = new Date();
+        if (date.getTime() <= this.previousEntryTimestamp) {
+            this.previousEntryTimestamp++;
+            date.setTime(this.previousEntryTimestamp);
+        }
+        else
+            this.previousEntryTimestamp = date.getTime();
         const level = logger_1.LogLevel[logLevel].toLowerCase();
-        const message = Object.assign({ timestamp: new Date(), pubNubId: this.pubNubId, level: logLevel, minimumLevel: this.minLogLevel, location }, (typeof messageFactory === 'function' ? messageFactory() : { messageType: 'text', message: messageFactory }));
+        const message = Object.assign({ timestamp: date, pubNubId: this.pubNubId, level: logLevel, minimumLevel: this.minLogLevel, location }, (typeof messageFactory === 'function' ? messageFactory() : { messageType: 'text', message: messageFactory }));
         this.loggers.forEach((logger) => logger[level](message));
     }
 }

dist/web/pubnub.worker.js

@@ -38,6 +38,13 @@ class SubscriptionManager {
         this.subscribeCall = subscribeCall;
         this.heartbeatCall = heartbeatCall;
         this.leaveCall = leaveCall;
+        /**
+         * Whether user code in event handlers requested disconnection or not.
+         *
+         * Won't continue subscription loop if user requested disconnection/unsubscribe from all in response to received
+         * event.
+         */
+        this.disconnectedWhileHandledEvent = false;
         configuration.logger().trace('SubscriptionManager', 'Create manager.');
         this.reconnectionManager = new reconnection_manager_1.ReconnectionManager(time);
         this.dedupingManager = new deduping_manager_1.DedupingManager(this.configuration);
@@ -83,6 +90,9 @@ class SubscriptionManager {
     // endregion
     // region Subscription
     disconnect() {
+        // Potentially called during received events handling.
+        // Mark to prevent subscription loop continuation in subscribe response handler.
+        this.disconnectedWhileHandledEvent = true;
         this.stopSubscribeLoop();
         this.stopHeartbeatTimer();
         this.reconnectionManager.stopPolling();
@@ -200,6 +210,7 @@ class SubscriptionManager {
         this.reconnect(true);
     }
     unsubscribeAll(isOffline = false) {
+        this.disconnectedWhileHandledEvent = true;
         this.unsubscribe({
             channels: this.subscribedChannels,
             channelGroups: this.subscribedChannelGroups,
@@ -214,6 +225,7 @@ class SubscriptionManager {
      * @internal
      */
     startSubscribeLoop(restartOnUnsubscribe = false) {
+        this.disconnectedWhileHandledEvent = false;
         this.stopSubscribeLoop();
         const channelGroups = [...Object.keys(this.channelGroups)];
         const channels = [...Object.keys(this.channels)];
@@ -222,8 +234,8 @@ class SubscriptionManager {
         // There is no need to start subscription loop for an empty list of data sources.
         if (channels.length === 0 && channelGroups.length === 0)
             return;
-        this.subscribeCall(Object.assign(Object.assign({ channels,
-            channelGroups, state: this.presenceState, heartbeat: this.configuration.getPresenceTimeout(), timetoken: this.currentTimetoken }, (this.region !== null ? { region: this.region } : {})), (this.configuration.filterExpression ? { filterExpression: this.configuration.filterExpression } : {})), (status, result) => {
+        this.subscribeCall(Object.assign(Object.assign(Object.assign({ channels,
+            channelGroups, state: this.presenceState, heartbeat: this.configuration.getPresenceTimeout(), timetoken: this.currentTimetoken }, (this.region !== null ? { region: this.region } : {})), (this.configuration.filterExpression ? { filterExpression: this.configuration.filterExpression } : {})), { onDemand: !this.subscriptionStatusAnnounced || restartOnUnsubscribe }), (status, result) => {
             this.processSubscribeResponse(status, result);
         });
         if (!restartOnUnsubscribe && this.configuration.useSmartHeartbeat)
@@ -354,7 +366,10 @@ class SubscriptionManager {
             this.emitStatus(errorStatus);
         }
         this.region = result.cursor.region;
-        this.startSubscribeLoop();
+        if (!this.disconnectedWhileHandledEvent)
+            this.startSubscribeLoop();
+        else
+            this.disconnectedWhileHandledEvent = false;
     }
     // endregion
     // region Presence

dist/web/pubnub.worker.min.js

@@ -100,5 +100,12 @@ var StatusCategory;
      * PubNub client unexpectedly disconnected from the real-time updates streams.
      */
     StatusCategory["PNDisconnectedUnexpectedlyCategory"] = "PNDisconnectedUnexpectedlyCategory";
+    // --------------------------------------------------------
+    // ------------------ Shared worker events ----------------
+    // --------------------------------------------------------
+    /**
+     * SDK will announce when newer shared worker will be 'noticed'.
+     */
+    StatusCategory["PNSharedWorkerUpdatedCategory"] = "PNSharedWorkerUpdatedCategory";
 })(StatusCategory || (StatusCategory = {}));
 exports.default = StatusCategory;

lib/core/components/configuration.js

@@ -344,8 +344,10 @@ class SubscribeRequest extends BaseSubscribeRequest {
         return `/v2/subscribe/${subscribeKey}/${(0, utils_1.encodeNames)((_a = channels === null || channels === void 0 ? void 0 : channels.sort()) !== null && _a !== void 0 ? _a : [], ',')}/0`;
     }
     get queryParameters() {
-        const { channelGroups, filterExpression, heartbeat, state, timetoken, region } = this.parameters;
+        const { channelGroups, filterExpression, heartbeat, state, timetoken, region, onDemand } = this.parameters;
         const query = {};
+        if (onDemand)
+            query['on-demand'] = 1;
         if (channelGroups && channelGroups.length > 0)
             query['channel-group'] = channelGroups.sort().join(',');
         if (filterExpression && filterExpression.length > 0)

lib/core/components/logger-manager.js

@@ -28,8 +28,11 @@ class HandshakeSubscribeRequest extends subscribe_1.BaseSubscribeRequest {
         return `/v2/subscribe/${subscribeKey}/${(0, utils_1.encodeNames)(channels.sort(), ',')}/0`;
     }
     get queryParameters() {
-        const { channelGroups, filterExpression, state } = this.parameters;
+        const { channelGroups, filterExpression, state, onDemand } = this
+            .parameters;
         const query = { ee: '' };
+        if (onDemand)
+            query['on-demand'] = 1;
         if (channelGroups && channelGroups.length > 0)
             query['channel-group'] = channelGroups.sort().join(',');
         if (filterExpression && filterExpression.length > 0)