@wix/duplexer-js 2.0.5

package/dist/src/transport/params.js

@@ -0,0 +1,70 @@
+"use strict";
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+var __generator = (this && this.__generator) || function (thisArg, body) {
+    var _ = { label: 0, sent: function() { if (t[0] & 1) throw t[1]; return t[1]; }, trys: [], ops: [] }, f, y, t, g;
+    return g = { next: verb(0), "throw": verb(1), "return": verb(2) }, typeof Symbol === "function" && (g[Symbol.iterator] = function() { return this; }), g;
+    function verb(n) { return function (v) { return step([n, v]); }; }
+    function step(op) {
+        if (f) throw new TypeError("Generator is already executing.");
+        while (g && (g = 0, op[0] && (_ = 0)), _) try {
+            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;
+            if (y = 0, t) op = [op[0] & 2, t.value];
+            switch (op[0]) {
+                case 0: case 1: t = op; break;
+                case 4: _.label++; return { value: op[1], done: false };
+                case 5: _.label++; y = op[1]; op = [0]; continue;
+                case 7: op = _.ops.pop(); _.trys.pop(); continue;
+                default:
+                    if (!(t = _.trys, t = t.length > 0 && t[t.length - 1]) && (op[0] === 6 || op[0] === 2)) { _ = 0; continue; }
+                    if (op[0] === 3 && (!t || (op[1] > t[0] && op[1] < t[3]))) { _.label = op[1]; break; }
+                    if (op[0] === 6 && _.label < t[1]) { _.label = t[1]; t = op; break; }
+                    if (t && _.label < t[2]) { _.label = t[2]; _.ops.push(op); break; }
+                    if (t[2]) _.ops.pop();
+                    _.trys.pop(); continue;
+            }
+            op = body.call(thisArg, _);
+        } catch (e) { op = [6, e]; y = 0; } finally { f = t = 0; }
+        if (op[0] & 5) throw op[1]; return { value: op[0] ? op[1] : void 0, done: true };
+    }
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.withParams = exports.createParams = void 0;
+function createParams(instanceUpdater, siteRevision) {
+    return __awaiter(this, void 0, void 0, function () {
+        var params, instance;
+        return __generator(this, function (_a) {
+            switch (_a.label) {
+                case 0:
+                    params = new URLSearchParams();
+                    if (!instanceUpdater) return [3 /*break*/, 2];
+                    return [4 /*yield*/, instanceUpdater.getInstance()];
+                case 1:
+                    instance = _a.sent();
+                    params.append('v', '2');
+                    params.append('instance', instance);
+                    _a.label = 2;
+                case 2:
+                    if (siteRevision) {
+                        params.append('siteRevision', siteRevision);
+                    }
+                    return [2 /*return*/, params];
+            }
+        });
+    });
+}
+exports.createParams = createParams;
+function withParams(url, params) {
+    var rawParams = params.toString();
+    var qs = rawParams === '' ? '' : "?".concat(rawParams);
+    return "".concat(url).concat(qs);
+}
+exports.withParams = withParams;
+//# sourceMappingURL=params.js.map

package/dist/src/transport/params.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"params.js","sourceRoot":"","sources":["../../../src/transport/params.ts"],"names":[],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAEA,SAAsB,YAAY,CAChC,eAAgC,EAChC,YAAoB;;;;;;oBAEd,MAAM,GAAG,IAAI,eAAe,EAAE,CAAC;yBAEjC,eAAe,EAAf,wBAAe;oBACA,qBAAM,eAAe,CAAC,WAAW,EAAE,EAAA;;oBAA9C,QAAQ,GAAG,SAAmC;oBAEpD,MAAM,CAAC,MAAM,CAAC,GAAG,EAAE,GAAG,CAAC,CAAC;oBACxB,MAAM,CAAC,MAAM,CAAC,UAAU,EAAE,QAAQ,CAAC,CAAC;;;oBAGtC,IAAI,YAAY,EAAE,CAAC;wBACjB,MAAM,CAAC,MAAM,CAAC,cAAc,EAAE,YAAY,CAAC,CAAC;oBAC9C,CAAC;oBAED,sBAAO,MAAM,EAAC;;;;CACf;AAlBD,oCAkBC;AAED,SAAgB,UAAU,CAAC,GAAW,EAAE,MAAuB;IAC7D,IAAM,SAAS,GAAG,MAAM,CAAC,QAAQ,EAAE,CAAC;IACpC,IAAM,EAAE,GAAG,SAAS,KAAK,EAAE,CAAC,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC,WAAI,SAAS,CAAE,CAAC;IACnD,OAAO,UAAG,GAAG,SAAG,EAAE,CAAE,CAAC;AACvB,CAAC;AAJD,gCAIC"}

package/dist/src/transport/transport-error.d.ts

@@ -0,0 +1,8 @@
+export type TransportType = 'websocket' | 'http_long_polling';
+export interface TransportError {
+    transport: TransportType;
+    status: number;
+    message: string;
+    recoverable: boolean;
+}
+export type InternalTransportError = Omit<TransportError, 'transport'>;

package/dist/src/transport/transport-error.js

@@ -0,0 +1,3 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+//# sourceMappingURL=transport-error.js.map

package/dist/src/transport/transport-error.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"transport-error.js","sourceRoot":"","sources":["../../../src/transport/transport-error.ts"],"names":[],"mappings":""}

