@wix/duplexer-js 2.0.5

package/README.md

@@ -0,0 +1,239 @@
+# @wix/duplexer-js
+
+Establish a connection to [wix-duplexer-sockets-server](../../services/wix-duplexer-sockets-server), subscribe and listen to channels & events from the
+browser.
+
+## Requirements
+
+| Environment | Minimum version |
+| --- | --- |
+| Node.js | 18.0.0 |
+| Chrome | 42 |
+| Firefox | 39 |
+| Safari | 10.1 |
+| Edge | 14 |
+
+The following Web APIs must be available at runtime:
+- `fetch` / `Response`
+- `AbortController` / `AbortSignal` (for request cancellation)
+
+### Testing in Node.js
+
+Node 18+ includes a global `fetch` (based on undici). If your test framework intercepts HTTP with `nock`, ensure you are using `nock` v13+ which supports intercepting native `fetch`.
+
+## Features
+
+### Send events
+
+Send event directly from the client (browser). Read more about [sending client event](../../docs/CLIENT_EVENTS.md).
+
+### Private channels
+
+Allow authorized-only clients to subscribe specific channels. Read more about [private channels](../../docs/PRIVATE_CHANNELS.md).
+
+### Multiplexing
+
+It means that N different clients can utilize/share same the physical socket while having a full isolation and, hence, improve general performance.
+
+### Environments
+
+- Browser (default).
+- [React Native](../../docs/REACT_NATIVE.md).
+
+## Install
+
+```sh
+npm install @wix/duplexer-js
+```
+
+## Usage
+
+```js
+import { Duplexer } from '@wix/duplexer-js';
+
+const instanceUpdater = {
+  getInstance() {
+    return window.__APP_INSTANCE__;
+  }
+};
+
+const siteRevision = '1';
+
+const duplexer = new Duplexer('duplexer.wix.com', {
+  instanceUpdater,
+  siteRevision,
+});
+
+const connection = duplexer.connect({
+  appDefId: '224b330b-f3dc-4898-8876-d177ab3877ca'
+});
+
+const channel = connection.subscribe('some-channel');
+
+connection.on('@duplexer:connected', () => {
+  // connection established
+})
+
+channel.on('some-event', payload => {
+  // do something with your payload
+});
+```
+
+**Note:** in case you use jsdom, you must specify its url with `http://` protocol in order to make Duplexer testkit to work properly (exposed websocket & http server are not under SSL).
+
+```js
+require('jsdom-global)('', { url: 'http://localhost:7000' });
+```
+
+**Note:** in case you run Duplexer in a Node.js environment (e.g. testing with Jest/Mocha), you need:
+
+1. **Node.js 18+** (provides global `fetch`, `AbortController`).
+2. A WebSocket implementation on the `global` object. You can install [`ws`](https://www.npmjs.com/package/ws):
+
+```js
+global.WebSocket = require('ws');
+```
+
+## API
+
+### new Duplexer(opts): Duplexer
+
+Create a new `Duplexer` instance that will open socket against `url`. It must be provided with `duplexer.wix.com` as the url, as it communicates with the sockets server directly (opens a connection, send commands etc.).
+
+Parameters:
+
+- opts (Object):
+  - `url` (String) - url to [wix-duplexer-sockets-server](../../services/wix-duplexer-sockets-server) service, must be protocol-less.
+  - `siteRevision` (String) - the [site's revision](https://www.wix.com/corvid/reference/wix-site.html#revision) number.
+  - `instanceUpdater` (InstanceUpdater) - an object that exposes `getInstance: () => string` member that is responsible of retrieving Wix's instance.
+  - `autoConnect` (Boolean, default: true) - whether to enable auto reconnect when a sudden disconnection accurs. Used for testing purposes.
+
+### Duplexer.connect(opts): VirtualSocket
+
+Establish a connection according to given `opts.appDefId`.
+
+Parameters:
+
+- opts
+  - `appDefId` (String)
+
+### Duplexer.getConnectionServerTime(): Promise<number>
+
+Retrieves the server time that the connection was established with. Promise is getting resolved upon successful connect.
+
+Note: it refers to the physical connection establishment (`connection_establish` packet).
+
+### Duplexer.triggerInstanceChanged(): void
+
+In case the signed instance is no longer valid (say, expired) and connection closed with status 401, you should make the instance updater to return a new valid signed instance. After you do that, you can call `triggerInstanceChanged()`, so Duplexer will try to reconnect (... and resubscribe).
+
+### VirtualSocket.disconnect(): void
+
+Closes namespace (might close the entire underlying connection or not, depends if pool contains more namespaces or not).
+
+### VirtualSocket.subscribe(channel, opts): Channel
+
+Subscribe to channel and start getting emitted events.
+
+Note: current limitation is up to 10 different subscriptions (channels) per api key.
+
+Parameters:
+
+- channel (String)
+- opts (Object) (Optional)
+  - restoreStrategy (Object) - custom restore strategy taht will be attached to the subscribe command, see [RestoreStrategyBuilderFactory](#restorestrategybuilderfactory) for more information about possible restore strategies.
+  - resourceId - if you have a specific channel for each resource, like `scores/1` and `scores/2`.
+  
+### VirtualSocket.subscribeToUserChannel(): Channel
+  
+Subscribe to user's dedicated channel. This channel acts like his own inbox, so nobody else can listen to.
+
+In order to publish to user channel (backend perspective), the `USER` context should be used along with the `recipients` field (that represents the user IDs that should receive the message).
+
+### VirtualSocket.unsubscribe(channel): void
+
+Unsubscribe channel, stop getting emitted events.
+
+Parameters:
+
+- channel (String)
+
+### VirtualSocket.on(event, handler)
+
+Listen to event and execute handler on every event that emitted on this connection.
+
+Parameters:
+
+- event (String)
+- handler (Function: payload? => void)
+
+#### Reserved events
+
+| Event                      | Description |
+| -------------------------- | ----------- |
+| @duplexer:connected        | Emitted on connection successfully established              |
+| @duplexer:disconnected     | Emitted on connection closed, either intentionally or caused by error. If connection was closed due to error, a `TransportError` instance will be passed. In case `TransportError` contains `{ recoverable: false }`, you will have to conneect manually (you should check the `status` and act accordingly; for instance, in case it's `401` - the provided signed instance is invalid)  |
+| @duplexer:connect_error     | Emitted on every connect try error, a `TransportError` instance will be passed. In case error is unrecoverable, `@duplexer:connect_error` won't be thrown, but `@duplexer:diconnected` with `TransportError` that contains `{ recoverable: false }`  |
+
+**Note:** all above events might be called multiple times, for instance:
+
+`connected -> disconnected (with error) -> connect_erorr -> connect_erorr -> connected`
+
+This happens because duplexer client tries to recover itself in case of unexpected disconnection.
+
+### VirtualSocket.off(event, handler?)
+
+Remove `handler` from being executed on `event`. In case no handler passed, all handlers will be removed.
+
+Parameters:
+
+- event (String)
+- handler (Optional) (Function)
+
+### Channel.on(event, handler): Channel
+
+Listen to event and execute handler on every event that emitted on this channel.
+
+Parameters:
+
+- event (String)
+- handler (Function: (payload?, attachments?) => void) - handler that will be executed every time an event received:
+  - payload (any)
+  - attachments (Object)
+    - user (Object) - user informartion that was attached to event (from signed subscription token).
+
+```js
+channel.on('client-typing', (_, {user}) => {
+  // ${user.info.name} is typing!
+})
+```
+
+#### Reserved events
+
+| Event                            | Description |
+| -------------------------------- | ----------- |
+| @duplexer:subscription_succeeded        | Subscription established successfully and from now on messages will be delivered. Note: will be called on every resubscribe (in case of reconnect for instance), so make sure your handler is idempotent.<br />Payload is an object that contains:<br />- `isSynced` (Boolean) - determines if app server should resync (possibly) missed messages. Will always return `false` at the beginning, and app server might needs to fetch its recent messages in this phase.             |
+| @duplexer:subscription_failed    | Emitted on authorization failure - in case request returns status other than 2xx.<br />Payload is an object that contains:<br />- `status` (Boolean) - status code the request returned with.<br />- `message` (String) - detailed message about the error |
+| @duplexer:unsubscribe_succeeded        | Unsubscribed successfully from channel and messages will stop being delivered.              |
+
+### Channel.off(event, handler?)
+
+Remove `handler` from being executed on `event`. In case no handler passed, all handlers will be removed.
+
+Parameters:
+
+- event (String)
+- handler (Optional) (Function)
+
+### Channel.send(event, payload): void
+
+Send a client event. User is implicitly attached.
+
+Parameters:
+
+- event (String)
+- payload (Object)
+
+### RestoreStrategyBuilderFactory
+
+Possible restore strategies, see [wix-duplexer-protocol#RestoreStrategyBuilderFactory](../../utils/wix-duplexer-protocol#restorestrategybuilderfactory)

package/dist/src/_external-types.d.ts

@@ -0,0 +1 @@
+declare module 'backo2';

package/dist/src/authenticator.d.ts

@@ -0,0 +1,22 @@
+export interface AuthenticatorOptions {
+    url: string;
+    onBeforeRequest?(): OnBeforeRequest;
+}
+export interface OnBeforeRequest {
+    body?: object;
+    headers?: object;
+}
+export interface AuthResponse {
+    success: boolean;
+    auth?: string;
+    error?: AuthError;
+}
+export interface AuthError {
+    status: number;
+    message: string;
+}
+export default class Authenticator {
+    private readonly opts;
+    constructor(opts: AuthenticatorOptions);
+    auth(channelName: string, sessionId: string): Promise<AuthResponse>;
+}

package/dist/src/authenticator.js

@@ -0,0 +1,42 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+var request_1 = require("./utils/request");
+var Authenticator = /** @class */ (function () {
+    function Authenticator(opts) {
+        this.opts = opts;
+    }
+    Authenticator.prototype.auth = function (channelName, sessionId) {
+        var _a = this.opts.onBeforeRequest
+            ? this.opts.onBeforeRequest()
+            : {}, body = _a.body, headers = _a.headers;
+        var payload = {
+            sessionId: sessionId,
+            channelName: channelName,
+            custom: body,
+        };
+        return (0, request_1.post)(this.opts.url, payload, {
+            withCredentials: true,
+            headers: headers,
+        }).then(authSuceess, authFailure);
+    };
+    return Authenticator;
+}());
+exports.default = Authenticator;
+function authSuceess(_a) {
+    var data = _a.data;
+    return {
+        success: true,
+        auth: typeof data === 'object' ? data.token : data,
+    };
+}
+function authFailure(error) {
+    var response = error.response;
+    return {
+        success: false,
+        error: {
+            status: response ? response.status : -1,
+            message: error.toString(),
+        },
+    };
+}
+//# sourceMappingURL=authenticator.js.map

package/dist/src/authenticator.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"authenticator.js","sourceRoot":"","sources":["../../src/authenticator.ts"],"names":[],"mappings":";;AAAA,2CAAgE;AAuBhE;IAGE,uBAAY,IAA0B;QACpC,IAAI,CAAC,IAAI,GAAG,IAAI,CAAC;IACnB,CAAC;IAEM,4BAAI,GAAX,UAAY,WAAmB,EAAE,SAAiB;QAC1C,IAAA,KAAqC,IAAI,CAAC,IAAI,CAAC,eAAe;YAClE,CAAC,CAAC,IAAI,CAAC,IAAI,CAAC,eAAe,EAAE;YAC7B,CAAC,CAAC,EAAE,EAFE,IAAI,UAAA,EAAE,OAAO,aAEf,CAAC;QACP,IAAM,OAAO,GAAG;YACd,SAAS,WAAA;YACT,WAAW,aAAA;YACX,MAAM,EAAE,IAAI;SACb,CAAC;QAEF,OAAO,IAAA,cAAI,EAAC,IAAI,CAAC,IAAI,CAAC,GAAG,EAAE,OAAO,EAAE;YAClC,eAAe,EAAE,IAAI;YACrB,OAAO,SAAA;SACR,CAAC,CAAC,IAAI,CAAC,WAAW,EAAE,WAAW,CAAC,CAAC;IACpC,CAAC;IACH,oBAAC;AAAD,CAAC,AAtBD,IAsBC;;AAED,SAAS,WAAW,CAAC,EAAkB;QAAhB,IAAI,UAAA;IACzB,OAAO;QACL,OAAO,EAAE,IAAI;QACb,IAAI,EAAE,OAAO,IAAI,KAAK,QAAQ,CAAC,CAAC,CAAC,IAAI,CAAC,KAAK,CAAC,CAAC,CAAC,IAAI;KACnD,CAAC;AACJ,CAAC;AAED,SAAS,WAAW,CAAC,KAAoB;IAC/B,IAAA,QAAQ,GAAK,KAAK,SAAV,CAAW;IAC3B,OAAO;QACL,OAAO,EAAE,KAAK;QACd,KAAK,EAAE;YACL,MAAM,EAAE,QAAQ,CAAC,CAAC,CAAC,QAAQ,CAAC,MAAM,CAAC,CAAC,CAAC,CAAC,CAAC;YACvC,OAAO,EAAE,KAAK,CAAC,QAAQ,EAAE;SAC1B;KACF,CAAC;AACJ,CAAC"}

package/dist/src/channels/channel.d.ts

@@ -0,0 +1,29 @@
+import { Emitter } from '../utils/event-emitter';
+import { Protocol } from '@wix/wix-duplexer-typescript-definitions';
+import RestoreStrategy from '@wix/wix-duplexer-protocol/dist/lib/restore/RestoreStrategy';
+import { MessageIdRestoreStrategy } from '@wix/wix-duplexer-protocol/dist/lib/restore/MessageIdRestoreStrategyBuilder';
+import VirtualSocket from '../virtual-socket';
+export interface SubscribeOptions {
+    restoreStrategy?: RestoreStrategy;
+}
+export interface ChannelOptions<T> {
+    forceTokenRequest?: boolean;
+    resourceId?: string;
+    info?: T;
+}
+export default class Channel<T = any> extends Emitter {
+    readonly name: string;
+    readonly resourceId: string;
+    private readonly virtualSocket;
+    private readonly info;
+    private restore;
+    private subscribingState;
+    constructor(virtualSocket: VirtualSocket, name: string, resourceId?: string, info?: T);
+    setMessageIdRestore(messageId: string): MessageIdRestoreStrategy;
+    subscribe(opts?: SubscribeOptions): Promise<void>;
+    setUnsubscribe(): void;
+    private sendSubscribe;
+    unsubscribe(): Promise<void>;
+    send(event: string, payload?: string): Promise<Protocol.Ack | Protocol.ErrorPacket>;
+    private emitSubscriptionSucceeded;
+}

package/dist/src/channels/channel.js

@@ -0,0 +1,159 @@
+"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 };
+    }
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+var event_emitter_1 = require("../utils/event-emitter");
+var wix_duplexer_protocol_1 = require("@wix/wix-duplexer-protocol");
+var Channel = /** @class */ (function (_super) {
+    __extends(Channel, _super);
+    function Channel(virtualSocket, name, resourceId, info) {
+        var _this = _super.call(this) || this;
+        _this.subscribingState = 1 /* SubscribingState.UNSUBSCRIBED */;
+        _this.name = name;
+        _this.virtualSocket = virtualSocket;
+        _this.resourceId = resourceId;
+        _this.info = info;
+        return _this;
+    }
+    Channel.prototype.setMessageIdRestore = function (messageId) {
+        this.restore = wix_duplexer_protocol_1.RestoreStrategyBuilderFactory.messageId()
+            .withId(messageId)
+            .build();
+        return this.restore;
+    };
+    Channel.prototype.subscribe = function (opts) {
+        if (opts === void 0) { opts = {}; }
+        return __awaiter(this, void 0, void 0, function () {
+            var _this = this;
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0:
+                        if (this.subscribingState === 0 /* SubscribingState.SUBSCRIBED */) {
+                            setTimeout(function () { return _this.emitSubscriptionSucceeded(true); }, 0);
+                            return [2 /*return*/];
+                        }
+                        if (this.subscribingState === 2 /* SubscribingState.SUBSCRIBING */) {
+                            return [2 /*return*/];
+                        }
+                        this.subscribingState = 2 /* SubscribingState.SUBSCRIBING */;
+                        return [4 /*yield*/, this.sendSubscribe(opts)];
+                    case 1:
+                        _a.sent();
+                        return [2 /*return*/];
+                }
+            });
+        });
+    };
+    Channel.prototype.setUnsubscribe = function () {
+        this.subscribingState = 1 /* SubscribingState.UNSUBSCRIBED */;
+    };
+    Channel.prototype.sendSubscribe = function (opts) {
+        return __awaiter(this, void 0, void 0, function () {
+            var res;
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0: return [4 /*yield*/, this.virtualSocket.send({
+                            type: 'subscribe',
+                            channel: this.name,
+                            resourceId: this.resourceId,
+                            auth: '',
+                            restore: opts.restoreStrategy || this.restore,
+                            info: this.info,
+                        })];
+                    case 1:
+                        res = _a.sent();
+                        if (res.type === 'error') {
+                            this.emit('@duplexer:subscription_failed', res);
+                        }
+                        else {
+                            this.subscribingState = 0 /* SubscribingState.SUBSCRIBED */;
+                            this.emitSubscriptionSucceeded(res.isSynced);
+                        }
+                        return [2 /*return*/];
+                }
+            });
+        });
+    };
+    Channel.prototype.unsubscribe = function () {
+        return __awaiter(this, void 0, void 0, function () {
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0: return [4 /*yield*/, this.virtualSocket.send({
+                            type: 'unsubscribe',
+                            channel: this.name,
+                            resourceId: this.resourceId,
+                        })];
+                    case 1:
+                        _a.sent();
+                        this.subscribingState = 1 /* SubscribingState.UNSUBSCRIBED */;
+                        this.emit('@duplexer:unsubscribe_succeeded');
+                        return [2 /*return*/];
+                }
+            });
+        });
+    };
+    Channel.prototype.send = function (event, payload) {
+        return this.virtualSocket.send({
+            type: 'client_message',
+            channel: this.name,
+            resourceId: this.resourceId,
+            event: event,
+            payload: payload,
+        }, { affectState: false });
+    };
+    Channel.prototype.emitSubscriptionSucceeded = function (isSynced) {
+        this.emit('@duplexer:subscription_succeeded', { isSynced: isSynced });
+    };
+    return Channel;
+}(event_emitter_1.Emitter));
+exports.default = Channel;
+//# sourceMappingURL=channel.js.map

