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

package/dist/esm/connect/connect.js

@@ -4,7 +4,6 @@ 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';
@@ -42,11 +41,10 @@ let DefaultConnect = class DefaultConnect {
         var _a;
         return (_a = this.socket.isConnectedSubject) === null || _a === void 0 ? void 0 : _a.asObservable();
     }
-    constructor(socket, messageBuilder, metaCache, events, config = defaultConnectConfig) {
+    constructor(socket, messageBuilder, metaCache, config = defaultConnectConfig) {
         this.socket = socket;
         this.messageBuilder = messageBuilder;
         this.metaCache = metaCache;
-        this.events = events;
         this.config = config;
         this.isWorking = false;
     }
@@ -81,16 +79,9 @@ let DefaultConnect = class DefaultConnect {
         });
     }
     stream(resourceName, onMessage, onError, params) {
-        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;
+        const streamMessage = this.messageBuilder.createDataLogonMessage(resourceName, params);
+        logger.debug(`${streamMessage.MESSAGE_TYPE} (stream) message created -> `, streamMessage);
+        return this.socket.sendForStream(streamMessage, onMessage, onError);
     }
     getMoreRows(sourceRef) {
         return __awaiter(this, void 0, void 0, function* () {
@@ -99,12 +90,6 @@ 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);
@@ -124,7 +109,6 @@ 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);
@@ -134,12 +118,9 @@ 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;
@@ -185,11 +166,9 @@ let DefaultConnect = class DefaultConnect {
     }
     commitEvent(eventName, params) {
         return __awaiter(this, void 0, void 0, function* () {
-            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;
+            const commitMessage = this.messageBuilder.createCommitMessage(eventName, params);
+            logger.debug(`${commitMessage.MESSAGE_TYPE} (commit) message created -> `, commitMessage);
+            return this.socket.send(commitMessage);
         });
     }
 };
@@ -203,8 +182,7 @@ DefaultConnect = __decorate([
     __param(0, Socket),
     __param(1, MessageBuilder),
     __param(2, MetaCache),
-    __param(3, ConnectEventsEmitter),
-    __param(4, optional(ConnectConfig))
+    __param(3, optional(ConnectConfig))
 ], DefaultConnect);
 export { DefaultConnect };
 const useHttpConnect = FORCE_HTTP === 'true' || false;

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

@@ -162,12 +162,6 @@ 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,10 +1,8 @@
-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,8 +16,6 @@ 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";
@@ -64,25 +62,10 @@ 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
  */