package/dist/src/transport/transport-params.d.ts

@@ -0,0 +1,3 @@
+export default interface TransportParams {
+    [key: string]: string;
+}

package/dist/src/transport/transport-params.js

@@ -0,0 +1,3 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+//# sourceMappingURL=transport-params.js.map

package/dist/src/transport/transport-params.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"transport-params.js","sourceRoot":"","sources":["../../../src/transport/transport-params.ts"],"names":[],"mappings":""}

package/dist/src/transport/transport.d.ts

@@ -0,0 +1,50 @@
+import { Emitter } from '../utils/event-emitter';
+import { Protocol } from '@wix/wix-duplexer-typescript-definitions';
+import { PollPayloadProtocol } from '@wix/wix-duplexer-protocol/dist/lib/PollPayloadBuilder';
+import ReadyState from '../ready-state';
+import { TransportError, InternalTransportError, TransportType } from './transport-error';
+export interface WriteOptions {
+    affectState: boolean;
+}
+export interface TransportOpts {
+    keepAlive: boolean;
+}
+/**
+ * Transport responsibilities:
+ *
+ * - Open/close connection
+ * - Encode/decode packets and pass through
+ * - Mark connection as open by waiting for connection_established packet, dealing with session id
+ * - Todo: handling packets queue (move from virtual socket)
+ *
+ * Events:
+ *
+ * - "open" - on "connection_established" packet from connectioon.
+ * - "close" - on close either from transport side or client one, error might be attached.
+ * - "packet" - pass through packets coming from connection.
+ */
+export default abstract class Transport extends Emitter {
+    private readonly keepAlive;
+    protected payload: PollPayloadProtocol;
+    readyState: ReadyState;
+    sessionId: string;
+    constructor(opts: TransportOpts);
+    get keepAliveEnabled(): boolean;
+    send(packet: Protocol.Packet, opts?: WriteOptions): void;
+    updatePayload(params: PollPayloadProtocol): void;
+    close(error?: InternalTransportError): void;
+    abstract get name(): TransportType;
+    abstract open(): Promise<void>;
+    protected abstract closeClient(): void;
+    protected transportError(error: InternalTransportError): TransportError;
+    protected abstract write(packet: Protocol.Packet, opts?: WriteOptions): void;
+    protected onData(packet: Protocol.Packet | Protocol.Packet[]): void;
+    /**
+     * this function should be called by transport when it decides to close - for whatever
+     * reason (usually unexpected on such as network error or invalid request). then it
+     * propagaes to the client until it reaches virtual socket.
+     */
+    protected onTransportClose(error: TransportError): void;
+    protected restoreState(): void;
+    private handlePacket;
+}

package/dist/src/transport/transport.js