package/dist/src/channels/channel.js.map

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

package/dist/src/channels/channels.d.ts

@@ -0,0 +1,13 @@
+import Channel from './channel';
+import VirtualSocket from '../virtual-socket';
+export default class Channels {
+    private readonly virtualSocket;
+    private channelsList;
+    constructor(virtualSocket: VirtualSocket);
+    add<T>(name: string, resourceId?: string, info?: T): Channel<any>;
+    remove(name: string, resourceId?: string): Channel<any>;
+    find(name: string, resourceId?: string): Channel<any>;
+    all(): Channel<any>[];
+    subscribeAll(): void;
+    setUnsubscribeAll(): void;
+}

package/dist/src/channels/channels.js

@@ -0,0 +1,41 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+var channel_1 = __importDefault(require("./channel"));
+var Channels = /** @class */ (function () {
+    function Channels(virtualSocket) {
+        this.virtualSocket = virtualSocket;
+        this.channelsList = [];
+    }
+    Channels.prototype.add = function (name, resourceId, info) {
+        var maybeChannel = this.find(name, resourceId);
+        if (maybeChannel) {
+            return maybeChannel;
+        }
+        var channel = new channel_1.default(this.virtualSocket, name, resourceId, info);
+        this.channelsList.push(channel);
+        return channel;
+    };
+    Channels.prototype.remove = function (name, resourceId) {
+        var channel = this.find(name, resourceId);
+        this.channelsList = this.channelsList.filter(function (c) { return c.name !== name || c.resourceId !== resourceId; });
+        return channel;
+    };
+    Channels.prototype.find = function (name, resourceId) {
+        return this.channelsList.find(function (c) { return c.name === name && c.resourceId === resourceId; });
+    };
+    Channels.prototype.all = function () {
+        return this.channelsList;
+    };
+    Channels.prototype.subscribeAll = function () {
+        this.all().forEach(function (c) { return c.subscribe(); });
+    };
+    Channels.prototype.setUnsubscribeAll = function () {
+        this.all().forEach(function (c) { return c.setUnsubscribe(); });
+    };
+    return Channels;
+}());
+exports.default = Channels;
+//# sourceMappingURL=channels.js.map