-/**
- * Default MessageBuilder implementation.
- * @public
- */
-let DefaultMessageBuilder = class DefaultMessageBuilder {
+let MessageBuilderService = class MessageBuilderService {
     /**
      * UUID will be created in the DI with the App specific requirements.
      * Keeping it encapsulated means messages will always conform.
@@ -224,9 +207,6 @@ let DefaultMessageBuilder = class DefaultMessageBuilder {
             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) {
@@ -242,13 +222,12 @@ let DefaultMessageBuilder = class DefaultMessageBuilder {
         return headers;
     }
 };
-DefaultMessageBuilder = __decorate([
+MessageBuilderService = __decorate([
     __param(0, Session),
     __param(1, UUID)
-], DefaultMessageBuilder);
-export { DefaultMessageBuilder };
+], MessageBuilderService);
 /**
  * The DI token for the MessageBUilder interface.
  * @internal
  */
-export const MessageBuilder = DI.createInterface((x) => x.singleton(DefaultMessageBuilder));
+export const MessageBuilder = DI.createInterface((x) => x.singleton(MessageBuilderService));

package/dist/esm/connect/socket.js

@@ -3,14 +3,13 @@ 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 { Observable, of, Subject, Subscription, takeUntil, throwError } from 'rxjs';
+import { BehaviorSubject, from, Observable, of, Subject, Subscription, 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.
@@ -77,48 +76,23 @@ export class SocketMessageHandler {
         return this._isSubscription;
     }
 }
-/**
- * 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;
+let SocketService = class SocketService {
+    isConnectedChanged(_, isConnected) {
+        this.isConnectedSubject.next(isConnected);
     }
-    get hasValidSession() {
-        return this.status.hasValidSession;
-    }
-    set hasValidSession(value) {
-        this.status.hasValidSession = value;
-    }
-    constructor(messageBuilder, session, serializer, uuid, status) {
+    constructor(messageBuilder, session, serializer, uuid) {
         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() {
@@ -136,7 +110,6 @@ let DefaultSocket = class DefaultSocket {
         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();
@@ -147,7 +120,7 @@ let DefaultSocket = class DefaultSocket {
                 openObserver: {
                     next: () => {
                         this.session.setSessionStorageItem('hostUrl', this.url);
-                        this.status.isConnected = true;
+                        this.isConnected = true;
                         this.prepareHeartbeat();
                         logger.info(`WebSocket connection is now open`);
                         resolve(this.isConnected);
@@ -155,8 +128,9 @@ let DefaultSocket = class DefaultSocket {
                 },
                 closeObserver: {
                     next: (closeEvent) => {
-                        this.status.onClose(closeEvent);
-                        if (this.isDisconnectedByServer) {
+                        this.disconnectedByServer = !closeEvent.wasClean;
+                        this.isConnected = false;
+                        if (this.disconnectedByServer) {
                             logger.info(`WebSocket connection was closed due an error - Code: ${closeEvent.code} ${closeEvent.reason ? ' | Reason: ' + closeEvent.reason : ''}`);
                         }
                         resolve(this.isConnected);
@@ -222,7 +196,8 @@ let DefaultSocket = class DefaultSocket {
                     }
                     case MessageType.QUERY_UPDATE: {
                         if (!messageHandler.isSubscription) {
-                            this.sendDataLogoff(SOURCE_REF);
+                            const dataLogoffMessage = this.messageBuilder.createDataLogoffMessage(SOURCE_REF);
+                            this.send(dataLogoffMessage);
                         }
                         break;
                     }
@@ -252,7 +227,7 @@ let DefaultSocket = class DefaultSocket {
             };
             const onComplete = () => {
                 var _a;
-                if (this.isDisconnectedByServer && ((_a = this.connectOptions) === null || _a === void 0 ? void 0 : _a.alwaysOn)) {
+                if (this.disconnectedByServer && ((_a = this.connectOptions) === null || _a === void 0 ? void 0 : _a.alwaysOn)) {
                     this.reconnect();
                     return;
                 }
@@ -263,7 +238,6 @@ let DefaultSocket = class DefaultSocket {
                 error: onError,
                 complete: onComplete,
             });
-            this.status.isConfigured = true;
         });
     }
     prepareHeartbeat() {
@@ -301,7 +275,7 @@ let DefaultSocket = class DefaultSocket {
         if (this.isReconnecting || notAlwaysOnAndHeartbeating) {
             return;
         }
-        this.status.isReconnecting = true;
+        this.isReconnecting = true;
         const scheduler = ((_c = this.reconnectOptions) === null || _c === void 0 ? void 0 : _c.reconnectStrategy) === SocketReconnectStrategy.Exponential
             ? exponentialScheduler
             : linearScheduler;
@@ -319,7 +293,6 @@ let DefaultSocket = class DefaultSocket {
                 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));
@@ -333,11 +306,11 @@ let DefaultSocket = class DefaultSocket {
                 var _a;
                 logger.debug(error);
                 (_a = this.socketSubscription) === null || _a === void 0 ? void 0 : _a.unsubscribe();
-                this.status.isReconnecting = false;
+                this.isReconnecting = false;
             },
             complete: () => {
                 logger.info(this.isConnected ? 'Reconnected' : 'Disconnected');
-                this.status.isReconnecting = false;
+                this.isReconnecting = false;
                 this.wsMessageHandlers.forEach((mh) => {
                     if (mh.isSubscription) {
                         this.websocket.next(mh.sentMessage);
@@ -347,8 +320,7 @@ let DefaultSocket = class DefaultSocket {
         });
     }
     reset() {
-        this.status.isConnected = false;
-        this.status.isConfigured = false;
+        this.isConnected = false;
         this.websocket && this.websocket.complete();
         this.websocket = null;
         this.cleanMessages();
@@ -360,7 +332,8 @@ let DefaultSocket = class DefaultSocket {
     }
     send(message, needsHandling = true) {
         if (!this.isConnected) {
-            return Promise.reject(new Error('WebSocket connection is closed'));
+            Promise.reject(new Error('WebSocket connection is closed'));
+            return;
         }
         const sendingMessasgeLog = `Sending Message for SourceRef: ${message.SOURCE_REF} | MessageType: ${message.MESSAGE_TYPE}`;
         this.logMessageTypeFlow(message.MESSAGE_TYPE, logger.info, sendingMessasgeLog);
@@ -377,7 +350,7 @@ let DefaultSocket = class DefaultSocket {
             this.websocket.next(message);
         });
     }
-    sendForStream(message, onMessage, onError, onComplete) {
+    sendForStream(message, onMessage, onError) {
         if (!this.isConnected) {
             return throwError(() => new Error('WebSocket connection is closed'));
         }
@@ -388,44 +361,13 @@ let DefaultSocket = class DefaultSocket {
         this.logMessageTypeFlow(message.MESSAGE_TYPE, logger.info, sendingMessageLog);
         this.setMessageHandler(message, onMessage, onError, true);
         this.websocket.next(message);
-        /**
-         * @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();
-            };
-        });
+        return from(this.wsMessages.pipe(filter((msg) => msg.SOURCE_REF === message.SOURCE_REF)));
     }
     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);
     }
@@ -436,9 +378,6 @@ let DefaultSocket = class DefaultSocket {
     }
     logMessageTypeFlow(messageType, logFunc, logMsg) {
         switch (messageType) {
-            case EventMessageType.DATA_LOGOFF:
-                logFunc(logMsg);
-                break;
             case MessageType.HEARTBEAT_PING:
             case MessageType.HEARTBEAT_PONG:
                 if (this.heartbeatLoggingIsEnabled) {
@@ -455,44 +394,36 @@ let DefaultSocket = class DefaultSocket {
 };
 __decorate([
     observable
-], DefaultSocket.prototype, "websocket", void 0);
+], SocketService.prototype, "websocket", void 0);
+__decorate([
+    observable
+], SocketService.prototype, "wsMessages", void 0);
+__decorate([
+    observable
+], SocketService.prototype, "wsMessageHandlers", void 0);
 __decorate([
     observable
-], DefaultSocket.prototype, "wsMessages", void 0);
+], SocketService.prototype, "isConnected", void 0);
 __decorate([
     observable
-], DefaultSocket.prototype, "wsMessageHandlers", void 0);
+], SocketService.prototype, "disconnectedByServer", void 0);
 __decorate([
     observable
-], DefaultSocket.prototype, "heartbeatIsEnabled", void 0);
-DefaultSocket = __decorate([
+], SocketService.prototype, "hasValidSession", void 0);
+__decorate([
+    observable
+], SocketService.prototype, "heartbeatIsEnabled", void 0);
+__decorate([
+    observable
+], SocketService.prototype, "isReconnecting", void 0);
+SocketService = __decorate([
     __param(0, MessageBuilder),
     __param(1, Session),
     __param(2, JSONSerializer),
-    __param(3, UUID),
-    __param(4, SocketStatus)
-], DefaultSocket);
-export { DefaultSocket };
+    __param(3, UUID)
+], SocketService);
 /**
  * The DI token for the Socket interface.
  * @internal
  */
-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);
-}
+export const Socket = DI.createInterface((x) => x.singleton(SocketService));

