@aws-amplify/pubsub 6.0.1-api-v6-models.9351bcf.0 → 6.0.1-api-v6-models.891fe0d.0

package/lib-esm/utils/ConnectionStateMonitor.js

@@ -1,10 +1,9 @@
 // Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
 // SPDX-License-Identifier: Apache-2.0
-import { __assign } from "tslib";
 import { Observable, map, filter } from 'rxjs';
 import { ConnectionState } from '../types/PubSub';
 import { ReachabilityMonitor } from './ReachabilityMonitor';
-export var CONNECTION_CHANGE = {
+export const CONNECTION_CHANGE = {
     KEEP_ALIVE_MISSED: { keepAliveState: 'unhealthy' },
     KEEP_ALIVE: { keepAliveState: 'healthy' },
     CONNECTION_ESTABLISHED: { connectionState: 'connected' },
@@ -21,9 +20,8 @@ export var CONNECTION_CHANGE = {
     ONLINE: { networkState: 'connected' },
     OFFLINE: { networkState: 'disconnected' },
 };
-var ConnectionStateMonitor = /** @class */ (function () {
-    function ConnectionStateMonitor() {
-        var _this = this;
+export class ConnectionStateMonitor {
+    constructor() {
         this._networkMonitoringSubscription = undefined;
         this._linkedConnectionState = {
             networkState: 'connected',
@@ -32,73 +30,61 @@ var ConnectionStateMonitor = /** @class */ (function () {
             keepAliveState: 'healthy',
         };
         // Attempt to update the state with the current actual network state
-        this._initialNetworkStateSubscription = ReachabilityMonitor().subscribe(function (_a) {
-            var _b;
-            var online = _a.online;
-            _this.record(online ? CONNECTION_CHANGE.ONLINE : CONNECTION_CHANGE.OFFLINE);
-            (_b = _this._initialNetworkStateSubscription) === null || _b === void 0 ? void 0 : _b.unsubscribe();
+        this._initialNetworkStateSubscription = ReachabilityMonitor().subscribe(({ online }) => {
+            this.record(online ? CONNECTION_CHANGE.ONLINE : CONNECTION_CHANGE.OFFLINE);
+            this._initialNetworkStateSubscription?.unsubscribe();
         });
         this._linkedConnectionStateObservable =
-            new Observable(function (connectionStateObserver) {
-                connectionStateObserver.next(_this._linkedConnectionState);
-                _this._linkedConnectionStateObserver = connectionStateObserver;
+            new Observable(connectionStateObserver => {
+                connectionStateObserver.next(this._linkedConnectionState);
+                this._linkedConnectionStateObserver = connectionStateObserver;
             });
     }
     /**
      * Turn network state monitoring on if it isn't on already
      */
-    ConnectionStateMonitor.prototype.enableNetworkMonitoring = function () {
-        var _this = this;
-        var _a;
+    enableNetworkMonitoring() {
         // If no initial network state was discovered, stop trying
-        (_a = this._initialNetworkStateSubscription) === null || _a === void 0 ? void 0 : _a.unsubscribe();
+        this._initialNetworkStateSubscription?.unsubscribe();
         // Maintain the network state based on the reachability monitor
         if (this._networkMonitoringSubscription === undefined) {
-            this._networkMonitoringSubscription = ReachabilityMonitor().subscribe(function (_a) {
-                var online = _a.online;
-                _this.record(online ? CONNECTION_CHANGE.ONLINE : CONNECTION_CHANGE.OFFLINE);
+            this._networkMonitoringSubscription = ReachabilityMonitor().subscribe(({ online }) => {
+                this.record(online ? CONNECTION_CHANGE.ONLINE : CONNECTION_CHANGE.OFFLINE);
             });
         }
-    };
+    }
     /**
      * Turn network state monitoring off if it isn't off already
      */
-    ConnectionStateMonitor.prototype.disableNetworkMonitoring = function () {
-        var _a;
-        (_a = this._networkMonitoringSubscription) === null || _a === void 0 ? void 0 : _a.unsubscribe();
+    disableNetworkMonitoring() {
+        this._networkMonitoringSubscription?.unsubscribe();
         this._networkMonitoringSubscription = undefined;
-    };
-    Object.defineProperty(ConnectionStateMonitor.prototype, "connectionStateObservable", {
-        /**
-         * Get the observable that allows us to monitor the connection state
-         *
-         * @returns {Observable<ConnectionState>} - The observable that emits ConnectionState updates
-         */
-        get: function () {
-            var _this = this;
-            var previous;
-            // The linked state aggregates state changes to any of the network, connection,
-            // intendedConnection and keepAliveHealth. Some states will change these independent
-            // states without changing the overall connection state.
-            // After translating from linked states to ConnectionState, then remove any duplicates
-            return this._linkedConnectionStateObservable
-                .pipe(map(function (value) {
-                return _this.connectionStatesTranslator(value);
-            }))
-                .pipe(filter(function (current) {
-                var toInclude = current !== previous;
-                previous = current;
-                return toInclude;
-            }));
-        },
-        enumerable: false,
-        configurable: true
-    });
+    }
+    /**
+     * Get the observable that allows us to monitor the connection state
+     *
+     * @returns {Observable<ConnectionState>} - The observable that emits ConnectionState updates
+     */
+    get connectionStateObservable() {
+        let previous;
+        // The linked state aggregates state changes to any of the network, connection,
+        // intendedConnection and keepAliveHealth. Some states will change these independent
+        // states without changing the overall connection state.
+        // After translating from linked states to ConnectionState, then remove any duplicates
+        return this._linkedConnectionStateObservable
+            .pipe(map(value => {
+            return this.connectionStatesTranslator(value);
+        }))
+            .pipe(filter(current => {
+            const toInclude = current !== previous;
+            previous = current;
+            return toInclude;
+        }));
+    }
     /*
      * Updates local connection state and emits the full state to the observer.
      */
-    ConnectionStateMonitor.prototype.record = function (statusUpdates) {
-        var _a;
+    record(statusUpdates) {
         // Maintain the network monitor
         if (statusUpdates.intendedConnectionState === 'connected') {
             this.enableNetworkMonitoring();
@@ -107,15 +93,17 @@ var ConnectionStateMonitor = /** @class */ (function () {
             this.disableNetworkMonitoring();
         }
         // Maintain the socket state
-        var newSocketStatus = __assign(__assign({}, this._linkedConnectionState), statusUpdates);
-        this._linkedConnectionState = __assign({}, newSocketStatus);
-        (_a = this._linkedConnectionStateObserver) === null || _a === void 0 ? void 0 : _a.next(this._linkedConnectionState);
-    };
+        const newSocketStatus = {
+            ...this._linkedConnectionState,
+            ...statusUpdates,
+        };
+        this._linkedConnectionState = { ...newSocketStatus };
+        this._linkedConnectionStateObserver?.next(this._linkedConnectionState);
+    }
     /*
      * Translate the ConnectionState structure into a specific ConnectionState string literal union
      */
-    ConnectionStateMonitor.prototype.connectionStatesTranslator = function (_a) {
-        var connectionState = _a.connectionState, networkState = _a.networkState, intendedConnectionState = _a.intendedConnectionState, keepAliveState = _a.keepAliveState;
+    connectionStatesTranslator({ connectionState, networkState, intendedConnectionState, keepAliveState, }) {
         if (connectionState === 'connected' && networkState === 'disconnected')
             return ConnectionState.ConnectedPendingNetwork;
         if (connectionState === 'connected' &&
@@ -136,7 +124,5 @@ var ConnectionStateMonitor = /** @class */ (function () {
         if (connectionState === 'disconnected')
             return ConnectionState.Disconnected;
         return ConnectionState.Connected;
-    };
-    return ConnectionStateMonitor;
-}());
-export { ConnectionStateMonitor };
+    }
+}

package/lib-esm/utils/ReachabilityMonitor/index.js

@@ -1,4 +1,4 @@
 // Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
 // SPDX-License-Identifier: Apache-2.0
 import { Reachability } from '@aws-amplify/core/internals/utils';
-export var ReachabilityMonitor = function () { return new Reachability().networkMonitor(); };
+export const ReachabilityMonitor = () => new Reachability().networkMonitor();

package/lib-esm/utils/ReachabilityMonitor/index.native.js

@@ -2,6 +2,4 @@
 // SPDX-License-Identifier: Apache-2.0
 import { Reachability } from '@aws-amplify/core/internals/utils';
 import { default as NetInfo } from '@react-native-community/netinfo';
-export var ReachabilityMonitor = function () {
-    return new Reachability().networkMonitor(NetInfo);
-};
+export const ReachabilityMonitor = () => new Reachability().networkMonitor(NetInfo);

package/lib-esm/utils/ReconnectionMonitor.js

@@ -10,31 +10,30 @@ export var ReconnectEvent;
  *   Attempting to reconnect only once creates unrecoverable states when the network state isn't
  *   supported by the browser, so this keeps retrying every minute until halted.
  */
-var ReconnectionMonitor = /** @class */ (function () {
-    function ReconnectionMonitor() {
+export class ReconnectionMonitor {
+    constructor() {
         this.reconnectObservers = [];
     }
     /**
      * Add reconnect observer to the list of observers to alert on reconnect
      */
-    ReconnectionMonitor.prototype.addObserver = function (reconnectObserver) {
+    addObserver(reconnectObserver) {
         this.reconnectObservers.push(reconnectObserver);
-    };
+    }
     /**
      * Given a reconnect event, start the appropriate behavior
      */
-    ReconnectionMonitor.prototype.record = function (event) {
-        var _this = this;
+    record(event) {
         if (event === ReconnectEvent.START_RECONNECT) {
             // If the reconnection hasn't been started
             if (this.reconnectSetTimeoutId === undefined &&
                 this.reconnectIntervalId === undefined) {
-                this.reconnectSetTimeoutId = setTimeout(function () {
+                this.reconnectSetTimeoutId = setTimeout(() => {
                     // Reconnect now
-                    _this._triggerReconnect();
+                    this._triggerReconnect();
                     // Retry reconnect every periodically until it works
-                    _this.reconnectIntervalId = setInterval(function () {
-                        _this._triggerReconnect();
+                    this.reconnectIntervalId = setInterval(() => {
+                        this._triggerReconnect();
                     }, RECONNECT_INTERVAL);
                 }, RECONNECT_DELAY);
             }
@@ -49,22 +48,18 @@ var ReconnectionMonitor = /** @class */ (function () {
                 this.reconnectSetTimeoutId = undefined;
             }
         }
-    };
+    }
     /**
      * Complete all reconnect observers
      */
-    ReconnectionMonitor.prototype.close = function () {
-        this.reconnectObservers.forEach(function (reconnectObserver) {
-            var _a;
-            (_a = reconnectObserver.complete) === null || _a === void 0 ? void 0 : _a.call(reconnectObserver);
+    close() {
+        this.reconnectObservers.forEach(reconnectObserver => {
+            reconnectObserver.complete?.();
         });
-    };
-    ReconnectionMonitor.prototype._triggerReconnect = function () {
-        this.reconnectObservers.forEach(function (reconnectObserver) {
-            var _a;
-            (_a = reconnectObserver.next) === null || _a === void 0 ? void 0 : _a.call(reconnectObserver);
+    }
+    _triggerReconnect() {
+        this.reconnectObservers.forEach(reconnectObserver => {
+            reconnectObserver.next?.();
         });
-    };
-    return ReconnectionMonitor;
-}());
-export { ReconnectionMonitor };
+    }
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@aws-amplify/pubsub",
-  "version": "6.0.1-api-v6-models.9351bcf.0+9351bcf",
+  "version": "6.0.1-api-v6-models.891fe0d.0+891fe0d",
   "description": "Pubsub category of aws-amplify",
   "main": "./lib/index.js",
   "module": "./lib-esm/index.js",
@@ -28,10 +28,7 @@
     "ts-coverage": "typescript-coverage-report -p ./tsconfig.json -t 93.0 -i src/vendor/paho-mqtt.js"
   },
   "typesVersions": {
-    ">=4.0": {
-      "*": [
-        "./lib-esm/index.d.ts"
-      ],
+    ">=4.2": {
       "iot": [
         "./lib-esm/clients/iot.d.ts"
       ],
@@ -75,7 +72,7 @@
     "mqtt"
   ],
   "dependencies": {
-    "@aws-amplify/auth": "6.0.1-api-v6-models.9351bcf.0+9351bcf",
+    "@aws-amplify/auth": "6.0.1-api-v6-models.891fe0d.0+891fe0d",
     "buffer": "4.9.2",
     "graphql": "15.8.0",
     "rxjs": "^7.8.1",
@@ -83,11 +80,10 @@
     "url": "0.11.0"
   },
   "peerDependencies": {
-    "@aws-amplify/core": "6.0.1-api-v6-models.9351bcf.0+9351bcf"
+    "@aws-amplify/core": "6.0.1-api-v6-models.891fe0d.0+891fe0d"
   },
   "devDependencies": {
-    "@aws-amplify/core": "6.0.1-api-v6-models.9351bcf.0+9351bcf",
-    "cpx": "^1.5.0",
+    "@aws-amplify/core": "6.0.1-api-v6-models.891fe0d.0+891fe0d",
     "typescript": "5.0.2"
   },
   "size-limit": [
@@ -148,5 +144,5 @@
       "lib-esm"
     ]
   },
-  "gitHead": "9351bcfbeb9ec15f67fc6404ca192689a398d260"
+  "gitHead": "891fe0dc64e168de42b3b8d42def3eb9aed89efa"
 }

package/src/Providers/MqttOverWS.ts

@@ -11,6 +11,8 @@ import {
 	PubSubContentObserver,
 	PubSubContent,
 	PubSubOptions,
+	PublishInput,
+	SubscribeInput,
 } from '../types/PubSub';
 import { Hub, HubPayload, ConsoleLogger as Logger } from '@aws-amplify/core';
 import { amplifyUuid } from '@aws-amplify/core/internals/utils';
@@ -248,15 +250,15 @@ export class MqttOverWS extends AbstractPubSub<MqttOptions> {
 		this.connectionStateMonitor.record(CONNECTION_CHANGE.CLOSED);
 	}
 
-	async publish(topics: string[] | string, msg: PubSubContent) {
+	async publish({ topics, message }: PublishInput) {
 		const targetTopics = ([] as string[]).concat(topics);
-		const message = JSON.stringify(msg);
+		const msg = JSON.stringify(message);
 
 		const client = await this.clientsQueue.get(this.clientId);
 
 		if (client) {
 			logger.debug('Publishing to topic(s)', targetTopics.join(','), message);
-			targetTopics.forEach(topic => client.send(topic, message));
+			targetTopics.forEach(topic => client.send(topic, msg));
 		} else {
 			logger.debug(
 				'Publishing to topic(s) failed',
@@ -295,10 +297,10 @@ export class MqttOverWS extends AbstractPubSub<MqttOptions> {
 		}
 	}
 
-	subscribe(
-		topics: string[] | string,
-		options: MqttOptions = {}
-	): Observable<PubSubContent> {
+	subscribe({
+		topics,
+		options = {},
+	}: SubscribeInput & { options?: MqttOptions }): Observable<PubSubContent> {
 		const targetTopics = ([] as string[]).concat(topics);
 		logger.debug('Subscribing to topic(s)', targetTopics.join(','));
 		let reconnectSubscription: Subscription;

package/src/Providers/PubSub.ts

@@ -1,8 +1,13 @@
 // Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
 // SPDX-License-Identifier: Apache-2.0
 import { Observable } from 'rxjs';
-import { PubSubBase, PubSubOptions, PubSubContent } from '../types/PubSub';
-import { CustomUserAgentDetails } from '@aws-amplify/core/internals/utils';
+import {
+	PubSubBase,
+	PubSubOptions,
+	PubSubContent,
+	PublishInput,
+	SubscribeInput,
+} from '../types/PubSub';
 import { ConsoleLogger as Logger } from '@aws-amplify/core';
 const logger = new Logger('AbstractPubSubProvider');
 
@@ -29,15 +34,7 @@ export abstract class AbstractPubSub<T extends PubSubOptions>
 
 	public abstract newClient(clientOptions: T): Promise<any>;
 
-	public abstract publish(
-		topics: string[] | string,
-		msg: PubSubContent,
-		options?: T
-	): void;
-
-	public abstract subscribe(
-		topics: string[] | string,
-		options?: T,
-		customUserAgentDetails?: CustomUserAgentDetails
-	): Observable<PubSubContent>;
+	public abstract publish(input: PublishInput): void;
+
+	public abstract subscribe(input: SubscribeInput): Observable<PubSubContent>;
 }

package/src/types/PubSub.ts

@@ -64,14 +64,18 @@ export interface PubSubBase {
 	// configure your provider
 	configure(config: Record<string, unknown>): Record<string, unknown>;
 
-	publish(
-		topics: string[] | string,
-		msg: PubSubContent,
-		options?: PubSubOptions
-	): void;
+	publish(input: PublishInput): void;
 
-	subscribe(
-		topics: string[] | string,
-		options?: PubSubOptions
-	): Observable<PubSubContent>;
+	subscribe(input: SubscribeInput): Observable<PubSubContent>;
 }
+
+export type PublishInput = {
+	topics: string[] | string;
+	message: PubSubContent;
+	options?: PubSubOptions;
+};
+
+export type SubscribeInput = {
+	topics: string[] | string;
+	options?: PubSubOptions;
+};