package/dist/src/channels/channels.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"channels.js","sourceRoot":"","sources":["../../../src/channels/channels.ts"],"names":[],"mappings":";;;;;AAAA,sDAAgC;AAGhC;IAGE,kBAA6B,aAA4B;QAA5B,kBAAa,GAAb,aAAa,CAAe;QAFjD,iBAAY,GAAc,EAAE,CAAC;IAEuB,CAAC;IAE7D,sBAAG,GAAH,UAAO,IAAY,EAAE,UAAmB,EAAE,IAAQ;QAChD,IAAM,YAAY,GAAG,IAAI,CAAC,IAAI,CAAC,IAAI,EAAE,UAAU,CAAC,CAAC;QAEjD,IAAI,YAAY,EAAE,CAAC;YACjB,OAAO,YAAY,CAAC;QACtB,CAAC;QAED,IAAM,OAAO,GAAG,IAAI,iBAAO,CAAI,IAAI,CAAC,aAAa,EAAE,IAAI,EAAE,UAAU,EAAE,IAAI,CAAC,CAAC;QAE3E,IAAI,CAAC,YAAY,CAAC,IAAI,CAAC,OAAO,CAAC,CAAC;QAEhC,OAAO,OAAO,CAAC;IACjB,CAAC;IAED,yBAAM,GAAN,UAAO,IAAY,EAAE,UAAmB;QACtC,IAAM,OAAO,GAAG,IAAI,CAAC,IAAI,CAAC,IAAI,EAAE,UAAU,CAAC,CAAC;QAC5C,IAAI,CAAC,YAAY,GAAG,IAAI,CAAC,YAAY,CAAC,MAAM,CAC1C,UAAC,CAAC,IAAK,OAAA,CAAC,CAAC,IAAI,KAAK,IAAI,IAAI,CAAC,CAAC,UAAU,KAAK,UAAU,EAA9C,CAA8C,CACtD,CAAC;QACF,OAAO,OAAO,CAAC;IACjB,CAAC;IAED,uBAAI,GAAJ,UAAK,IAAY,EAAE,UAAmB;QACpC,OAAO,IAAI,CAAC,YAAY,CAAC,IAAI,CAC3B,UAAC,CAAC,IAAK,OAAA,CAAC,CAAC,IAAI,KAAK,IAAI,IAAI,CAAC,CAAC,UAAU,KAAK,UAAU,EAA9C,CAA8C,CACtD,CAAC;IACJ,CAAC;IAED,sBAAG,GAAH;QACE,OAAO,IAAI,CAAC,YAAY,CAAC;IAC3B,CAAC;IAED,+BAAY,GAAZ;QACE,IAAI,CAAC,GAAG,EAAE,CAAC,OAAO,CAAC,UAAC,CAAC,IAAK,OAAA,CAAC,CAAC,SAAS,EAAE,EAAb,CAAa,CAAC,CAAC;IAC3C,CAAC;IAED,oCAAiB,GAAjB;QACE,IAAI,CAAC,GAAG,EAAE,CAAC,OAAO,CAAC,UAAC,CAAC,IAAK,OAAA,CAAC,CAAC,cAAc,EAAE,EAAlB,CAAkB,CAAC,CAAC;IAChD,CAAC;IACH,eAAC;AAAD,CAAC,AA5CD,IA4CC"}

