File Explorer

1"use strict";2/*3 * Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.4 * SPDX-License-Identifier: Apache-2.0.5 */6var __extends = (this && this.__extends) || (function () {7    var extendStatics = function (d, b) {8        extendStatics = Object.setPrototypeOf ||9            ({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) ||10            function (d, b) { for (var p in b) if (Object.prototype.hasOwnProperty.call(b, p)) d[p] = b[p]; };11        return extendStatics(d, b);12    };13    return function (d, b) {14        if (typeof b !== "function" && b !== null)15            throw new TypeError("Class extends value " + String(b) + " is not a constructor or null");16        extendStatics(d, b);17        function __() { this.constructor = d; }18        d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());19    };20})();21var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {22    if (k2 === undefined) k2 = k;23    var desc = Object.getOwnPropertyDescriptor(m, k);24    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {25      desc = { enumerable: true, get: function() { return m[k]; } };26    }27    Object.defineProperty(o, k2, desc);28}) : (function(o, m, k, k2) {29    if (k2 === undefined) k2 = k;30    o[k2] = m[k];31}));32var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {33    Object.defineProperty(o, "default", { enumerable: true, value: v });34}) : function(o, v) {35    o["default"] = v;36});37var __importStar = (this && this.__importStar) || function (mod) {38    if (mod && mod.__esModule) return mod;39    var result = {};40    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);41    __setModuleDefault(result, mod);42    return result;43};44var __exportStar = (this && this.__exportStar) || function(m, exports) {45    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);46};47var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {48    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }49    return new (P || (P = Promise))(function (resolve, reject) {50        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }51        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }52        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }53        step((generator = generator.apply(thisArg, _arguments || [])).next());54    });55};56var __generator = (this && this.__generator) || function (thisArg, body) {57    var _ = { label: 0, sent: function() { if (t[0] & 1) throw t[1]; return t[1]; }, trys: [], ops: [] }, f, y, t, g;58    return g = { next: verb(0), "throw": verb(1), "return": verb(2) }, typeof Symbol === "function" && (g[Symbol.iterator] = function() { return this; }), g;59    function verb(n) { return function (v) { return step([n, v]); }; }60    function step(op) {61        if (f) throw new TypeError("Generator is already executing.");62        while (g && (g = 0, op[0] && (_ = 0)), _) try {63            if (f = 1, y && (t = op[0] & 2 ? y["return"] : op[0] ? y["throw"] || ((t = y["return"]) && t.call(y), 0) : y.next) && !(t = t.call(y, op[1])).done) return t;64            if (y = 0, t) op = [op[0] & 2, t.value];65            switch (op[0]) {66                case 0: case 1: t = op; break;67                case 4: _.label++; return { value: op[1], done: false };68                case 5: _.label++; y = op[1]; op = [0]; continue;69                case 7: op = _.ops.pop(); _.trys.pop(); continue;70                default:71                    if (!(t = _.trys, t = t.length > 0 && t[t.length - 1]) && (op[0] === 6 || op[0] === 2)) { _ = 0; continue; }72                    if (op[0] === 3 && (!t || (op[1] > t[0] && op[1] < t[3]))) { _.label = op[1]; break; }73                    if (op[0] === 6 && _.label < t[1]) { _.label = t[1]; t = op; break; }74                    if (t && _.label < t[2]) { _.label = t[2]; _.ops.push(op); break; }75                    if (t[2]) _.ops.pop();76                    _.trys.pop(); continue;77            }78            op = body.call(thisArg, _);79        } catch (e) { op = [6, e]; y = 0; } finally { f = t = 0; }80        if (op[0] & 5) throw op[1]; return { value: op[0] ? op[1] : void 0, done: true };81    }82};83var __read = (this && this.__read) || function (o, n) {84    var m = typeof Symbol === "function" && o[Symbol.iterator];85    if (!m) return o;86    var i = m.call(o), r, ar = [], e;87    try {88        while ((n === void 0 || n-- > 0) && !(r = i.next()).done) ar.push(r.value);89    }90    catch (error) { e = { error: error }; }91    finally {92        try {93            if (r && !r.done && (m = i["return"])) m.call(i);94        }95        finally { if (e) throw e.error; }96    }97    return ar;98};99Object.defineProperty(exports, "__esModule", { value: true });100exports.Mqtt5Client = exports.Mqtt5WebsocketUrlFactoryType = void 0;101/**102 * Browser specific MQTT5 client implementation103 *104 * [MQTT5 Client User Guide](https://www.github.com/awslabs/aws-crt-nodejs/blob/main/MQTT5-UserGuide.md)105 *106 * @packageDocumentation107 * @module mqtt5108 * @mergeTarget109 *110 */111var event_1 = require("../common/event");112var mqtt = __importStar(require("mqtt")); /* The mqtt-js external dependency */113var mqtt5 = __importStar(require("../common/mqtt5"));114var mqtt5_1 = require("../common/mqtt5");115var mqtt5_packet = __importStar(require("../common/mqtt5_packet"));116var error_1 = require("./error");117var WebsocketUtils = __importStar(require("./ws"));118var mqtt_utils = __importStar(require("./mqtt5_utils"));119var mqtt_shared = __importStar(require("../common/mqtt_shared"));120__exportStar(require("../common/mqtt5"), exports);121__exportStar(require("../common/mqtt5_packet"), exports);122/**123 * Type of url to construct when establishing an MQTT5 connection over websockets124 */125var Mqtt5WebsocketUrlFactoryType;126(function (Mqtt5WebsocketUrlFactoryType) {127    /**128     * Websocket connection over plain-text with no additional handshake transformation129     */130    Mqtt5WebsocketUrlFactoryType[Mqtt5WebsocketUrlFactoryType["Ws"] = 1] = "Ws";131    /**132     * Websocket connection over TLS with no additional handshake transformation133     */134    Mqtt5WebsocketUrlFactoryType[Mqtt5WebsocketUrlFactoryType["Wss"] = 2] = "Wss";135    /**136     * Websocket connection over TLS with a handshake signed by the Aws Sigv4 signing process137     */138    Mqtt5WebsocketUrlFactoryType[Mqtt5WebsocketUrlFactoryType["Sigv4"] = 3] = "Sigv4";139    /**140     * Websocket connection whose url is formed by a user-supplied callback function141     */142    Mqtt5WebsocketUrlFactoryType[Mqtt5WebsocketUrlFactoryType["Custom"] = 4] = "Custom";143})(Mqtt5WebsocketUrlFactoryType = exports.Mqtt5WebsocketUrlFactoryType || (exports.Mqtt5WebsocketUrlFactoryType = {}));144;145;146;147/**148 * @internal149 *150 * Mqtt-js only supports reconnect on a fixed delay.151 *152 * This helper class allows for variable time-delay rescheduling of reconnect attempts by implementing the153 * reconnect delay options supported by the native client.  Variable-delay reconnect actually happens by configuring154 * the mqtt-js client to have a much longer reconnect delay than our configured maximum and then letting this class155 * "interrupt" that long reconnect delay with the real, shorter wait-then-connect each time.156 */157var ReconnectionScheduler = /** @class */ (function () {158    function ReconnectionScheduler(browserClient, clientConfig) {159        this.browserClient = browserClient;160        this.clientConfig = clientConfig;161        this.connectionFailureCount = 0;162        this.lastReconnectDelay = 0;163        this.resetConnectionFailureCountTask = undefined;164        this.reconnectionTask = undefined;165        this.lastReconnectDelay = undefined;166    }167    /**168     * Invoked by the client when a successful connection is established.  Schedules the task that will reset the169     * delay if a configurable amount of time elapses with a good connection.170     */171    ReconnectionScheduler.prototype.onSuccessfulConnection = function () {172        var _this = this;173        var _a;174        this.clearTasks();175        this.resetConnectionFailureCountTask = setTimeout(function () {176            _this.connectionFailureCount = 0;177            _this.lastReconnectDelay = undefined;178        }, (_a = this.clientConfig.minConnectedTimeToResetReconnectDelayMs) !== null && _a !== void 0 ? _a : mqtt_utils.DEFAULT_MIN_CONNECTED_TIME_TO_RESET_RECONNECT_DELAY_MS);179    };180    /**181     * Invoked by the client after a disconnection or connection failure occurs.  Schedules the next reconnect182     * task.183     */184    ReconnectionScheduler.prototype.onConnectionFailureOrDisconnection = function () {185        var _this = this;186        this.clearTasks();187        var nextDelay = this.calculateNextReconnectDelay();188        this.lastReconnectDelay = nextDelay;189        this.connectionFailureCount += 1;190        this.reconnectionTask = setTimeout(function () { return __awaiter(_this, void 0, void 0, function () {191            var wsOptions, sigv4Options;192            return __generator(this, function (_a) {193                switch (_a.label) {194                    case 0:195                        wsOptions = this.clientConfig.websocketOptions;196                        if (!(wsOptions && wsOptions.urlFactoryOptions.urlFactory == Mqtt5WebsocketUrlFactoryType.Sigv4)) return [3 /*break*/, 2];197                        sigv4Options = wsOptions.urlFactoryOptions;198                        if (!sigv4Options.credentialsProvider) return [3 /*break*/, 2];199                        return [4 /*yield*/, sigv4Options.credentialsProvider.refreshCredentials()];200                    case 1:201                        _a.sent();202                        _a.label = 2;203                    case 2:204                        this.browserClient.reconnect();205                        return [2 /*return*/];206                }207            });208        }); }, nextDelay);209    };210    /**211     * Resets any reconnect/clear-delay tasks.212     */213    ReconnectionScheduler.prototype.clearTasks = function () {214        if (this.reconnectionTask) {215            clearTimeout(this.reconnectionTask);216        }217        if (this.resetConnectionFailureCountTask) {218            clearTimeout(this.resetConnectionFailureCountTask);219        }220    };221    ReconnectionScheduler.prototype.randomInRange = function (min, max) {222        return min + (max - min) * Math.random();223    };224    /**225     * Computes the next reconnect delay based on the Jitter/Retry configuration.226     * Implements jitter calculations in https://aws.amazon.com/blogs/architecture/exponential-backoff-and-jitter/227     * @private228     */229    ReconnectionScheduler.prototype.calculateNextReconnectDelay = function () {230        var _a;231        var jitterType = (_a = this.clientConfig.retryJitterMode) !== null && _a !== void 0 ? _a : mqtt5.RetryJitterType.Default;232        var _b = __read(mqtt_utils.getOrderedReconnectDelayBounds(this.clientConfig.minReconnectDelayMs, this.clientConfig.maxReconnectDelayMs), 2), minDelay = _b[0], maxDelay = _b[1];233        var clampedFailureCount = Math.min(52, this.connectionFailureCount);234        var delay = 0;235        if (jitterType == mqtt5.RetryJitterType.None) {236            delay = minDelay * Math.pow(2, clampedFailureCount);237        }238        else if (jitterType == mqtt5.RetryJitterType.Decorrelated && this.lastReconnectDelay) {239            delay = this.randomInRange(minDelay, 3 * this.lastReconnectDelay);240        }241        else {242            delay = this.randomInRange(minDelay, Math.min(maxDelay, minDelay * Math.pow(2, clampedFailureCount)));243        }244        delay = Math.min(maxDelay, delay);245        this.lastReconnectDelay = delay;246        return delay;247    };248    return ReconnectionScheduler;249}());250/**251 * Elements of a simple state machine that allows us to adapt the mqtt-js control model to our mqtt5 client252 * control model (start/stop).253 *254 * @internal255 */256var Mqtt5ClientState;257(function (Mqtt5ClientState) {258    Mqtt5ClientState[Mqtt5ClientState["Stopped"] = 0] = "Stopped";259    Mqtt5ClientState[Mqtt5ClientState["Running"] = 1] = "Running";260    Mqtt5ClientState[Mqtt5ClientState["Stopping"] = 2] = "Stopping";261    Mqtt5ClientState[Mqtt5ClientState["Restarting"] = 3] = "Restarting";262})(Mqtt5ClientState || (Mqtt5ClientState = {}));263/**264 * Elements of a simple state machine that allows us to adapt the mqtt-js event set to our mqtt5 client's265 * lifecycle event set.266 *267 * @internal268 */269var Mqtt5ClientLifecycleEventState;270(function (Mqtt5ClientLifecycleEventState) {271    Mqtt5ClientLifecycleEventState[Mqtt5ClientLifecycleEventState["None"] = 0] = "None";272    Mqtt5ClientLifecycleEventState[Mqtt5ClientLifecycleEventState["Connecting"] = 1] = "Connecting";273    Mqtt5ClientLifecycleEventState[Mqtt5ClientLifecycleEventState["Connected"] = 2] = "Connected";274    Mqtt5ClientLifecycleEventState[Mqtt5ClientLifecycleEventState["Disconnected"] = 3] = "Disconnected";275})(Mqtt5ClientLifecycleEventState || (Mqtt5ClientLifecycleEventState = {}));276/**277 * Browser specific MQTT5 client implementation278 *279 * [MQTT5 Client User Guide](https://www.github.com/awslabs/aws-crt-nodejs/blob/main/MQTT5-UserGuide.md)280 */281var Mqtt5Client = /** @class */ (function (_super) {282    __extends(Mqtt5Client, _super);283    /**284     * Client constructor285     *286     * @param config The configuration for this client287     */288    function Mqtt5Client(config) {289        var _this = _super.call(this) || this;290        _this.config = config;291        _this.on_message = function (topic, payload, packet) {292            var crtPublish = mqtt_utils.transform_mqtt_js_publish_to_crt_publish(packet);293            var messageReceivedEvent = {294                message: crtPublish295            };296            setTimeout(function () {297                _this.emit(Mqtt5Client.MESSAGE_RECEIVED, messageReceivedEvent);298            }, 0);299        };300        _this.mqttJsConfig = mqtt_utils.create_mqtt_js_client_config_from_crt_client_config(_this.config);301        _this.state = Mqtt5ClientState.Stopped;302        _this.lifecycleEventState = Mqtt5ClientLifecycleEventState.None;303        _this.topicAliasBindings = new Map();304        return _this;305    }306    /**307     * Triggers cleanup of native resources associated with the MQTT5 client.  On the browser, the implementation is308     * an empty function.309     */310    Mqtt5Client.prototype.close = function () { };311    /**312     * Notifies the MQTT5 client that you want it to maintain connectivity to the configured endpoint.313     * The client will attempt to stay connected using the properties of the reconnect-related parameters314     * in the mqtt5 client configuration.315     *316     * This is an asynchronous operation.317     */318    Mqtt5Client.prototype.start = function () {319        var _this = this;320        if (this.state == Mqtt5ClientState.Stopped) {321            this.lifecycleEventState = Mqtt5ClientLifecycleEventState.Connecting;322            this.lastDisconnect = undefined;323            /* pause event emission until everything is fully-initialized */324            this.cork();325            this.emit('attemptingConnect');326            var create_websocket_stream = function (client) { return WebsocketUtils.create_mqtt5_websocket_stream(_this.config); };327            this.browserClient = new mqtt.MqttClient(create_websocket_stream, this.mqttJsConfig);328            // hook up events329            this.browserClient.on('end', function () { _this._on_stopped_internal(); });330            this.browserClient.on('reconnect', function () { _this.on_attempting_connect(); });331            this.browserClient.on('connect', function (connack) { _this.on_connection_success(connack); });332            this.browserClient.on('message', function (topic, payload, packet) { _this.on_message(topic, payload, packet); });333            this.browserClient.on('error', function (error) { _this.on_browser_client_error(error); });334            this.browserClient.on('close', function () { _this.on_browser_close(); });335            this.browserClient.on('disconnect', function (packet) { _this.on_browser_disconnect_packet(packet); });336            this.reconnectionScheduler = new ReconnectionScheduler(this.browserClient, this.config);337            this.state = Mqtt5ClientState.Running;338            /* unpause event emission */339            this.uncork();340        }341        else if (this.state == Mqtt5ClientState.Stopping) {342            this.state = Mqtt5ClientState.Restarting;343        }344    };345    /**346     * Notifies the MQTT5 client that you want it to end connectivity to the configured endpoint, disconnecting any347     * existing connection and halting reconnection attempts.348     *349     * This is an asynchronous operation.  Once the process completes, no further events will be emitted until the client350     * has {@link start} invoked.  Invoking {@link start start()} after a {@link stop stop()} will always result in351     * a new MQTT session.352     *353     * @param disconnectPacket (optional) properties of a DISCONNECT packet to send as part of the shutdown process354     */355    Mqtt5Client.prototype.stop = function (disconnectPacket) {356        var _a, _b;357        if (this.state == Mqtt5ClientState.Running) {358            if (disconnectPacket) {359                (_a = this.browserClient) === null || _a === void 0 ? void 0 : _a.end(true, mqtt_utils.transform_crt_disconnect_to_mqtt_js_disconnect(disconnectPacket));360            }361            else {362                (_b = this.browserClient) === null || _b === void 0 ? void 0 : _b.end(true);363            }364            this.state = Mqtt5ClientState.Stopping;365        }366        else if (this.state == Mqtt5ClientState.Restarting) {367            this.state = Mqtt5ClientState.Stopping;368        }369    };370    /**371     * Subscribe to one or more topic filters by queuing a SUBSCRIBE packet to be sent to the server.372     *373     * @param packet SUBSCRIBE packet to send to the server374     * @returns a promise that will be rejected with an error or resolved with the SUBACK response375     */376    Mqtt5Client.prototype.subscribe = function (packet) {377        return __awaiter(this, void 0, void 0, function () {378            var _this = this;379            return __generator(this, function (_a) {380                return [2 /*return*/, new Promise(function (resolve, reject) {381                        try {382                            if (!_this.browserClient) {383                                reject(new Error("Client is stopped and cannot subscribe"));384                                return;385                            }386                            if (!packet) {387                                reject(new Error("Invalid subscribe packet"));388                                return;389                            }390                            var subMap = mqtt_utils.transform_crt_subscribe_to_mqtt_js_subscription_map(packet);391                            var subOptions = mqtt_utils.transform_crt_subscribe_to_mqtt_js_subscribe_options(packet);392                            // @ts-ignore393                            _this.browserClient.subscribe(subMap, subOptions, function (error, grants) {394                                if (error) {395                                    reject(error);396                                    return;397                                }398                                var suback = mqtt_utils.transform_mqtt_js_subscription_grants_to_crt_suback(grants);399                                resolve(suback);400                            });401                        }402                        catch (err) {403                            reject(err);404                        }405                    })];406            });407        });408    };409    /**410     * Unsubscribe from one or more topic filters by queuing an UNSUBSCRIBE packet to be sent to the server.411     *412     * @param packet UNSUBSCRIBE packet to send to the server413     * @returns a promise that will be rejected with an error or resolved with the UNSUBACK response414     */415    Mqtt5Client.prototype.unsubscribe = function (packet) {416        return __awaiter(this, void 0, void 0, function () {417            var _this = this;418            return __generator(this, function (_a) {419                return [2 /*return*/, new Promise(function (resolve, reject) {420                        try {421                            if (!_this.browserClient) {422                                reject(new Error("Client is stopped and cannot unsubscribe"));423                                return;424                            }425                            if (!packet) {426                                reject(new Error("Invalid unsubscribe packet"));427                                return;428                            }429                            var topicFilters_1 = packet.topicFilters;430                            var unsubOptions = mqtt_utils.transform_crt_unsubscribe_to_mqtt_js_unsubscribe_options(packet);431                            _this.browserClient.unsubscribe(topicFilters_1, unsubOptions, function (error, packet) {432                                if (error) {433                                    reject(error);434                                    return;435                                }436                                /*437                                 * sigh, mqtt-js doesn't emit the unsuback packet, we have to make something up that won't reflect438                                 * reality.439                                 */440                                if (!packet || packet.cmd !== 'unsuback') {441                                    /* this is a complete lie */442                                    var unsuback = {443                                        type: mqtt5_packet.PacketType.Unsuback,444                                        reasonCodes: topicFilters_1.map(function (filter, index, array) {445                                            return mqtt5_packet.UnsubackReasonCode.Success;446                                        })447                                    };448                                    resolve(unsuback);449                                }450                                else {451                                    var unsuback = mqtt_utils.transform_mqtt_js_unsuback_to_crt_unsuback(packet);452                                    resolve(unsuback);453                                }454                            });455                        }456                        catch (err) {457                            reject(err);458                        }459                    })];460            });461        });462    };463    Mqtt5Client.prototype.reset_topic_aliases = function () {464        this.topicAliasBindings.clear();465    };466    Mqtt5Client.prototype.bind_topic_alias = function (alias, topic) {467        this.topicAliasBindings.set(alias, topic);468    };469    Mqtt5Client.prototype.is_topic_alias_bound = function (alias, topic) {470        if (!topic) {471            return false;472        }473        return this.topicAliasBindings.get(alias) === topic;474    };475    /**476     * Send a message to subscribing clients by queuing a PUBLISH packet to be sent to the server.477     *478     * @param packet PUBLISH packet to send to the server479     * @returns a promise that will be rejected with an error or resolved with the PUBACK response (QoS 1), or480     * undefined (QoS 0)481     */482    Mqtt5Client.prototype.publish = function (packet) {483        return __awaiter(this, void 0, void 0, function () {484            var _this = this;485            return __generator(this, function (_a) {486                return [2 /*return*/, new Promise(function (resolve, reject) {487                        var _a, _b;488                        try {489                            if (!_this.browserClient) {490                                reject(new Error("Client is stopped and cannot publish"));491                                return;492                            }493                            if (!packet) {494                                reject(new Error("Invalid publish packet"));495                                return;496                            }497                            /*498                             * Out topic aliasing contract and mqtt-js's don't quite match, so we do some fixup here.499                             *500                             * In our manual mode, the contract is that you must *always* submit both the topic and the alias.501                             *502                             * In Mqtt-js's manual mode, the alias will only be used if it's been previously bound and you don't503                             * submit an alias in the publish (this is not reasonable behavior, but it's not under out control).504                             * So when we're in manual aliasing mode, we track all the current bindings and strip out the alias505                             * when there's a match, signaling to mqtt-js that the alias binding should be used.506                             */507                            if (((_b = (_a = _this.config.topicAliasingOptions) === null || _a === void 0 ? void 0 : _a.outboundBehavior) !== null && _b !== void 0 ? _b : mqtt5_1.OutboundTopicAliasBehaviorType.Default) == mqtt5_1.OutboundTopicAliasBehaviorType.Manual) {508                                if (packet.topicAlias && _this.lifecycleEventState == Mqtt5ClientLifecycleEventState.Connected) {509                                    if (_this.is_topic_alias_bound(packet.topicAlias, packet.topicName)) {510                                        delete (packet.topicAlias);511                                    }512                                    _this.bind_topic_alias(packet.topicAlias, packet.topicName);513                                }514                            }515                            else {516                                delete (packet.topicAlias);517                            }518                            var publishOptions = mqtt_utils.transform_crt_publish_to_mqtt_js_publish_options(packet);519                            var qos_1 = packet.qos;520                            var payload = mqtt_shared.normalize_payload(packet.payload);521                            _this.browserClient.publish(packet.topicName, payload, publishOptions, function (error, completionPacket) {522                                if (error) {523                                    reject(error);524                                    return;525                                }526                                switch (qos_1) {527                                    case mqtt5_packet.QoS.AtMostOnce:528                                        resolve(undefined);529                                        break;530                                    case mqtt5_packet.QoS.AtLeastOnce:531                                        if (!completionPacket) {532                                            reject(new Error("Invalid puback packet from mqtt-js"));533                                            return;534                                        }535                                        /*536                                         * sadly, mqtt-js returns the original publish packet when the puback is a success, so we have537                                         * to create a fake puback instead.  This means we won't reflect any reason string or538                                         * user properties that might have been present in the real puback.539                                         */540                                        if (completionPacket.cmd !== "puback") {541                                            resolve({542                                                type: mqtt5_packet.PacketType.Puback,543                                                reasonCode: mqtt5_packet.PubackReasonCode.Success544                                            });545                                        }546                                        var puback = mqtt_utils.transform_mqtt_js_puback_to_crt_puback(completionPacket);547                                        resolve(puback);548                                        break;549                                    default:550                                        /* Technically, mqtt-js supports QoS 2 but we don't yet model it in the CRT types */551                                        reject(new Error("Unsupported QoS value"));552                                        break;553                                }554                            });555                        }556                        catch (err) {557                            reject(err);558                        }559                    })];560            });561        });562    };563    /**564     * Queries whether the client is currently connected565     *566     * @returns whether the client is currently connected567     */568    Mqtt5Client.prototype.isConnected = function () {569        return this.lifecycleEventState == Mqtt5ClientLifecycleEventState.Connected;570    };571    Mqtt5Client.prototype.on = function (event, listener) {572        _super.prototype.on.call(this, event, listener);573        return this;574    };575    Mqtt5Client.prototype.on_browser_disconnect_packet = function (packet) {576        this.lastDisconnect = mqtt_utils.transform_mqtt_js_disconnect_to_crt_disconnect(packet);577    };578    Mqtt5Client.prototype.on_browser_close = function () {579        var _this = this;580        var _a, _b, _c, _d;581        var lastDisconnect = this.lastDisconnect;582        var lastError = this.lastError;583        if (this.lifecycleEventState == Mqtt5ClientLifecycleEventState.Connected) {584            this.lifecycleEventState = Mqtt5ClientLifecycleEventState.Disconnected;585            (_a = this.reconnectionScheduler) === null || _a === void 0 ? void 0 : _a.onConnectionFailureOrDisconnection();586            var disconnectionEvent_1 = {587                error: new error_1.CrtError((_b = lastError === null || lastError === void 0 ? void 0 : lastError.toString()) !== null && _b !== void 0 ? _b : "disconnected")588            };589            if (lastDisconnect !== undefined) {590                disconnectionEvent_1.disconnect = lastDisconnect;591            }592            setTimeout(function () {593                _this.emit(Mqtt5Client.DISCONNECTION, disconnectionEvent_1);594            }, 0);595        }596        else if (this.lifecycleEventState == Mqtt5ClientLifecycleEventState.Connecting) {597            this.lifecycleEventState = Mqtt5ClientLifecycleEventState.Disconnected;598            (_c = this.reconnectionScheduler) === null || _c === void 0 ? void 0 : _c.onConnectionFailureOrDisconnection();599            var connectionFailureEvent_1 = {600                error: new error_1.CrtError((_d = lastError === null || lastError === void 0 ? void 0 : lastError.toString()) !== null && _d !== void 0 ? _d : "connectionFailure")601            };602            setTimeout(function () {603                _this.emit(Mqtt5Client.CONNECTION_FAILURE, connectionFailureEvent_1);604            }, 0);605        }606        this.lastDisconnect = undefined;607        this.lastError = undefined;608    };609    Mqtt5Client.prototype.on_browser_client_error = function (error) {610        var _this = this;611        this.lastError = error;612        setTimeout(function () {613            _this.emit(Mqtt5Client.INFO, new error_1.CrtError(error));614        }, 0);615    };616    Mqtt5Client.prototype.on_attempting_connect = function () {617        var _this = this;618        this.lifecycleEventState = Mqtt5ClientLifecycleEventState.Connecting;619        var attemptingConnectEvent = {};620        setTimeout(function () {621            _this.emit(Mqtt5Client.ATTEMPTING_CONNECT, attemptingConnectEvent);622        }, 0);623    };624    Mqtt5Client.prototype.on_connection_success = function (connack) {625        var _this = this;626        var _a;627        this.lifecycleEventState = Mqtt5ClientLifecycleEventState.Connected;628        this.reset_topic_aliases();629        (_a = this.reconnectionScheduler) === null || _a === void 0 ? void 0 : _a.onSuccessfulConnection();630        var crt_connack = mqtt_utils.transform_mqtt_js_connack_to_crt_connack(connack);631        var settings = mqtt_utils.create_negotiated_settings(this.config, crt_connack);632        var connectionSuccessEvent = {633            connack: crt_connack,634            settings: settings635        };636        setTimeout(function () {637            _this.emit(Mqtt5Client.CONNECTION_SUCCESS, connectionSuccessEvent);638        }, 0);639    };640    Mqtt5Client.prototype._on_stopped_internal = function () {641        var _a;642        (_a = this.reconnectionScheduler) === null || _a === void 0 ? void 0 : _a.clearTasks();643        this.reconnectionScheduler = undefined;644        this.browserClient = undefined;645        this.lifecycleEventState = Mqtt5ClientLifecycleEventState.None;646        this.lastDisconnect = undefined;647        this.lastError = undefined;648        if (this.state == Mqtt5ClientState.Restarting) {649            this.state = Mqtt5ClientState.Stopped;650            this.start();651        }652        else if (this.state != Mqtt5ClientState.Stopped) {653            this.state = Mqtt5ClientState.Stopped;654            this.emit(Mqtt5Client.STOPPED);655        }656    };657    /**658     * Event emitted when the client encounters a disruptive error condition.  Not currently used.659     *660     * Listener type: {@link ErrorEventListener}661     *662     * @event663     */664    Mqtt5Client.ERROR = 'error';665    /**666     * Event emitted when the client encounters a transient error event that will not disrupt promises based on667     * lifecycle events.  Currently, mqtt-js client error events are relayed to this event.668     *669     * Listener type: {@link ErrorEventListener}670     *671     * @event672     * @group Browser-only673     */674    Mqtt5Client.INFO = 'info';675    /**676     * Event emitted when an MQTT PUBLISH packet is received by the client.677     *678     * Listener type: {@link MessageReceivedEventListener}679     *680     * @event681     */682    Mqtt5Client.MESSAGE_RECEIVED = 'messageReceived';683    /**684     * Event emitted when the client begins a connection attempt.685     *686     * Listener type: {@link AttemptingConnectEventListener}687     *688     * @event689     */690    Mqtt5Client.ATTEMPTING_CONNECT = 'attemptingConnect';691    /**692     * Event emitted when the client successfully establishes an MQTT connection.  Only emitted after693     * an {@link ATTEMPTING_CONNECT attemptingConnect} event.694     *695     * Listener type: {@link ConnectionSuccessEventListener}696     *697     * @event698     */699    Mqtt5Client.CONNECTION_SUCCESS = 'connectionSuccess';700    /**701     * Event emitted when the client fails to establish an MQTT connection.  Only emitted after702     * an {@link ATTEMPTING_CONNECT attemptingConnect} event.703     *704     * Listener type: {@link ConnectionFailureEventListener}705     *706     * @event707     */708    Mqtt5Client.CONNECTION_FAILURE = 'connectionFailure';709    /**710     * Event emitted when the client's current connection is closed for any reason.  Only emitted after711     * a {@link CONNECTION_SUCCESS connectionSuccess} event.712     *713     * Listener type: {@link DisconnectionEventListener}714     *715     * @event716     */717    Mqtt5Client.DISCONNECTION = 'disconnection';718    /**719     * Event emitted when the client finishes shutdown as a result of the user invoking {@link stop}.720     *721     * Listener type: {@link StoppedEventListener}722     *723     * @event724     */725    Mqtt5Client.STOPPED = 'stopped';726    return Mqtt5Client;727}(event_1.BufferedEventEmitter));728exports.Mqtt5Client = Mqtt5Client;729//# sourceMappingURL=mqtt5.js.map