@genesislcap/foundation-comms 14.167.3-alpha-69ba23f.0 → 14.168.0

package/dist/esm/connect/connect.events.js

@@ -0,0 +1,113 @@
+import { createObserver } from '@genesislcap/foundation-utils';
+import { DI } from '@microsoft/fast-foundation';
+/**
+ * @public
+ */
+export const CommitEventType = 'connect-commit-event';
+/**
+ * @public
+ */
+export const StreamEventType = 'connect-stream-event';
+/**
+ * @public
+ */
+export const StreamCompleteEventType = 'connect-stream-complete-event';
+/**
+ * @public
+ */
+export const MetadataEventType = 'connect-metadata-event';
+/**
+ * Default ConnectEvents implementation.
+ * @public
+ */
+export class DefaultConnectEvents {
+    constructor() {
+        /** @internal */
+        this.streamListeners = createObserver();
+        /** @internal */
+        this.streamCompleteListeners = createObserver();
+        /** @internal */
+        this.commitListeners = createObserver();
+        /** @internal */
+        this.metadataListeners = createObserver();
+    }
+    /** {@inheritDoc ConnectEvents.addStreamListener} */
+    addStreamListener(listener, complete) {
+        var _a, _b;
+        const unsubscribe = (_a = this.streamListeners) === null || _a === void 0 ? void 0 : _a.subscribe(listener);
+        const completeUnsubscribe = (_b = this.streamCompleteListeners) === null || _b === void 0 ? void 0 : _b.subscribe(complete);
+        return () => {
+            unsubscribe();
+            completeUnsubscribe();
+        };
+    }
+    /** {@inheritDoc ConnectEventsEmitter.onStreamEvent} */
+    onStreamEvent(resourceName, message, stream, functions) {
+        var _a;
+        (_a = this.streamListeners) === null || _a === void 0 ? void 0 : _a.publish(new CustomEvent(StreamEventType, {
+            detail: {
+                functions,
+                message,
+                resourceName,
+                stream,
+            },
+        }));
+    }
+    /** {@inheritDoc ConnectEventsEmitter.onStreamCompleteEvent} */
+    onStreamCompleteEvent(stream) {
+        var _a;
+        (_a = this.streamCompleteListeners) === null || _a === void 0 ? void 0 : _a.publish(new CustomEvent(StreamCompleteEventType, {
+            detail: stream,
+        }));
+    }
+    /** {@inheritDoc ConnectEvents.addCommitListener} */
+    addCommitListener(listener) {
+        var _a;
+        return (_a = this.commitListeners) === null || _a === void 0 ? void 0 : _a.subscribe(listener);
+    }
+    /** {@inheritDoc ConnectEventsEmitter.onStreamEvent} */
+    onCommitEvent(eventName, message) {
+        var _a;
+        (_a = this.commitListeners) === null || _a === void 0 ? void 0 : _a.publish(new CustomEvent(CommitEventType, {
+            detail: {
+                eventName,
+                message,
+            },
+        }));
+    }
+    /** {@inheritDoc ConnectEvents.addMetadataListener} */
+    addMetadataListener(listener) {
+        var _a;
+        return (_a = this.metadataListeners) === null || _a === void 0 ? void 0 : _a.subscribe(listener);
+    }
+    /** {@inheritDoc ConnectEventsEmitter.onMetadataEvent} */
+    onMetadataEvent(resourceName, message, error) {
+        var _a;
+        (_a = this.metadataListeners) === null || _a === void 0 ? void 0 : _a.publish(new CustomEvent(MetadataEventType, {
+            detail: {
+                resourceName,
+                message,
+                error,
+            },
+        }));
+    }
+}
+/**
+ * ConnectEvents DI key.
+ *
+ * @privateRemarks
+ * Marked as internal to stop api-extractor becoming confused cross-linking tokens with the same name.
+ *
+ * @internal
+ */
+export const ConnectEvents = DI.createInterface((x) => x.singleton(DefaultConnectEvents));
+/**
+ * ConnectEventsEmitter DI key.
+ *
+ * @privateRemarks
+ * ConnectEventsEmitter is used by Connect.
+ * Marked as internal to stop api-extractor becoming confused cross-linking tokens with the same name.
+ *
+ * @internal
+ */
+export const ConnectEventsEmitter = DI.createInterface((x) => x.aliasTo(ConnectEvents));