@@ -0,0 +1,120 @@
+"use strict";
+var __extends = (this && this.__extends) || (function () {
+    var extendStatics = function (d, b) {
+        extendStatics = Object.setPrototypeOf ||
+            ({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) ||
+            function (d, b) { for (var p in b) if (Object.prototype.hasOwnProperty.call(b, p)) d[p] = b[p]; };
+        return extendStatics(d, b);
+    };
+    return function (d, b) {
+        if (typeof b !== "function" && b !== null)
+            throw new TypeError("Class extends value " + String(b) + " is not a constructor or null");
+        extendStatics(d, b);
+        function __() { this.constructor = d; }
+        d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());
+    };
+})();
+var __assign = (this && this.__assign) || function () {
+    __assign = Object.assign || function(t) {
+        for (var s, i = 1, n = arguments.length; i < n; i++) {
+            s = arguments[i];
+            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))
+                t[p] = s[p];
+        }
+        return t;
+    };
+    return __assign.apply(this, arguments);
+};
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+/* eslint-disable no-shadow */
+var event_emitter_1 = require("../utils/event-emitter");
+var ready_state_1 = __importDefault(require("../ready-state"));
+/**
+ * Transport responsibilities:
+ *
+ * - Open/close connection
+ * - Encode/decode packets and pass through
+ * - Mark connection as open by waiting for connection_established packet, dealing with session id
+ * - Todo: handling packets queue (move from virtual socket)
+ *
+ * Events:
+ *
+ * - "open" - on "connection_established" packet from connectioon.
+ * - "close" - on close either from transport side or client one, error might be attached.
+ * - "packet" - pass through packets coming from connection.
+ */
+var Transport = /** @class */ (function (_super) {
+    __extends(Transport, _super);
+    function Transport(opts) {
+        var _this = _super.call(this) || this;
+        _this.readyState = ready_state_1.default.CLOSED;
+        _this.restoreState();
+        _this.keepAlive = opts.keepAlive;
+        return _this;
+    }
+    Object.defineProperty(Transport.prototype, "keepAliveEnabled", {
+        get: function () {
+            return this.keepAlive;
+        },
+        enumerable: false,
+        configurable: true
+    });
+    Transport.prototype.send = function (packet, opts) {
+        this.write(packet, opts);
+    };
+    Transport.prototype.updatePayload = function (params) {
+        this.payload = params;
+    };
+    Transport.prototype.close = function (error) {
+        var transportError = error ? this.transportError(error) : undefined;
+        this.closeClient();
+        this.onTransportClose(transportError);
+    };
+    Transport.prototype.transportError = function (error) {
+        return __assign(__assign({}, error), { transport: this.name });
+    };
+    Transport.prototype.onData = function (packet) {
+        var _this = this;
+        if (!Array.isArray(packet)) {
+            this.handlePacket(packet);
+        }
+        else {
+            packet.forEach(function (packet) { return _this.handlePacket(packet); });
+        }
+    };
+    /**
+     * this function should be called by transport when it decides to close - for whatever
+     * reason (usually unexpected on such as network error or invalid request). then it
+     * propagaes to the client until it reaches virtual socket.
+     */
+    Transport.prototype.onTransportClose = function (error) {
+        if (this.readyState !== ready_state_1.default.CLOSED) {
+            this.restoreState();
+            this.emit('close', error);
+        }
+        else {
+            this.emit('connect_error', error);
+        }
+    };
+    Transport.prototype.restoreState = function () {
+        this.readyState = ready_state_1.default.CLOSED;
+        this.sessionId = '';
+    };
+    Transport.prototype.handlePacket = function (packet) {
+        switch (packet.type) {
+            case 'connection_established':
+                this.sessionId = packet.sessionId;
+                this.readyState = ready_state_1.default.OPEN;
+                this.emit('open', packet);
+                break;
+            default:
+                this.emit('packet', packet);
+        }
+    };
+    return Transport;
+}(event_emitter_1.Emitter));
+exports.default = Transport;
+//# sourceMappingURL=transport.js.map

