core-3nweb-client-lib 0.48.4 → 0.48.6

package/build/core/asmail/inbox/inbox-events.d.ts

@@ -1,7 +1,7 @@
 import { MailRecipient } from '../../../lib-client/asmail/recipient';
 import { Observable } from 'rxjs';
 import { LogError } from '../../../lib-client/logging/log-to-file';
-import { ConnectionStatus } from '../../../lib-common/ipc/ws-ipc';
+import type { ConnectionStatus } from '../../../lib-client/request-utils';
 type IncomingMessage = web3n.asmail.IncomingMessage;
 type InboxEventType = web3n.asmail.InboxEventType;
 type Observer<T> = web3n.Observer<T>;

package/build/core/asmail/inbox/inbox-events.js

@@ -57,9 +57,9 @@ class InboxEvents {
         Object.seal(this);
     }
     makeProc() {
-        const proc$ = (0, rxjs_1.from)(this.msgReceiver.openEventSource().then(({ client, heartbeat }) => {
+        const proc$ = (0, rxjs_1.from)(this.msgReceiver.openEventSource().then(({ client, watchHeartbeat }) => {
             const channel = retrieval_1.msgRecievedCompletely.EVENT_NAME;
-            heartbeat.subscribe({
+            watchHeartbeat({
                 next: ev => {
                     this.connectionEvents.next(toInboxConnectionStatus(ev));
                     if (ev.type === 'heartbeat') {

package/build/core/storage/synced/remote-events.d.ts

@@ -2,8 +2,8 @@ import { Observable } from 'rxjs';
 import { StorageOwner } from '../../../lib-client/3nstorage/storage-owner';
 import { ObjFiles } from './obj-files';
 import { Storage } from '../../../lib-client/xsp-fs/common';
-import { LogError } from '../../../lib-client/logging/log-to-file';
-import { ConnectionStatus } from '../../../lib-common/ipc/ws-ipc';
+import type { LogError } from '../../../lib-client/logging/log-to-file';
+import type { ConnectionStatus } from '../../../lib-client/request-utils';
 export interface StorageConnectionStatus extends ConnectionStatus {
     service: 'storage';
 }

package/build/core/storage/synced/remote-events.js

@@ -44,9 +44,9 @@ class RemoteEvents {
         Object.seal(this);
     }
     makeProc() {
-        return (0, rxjs_1.from)(this.remoteStorage.openEventSource().then(({ client, heartbeat }) => {
+        return (0, rxjs_1.from)(this.remoteStorage.openEventSource().then(({ client, watchHeartbeat }) => {
             this.remoteStorage.connectedState.setState();
-            heartbeat.subscribe({
+            watchHeartbeat({
                 next: ev => {
                     this.connectionEvents.next(toStorageConnectionStatus(ev));
                     if (ev.type === 'heartbeat') {

package/build/lib-client/3nstorage/storage-owner.d.ts

@@ -1,11 +1,12 @@
-import { NetClient } from '../request-utils';
+import { ConnectionStatus, NetClient } from '../request-utils';
 import * as api from '../../lib-common/service-api/3nstorage/owner';
 import { ServiceUser, IGetMailerIdSigner } from '../user-with-mid-session';
 import * as keyGen from '../key-derivation';
-import { makeSubscriber } from '../../lib-common/ipc/ws-ipc';
+import { SubscribingClient } from '../../lib-common/ipc/ws-ipc';
 import { ObjId } from '../xsp-fs/common';
 export type FirstSaveReqOpts = api.PutObjFirstQueryOpts;
 export type FollowingSaveReqOpts = api.PutObjSecondQueryOpts;
+type Observer<T> = web3n.Observer<T>;
 export declare class StorageOwner extends ServiceUser {
     maxChunkSize: number | undefined;
     private constructor();
@@ -86,5 +87,9 @@ export declare class StorageOwner extends ServiceUser {
      * @return a promise, resolvable, when an object is deleted.
      */
     deleteObj(objId: string): Promise<void>;
-    openEventSource(): Promise<ReturnType<typeof makeSubscriber>>;
+    openEventSource(): Promise<{
+        client: SubscribingClient;
+        watchHeartbeat: (obs: Observer<ConnectionStatus>) => (() => void);
+    }>;
 }
+export {};

package/build/lib-client/3nstorage/storage-owner.js

@@ -23,9 +23,9 @@ const user_with_mid_session_1 = require("../user-with-mid-session");
 const service_locator_1 = require("../service-locator");
 const keyGen = require("../key-derivation");
 const exceptions_1 = require("../xsp-fs/exceptions");
-const ws_ipc_1 = require("../../lib-common/ipc/ws-ipc");
 const assert_1 = require("../../lib-common/assert");
 const http_1 = require("../../lib-common/exceptions/http");
+const generic_ipc_1 = require("../../lib-common/ipc/generic-ipc");
 const storageAccessParams = {
     login: api.midLogin.MID_URL_PART,
     logout: api.closeSession.URL_END,
@@ -336,12 +336,14 @@ class StorageOwner extends user_with_mid_session_1.ServiceUser {
         }
     }
     async openEventSource() {
-        const rep = await this.openWS(api.wsEventChannel.URL_END);
+        const { rep, req } = await this.openEventSrc(api.wsEventChannel.URL_END);
         if (rep.status === api.wsEventChannel.SC.ok) {
-            return (0, ws_ipc_1.makeSubscriber)(rep.data, undefined);
+            const { comm, watch: watchHeartbeat } = rep.data;
+            const client = (0, generic_ipc_1.makeSubscribingClient)(undefined, comm);
+            return { client, watchHeartbeat };
         }
         else {
-            throw (0, http_1.makeUnexpectedStatusHTTPException)(rep);
+            throw (0, http_1.makeUnexpectedStatusHTTPException)({ url: req.url, method: req.method, status: rep.status });
         }
     }
 }

package/build/lib-client/asmail/recipient.d.ts

@@ -1,8 +1,9 @@
-import { NetClient } from '../request-utils';
+import { ConnectionStatus, NetClient } from '../request-utils';
 import * as api from '../../lib-common/service-api/asmail/retrieval';
 import { ServiceUser, IGetMailerIdSigner } from '../user-with-mid-session';
-import { makeSubscriber } from '../../lib-common/ipc/ws-ipc';
+import { SubscribingClient } from '../../lib-common/ipc/ws-ipc';
 type InboxException = web3n.asmail.InboxException;
+type Observer<T> = web3n.Observer<T>;
 export declare function makeMsgNotFoundException(msgId: string): InboxException;
 export declare function makeObjNotFoundException(msgId: string, objId: string): InboxException;
 export declare function makeMsgIsBrokenException(msgId: string): InboxException;
@@ -36,6 +37,9 @@ export declare class MailRecipient extends ServiceUser {
      */
     getObjSegs(msgId: string, objId: string, start: number, end: number): Promise<Uint8Array>;
     removeMsg(msgId: string): Promise<void>;
-    openEventSource(): Promise<ReturnType<typeof makeSubscriber>>;
+    openEventSource(): Promise<{
+        client: SubscribingClient;
+        watchHeartbeat: (obs: Observer<ConnectionStatus>) => (() => void);
+    }>;
 }
 export {};

package/build/lib-client/asmail/recipient.js

@@ -24,9 +24,9 @@ const request_utils_1 = require("../request-utils");
 const api = require("../../lib-common/service-api/asmail/retrieval");
 const user_with_mid_session_1 = require("../user-with-mid-session");
 const service_locator_1 = require("../service-locator");
-const ws_ipc_1 = require("../../lib-common/ipc/ws-ipc");
 const http_1 = require("../../lib-common/exceptions/http");
 const runtime_1 = require("../../lib-common/exceptions/runtime");
+const generic_ipc_1 = require("../../lib-common/ipc/generic-ipc");
 function makeMsgNotFoundException(msgId) {
     const exc = {
         runtimeException: true,
@@ -201,12 +201,14 @@ class MailRecipient extends user_with_mid_session_1.ServiceUser {
         }
     }
     async openEventSource() {
-        const rep = await this.openWS(api.wsEventChannel.URL_END);
+        const { rep, req } = await this.openEventSrc(api.wsEventChannel.URL_END);
         if (rep.status === api.wsEventChannel.SC.ok) {
-            return (0, ws_ipc_1.makeSubscriber)(rep.data, undefined);
+            const { comm, watch: watchHeartbeat } = rep.data;
+            const client = (0, generic_ipc_1.makeSubscribingClient)(undefined, comm);
+            return { client, watchHeartbeat };
         }
         else {
-            throw (0, http_1.makeUnexpectedStatusHTTPException)(rep);
+            throw (0, http_1.makeUnexpectedStatusHTTPException)({ url: req.url, method: req.method, status: rep.status });
         }
     }
 }

package/build/lib-client/request-utils.d.ts

@@ -1,6 +1,6 @@
 import type * as https from 'https';
-import type * as WebSocket from 'ws';
 import type { ClientRequest, OutgoingHttpHeaders } from 'http';
+import { Envelope, RawDuplex } from '../lib-common/ipc/generic-ipc';
 export declare const SESSION_ID_HEADER = "X-Session-Id";
 export declare const CONTENT_TYPE_HEADER = "Content-Type";
 export interface JSONHttpRequest extends XMLHttpRequest {
@@ -32,7 +32,15 @@ export type RequestFn<T> = (opts: RequestOpts, reqContentType?: ContentType, req
 export declare function processRequest<T>(requester: (opts: https.RequestOptions) => ClientRequest, httpsOpts: https.RequestOptions, opts: RequestOpts, reqBody: Uint8Array | undefined, attempt?: number): Promise<Reply<T>>;
 export declare function formHttpsReqOpts(opts: RequestOpts, reqContentType?: ContentType, reqBody?: Uint8Array): https.RequestOptions;
 export declare function extractIntHeader(rep: Reply<any>, headerName: string): number;
-export type OpenWebSocket = (url: string, sessionId: string) => Promise<Reply<WebSocket>>;
+export type OpenServiceEventsSource = (req: RequestOpts) => Promise<{
+    status: number;
+    data: ServiceEventsSource;
+}>;
+export interface ServiceEventsSource {
+    comm: RawDuplex<Envelope>;
+    watch: (obs: Observer<ConnectionStatus>) => (() => void);
+}
+type Observer<T> = web3n.Observer<T>;
 export interface NetClient {
     /**
      * This makes a 'Content-Type: application/json' request with given json,
@@ -55,6 +63,22 @@ export interface NetClient {
      */
     doBodylessRequest<T>(opts: RequestOpts): Promise<Reply<T>>;
     reset(): void;
-    openWebSocket: (url: string, sessionId: string) => Promise<Reply<WebSocket>>;
+    openEventSource: OpenServiceEventsSource;
+}
+export interface ConnectionStatus {
+    type: 'heartbeat' | 'heartbeat-skip' | 'disconnected' | 'connected';
+    url: string;
+    /**
+     * ping number is a number of millisecond between previous and current data receiving from server.
+     */
+    ping?: number;
+    /**
+     * This mirrors a "slow socket" exception, thrown to data sending process.
+     */
+    slowSocket?: true;
+    missingPongsFromServer?: number;
+    socketClosed?: true;
+    error?: any;
 }
-export declare function makeNetClient(request: RequestFn<unknown>, openWebSocket: NetClient['openWebSocket'], reset?: () => void): NetClient;
+export declare function makeNetClient(request: RequestFn<unknown>, openEventSource: OpenServiceEventsSource, reset?: () => void): NetClient;
+export {};

package/build/lib-client/request-utils.js

@@ -178,7 +178,7 @@ function extractIntHeader(rep, headerName) {
     }
     return intHeader;
 }
-function makeNetClient(request, openWebSocket, reset = () => { }) {
+function makeNetClient(request, openEventSource, reset = () => { }) {
     const client = {
         doBinaryRequest(opts, bytes) {
             let reqBody;
@@ -202,7 +202,7 @@ function makeNetClient(request, openWebSocket, reset = () => { }) {
             return request(opts, 'application/json', reqBody);
         },
         reset,
-        openWebSocket
+        openEventSource
     };
     return Object.freeze(client);
 }

package/build/lib-client/user-with-mid-session.d.ts

@@ -2,8 +2,7 @@
  * This defines a base class for some service's client that logs in with
  * MailerId and uses respectively authenticated session.
  */
-import { Reply, RequestOpts, NetClient } from '../lib-client/request-utils';
-import type * as WebSocket from 'ws';
+import { Reply, RequestOpts, NetClient, ServiceEventsSource } from '../lib-client/request-utils';
 import { MailerIdSigner } from '../lib-common/mailerid-sigs/user';
 import { AwaitableState } from '../lib-common/awaitable-state';
 export type IGetMailerIdSigner = () => Promise<MailerIdSigner>;
@@ -53,9 +52,15 @@ export declare abstract class ServiceUser {
      */
     logout(): Promise<void>;
     private callEnsuringLogin;
-    private prepCallOpts;
+    protected prepCallOpts(opts: RequestOpts, isWS?: true): RequestOpts;
     protected doBodylessSessionRequest<T>(opts: RequestOpts): Promise<Reply<T>>;
     protected doJsonSessionRequest<T>(opts: RequestOpts, json: any): Promise<Reply<T>>;
     protected doBinarySessionRequest<T>(opts: RequestOpts, bytes: Uint8Array | Uint8Array[]): Promise<Reply<T>>;
-    protected openWS(appPath: string): Promise<Reply<WebSocket>>;
+    protected openEventSrc(appPath: string): Promise<{
+        req: RequestOpts;
+        rep: {
+            status: number;
+            data: ServiceEventsSource;
+        };
+    }>;
 }

package/build/lib-client/user-with-mid-session.js

@@ -168,7 +168,7 @@ class ServiceUser {
                 reply = await func();
             }
             else {
-                // first attepmt
+                // first attempt
                 const initSessionId = this.sessionId;
                 const rep = await func();
                 if (rep.status !== api.ERR_SC.needAuth) {
@@ -201,6 +201,7 @@ class ServiceUser {
         else if (!opts.url) {
             throw new Error(`Missing both appPath and ready url in request options.`);
         }
+        return opts;
     }
     doBodylessSessionRequest(opts) {
         return this.callEnsuringLogin(() => {
@@ -220,15 +221,14 @@ class ServiceUser {
             return this.net.doBinaryRequest(opts, bytes);
         });
     }
-    openWS(appPath) {
-        const opts = {
-            appPath,
-            method: 'GET'
-        };
-        return this.callEnsuringLogin(() => {
-            this.prepCallOpts(opts, true);
-            return this.net.openWebSocket(opts.url, opts.sessionId);
+    async openEventSrc(appPath) {
+        let opts;
+        const rep = await this.callEnsuringLogin(async () => {
+            const reqOpts = this.prepCallOpts({ appPath, method: 'GET' }, true);
+            const rep = await this.net.openEventSource(reqOpts);
+            return rep;
         });
+        return { req: opts, rep };
     }
 }
 exports.ServiceUser = ServiceUser;

package/build/lib-client/xsp-fs/xsp-payload-v2.js

@@ -95,12 +95,9 @@ class ReadonlyPayloadV2 {
         if (start === end) {
             return undefined;
         }
-        const startSecInd = this.contentSections
-            .findIndex(s => (s.ofs <= start));
-        const endSecInd = this.contentSections
-            .findIndex(s => ((s.ofs + s.len) >= end));
-        (0, assert_1.assert)((startSecInd >= 0) && (endSecInd >= 0) &&
-            (startSecInd <= endSecInd));
+        const startSecInd = this.contentSections.findIndex(s => (s.ofs <= start));
+        const endSecInd = this.contentSections.findIndex(s => ((s.ofs + s.len) >= end));
+        (0, assert_1.assert)((startSecInd >= 0) && (endSecInd >= 0) && (startSecInd <= endSecInd));
         return await this.syncProc.startOrChain((startSecInd === endSecInd) ?
             async () => {
                 const s = this.contentSections[startSecInd];
@@ -790,8 +787,21 @@ function payloadLayoutException(msg, cause) {
 }
 async function sureReadOfBytesFrom(src, ofs, len) {
     const bytes = await src.readAt(ofs, len);
-    (0, assert_1.assert)(!!bytes && (bytes.length === len));
-    return bytes;
+    (0, assert_1.assert)(!!bytes);
+    if (bytes.length === len) {
+        return bytes;
+    }
+    // somehow, on Android src.readAt(ofs, len) may produce a thing that is shorter than len, hence, loop below
+    len -= bytes.length;
+    ofs += bytes.length;
+    const chunks = [bytes];
+    while (len > 0) {
+        const chunk = await src.readAt(ofs, len);
+        (0, assert_1.assert)(!!chunk);
+        len -= chunk.length;
+        ofs += chunk.length;
+    }
+    return (0, buffer_utils_1.joinByteArrs)(chunks);
 }
 function noop() { }
 // XXX we may add smaller bytes for packing section info: there is enough values

package/build/lib-common/ipc/ws-ipc.d.ts

@@ -1,7 +1,5 @@
 import { Observable } from 'rxjs';
-import { SubscribingClient } from './generic-ipc';
-import type * as WebSocket from 'ws';
-import type { ConnectException, HTTPException } from '../exceptions/http';
+import type { ConnectionStatus } from '../../lib-client/request-utils';
 export { RequestEnvelope, RequestHandler, EventfulServer, makeEventfulServer, SubscribingClient } from './generic-ipc';
 export interface WSException extends web3n.RuntimeException {
     type: 'websocket';
@@ -9,27 +7,7 @@ export interface WSException extends web3n.RuntimeException {
     socketClosed?: true;
 }
 export declare function makeWSException(params: Partial<WSException>, flags?: Partial<WSException>): WSException;
-export interface ConnectionStatus {
-    type: 'heartbeat' | 'heartbeat-skip' | 'disconnected' | 'connected';
-    url: string;
-    /**
-     * ping number is a number of millisecond between previous and current data receiving from server.
-     */
-    ping?: number;
-    /**
-     * This mirrors a "slow socket" exception, thrown to data sending process.
-     */
-    slowSocket?: true;
-    missingPongsFromServer?: number;
-    socketClosed?: true;
-    error?: any;
-}
-export declare function makeSubscriber(ws: WebSocket, ipcChannel: string | undefined): {
-    client: SubscribingClient;
-    heartbeat: Observable<ConnectionStatus>;
-};
 export declare function addToStatus<T extends ConnectionStatus>(status: ConnectionStatus, params: Partial<T>): T;
-export declare function shouldRestartWSAfterErr(exc: WSException | ConnectException | HTTPException): boolean;
 export declare class WebSocketListening {
     readonly restartWaitSecs: number;
     private readonly startWSProc;

package/build/lib-common/ipc/ws-ipc.js

@@ -18,138 +18,14 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.WebSocketListening = exports.makeEventfulServer = void 0;
 exports.makeWSException = makeWSException;
-exports.makeSubscriber = makeSubscriber;
 exports.addToStatus = addToStatus;
-exports.shouldRestartWSAfterErr = shouldRestartWSAfterErr;
-const rxjs_1 = require("rxjs");
 const runtime_1 = require("../exceptions/runtime");
-const generic_ipc_1 = require("./generic-ipc");
 const sleep_1 = require("../processes/sleep");
-var generic_ipc_2 = require("./generic-ipc");
-Object.defineProperty(exports, "makeEventfulServer", { enumerable: true, get: function () { return generic_ipc_2.makeEventfulServer; } });
+var generic_ipc_1 = require("./generic-ipc");
+Object.defineProperty(exports, "makeEventfulServer", { enumerable: true, get: function () { return generic_ipc_1.makeEventfulServer; } });
 function makeWSException(params, flags) {
     return (0, runtime_1.makeRuntimeException)('websocket', params, flags !== null && flags !== void 0 ? flags : {});
 }
-const MAX_TXT_BUFFER = 64 * 1024;
-const CLIENT_SIDE_PING_PERIOD = 10 * 1000;
-/**
- * This creates a json communication point on a given web socket.
- * Point may have many listeners, allowing for single parsing of incoming
- * messages.
- * @param ws
- */
-function makeJsonCommPoint(ws) {
-    const observers = new generic_ipc_1.MultiObserverWrap();
-    const { heartbeat, healthyBeat, otherBeat } = makeHeartbeat(ws.url);
-    let outstandingPongs = 0;
-    let closedByPingProc = false;
-    const pingRepeat = setInterval(() => {
-        if (outstandingPongs >= 2) {
-            ws.close();
-            closedByPingProc = true;
-            clearInterval(pingRepeat);
-            return;
-        }
-        if (outstandingPongs > 0) {
-            otherBeat('heartbeat-skip', { missingPongsFromServer: outstandingPongs });
-        }
-        ws.ping();
-        outstandingPongs += 1;
-    }, CLIENT_SIDE_PING_PERIOD);
-    ws.on('message', data => {
-        if (observers.done) {
-            return;
-        }
-        let env;
-        try {
-            env = JSON.parse(data.toString('utf8'));
-        }
-        catch (err) {
-            ws.close();
-            clearInterval(pingRepeat);
-            otherBeat('disconnected', err, true);
-            observers.error(err);
-            return;
-        }
-        observers.next(env);
-        healthyBeat();
-    });
-    ws.on('close', (code, reason) => {
-        clearInterval(pingRepeat);
-        if (code === 1000) {
-            otherBeat('disconnected', { socketClosed: true }, true);
-            observers.complete();
-        }
-        else {
-            otherBeat('disconnected', { error: { code, reason } }, true);
-            observers.error(makeWSException({
-                socketClosed: true,
-                cause: { code, reason }
-            }));
-        }
-    });
-    ws.on('error', (err) => {
-        otherBeat('disconnected', err, true);
-        observers.error(makeWSException({ cause: err }));
-        clearInterval(pingRepeat);
-        ws.close();
-    });
-    ws.on('ping', () => {
-        ws.pong();
-        healthyBeat();
-    });
-    ws.on('pong', () => {
-        healthyBeat();
-        outstandingPongs = 0;
-    });
-    const comm = {
-        subscribe: obs => observers.add(obs),
-        postMessage(env) {
-            if (ws.bufferedAmount > MAX_TXT_BUFFER) {
-                otherBeat('heartbeat', { slowSocket: true });
-                throw makeWSException({ socketSlow: true });
-            }
-            ws.send(JSON.stringify(env));
-        }
-    };
-    otherBeat('connected', {});
-    return { comm, heartbeat };
-}
-function makeHeartbeat(url) {
-    const status = new rxjs_1.Subject();
-    let lastInfo = Date.now();
-    function healthyBeat() {
-        const now = Date.now();
-        status.next({
-            type: 'heartbeat',
-            url,
-            ping: now - lastInfo
-        });
-        lastInfo = now;
-    }
-    function otherBeat(type, params, end = false) {
-        status.next({
-            type,
-            url,
-            ...params
-        });
-        if (end) {
-            status.complete();
-        }
-    }
-    return {
-        heartbeat: status.asObservable().pipe((0, rxjs_1.share)()),
-        healthyBeat,
-        otherBeat
-    };
-}
-function makeSubscriber(ws, ipcChannel) {
-    const { comm, heartbeat } = makeJsonCommPoint(ws);
-    return {
-        client: (0, generic_ipc_1.makeSubscribingClient)(ipcChannel, comm),
-        heartbeat
-    };
-}
 function addToStatus(status, params) {
     for (const [field, value] of Object.entries(params)) {
         status[field] = value;

package/build/lib-common-on-node/websocket-from-node.d.ts

@@ -1,3 +1,11 @@
-import * as WebSocket from 'ws';
-import { Reply } from '../lib-client/request-utils';
-export declare function openSocketFromNode(url: string, sessionId: string): Promise<Reply<WebSocket>>;
+import { ConnectionStatus, RequestOpts } from '../lib-client/request-utils';
+import { type Envelope, type RawDuplex } from '../lib-common/ipc/generic-ipc';
+type Observer<T> = web3n.Observer<T>;
+export declare function openServiceEventsSrcFromNode(req: RequestOpts): Promise<{
+    status: number;
+    data: {
+        comm: RawDuplex<Envelope>;
+        watch: (obs: Observer<ConnectionStatus>) => (() => void);
+    };
+}>;
+export {};

package/build/lib-common-on-node/websocket-from-node.js

@@ -16,12 +16,146 @@
  this program. If not, see <http://www.gnu.org/licenses/>.
 */
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.openSocketFromNode = openSocketFromNode;
+exports.openServiceEventsSrcFromNode = openServiceEventsSrcFromNode;
 const WebSocket = require("ws");
 const request_utils_1 = require("../lib-client/request-utils");
 const deferred_1 = require("../lib-common/processes/deferred");
 const http_1 = require("../lib-common/exceptions/http");
 const https_1 = require("https");
+const generic_ipc_1 = require("../lib-common/ipc/generic-ipc");
+const ws_ipc_1 = require("../lib-common/ipc/ws-ipc");
+const rxjs_1 = require("rxjs");
+async function openServiceEventsSrcFromNode(req) {
+    const { url, sessionId } = req;
+    const rep = await openSocketFromNode(url, sessionId);
+    if (rep.status !== 200) {
+        return rep;
+    }
+    const { comm, heartbeat } = makeJsonCommPoint(rep.data);
+    return {
+        status: rep.status,
+        data: {
+            comm,
+            watch: obs => {
+                const sub = heartbeat.subscribe(obs);
+                return () => sub.unsubscribe();
+            }
+        }
+    };
+}
+const MAX_TXT_BUFFER = 64 * 1024;
+const CLIENT_SIDE_PING_PERIOD = 10 * 1000;
+/**
+ * This creates a json communication point on a given web socket.
+ * Point may have many listeners, allowing for single parsing of incoming
+ * messages.
+ * @param ws
+ */
+function makeJsonCommPoint(ws) {
+    const observers = new generic_ipc_1.MultiObserverWrap();
+    const { heartbeat, healthyBeat, otherBeat } = makeHeartbeat(ws.url);
+    let outstandingPongs = 0;
+    let closedByPingProc = false;
+    const pingRepeat = setInterval(() => {
+        if (outstandingPongs >= 2) {
+            ws.close();
+            closedByPingProc = true;
+            clearInterval(pingRepeat);
+            return;
+        }
+        if (outstandingPongs > 0) {
+            otherBeat('heartbeat-skip', { missingPongsFromServer: outstandingPongs });
+        }
+        ws.ping();
+        outstandingPongs += 1;
+    }, CLIENT_SIDE_PING_PERIOD);
+    ws.on('message', data => {
+        if (observers.done) {
+            return;
+        }
+        let env;
+        try {
+            env = JSON.parse(data.toString('utf8'));
+        }
+        catch (err) {
+            ws.close();
+            clearInterval(pingRepeat);
+            otherBeat('disconnected', err, true);
+            observers.error(err);
+            return;
+        }
+        observers.next(env);
+        healthyBeat();
+    });
+    ws.on('close', (code, reason) => {
+        clearInterval(pingRepeat);
+        if (code === 1000) {
+            otherBeat('disconnected', { socketClosed: true }, true);
+            observers.complete();
+        }
+        else {
+            otherBeat('disconnected', { error: { code, reason } }, true);
+            observers.error((0, ws_ipc_1.makeWSException)({
+                socketClosed: true,
+                cause: { code, reason }
+            }));
+        }
+    });
+    ws.on('error', (err) => {
+        otherBeat('disconnected', err, true);
+        observers.error((0, ws_ipc_1.makeWSException)({ cause: err }));
+        clearInterval(pingRepeat);
+        ws.close();
+    });
+    ws.on('ping', () => {
+        ws.pong();
+        healthyBeat();
+    });
+    ws.on('pong', () => {
+        healthyBeat();
+        outstandingPongs = 0;
+    });
+    const comm = {
+        subscribe: obs => observers.add(obs),
+        postMessage(env) {
+            if (ws.bufferedAmount > MAX_TXT_BUFFER) {
+                otherBeat('heartbeat', { slowSocket: true });
+                throw (0, ws_ipc_1.makeWSException)({ socketSlow: true });
+            }
+            ws.send(JSON.stringify(env));
+        }
+    };
+    otherBeat('connected', {});
+    return { comm, heartbeat };
+}
+function makeHeartbeat(url) {
+    const status = new rxjs_1.Subject();
+    let lastInfo = Date.now();
+    function healthyBeat() {
+        const now = Date.now();
+        status.next({
+            type: 'heartbeat',
+            url,
+            ping: now - lastInfo
+        });
+        lastInfo = now;
+    }
+    function otherBeat(type, params, end = false) {
+        status.next({
+            type,
+            url,
+            ...params
+        });
+        if (end) {
+            status.complete();
+        }
+    }
+    return {
+        heartbeat: status.asObservable().pipe((0, rxjs_1.share)()),
+        healthyBeat,
+        otherBeat
+    };
+}
 function openSocketFromNode(url, sessionId) {
     if (!url.startsWith('wss://')) {
         throw new Error(`Url protocol must be wss`);

package/build/tests/libs-for-tests/core-runner.js

@@ -82,7 +82,7 @@ class CoreRunner {
             this.appCaps.close();
             this.appCaps = undefined;
         }
-        this.runningCore = lib_index_1.Core.make({ dataDir: this.dataFolder, signUpUrl: this.signUpUrl }, () => (0, lib_index_1.makeNetClient)((0, request_from_node_1.makeRequestFromNode)(), websocket_from_node_1.openSocketFromNode), (0, service_locator_1.makeServiceLocator)({
+        this.runningCore = lib_index_1.Core.make({ dataDir: this.dataFolder, signUpUrl: this.signUpUrl }, () => (0, lib_index_1.makeNetClient)((0, request_from_node_1.makeRequestFromNode)(), websocket_from_node_1.openServiceEventsSrcFromNode), (0, service_locator_1.makeServiceLocator)({
             resolveTxt: domain => new Promise((resolve, reject) => (0, dns_1.resolveTxt)(domain, (err, texts) => {
                 if (err) {
                     reject(err);

package/build/tests/libs-for-tests/setups.js

@@ -262,7 +262,7 @@ function domainFromUserId(userId) {
 function serviceWithMailerIdLogin() {
     const testSrv = (new URL(SIGNUP_URL)).host;
     const serviceUrl = `https://${testSrv}/asmail/retrieval/login/mailerid`;
-    const net = (0, request_utils_1.makeNetClient)((0, request_from_node_1.makeRequestFromNode)(), websocket_from_node_1.openSocketFromNode);
+    const net = (0, request_utils_1.makeNetClient)((0, request_from_node_1.makeRequestFromNode)(), websocket_from_node_1.openServiceEventsSrcFromNode);
     async function isSessionValid(sessionId) {
         const rep = await net.doBodylessRequest({
             url: `https://${testSrv}/asmail/retrieval/${retrieval_1.listMsgs.genUrlEnd()}`,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "core-3nweb-client-lib",
-  "version": "0.48.4",
+  "version": "0.48.6",
   "description": "3NWeb client core library, embeddable into different environments",
   "main": "build/lib-index.js",
   "types": "build/lib-index.d.ts",