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

package/dist/esm/connect/socket.status.js

@@ -0,0 +1,119 @@
+import { __decorate } from "tslib";
+import { observable } from '@microsoft/fast-element';
+import { DI } from '@microsoft/fast-foundation';
+import { BehaviorSubject } from 'rxjs';
+/**
+ * Default SocketStatus implementation.
+ * @public
+ */
+export class DefaultSocketStatus {
+    constructor() {
+        this.isConfigured = false;
+        this.isConnecting = false;
+        this.isConnected = false;
+        this.isReconnecting = false;
+        this.reconnectionLimitReached = false;
+        this.hasValidSession = false;
+        this.isConnectedSubject = new BehaviorSubject(this.isConnected);
+    }
+    get isDisconnected() {
+        return !this.isConnected;
+    }
+    get isDisconnectedByServer() {
+        return this.closedClean !== undefined ? !this.closedClean : false;
+    }
+    isConnectedChanged() {
+        var _a;
+        if (this.isConnected) {
+            this.resetClosedState();
+        }
+        this.isConnecting = false;
+        this.isReconnecting = false;
+        (_a = this.isConnectedSubject) === null || _a === void 0 ? void 0 : _a.next(this.isConnected);
+    }
+    isReconnectingChanged() {
+        if (this.isReconnecting) {
+            this.reconnectionLimitReached = false;
+        }
+    }
+    resetClosedState() {
+        this.closedCode = undefined;
+        this.closedReason = undefined;
+        this.closedClean = undefined;
+    }
+    serialize() {
+        return {
+            isConfigured: this.isConfigured,
+            isConnecting: this.isConnecting,
+            isConnected: this.isConnected,
+            isDisconnected: this.isDisconnected,
+            isDisconnectedByServer: this.isDisconnectedByServer,
+            isReconnecting: this.isReconnecting,
+            reconnectionLimitReached: this.reconnectionLimitReached,
+            hasValidSession: this.hasValidSession,
+            closedCode: this.closedCode,
+            closedReason: this.closedReason,
+            closedClean: this.closedClean,
+        };
+    }
+    onClose(event) {
+        this.isConnected = false;
+        this.closedCode = event.code;
+        this.closedReason = event.reason;
+        this.closedClean = event.wasClean;
+    }
+}
+__decorate([
+    observable
+], DefaultSocketStatus.prototype, "isConfigured", void 0);
+__decorate([
+    observable
+], DefaultSocketStatus.prototype, "isConnecting", void 0);
+__decorate([
+    observable
+], DefaultSocketStatus.prototype, "isConnected", void 0);
+__decorate([
+    observable
+], DefaultSocketStatus.prototype, "isReconnecting", void 0);
+__decorate([
+    observable
+], DefaultSocketStatus.prototype, "reconnectionLimitReached", void 0);
+__decorate([
+    observable
+], DefaultSocketStatus.prototype, "hasValidSession", void 0);
+__decorate([
+    observable
+], DefaultSocketStatus.prototype, "closedCode", void 0);
+__decorate([
+    observable
+], DefaultSocketStatus.prototype, "closedReason", void 0);
+__decorate([
+    observable
+], DefaultSocketStatus.prototype, "closedClean", void 0);
+/**
+ * SocketStatus DI key.
+ *
+ * @privateRemarks
+ * Marked as internal to stop api-extractor becoming confused cross-linking tokens with the same name.
+ *
+ * @internal
+ */
+export const SocketStatus = DI.createInterface((x) => x.singleton(DefaultSocketStatus));
+/**
+ * Gets SocketStatus from the DI container.
+ *
+ * @remarks
+ * A utility method for host applications that are not using decorators or the DI container.
+ *
+ * @example
+ * ```ts
+ * import { getSocketStatus } from '@genesislcap/foundation-comms';
+ * ...
+ * private socketStatus = getSocketStatus();
+ * ```
+ *
+ * @public
+ */
+export function getSocketStatus() {
+    return DI.getOrCreateDOMContainer().get(SocketStatus);
+}

package/dist/esm/datasource/datasource.js

@@ -1,5 +1,5 @@
 import { __awaiter, __decorate, __param, __rest } from "tslib";
-import { observable, volatile } from '@microsoft/fast-element';
+import { observable } from '@microsoft/fast-element';
 import { DI, optional } from '@microsoft/fast-foundation';
 import { combineLatest, from, timer } from 'rxjs';
 import { switchMap, takeWhile } from 'rxjs/operators';