package/dist/src/transport/transport.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"transport.js","sourceRoot":"","sources":["../../../src/transport/transport.ts"],"names":[],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAAA,8BAA8B;AAC9B,wDAAiD;AAGjD,+DAAwC;AAexC;;;;;;;;;;;;;GAaG;AACH;IAAgD,6BAAO;IAOrD,mBAAY,IAAmB;QAC7B,YAAA,MAAK,WAAE,SAAC;QAJH,gBAAU,GAAG,qBAAU,CAAC,MAAM,CAAC;QAMpC,KAAI,CAAC,YAAY,EAAE,CAAC;QACpB,KAAI,CAAC,SAAS,GAAG,IAAI,CAAC,SAAS,CAAC;;IAClC,CAAC;IAED,sBAAI,uCAAgB;aAApB;YACE,OAAO,IAAI,CAAC,SAAS,CAAC;QACxB,CAAC;;;OAAA;IAED,wBAAI,GAAJ,UAAK,MAAuB,EAAE,IAAmB;QAC/C,IAAI,CAAC,KAAK,CAAC,MAAM,EAAE,IAAI,CAAC,CAAC;IAC3B,CAAC;IAED,iCAAa,GAAb,UAAc,MAA2B;QACvC,IAAI,CAAC,OAAO,GAAG,MAAM,CAAC;IACxB,CAAC;IAED,yBAAK,GAAL,UAAM,KAA8B;QAClC,IAAM,cAAc,GAAG,KAAK,CAAC,CAAC,CAAC,IAAI,CAAC,cAAc,CAAC,KAAK,CAAC,CAAC,CAAC,CAAC,SAAS,CAAC;QAEtE,IAAI,CAAC,WAAW,EAAE,CAAC;QACnB,IAAI,CAAC,gBAAgB,CAAC,cAAc,CAAC,CAAC;IACxC,CAAC;IAQS,kCAAc,GAAxB,UAAyB,KAA6B;QACpD,6BAAY,KAAK,KAAE,SAAS,EAAE,IAAI,CAAC,IAAI,IAAG;IAC5C,CAAC;IAIS,0BAAM,GAAhB,UAAiB,MAA2C;QAA5D,iBAMC;QALC,IAAI,CAAC,KAAK,CAAC,OAAO,CAAC,MAAM,CAAC,EAAE,CAAC;YAC3B,IAAI,CAAC,YAAY,CAAC,MAAM,CAAC,CAAC;QAC5B,CAAC;aAAM,CAAC;YACN,MAAM,CAAC,OAAO,CAAC,UAAC,MAAM,IAAK,OAAA,KAAI,CAAC,YAAY,CAAC,MAAM,CAAC,EAAzB,CAAyB,CAAC,CAAC;QACxD,CAAC;IACH,CAAC;IAED;;;;OAIG;IACO,oCAAgB,GAA1B,UAA2B,KAAqB;QAC9C,IAAI,IAAI,CAAC,UAAU,KAAK,qBAAU,CAAC,MAAM,EAAE,CAAC;YAC1C,IAAI,CAAC,YAAY,EAAE,CAAC;YACpB,IAAI,CAAC,IAAI,CAAC,OAAO,EAAE,KAAK,CAAC,CAAC;QAC5B,CAAC;aAAM,CAAC;YACN,IAAI,CAAC,IAAI,CAAC,eAAe,EAAE,KAAK,CAAC,CAAC;QACpC,CAAC;IACH,CAAC;IAES,gCAAY,GAAtB;QACE,IAAI,CAAC,UAAU,GAAG,qBAAU,CAAC,MAAM,CAAC;QACpC,IAAI,CAAC,SAAS,GAAG,EAAE,CAAC;IACtB,CAAC;IAEO,gCAAY,GAApB,UAAqB,MAAuB;QAC1C,QAAQ,MAAM,CAAC,IAAI,EAAE,CAAC;YACpB,KAAK,wBAAwB;gBAC3B,IAAI,CAAC,SAAS,GACZ,MACD,CAAC,SAAS,CAAC;gBACZ,IAAI,CAAC,UAAU,GAAG,qBAAU,CAAC,IAAI,CAAC;gBAClC,IAAI,CAAC,IAAI,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC;gBAC1B,MAAM;YAER;gBACE,IAAI,CAAC,IAAI,CAAC,QAAQ,EAAE,MAAM,CAAC,CAAC;QAChC,CAAC;IACH,CAAC;IACH,gBAAC;AAAD,CAAC,AAtFD,CAAgD,uBAAO,GAsFtD"}

package/dist/src/transport/transports-manager.d.ts