package/dist/esm/datasource/datasource.js

@@ -1,5 +1,5 @@
 import { __awaiter, __decorate, __param, __rest } from "tslib";
-import { observable } from '@microsoft/fast-element';
+import { observable, volatile } from '@microsoft/fast-element';
 import { DI, optional } from '@microsoft/fast-foundation';
 import { combineLatest, from, timer } from 'rxjs';
 import { switchMap, takeWhile } from 'rxjs/operators';
@@ -60,12 +60,11 @@ let DefaultDatasource = class DefaultDatasource {
                 return false;
             }
             this.options = Object.assign(Object.assign({}, this.config.options), options);
-            const resourceName = this.options.resourceName;
             if (fetchMeta) {
-                logger.debug(`Initializing ${resourceName} Datasource`);
+                logger.debug(`Initializing ${this.options.resourceName} Datasource`);
                 const meta = yield this.connect
-                    .getMetadata(resourceName)
-                    .catch((e) => logger.error(`Metadata Fetch failed for ${resourceName}:`, e));
+                    .getMetadata(this.options.resourceName)
+                    .catch((e) => logger.error(`Metadata Fetch failed for ${options.resourceName}:`, e));
                 if (!meta) {
                     this.deinit();
                     return false;
@@ -75,7 +74,7 @@ let DefaultDatasource = class DefaultDatasource {
                 this.originalFieldDef = extractFieldDefinitions(meta);
                 this.fieldMetadata = toFieldMetadata(this.originalFieldDef);
                 this.requestFields = meta.REQUEST_FIELD || [];
-                logger.debug(`Datasource for ${resourceName} is ready`);
+                logger.debug(`Datasource for ${this.options.resourceName} is ready`);
             }
             if (!this.options.isSnapshot) {
                 this._stream = yield this.createStream();
@@ -85,23 +84,14 @@ let DefaultDatasource = class DefaultDatasource {
         });
     }
     deinit() {
-        var _a;
-        logger.debug('Datasource.deinit', (_a = this.options) === null || _a === void 0 ? void 0 : _a.resourceName);
         this.initialized = false;
-        this.options = {};
+        this.options = undefined;
         this.resourceType = undefined;
         this.availableIndexes = [];
         this.originalFieldDef = [];
         this.fieldMetadata = [];
         this.requestFields = [];
     }
-    /** {@inheritDoc Datasource.destroy} */
-    destroy() {
-        var _a;
-        logger.debug('Datasource.destroy', (_a = this.options) === null || _a === void 0 ? void 0 : _a.resourceName);
-        this.deinit();
-        delete this._stream;
-    }
     get stream() {
         return this._stream;
     }
@@ -200,8 +190,8 @@ __decorate([
     observable
 ], DefaultDatasource.prototype, "readOnly", void 0);
 __decorate([
-    observable
-], DefaultDatasource.prototype, "_stream", void 0);
+    volatile
+], DefaultDatasource.prototype, "stream", null);
 DefaultDatasource = __decorate([
     __param(0, Connect),
     __param(1, Auth),

package/dist/esm/fdc3/fdc3.js

@@ -10,7 +10,7 @@ import { logger } from '../utils';
  * The FDC3 implementation.
  * @internal
  */
-export class DefaultFDC3 {
+class FDC3Service {
     constructor() {
         this.isReady = false;
         this.connect();
@@ -71,9 +71,9 @@ export class DefaultFDC3 {
 }
 __decorate([
     observable
-], DefaultFDC3.prototype, "isReady", void 0);
+], FDC3Service.prototype, "isReady", void 0);
 /**
- * The DI token for the FDC3 interface.
+ * The DI token for the FDC3Service interface.
  * @internal
  */
-export const FDC3 = DI.createInterface((x) => x.singleton(DefaultFDC3));
+export const FDC3 = DI.createInterface((x) => x.singleton(FDC3Service));

package/dist/esm/index.js

@@ -5,7 +5,6 @@ export * from './credentialManager';
 export * from './datasource';
 export * from './fdc3';
 export * from './metadata';
-export * from './networkMonitor';
 export * from './session';
 export * from './storage';
 export * from './testing';

package/dist/esm/testing/mocks/connect/connect.js

@@ -50,9 +50,6 @@ export class ConnectMock {
     getMoreRows(sourceRef) {
         return Promise.resolve(this.nextMessage);
     }
-    getMoreColumns(sourceRef) {
-        return Promise.resolve(this.nextMessage);
-    }
     dataLogoff(sourceRef) {
         return Promise.resolve(this.nextMessage);
     }

package/dist/esm/testing/mocks/connect/socket.js

@@ -15,7 +15,7 @@ export class SocketMock {
     send(message) {
         return Promise.resolve(this.nextMessage);
     }
-    sendForStream(message, onMessage, onError, onComplete) {
+    sendForStream(message, onMessage, onError) {
         return from(Promise.resolve(this.nextMessage));
     }
     socketMessages() {

package/dist/esm/testing/mocks/datasource/datasource.js

@@ -6,7 +6,6 @@ export class DatasourceMock {
         return Promise.resolve(this.initialized);
     }
     deinit() { }
-    destroy() { }
     validResourceName(resourceName) {
         if (!resourceName)
             return false;

package/dist/esm/user/user.js

@@ -1,26 +1,12 @@
 import { __decorate } from "tslib";
 import { observable } from '@microsoft/fast-element';
-import { DI } from '@microsoft/fast-foundation';
 /**
  * Represents the current user (i.e. the user that is currently logged in).
  * @public
  */
 export class CurrentUser {
     constructor(options) {
-        this.set(options);
-    }
-    set(options) {
-        if (!options) {
-            return;
-        }
-        this.permissions = options.permissions;
-        this.profiles = options.profiles;
-        this.username = options.username;
-    }
-    unset() {
-        this.permissions = undefined;
-        this.profiles = undefined;
-        this.username = undefined;
+        Object.assign(this, options);
     }
     hasAdminProfile() {
         return this.hasProfile('ADMIN');
@@ -57,10 +43,3 @@ __decorate([
 __decorate([
     observable
 ], CurrentUser.prototype, "username", void 0);
-/**
- * User DI key.
- * @privateRemarks
- * Marked as internal to stop api-extractor becoming confused cross-linking tokens with the same name.
- * @internal
- */
-export const User = DI.createInterface((x) => x.singleton(CurrentUser));