@@ -60,11 +60,12 @@ 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 ${this.options.resourceName} Datasource`);
+                logger.debug(`Initializing ${resourceName} Datasource`);
                 const meta = yield this.connect
-                    .getMetadata(this.options.resourceName)
-                    .catch((e) => logger.error(`Metadata Fetch failed for ${options.resourceName}:`, e));
+                    .getMetadata(resourceName)
+                    .catch((e) => logger.error(`Metadata Fetch failed for ${resourceName}:`, e));
                 if (!meta) {
                     this.deinit();
                     return false;
@@ -74,7 +75,7 @@ let DefaultDatasource = class DefaultDatasource {
                 this.originalFieldDef = extractFieldDefinitions(meta);
                 this.fieldMetadata = toFieldMetadata(this.originalFieldDef);
                 this.requestFields = meta.REQUEST_FIELD || [];
-                logger.debug(`Datasource for ${this.options.resourceName} is ready`);
+                logger.debug(`Datasource for ${resourceName} is ready`);
             }
             if (!this.options.isSnapshot) {
                 this._stream = yield this.createStream();
@@ -84,14 +85,23 @@ 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 = undefined;
+        this.options = {};
         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;
     }
@@ -190,8 +200,8 @@ __decorate([
     observable
 ], DefaultDatasource.prototype, "readOnly", void 0);
 __decorate([
-    volatile
-], DefaultDatasource.prototype, "stream", null);
+    observable
+], DefaultDatasource.prototype, "_stream", void 0);
 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
  */
-class FDC3Service {
+export class DefaultFDC3 {
     constructor() {
         this.isReady = false;
         this.connect();
@@ -71,9 +71,9 @@ class FDC3Service {
 }
 __decorate([
     observable
-], FDC3Service.prototype, "isReady", void 0);
+], DefaultFDC3.prototype, "isReady", void 0);
 /**
- * The DI token for the FDC3Service interface.
+ * The DI token for the FDC3 interface.
  * @internal
  */
-export const FDC3 = DI.createInterface((x) => x.singleton(FDC3Service));
+export const FDC3 = DI.createInterface((x) => x.singleton(DefaultFDC3));

package/dist/esm/index.js

@@ -5,6 +5,7 @@ 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/networkMonitor/config.js

@@ -0,0 +1,46 @@
+import { __awaiter } from "tslib";
+import { DI } from '@microsoft/fast-foundation';
+import { getConnect, getSocket } from '../connect';
+import { MessageType } from '../connect/message';
+/**
+ * Default NetworkMonitorConfig DI implementation.
+ * @public
+ */
+export const defaultNetworkMonitorConfig = {
+    windowEvents: ['online', 'offline', 'pageshow'],
+    documentEvents: ['visibilitychange'],
+    genesisConnectEvents: ['stream', 'commit'],
+    checkInterval: 10000,
+    checkTimeout: 3000,
+    /**
+     * The default when a custom check function is not explicitly provided for a resource.
+     */
+    resourceChecks: (sourceRef) => __awaiter(void 0, void 0, void 0, function* () {
+        var _a;
+        const connect = getConnect();
+        const message = yield connect.getMoreColumns(sourceRef);
+        const lastUpdated = Date.now();
+        const lastMessage = message;
+        const isConnected = (_a = (message === null || message === void 0 ? void 0 : message.MESSAGE_TYPE) === MessageType.MORE_COLUMNS_ACK) !== null && _a !== void 0 ? _a : false;
+        return {
+            isConnected,
+            lastUpdated,
+            lastMessage,
+        };
+    }),
+    /**
+     * The default when a custom data logon function is not explicitly provided for a resource.
+     */
+    resourceDataLogon: ({ message, functions }) => {
+        const { onMessage, onError } = functions;
+        getSocket().sendForStream(message, onMessage, onError);
+    },
+};
+/**
+ * NetworkMonitorConfig DI key.
+ *
+ * @internal
+ * @privateRemarks
+ * Marked as internal to stop api-extractor becoming confused cross-linking tokens with the same name.
+ */
+export const NetworkMonitorConfig = DI.createInterface((x) => x.instance(defaultNetworkMonitorConfig));

package/dist/esm/networkMonitor/index.js

@@ -0,0 +1,3 @@
+export * from './types';
+export * from './config';
+export * from './service';