@@ -0,0 +1,42 @@
+import { Emitter } from '../utils/event-emitter';
+import { Protocol } from '@wix/wix-duplexer-typescript-definitions';
+import Strategy from '../strategies/strategy';
+import Transport from './transport';
+import ReadyState from '../ready-state';
+export interface ConnectState {
+    success: boolean;
+    connectionEstablishedPacket?: Protocol.ConnectionEstablishedPacket;
+}
+/**
+ * TransportsManager responsibilities:
+ *
+ * - Initizlize "first to connect" (according given strategies)
+ * - Close active connection or connection process
+ *
+ * Events:
+ * - "close" - in case (1) connected trasnport closed or (2) connect canceled
+ * - "connect_error" - passes through "close" events coming from trasnports during connection
+ * phase, may occurs several times during the connect tries.
+ * - "message" - pass through packets coming from open transport.
+ */
+export default class TransportsManager extends Emitter {
+    private readonly strategies;
+    private _transport;
+    private disposables;
+    private cancelToken;
+    readyState: ReadyState;
+    constructor(strategies: Strategy[]);
+    get transport(): Transport;
+    connect(): Promise<ConnectState>;
+    close(): void;
+    isOpen(): boolean;
+    isClosed(): boolean;
+    private isOpening;
+    private connectToFirstToRespondStrategy;
+    private onClose;
+    private abortStrategiesWithNoOpenTransport;
+    private listenAndEmitConnectErrorsInAllTransportsOnConnecting;
+    private listenEventsOfActiveTransport;
+    private removeListeners;
+    private onData;
+}

package/dist/src/transport/transports-manager.js