package/dist/src/channels/subscription-error.d.ts

@@ -0,0 +1,6 @@
+export type SubscriptionErrorType = 'AuthRequest' | 'SubcriptionAuthFailed';
+export default interface SubscriptionError {
+    type: SubscriptionErrorType;
+    code: number;
+    reason: string;
+}

package/dist/src/channels/subscription-error.js

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

package/dist/src/channels/subscription-error.js.map

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

package/dist/src/connection-manager.d.ts

@@ -0,0 +1,62 @@
+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 Environment from './environments/core/environment';
+import { KeepAliveOpts } from './keep-alive';
+import { WriteOptions } from './transport/transport';
+import Timeline from './timeline/timeline';
+import { InstanceUpdater } from './instance-updater';
+export interface ConnectionManagerOpts extends KeepAliveOpts {
+    environment: Environment;
+    timeline: Timeline;
+    instanceUpdater?: InstanceUpdater;
+    autoConnectEnabed?: boolean;
+}
+/**
+ * ConnectionManager responsibilities:
+ * - Auto reconnections on abrupt disconnections and environment state changes
+ * - Keep alive (in relevant transports only)
+ * - Network state changes (on online hints)
+ * - Dealing with TransportsManager
+ *
+ * Events:
+ * - "open" - on connection open, depends on result from TransportsManager#connect
+ * - "close" - passed through from TransportsManager
+ * - "connect_error" - passed through from TransportsManager
+ * - "message" - passed through from TransportsManager
+ */
+export default class ConnectionManager extends Emitter {
+    private readonly opts;
+    private keepAlive;
+    private autoConnect;
+    private readonly environment;
+    private readonly timeline;
+    private readonly autoConnectEnabled;
+    constructor(opts: ConnectionManagerOpts);
+    get sessionId(): string;
+    updatePayload(payload: PollPayloadProtocol): void;
+    send(packet: Protocol.Packet, opts?: WriteOptions): void;
+    close(): void;
+    get readyState(): import("./ready-state").default;
+    connect(): Promise<void>;
+    isClosed(): boolean;
+    private isOpen;
+    private get transport();
+    /**
+     * we reconnect in the following scenarios only:
+     *
+     * - unexpected close, due to command that errored out or any other unexpected
+     *   network error.
+     * - keep alive failed to return a pong during the defined timeout/timeframe.
+     * - sessions expired.
+     *
+     * note: invalid signed instance is currently an error we do not recover, it's a todo.
+     * basically we can recover it, because instance updater provided by the user should
+     * always return a valid signed instance, so we can retry multiple times.
+     */
+    private shouldReconnect;
+    private listenNeworkStateChanges;
+    private listenTransportEvents;
+    private dispose;
+    private maybeLogDisconnectionError;
+}