package/dist/esm/connect/connect.js

@@ -4,6 +4,7 @@ import { observable, volatile } from '@microsoft/fast-element';
 import { DI, optional } from '@microsoft/fast-foundation';
 import { MetaCache } from '../metadata';
 import { isWebSocketExpression, logger } from '../utils';
+import { ConnectEventsEmitter } from './connect.events';
 import { ConnectConfig } from './connect.types';
 import { HttpConnect } from './http.connect';
 import { EventMessageType, MessageBuilder } from './message';
@@ -41,10 +42,11 @@ let DefaultConnect = class DefaultConnect {
         var _a;
         return (_a = this.socket.isConnectedSubject) === null || _a === void 0 ? void 0 : _a.asObservable();
     }
-    constructor(socket, messageBuilder, metaCache, config = defaultConnectConfig) {
+    constructor(socket, messageBuilder, metaCache, events, config = defaultConnectConfig) {
         this.socket = socket;
         this.messageBuilder = messageBuilder;
         this.metaCache = metaCache;
+        this.events = events;
         this.config = config;
         this.isWorking = false;
     }
@@ -79,9 +81,16 @@ let DefaultConnect = class DefaultConnect {
         });
     }
     stream(resourceName, onMessage, onError, params) {
-        const streamMessage = this.messageBuilder.createDataLogonMessage(resourceName, params);
-        logger.debug(`${streamMessage.MESSAGE_TYPE} (stream) message created -> `, streamMessage);
-        return this.socket.sendForStream(streamMessage, onMessage, onError);
+        const msg = this.messageBuilder.createDataLogonMessage(resourceName, params);
+        logger.debug(`${msg.MESSAGE_TYPE} (stream) message created -> `, msg);
+        const resource = this.socket.sendForStream(msg, onMessage, onError, () => {
+            this.events.onStreamCompleteEvent(resource);
+        });
+        this.events.onStreamEvent(resourceName, msg, resource, {
+            onMessage,
+            onError,
+        });
+        return resource;
     }
     getMoreRows(sourceRef) {
         return __awaiter(this, void 0, void 0, function* () {
@@ -90,6 +99,12 @@ let DefaultConnect = class DefaultConnect {
             return this.socket.send(moreRowsMessage, false);
         });
     }
+    getMoreColumns(sourceRef) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const message = this.messageBuilder.createMoreColumnsMessage(sourceRef);
+            return this.socket.send(message);
+        });
+    }
     dataLogoff(streamSourceRef) {
         return __awaiter(this, void 0, void 0, function* () {
             const dataLogoffMessage = this.messageBuilder.createDataLogoffMessage(streamSourceRef);
@@ -109,6 +124,7 @@ let DefaultConnect = class DefaultConnect {
             const metaRequestMessage = this.messageBuilder.createMetaRequestMessage(resourceName);
             logger.debug(`${metaRequestMessage.MESSAGE_TYPE} (metadata) message created -> `, metaRequestMessage);
             let details;
+            let error;
             try {
                 this.isWorking = true;
                 const metaResponse = yield this.socket.send(metaRequestMessage);
@@ -118,9 +134,12 @@ let DefaultConnect = class DefaultConnect {
                 }
             }
             catch (e) {
+                error = e;
                 logger.error(e);
+                throw error;
             }
             finally {
+                this.events.onMetadataEvent(resourceName, metaRequestMessage, error);
                 this.isWorking = false;
             }
             return details;
@@ -166,9 +185,11 @@ let DefaultConnect = class DefaultConnect {
     }
     commitEvent(eventName, params) {
         return __awaiter(this, void 0, void 0, function* () {
-            const commitMessage = this.messageBuilder.createCommitMessage(eventName, params);
-            logger.debug(`${commitMessage.MESSAGE_TYPE} (commit) message created -> `, commitMessage);
-            return this.socket.send(commitMessage);
+            const msg = this.messageBuilder.createCommitMessage(eventName, params);
+            logger.debug(`${msg.MESSAGE_TYPE} (commit) message created -> `, msg);
+            const promise = this.socket.send(msg);
+            this.events.onCommitEvent(eventName, msg);
+            return promise;
         });
     }
 };
@@ -182,7 +203,8 @@ DefaultConnect = __decorate([
     __param(0, Socket),
     __param(1, MessageBuilder),
     __param(2, MetaCache),
-    __param(3, optional(ConnectConfig))
+    __param(3, ConnectEventsEmitter),
+    __param(4, optional(ConnectConfig))
 ], DefaultConnect);
 export { DefaultConnect };
 const useHttpConnect = FORCE_HTTP === 'true' || false;

package/dist/esm/connect/http.connect.js

@@ -162,6 +162,12 @@ let DefaultHttpConnect = class DefaultHttpConnect {
             return this.send(moreRowsMessage);
         });
     }
+    getMoreColumns(sourceRef) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const message = this.messageBuilder.createMoreColumnsMessage(sourceRef);
+            return this.send(message);
+        });
+    }
     dataLogoff(streamSourceRef) {
         return __awaiter(this, void 0, void 0, function* () {
             const dataLogoffMessage = this.messageBuilder.createDataLogoffMessage(streamSourceRef);

package/dist/esm/connect/index.js

@@ -1,8 +1,10 @@
+export * from './connect.events';
 export * from './connect';
 export * from './connect.types';
 export * from './http.connect';
 export * from './http';
 export * from './message';
 export * from './serializers';
+export * from './socket.status';
 export * from './socket';
 export * from './reconnectStrategy';

package/dist/esm/connect/message.js

@@ -16,6 +16,8 @@ export var MessageType;
     MessageType["HEARTBEAT_PING"] = "HEARTBEAT_PING";
     MessageType["HEARTBEAT_PONG"] = "HEARTBEAT_PONG";
     MessageType["MORE_ROWS"] = "MORE_ROWS";
+    MessageType["MORE_COLUMNS"] = "MORE_COLUMNS";
+    MessageType["MORE_COLUMNS_ACK"] = "MORE_COLUMNS_ACK";
     MessageType["MSG_ACK"] = "MSG_ACK";
     MessageType["MSG_NACK"] = "MSG_NACK";
     MessageType["LOGOUT_ACK"] = "LOGOUT_ACK";
@@ -62,10 +64,25 @@ export const messageOrThrow = (message) => {
     }
     return message;
 };
+/**
+ * Check if the message contains an error code.
+ * @param message - The message object.
+ * @param code - The error code.
+ * @public
+ */
+export const messageHasErrorCode = (message, code) => {
+    return Array.isArray(message === null || message === void 0 ? void 0 : message.ERROR)
+        ? message === null || message === void 0 ? void 0 : message.ERROR.some((error) => error.CODE === code)
+        : false;
+};
 /**
  * TODO: Abstract out localStorage interaction with shell io stuff
  */
-let MessageBuilderService = class MessageBuilderService {
+/**
+ * Default MessageBuilder implementation.
+ * @public
+ */
+let DefaultMessageBuilder = class DefaultMessageBuilder {
     /**
      * UUID will be created in the DI with the App specific requirements.
      * Keeping it encapsulated means messages will always conform.
@@ -207,6 +224,9 @@ let MessageBuilderService = class MessageBuilderService {
             SESSION_AUTH_TOKEN: this.session.getSessionStorageItem('authToken'),
         };
     }
+    createMoreColumnsMessage(sourceRef) {
+        return Object.assign(Object.assign({}, this.createMoreRowsMessage(sourceRef)), { MESSAGE_TYPE: MessageType.MORE_COLUMNS });
+    }
     createHTTPHeadersFromMessage(message, contentType = 'application/json; charset=UTF-8') {
         const headers = { 'Content-type': contentType };
         if (message.SOURCE_REF) {
@@ -222,12 +242,13 @@ let MessageBuilderService = class MessageBuilderService {
         return headers;
     }
 };
-MessageBuilderService = __decorate([
+DefaultMessageBuilder = __decorate([
     __param(0, Session),
     __param(1, UUID)
-], MessageBuilderService);
+], DefaultMessageBuilder);
+export { DefaultMessageBuilder };
 /**
  * The DI token for the MessageBUilder interface.
  * @internal
  */
-export const MessageBuilder = DI.createInterface((x) => x.singleton(MessageBuilderService));
+export const MessageBuilder = DI.createInterface((x) => x.singleton(DefaultMessageBuilder));

package/dist/esm/connect/socket.js

@@ -3,13 +3,14 @@ import { UUID } from '@genesislcap/foundation-utils';
 import { JSONSerializer } from '@genesislcap/foundation-utils';
 import { observable } from '@microsoft/fast-element';
 import { DI } from '@microsoft/fast-foundation';
-import { BehaviorSubject, from, Observable, of, Subject, Subscription, throwError, } from 'rxjs';
+import { Observable, of, Subject, Subscription, takeUntil, throwError } from 'rxjs';
 import { filter, mergeMap, switchMap, takeWhile } from 'rxjs/operators';
 import { WebSocketSubject } from 'rxjs/webSocket';
 import { Session } from '../session';
 import { logger } from '../utils';
 import { EventMessageType, MessageBuilder, MessageType } from './message';
 import { exponentialScheduler, linearScheduler, MAX_RECONNECT_ATTEMPTS, retryInterval, SocketReconnectStrategy, } from './reconnectStrategy';
+import { SocketStatus } from './socket.status';
 import { Ticker } from './ticker';
 /**
  * Subject that wraps a WebSocketSubject and provides a Subject interface for sending and receiving messages.
@@ -76,23 +77,48 @@ export class SocketMessageHandler {
         return this._isSubscription;
     }
 }
-let SocketService = class SocketService {
-    isConnectedChanged(_, isConnected) {
-        this.isConnectedSubject.next(isConnected);
+/**
+ * Default Socket implementation.
+ * @public
+ */
+let DefaultSocket = class DefaultSocket {
+    get isConfigured() {
+        return this.status.isConfigured;
+    }
+    get isConnecting() {
+        return this.status.isConnecting;
+    }
+    get isConnected() {
+        return this.status.isConnected;
+    }
+    get isConnectedSubject() {
+        return this.status.isConnectedSubject;
+    }
+    get isDisconnected() {
+        return this.status.isDisconnected;
+    }
+    get isDisconnectedByServer() {
+        return this.status.isDisconnectedByServer;
+    }
+    get isReconnecting() {
+        return this.status.isReconnecting;
     }
-    constructor(messageBuilder, session, serializer, uuid) {
+    get hasValidSession() {
+        return this.status.hasValidSession;
+    }
+    set hasValidSession(value) {
+        this.status.hasValidSession = value;
+    }
+    constructor(messageBuilder, session, serializer, uuid, status) {
         this.messageBuilder = messageBuilder;
         this.session = session;
         this.serializer = serializer;
         this.uuid = uuid;
+        this.status = status;
         this.defaultInterval = 10000;
         this.secondsMultiplier = 1000;
-        this.isConnectedSubject = new BehaviorSubject(false);
-        this.isConnected = false;
-        this.hasValidSession = false;
         this.heartbeatIsEnabled = true;
         this.heartbeatInterval = this.defaultInterval;
-        this.isReconnecting = false;
         this.socketMessages = () => this.wsMessages;
     }
     get heartbeatLoggingIsEnabled() {
@@ -110,6 +136,7 @@ let SocketService = class SocketService {
         return new Promise((resolve) => {
             var _a, _b, _c, _d;
             logger.info(`${this.isReconnecting ? 'Reconnecting' : 'Connecting'} to ${this.url}`);
+            this.status.isConnecting = !this.isReconnecting;
             const cleanMessages = !this.isReconnecting || !((_a = this.reconnectOptions) === null || _a === void 0 ? void 0 : _a.reconnectStreams);
             if (cleanMessages) {
                 this.cleanMessages();
@@ -120,7 +147,7 @@ let SocketService = class SocketService {
                 openObserver: {
                     next: () => {
                         this.session.setSessionStorageItem('hostUrl', this.url);
-                        this.isConnected = true;
+                        this.status.isConnected = true;
                         this.prepareHeartbeat();
                         logger.info(`WebSocket connection is now open`);
                         resolve(this.isConnected);
@@ -128,9 +155,8 @@ let SocketService = class SocketService {
                 },
                 closeObserver: {
                     next: (closeEvent) => {
-                        this.disconnectedByServer = !closeEvent.wasClean;
-                        this.isConnected = false;
-                        if (this.disconnectedByServer) {
+                        this.status.onClose(closeEvent);
+                        if (this.isDisconnectedByServer) {
                             logger.info(`WebSocket connection was closed due an error - Code: ${closeEvent.code} ${closeEvent.reason ? ' | Reason: ' + closeEvent.reason : ''}`);
                         }
                         resolve(this.isConnected);
@@ -196,8 +222,7 @@ let SocketService = class SocketService {
                     }
                     case MessageType.QUERY_UPDATE: {
                         if (!messageHandler.isSubscription) {
-                            const dataLogoffMessage = this.messageBuilder.createDataLogoffMessage(SOURCE_REF);
-                            this.send(dataLogoffMessage);
+                            this.sendDataLogoff(SOURCE_REF);
                         }
                         break;
                     }
@@ -227,7 +252,7 @@ let SocketService = class SocketService {
             };
             const onComplete = () => {
                 var _a;
-                if (this.disconnectedByServer && ((_a = this.connectOptions) === null || _a === void 0 ? void 0 : _a.alwaysOn)) {
+                if (this.isDisconnectedByServer && ((_a = this.connectOptions) === null || _a === void 0 ? void 0 : _a.alwaysOn)) {
                     this.reconnect();
                     return;
                 }
@@ -238,6 +263,7 @@ let SocketService = class SocketService {
                 error: onError,
                 complete: onComplete,
             });
+            this.status.isConfigured = true;
         });
     }
     prepareHeartbeat() {
@@ -275,7 +301,7 @@ let SocketService = class SocketService {
         if (this.isReconnecting || notAlwaysOnAndHeartbeating) {
             return;
         }
-        this.isReconnecting = true;
+        this.status.isReconnecting = true;
         const scheduler = ((_c = this.reconnectOptions) === null || _c === void 0 ? void 0 : _c.reconnectStrategy) === SocketReconnectStrategy.Exponential
             ? exponentialScheduler
             : linearScheduler;
@@ -293,6 +319,7 @@ let SocketService = class SocketService {
                 if (value < attemptsAmount) {
                     return of(value);
                 }
+                this.status.reconnectionLimitReached = true;
                 return throwError(() => new Error(`Max reconnect attempts ${attemptsAmount} reached.`));
             }))
             : of(-1)), takeWhile(() => this.websocket && !this.isConnected));
@@ -306,11 +333,11 @@ let SocketService = class SocketService {
                 var _a;
                 logger.debug(error);
                 (_a = this.socketSubscription) === null || _a === void 0 ? void 0 : _a.unsubscribe();
-                this.isReconnecting = false;
+                this.status.isReconnecting = false;
             },
             complete: () => {
                 logger.info(this.isConnected ? 'Reconnected' : 'Disconnected');
-                this.isReconnecting = false;
+                this.status.isReconnecting = false;
                 this.wsMessageHandlers.forEach((mh) => {
                     if (mh.isSubscription) {
                         this.websocket.next(mh.sentMessage);
@@ -320,7 +347,8 @@ let SocketService = class SocketService {
         });
     }
     reset() {
-        this.isConnected = false;
+        this.status.isConnected = false;
+        this.status.isConfigured = false;
         this.websocket && this.websocket.complete();
         this.websocket = null;
         this.cleanMessages();
@@ -332,8 +360,7 @@ let SocketService = class SocketService {
     }
     send(message, needsHandling = true) {
         if (!this.isConnected) {
-            Promise.reject(new Error('WebSocket connection is closed'));
-            return;
+            return Promise.reject(new Error('WebSocket connection is closed'));
         }
         const sendingMessasgeLog = `Sending Message for SourceRef: ${message.SOURCE_REF} | MessageType: ${message.MESSAGE_TYPE}`;
         this.logMessageTypeFlow(message.MESSAGE_TYPE, logger.info, sendingMessasgeLog);
@@ -350,7 +377,7 @@ let SocketService = class SocketService {
             this.websocket.next(message);
         });
     }
-    sendForStream(message, onMessage, onError) {
+    sendForStream(message, onMessage, onError, onComplete) {
         if (!this.isConnected) {
             return throwError(() => new Error('WebSocket connection is closed'));
         }
@@ -361,13 +388,44 @@ let SocketService = class SocketService {
         this.logMessageTypeFlow(message.MESSAGE_TYPE, logger.info, sendingMessageLog);
         this.setMessageHandler(message, onMessage, onError, true);
         this.websocket.next(message);
-        return from(this.wsMessages.pipe(filter((msg) => msg.SOURCE_REF === message.SOURCE_REF)));
+        /**
+         * @privateRemarks
+         * Running the data logoff from here makes more sense given the network monitor actor is optionally added.
+         */
+        return new Observable((subscriber) => {
+            const destroyNotifier = new Subject();
+            this.wsMessages
+                .pipe(filter((msg) => msg.SOURCE_REF === message.SOURCE_REF), takeUntil(destroyNotifier))
+                .subscribe({
+                next: (value) => {
+                    subscriber.next(value);
+                },
+                error: (err) => {
+                    subscriber.error(err);
+                },
+                complete: () => {
+                    subscriber.complete();
+                },
+            });
+            return () => {
+                destroyNotifier.complete();
+                this.sendDataLogoff(message.SOURCE_REF);
+                this.removeMessageHandler(message.SOURCE_REF);
+                onComplete && onComplete();
+            };
+        });
     }
     setMessageHandler(message, onMessage, onError, isSubscription = false) {
         const settingMessageHandlerLog = `Setting Message Handler for SourceRef: ${message.SOURCE_REF} | MessageType: ${message.MESSAGE_TYPE}`;
         this.logMessageTypeFlow(message.MESSAGE_TYPE, logger.debug, settingMessageHandlerLog);
         this.wsMessageHandlers.set(message.SOURCE_REF, new SocketMessageHandler(message, onMessage, onError, isSubscription));
     }
+    sendDataLogoff(sourceRef) {
+        if (!this.hasValidSession) {
+            return;
+        }
+        this.send(this.messageBuilder.createDataLogoffMessage(sourceRef), false);
+    }
     removeMessageHandler(sourceRef) {
         this.wsMessageHandlers.delete(sourceRef);
     }
@@ -378,6 +436,9 @@ let SocketService = class SocketService {
     }
     logMessageTypeFlow(messageType, logFunc, logMsg) {
         switch (messageType) {
+            case EventMessageType.DATA_LOGOFF:
+                logFunc(logMsg);
+                break;
             case MessageType.HEARTBEAT_PING:
             case MessageType.HEARTBEAT_PONG:
                 if (this.heartbeatLoggingIsEnabled) {
@@ -394,36 +455,44 @@ let SocketService = class SocketService {
 };
 __decorate([
     observable
-], SocketService.prototype, "websocket", void 0);
-__decorate([
-    observable
-], SocketService.prototype, "wsMessages", void 0);
-__decorate([
-    observable
-], SocketService.prototype, "wsMessageHandlers", void 0);
+], DefaultSocket.prototype, "websocket", void 0);
 __decorate([
     observable
-], SocketService.prototype, "isConnected", void 0);
+], DefaultSocket.prototype, "wsMessages", void 0);
 __decorate([
     observable
-], SocketService.prototype, "disconnectedByServer", void 0);
+], DefaultSocket.prototype, "wsMessageHandlers", void 0);
 __decorate([
     observable
-], SocketService.prototype, "hasValidSession", void 0);
-__decorate([
-    observable
-], SocketService.prototype, "heartbeatIsEnabled", void 0);
-__decorate([
-    observable
-], SocketService.prototype, "isReconnecting", void 0);
-SocketService = __decorate([
+], DefaultSocket.prototype, "heartbeatIsEnabled", void 0);
+DefaultSocket = __decorate([
     __param(0, MessageBuilder),
     __param(1, Session),
     __param(2, JSONSerializer),
-    __param(3, UUID)
-], SocketService);
+    __param(3, UUID),
+    __param(4, SocketStatus)
+], DefaultSocket);
+export { DefaultSocket };
 /**
  * The DI token for the Socket interface.
  * @internal
  */
-export const Socket = DI.createInterface((x) => x.singleton(SocketService));
+export const Socket = DI.createInterface((x) => x.singleton(DefaultSocket));
+/**
+ * Gets Socket from the DI container.
+ *
+ * @remarks
+ * A utility method for host applications that are not using decorators or the DI container.
+ *
+ * @example
+ * ```ts
+ * import { getSocket } from '@genesislcap/foundation-comms';
+ * ...
+ * private socket = getSocket();
+ * ```
+ *
+ * @public
+ */
+export function getSocket() {
+    return DI.getOrCreateDOMContainer().get(Socket);
+}