@@ -0,0 +1,248 @@
+"use strict";
+var __extends = (this && this.__extends) || (function () {
+    var extendStatics = function (d, b) {
+        extendStatics = Object.setPrototypeOf ||
+            ({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) ||
+            function (d, b) { for (var p in b) if (Object.prototype.hasOwnProperty.call(b, p)) d[p] = b[p]; };
+        return extendStatics(d, b);
+    };
+    return function (d, b) {
+        if (typeof b !== "function" && b !== null)
+            throw new TypeError("Class extends value " + String(b) + " is not a constructor or null");
+        extendStatics(d, b);
+        function __() { this.constructor = d; }
+        d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());
+    };
+})();
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+var __generator = (this && this.__generator) || function (thisArg, body) {
+    var _ = { label: 0, sent: function() { if (t[0] & 1) throw t[1]; return t[1]; }, trys: [], ops: [] }, f, y, t, g;
+    return g = { next: verb(0), "throw": verb(1), "return": verb(2) }, typeof Symbol === "function" && (g[Symbol.iterator] = function() { return this; }), g;
+    function verb(n) { return function (v) { return step([n, v]); }; }
+    function step(op) {
+        if (f) throw new TypeError("Generator is already executing.");
+        while (g && (g = 0, op[0] && (_ = 0)), _) try {
+            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;
+            if (y = 0, t) op = [op[0] & 2, t.value];
+            switch (op[0]) {
+                case 0: case 1: t = op; break;
+                case 4: _.label++; return { value: op[1], done: false };
+                case 5: _.label++; y = op[1]; op = [0]; continue;
+                case 7: op = _.ops.pop(); _.trys.pop(); continue;
+                default:
+                    if (!(t = _.trys, t = t.length > 0 && t[t.length - 1]) && (op[0] === 6 || op[0] === 2)) { _ = 0; continue; }
+                    if (op[0] === 3 && (!t || (op[1] > t[0] && op[1] < t[3]))) { _.label = op[1]; break; }
+                    if (op[0] === 6 && _.label < t[1]) { _.label = t[1]; t = op; break; }
+                    if (t && _.label < t[2]) { _.label = t[2]; _.ops.push(op); break; }
+                    if (t[2]) _.ops.pop();
+                    _.trys.pop(); continue;
+            }
+            op = body.call(thisArg, _);
+        } catch (e) { op = [6, e]; y = 0; } finally { f = t = 0; }
+        if (op[0] & 5) throw op[1]; return { value: op[0] ? op[1] : void 0, done: true };
+    }
+};
+var __spreadArray = (this && this.__spreadArray) || function (to, from, pack) {
+    if (pack || arguments.length === 2) for (var i = 0, l = from.length, ar; i < l; i++) {
+        if (ar || !(i in from)) {
+            if (!ar) ar = Array.prototype.slice.call(from, 0, i);
+            ar[i] = from[i];
+        }
+    }
+    return to.concat(ar || Array.prototype.slice.call(from));
+};
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+var event_emitter_1 = require("../utils/event-emitter");
+var ready_state_1 = __importDefault(require("../ready-state"));
+var on_1 = __importDefault(require("../utils/on"));
+var deferred_1 = __importDefault(require("../utils/deferred"));
+/**
+ * TransportsManager responsibilities:
+ *
+ * - Initizlize "first to connect" (according given strategies)
+ * - Close active connection or connection process
+ *
+ * Events:
+ * - "close" - in case (1) connected trasnport closed or (2) connect canceled
+ * - "connect_error" - passes through "close" events coming from trasnports during connection
+ * phase, may occurs several times during the connect tries.
+ * - "message" - pass through packets coming from open transport.
+ */
+var TransportsManager = /** @class */ (function (_super) {
+    __extends(TransportsManager, _super);
+    function TransportsManager(strategies) {
+        var _this = _super.call(this) || this;
+        _this.strategies = strategies;
+        _this.disposables = [];
+        _this.readyState = ready_state_1.default.CLOSED;
+        return _this;
+    }
+    Object.defineProperty(TransportsManager.prototype, "transport", {
+        get: function () {
+            return this._transport;
+        },
+        enumerable: false,
+        configurable: true
+    });
+    TransportsManager.prototype.connect = function () {
+        return __awaiter(this, void 0, void 0, function () {
+            var connectionEstablishedPacket, e_1;
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0:
+                        if (this.readyState !== ready_state_1.default.CLOSED) {
+                            return [2 /*return*/, connectCanceled()];
+                        }
+                        this.cancelToken = new deferred_1.default();
+                        this.readyState = ready_state_1.default.OPENING;
+                        this.listenAndEmitConnectErrorsInAllTransportsOnConnecting();
+                        _a.label = 1;
+                    case 1:
+                        _a.trys.push([1, 3, , 4]);
+                        return [4 /*yield*/, this.connectToFirstToRespondStrategy()];
+                    case 2:
+                        connectionEstablishedPacket =
+                            _a.sent();
+                        return [3 /*break*/, 4];
+                    case 3:
+                        e_1 = _a.sent();
+                        return [2 /*return*/, connectCanceled()];
+                    case 4:
+                        this.cancelToken = null;
+                        this.removeListeners();
+                        this.abortStrategiesWithNoOpenTransport();
+                        this.listenEventsOfActiveTransport();
+                        return [2 /*return*/, connectSuccess(connectionEstablishedPacket)];
+                }
+            });
+        });
+    };
+    TransportsManager.prototype.close = function () {
+        if (this.isOpen()) {
+            // transport emits 'close' event, so this.onClose() will be called later on
+            this.transport.close();
+        }
+        else if (this.isOpening()) {
+            this.cancelToken && this.cancelToken.reject();
+            this.onClose();
+            this.strategies.forEach(function (s) { return s.abort(); });
+        }
+    };
+    TransportsManager.prototype.isOpen = function () {
+        return this.readyState === ready_state_1.default.OPEN;
+    };
+    TransportsManager.prototype.isClosed = function () {
+        return this.readyState === ready_state_1.default.CLOSED;
+    };
+    TransportsManager.prototype.isOpening = function () {
+        return this.readyState === ready_state_1.default.OPENING;
+    };
+    TransportsManager.prototype.connectToFirstToRespondStrategy = function () {
+        return __awaiter(this, void 0, void 0, function () {
+            var _a, transport, connectionEstablishedPacket;
+            return __generator(this, function (_b) {
+                switch (_b.label) {
+                    case 0: return [4 /*yield*/, Promise.race(__spreadArray(__spreadArray([], this.strategies.map(function (s) { return s.connect(); }), true), [
+                            this.cancelToken.promise,
+                        ], false))];
+                    case 1:
+                        _a = _b.sent(), transport = _a.transport, connectionEstablishedPacket = _a.connectionEstablishedPacket;
+                        this._transport = transport;
+                        this.readyState = ready_state_1.default.OPEN;
+                        return [2 /*return*/, connectionEstablishedPacket];
+                }
+            });
+        });
+    };
+    TransportsManager.prototype.onClose = function (error) {
+        this.readyState = ready_state_1.default.CLOSED;
+        this._transport = null;
+        this.cancelToken = null;
+        this.removeListeners();
+        /**
+         * the reason we always propagaes 'close' event is that some entities in the system
+         * have to make a clean up or just react, for instance:
+         *
+         * - connection manager MAY reconnect.
+         * - vritual socket must notify to its user (disconnected event).
+         *
+         * so it doesn't matter WHY close happened - everyone should always get notified.
+         */
+        this.emit('close', error);
+    };
+    TransportsManager.prototype.abortStrategiesWithNoOpenTransport = function () {
+        this.strategies
+            .filter(function (s) { return s.transport.readyState !== ready_state_1.default.OPEN; })
+            .forEach(function (s) { return s.abort(); });
+    };
+    TransportsManager.prototype.listenAndEmitConnectErrorsInAllTransportsOnConnecting = function () {
+        var _this = this;
+        this.disposables = this.strategies.map(function (s) {
+            return (0, on_1.default)(s, 'connect_error', function (error) {
+                if (error.recoverable) {
+                    _this.emit('connect_error', error);
+                }
+                else {
+                    _this.close();
+                }
+            });
+        });
+    };
+    TransportsManager.prototype.listenEventsOfActiveTransport = function () {
+        var _this = this;
+        this.disposables = [
+            /**
+             * might be called either because transport got error or due to a side-effect
+             * when someone calls TransportsManager.close().
+             */
+            (0, on_1.default)(this.transport, 'close', function (error) {
+                _this.onClose(error);
+            }),
+            (0, on_1.default)(this.transport, 'packet', function (packet) {
+                _this.onData(packet);
+            }),
+        ];
+    };
+    TransportsManager.prototype.removeListeners = function () {
+        this.disposables.forEach(function (l) { return l.destroy(); });
+        this.disposables = [];
+    };
+    // todo: rewrite this method, it looks ugly
+    TransportsManager.prototype.onData = function (packet) {
+        switch (packet.type) {
+            case 'message':
+            case 'ack':
+            case 'error':
+            case 'UpdateRestoreStrategyOverrides':
+                this.emit('message', packet);
+                break;
+            default:
+                break;
+        }
+    };
+    return TransportsManager;
+}(event_emitter_1.Emitter));
+exports.default = TransportsManager;
+function connectSuccess(connectionEstablishedPacket) {
+    return {
+        success: true,
+        connectionEstablishedPacket: connectionEstablishedPacket,
+    };
+}
+function connectCanceled() {
+    return {
+        success: false,
+    };
+}
+//# sourceMappingURL=transports-manager.js.map

package/dist/src/transport/transports-manager.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"transports-manager.js","sourceRoot":"","sources":["../../../src/transport/transports-manager.ts"],"names":[],"mappings":"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"}

package/dist/src/transport/unrecoverable.d.ts

@@ -0,0 +1 @@
+export declare function isRecoverableCode(code: number): boolean;

package/dist/src/transport/unrecoverable.js

@@ -0,0 +1,8 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.isRecoverableCode = void 0;
+function isRecoverableCode(code) {
+    return [401].every(function (unrecoverableStatus) { return unrecoverableStatus !== code; });
+}
+exports.isRecoverableCode = isRecoverableCode;
+//# sourceMappingURL=unrecoverable.js.map

package/dist/src/transport/unrecoverable.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"unrecoverable.js","sourceRoot":"","sources":["../../../src/transport/unrecoverable.ts"],"names":[],"mappings":";;;AAAA,SAAgB,iBAAiB,CAAC,IAAY;IAC5C,OAAO,CAAC,GAAG,CAAC,CAAC,KAAK,CAAC,UAAC,mBAAmB,IAAK,OAAA,mBAAmB,KAAK,IAAI,EAA5B,CAA4B,CAAC,CAAC;AAC5E,CAAC;AAFD,8CAEC"}

package/dist/src/transport/websocket.d.ts

@@ -0,0 +1,18 @@
+import { Protocol } from '@wix/wix-duplexer-typescript-definitions';
+import Transport from './transport';
+import { TransportType } from './transport-error';
+import { InstanceUpdater } from '../instance-updater';
+export default class WS extends Transport {
+    private readonly url;
+    private readonly instanceUpdater;
+    private readonly siteRevision?;
+    private ws;
+    constructor(url: string, instanceUpdater?: InstanceUpdater, siteRevision?: string);
+    static isSupported(): boolean;
+    get name(): TransportType;
+    open(): Promise<void>;
+    protected closeClient(): void;
+    protected write(packet: Protocol.Packet): void;
+    private listen;
+    private cleanWebSocketHooks;
+}