@openfin/core 25.68.30 → 25.70.2

package/src/api/interappbus/channel/protocols/combined/strategy.d.ts

@@ -1,20 +1,20 @@
-import { ChannelStrategy } from '../strategy';
-declare type OverlapsOnlyIfMatching<T, U> = {
-    [K in Extract<keyof T, keyof U>]: U[K] extends T[K] ? U[K] : T[K] extends U[K] ? T[K] : never;
-};
-declare type OnlyIfCompatible<A, B, D = OverlapsOnlyIfMatching<A, B>> = D extends Record<any, never> ? keyof D extends never ? A | B : never : A | B;
-export default class CombinedStrategy<A, B> implements ChannelStrategy<OnlyIfCompatible<A, B>> {
-    private primary;
-    private secondary;
-    static combine<A, B>(a: ChannelStrategy<A>, b: ChannelStrategy<B>): OnlyIfCompatible<A, B> extends never ? never : CombinedStrategy<A, B>;
-    private constructor();
-    onEndpointDisconnect(endpointId: string, listener: () => void): void;
-    isValidEndpointPayload(payload: unknown): payload is OnlyIfCompatible<A, B>;
-    closeEndpoint(endpointId: string): Promise<void>;
-    isEndpointConnected(endpoint: string): boolean;
-    addEndpoint(endpoint: string, payload: OnlyIfCompatible<A, B>): Promise<void>;
-    receive(listener: (action: string, payload: any, identity: any) => Promise<any>): void;
-    send(endpointId: string, action: string, payload: any): Promise<any>;
-    close(): Promise<void>;
-}
-export {};
+import { ChannelStrategy } from '../strategy';
+declare type OverlapsOnlyIfMatching<T, U> = {
+    [K in Extract<keyof T, keyof U>]: U[K] extends T[K] ? U[K] : T[K] extends U[K] ? T[K] : never;
+};
+declare type OnlyIfCompatible<A, B, D = OverlapsOnlyIfMatching<A, B>> = D extends Record<any, never> ? keyof D extends never ? A | B : never : A | B;
+export default class CombinedStrategy<A, B> implements ChannelStrategy<OnlyIfCompatible<A, B>> {
+    private primary;
+    private secondary;
+    static combine<A, B>(a: ChannelStrategy<A>, b: ChannelStrategy<B>): OnlyIfCompatible<A, B> extends never ? never : CombinedStrategy<A, B>;
+    private constructor();
+    onEndpointDisconnect(endpointId: string, listener: () => void): void;
+    isValidEndpointPayload(payload: unknown): payload is OnlyIfCompatible<A, B>;
+    closeEndpoint(endpointId: string): Promise<void>;
+    isEndpointConnected(endpoint: string): boolean;
+    addEndpoint(endpoint: string, payload: OnlyIfCompatible<A, B>): Promise<void>;
+    receive(listener: (action: string, payload: any, identity: any) => Promise<any>): void;
+    send(endpointId: string, action: string, payload: any): Promise<any>;
+    close(): Promise<void>;
+}
+export {};

package/src/api/interappbus/channel/protocols/combined/strategy.js

@@ -1,58 +1,58 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-class CombinedStrategy {
-    // eslint-disable-next-line no-useless-constructor
-    constructor(primary, secondary) {
-        this.primary = primary;
-        this.secondary = secondary;
-    }
-    // Making this a static method because the constructor can't be typed.
-    // Otherwise it will error when calling addEndpoint but I'd rather the whole instance be typed as never.
-    static combine(a, b) {
-        return new CombinedStrategy(a, b);
-    }
-    onEndpointDisconnect(endpointId, listener) {
-        this.primary.onEndpointDisconnect(endpointId, () => {
-            if (!this.secondary.isEndpointConnected(endpointId)) {
-                listener();
-            }
-        });
-        this.secondary.onEndpointDisconnect(endpointId, () => {
-            if (!this.primary.isEndpointConnected(endpointId)) {
-                listener();
-            }
-        });
-    }
-    isValidEndpointPayload(payload) {
-        return this.primary.isValidEndpointPayload(payload) || this.secondary.isValidEndpointPayload(payload);
-    }
-    async closeEndpoint(endpointId) {
-        await this.primary.closeEndpoint(endpointId);
-        await this.secondary.closeEndpoint(endpointId);
-    }
-    isEndpointConnected(endpoint) {
-        return this.primary.isEndpointConnected(endpoint) || this.secondary.isEndpointConnected(endpoint);
-    }
-    async addEndpoint(endpoint, payload) {
-        if (this.primary.isValidEndpointPayload(payload)) {
-            await this.primary.addEndpoint(endpoint, payload);
-        }
-        if (this.secondary.isValidEndpointPayload(payload)) {
-            await this.secondary.addEndpoint(endpoint, payload);
-        }
-    }
-    receive(listener) {
-        this.primary.receive(listener);
-        this.secondary.receive(listener);
-    }
-    send(endpointId, action, payload) {
-        if (this.primary.isEndpointConnected(endpointId)) {
-            return this.primary.send(endpointId, action, payload);
-        }
-        return this.secondary.send(endpointId, action, payload);
-    }
-    async close() {
-        await Promise.all([this.primary.close(), this.secondary.close()]);
-    }
-}
-exports.default = CombinedStrategy;
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+class CombinedStrategy {
+    // eslint-disable-next-line no-useless-constructor
+    constructor(primary, secondary) {
+        this.primary = primary;
+        this.secondary = secondary;
+    }
+    // Making this a static method because the constructor can't be typed.
+    // Otherwise it will error when calling addEndpoint but I'd rather the whole instance be typed as never.
+    static combine(a, b) {
+        return new CombinedStrategy(a, b);
+    }
+    onEndpointDisconnect(endpointId, listener) {
+        this.primary.onEndpointDisconnect(endpointId, () => {
+            if (!this.secondary.isEndpointConnected(endpointId)) {
+                listener();
+            }
+        });
+        this.secondary.onEndpointDisconnect(endpointId, () => {
+            if (!this.primary.isEndpointConnected(endpointId)) {
+                listener();
+            }
+        });
+    }
+    isValidEndpointPayload(payload) {
+        return this.primary.isValidEndpointPayload(payload) || this.secondary.isValidEndpointPayload(payload);
+    }
+    async closeEndpoint(endpointId) {
+        await this.primary.closeEndpoint(endpointId);
+        await this.secondary.closeEndpoint(endpointId);
+    }
+    isEndpointConnected(endpoint) {
+        return this.primary.isEndpointConnected(endpoint) || this.secondary.isEndpointConnected(endpoint);
+    }
+    async addEndpoint(endpoint, payload) {
+        if (this.primary.isValidEndpointPayload(payload)) {
+            await this.primary.addEndpoint(endpoint, payload);
+        }
+        if (this.secondary.isValidEndpointPayload(payload)) {
+            await this.secondary.addEndpoint(endpoint, payload);
+        }
+    }
+    receive(listener) {
+        this.primary.receive(listener);
+        this.secondary.receive(listener);
+    }
+    send(endpointId, action, payload) {
+        if (this.primary.isEndpointConnected(endpointId)) {
+            return this.primary.send(endpointId, action, payload);
+        }
+        return this.secondary.send(endpointId, action, payload);
+    }
+    async close() {
+        await Promise.all([this.primary.close(), this.secondary.close()]);
+    }
+}
+exports.default = CombinedStrategy;

package/src/api/interappbus/channel/protocols/index.d.ts

@@ -1,44 +1,44 @@
-export interface ProtocolPacketBase {
-    version: number;
-    minimumVersion?: number;
-    type: string;
-    payload?: any;
-}
-export interface ClassicProtocolOffer extends ProtocolPacketBase {
-    type: 'classic';
-}
-export interface RTCProtocolOffer extends ProtocolPacketBase {
-    type: 'rtc';
-    payload: {
-        offer: RTCSessionDescriptionInit;
-        rtcConnectionId: string;
-    };
-}
-export declare type ProtocolOffer = ClassicProtocolOffer | RTCProtocolOffer;
-export declare type MessagingProtocols = ProtocolOffer['type'];
-export declare type LocalSupportedProtocol = {
-    type: MessagingProtocols;
-    minimumVersion: number;
-    version: number;
-};
-export interface ExternalClientOffer {
-    maxProtocols: number;
-    supportedProtocols: ProtocolPacketBase[];
-}
-export interface ClientOffer {
-    supportedProtocols: ProtocolOffer[];
-    maxProtocols: number;
-}
-export interface ClassicProtocolAnswer extends ProtocolPacketBase {
-    type: 'classic';
-}
-export interface RTCProtocolAnswer extends ProtocolPacketBase {
-    type: 'rtc';
-    payload: {
-        answer: RTCSessionDescriptionInit;
-    };
-}
-export declare type ProtocolAnswer = ClassicProtocolAnswer | RTCProtocolAnswer;
-export interface ClientAnswer {
-    supportedProtocols: ProtocolAnswer[];
-}
+export interface ProtocolPacketBase {
+    version: number;
+    minimumVersion?: number;
+    type: string;
+    payload?: any;
+}
+export interface ClassicProtocolOffer extends ProtocolPacketBase {
+    type: 'classic';
+}
+export interface RTCProtocolOffer extends ProtocolPacketBase {
+    type: 'rtc';
+    payload: {
+        offer: RTCSessionDescriptionInit;
+        rtcConnectionId: string;
+    };
+}
+export declare type ProtocolOffer = ClassicProtocolOffer | RTCProtocolOffer;
+export declare type MessagingProtocols = ProtocolOffer['type'];
+export declare type LocalSupportedProtocol = {
+    type: MessagingProtocols;
+    minimumVersion: number;
+    version: number;
+};
+export interface ExternalClientOffer {
+    maxProtocols: number;
+    supportedProtocols: ProtocolPacketBase[];
+}
+export interface ClientOffer {
+    supportedProtocols: ProtocolOffer[];
+    maxProtocols: number;
+}
+export interface ClassicProtocolAnswer extends ProtocolPacketBase {
+    type: 'classic';
+}
+export interface RTCProtocolAnswer extends ProtocolPacketBase {
+    type: 'rtc';
+    payload: {
+        answer: RTCSessionDescriptionInit;
+    };
+}
+export declare type ProtocolAnswer = ClassicProtocolAnswer | RTCProtocolAnswer;
+export interface ClientAnswer {
+    supportedProtocols: ProtocolAnswer[];
+}

package/src/api/interappbus/channel/protocols/index.js

@@ -1,2 +1,2 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/src/api/interappbus/channel/protocols/protocol-manager.d.ts

@@ -1,10 +1,10 @@
-import { MessagingProtocols, ExternalClientOffer, ProtocolOffer, LocalSupportedProtocol } from '.';
-export declare class ProtocolManager {
-    private ProtocolsInPreferenceOrder;
-    DefaultClientProtocols: ['classic'];
-    DefaultProviderProtocols: ['classic'];
-    constructor(ProtocolsInPreferenceOrder: MessagingProtocols[]);
-    getClientProtocols: (protocols?: string[]) => MessagingProtocols[];
-    getProviderProtocols: (protocols?: string[]) => ['rtc'] | ['rtc', 'classic'] | ['classic'];
-    getCompatibleProtocols: (providerProtocols: LocalSupportedProtocol[], clientOffer: ExternalClientOffer) => ProtocolOffer[];
-}
+import { MessagingProtocols, ExternalClientOffer, ProtocolOffer, LocalSupportedProtocol } from '.';
+export declare class ProtocolManager {
+    private ProtocolsInPreferenceOrder;
+    DefaultClientProtocols: ['classic'];
+    DefaultProviderProtocols: ['classic'];
+    constructor(ProtocolsInPreferenceOrder: MessagingProtocols[]);
+    getClientProtocols: (protocols?: string[]) => MessagingProtocols[];
+    getProviderProtocols: (protocols?: string[]) => ['rtc'] | ['rtc', 'classic'] | ['classic'];
+    getCompatibleProtocols: (providerProtocols: LocalSupportedProtocol[], clientOffer: ExternalClientOffer) => ProtocolOffer[];
+}

package/src/api/interappbus/channel/protocols/protocol-manager.js

@@ -1,43 +1,43 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.ProtocolManager = void 0;
-/*
-This should be agnostic of any actual openfin code to be unit testable.
-Dependencies on the actual srategies should be handled in ConnectionManager
-*/
-class ProtocolManager {
-    // eslint-disable-next-line no-useless-constructor
-    constructor(ProtocolsInPreferenceOrder) {
-        this.ProtocolsInPreferenceOrder = ProtocolsInPreferenceOrder;
-        this.DefaultClientProtocols = ['classic'];
-        this.DefaultProviderProtocols = ['classic'];
-        this.getClientProtocols = (protocols) => {
-            const supported = protocols
-                ? this.ProtocolsInPreferenceOrder.filter((x) => protocols.includes(x))
-                : this.DefaultClientProtocols;
-            if (!supported.length) {
-                throw new Error(`No valid protocols were passed in. Accepted values are: ${this.ProtocolsInPreferenceOrder.join(', ')}.`);
-            }
-            return supported;
-        };
-        this.getProviderProtocols = (protocols) => {
-            const supported = protocols
-                ? this.ProtocolsInPreferenceOrder.filter((x) => protocols.includes(x))
-                : this.DefaultProviderProtocols;
-            if (!supported.length) {
-                throw new Error(`No valid protocols were passed in. Accepted values are: ${this.ProtocolsInPreferenceOrder.join(', ')}.`);
-            }
-            return supported;
-        };
-        this.getCompatibleProtocols = (providerProtocols, clientOffer) => {
-            const supported = clientOffer.supportedProtocols.filter((clientProtocol) => providerProtocols.some((providerProtocol) => {
-                var _a;
-                return providerProtocol.type === clientProtocol.type &&
-                    clientProtocol.version >= providerProtocol.minimumVersion &&
-                    providerProtocol.version >= ((_a = clientProtocol.minimumVersion) !== null && _a !== void 0 ? _a : 0);
-            }));
-            return supported.slice(0, clientOffer.maxProtocols);
-        };
-    }
-}
-exports.ProtocolManager = ProtocolManager;
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ProtocolManager = void 0;
+/*
+This should be agnostic of any actual openfin code to be unit testable.
+Dependencies on the actual srategies should be handled in ConnectionManager
+*/
+class ProtocolManager {
+    // eslint-disable-next-line no-useless-constructor
+    constructor(ProtocolsInPreferenceOrder) {
+        this.ProtocolsInPreferenceOrder = ProtocolsInPreferenceOrder;
+        this.DefaultClientProtocols = ['classic'];
+        this.DefaultProviderProtocols = ['classic'];
+        this.getClientProtocols = (protocols) => {
+            const supported = protocols
+                ? this.ProtocolsInPreferenceOrder.filter((x) => protocols.includes(x))
+                : this.DefaultClientProtocols;
+            if (!supported.length) {
+                throw new Error(`No valid protocols were passed in. Accepted values are: ${this.ProtocolsInPreferenceOrder.join(', ')}.`);
+            }
+            return supported;
+        };
+        this.getProviderProtocols = (protocols) => {
+            const supported = protocols
+                ? this.ProtocolsInPreferenceOrder.filter((x) => protocols.includes(x))
+                : this.DefaultProviderProtocols;
+            if (!supported.length) {
+                throw new Error(`No valid protocols were passed in. Accepted values are: ${this.ProtocolsInPreferenceOrder.join(', ')}.`);
+            }
+            return supported;
+        };
+        this.getCompatibleProtocols = (providerProtocols, clientOffer) => {
+            const supported = clientOffer.supportedProtocols.filter((clientProtocol) => providerProtocols.some((providerProtocol) => {
+                var _a;
+                return providerProtocol.type === clientProtocol.type &&
+                    clientProtocol.version >= providerProtocol.minimumVersion &&
+                    providerProtocol.version >= ((_a = clientProtocol.minimumVersion) !== null && _a !== void 0 ? _a : 0);
+            }));
+            return supported.slice(0, clientOffer.maxProtocols);
+        };
+    }
+}
+exports.ProtocolManager = ProtocolManager;

package/src/api/interappbus/channel/protocols/rtc/endpoint.d.ts

@@ -1,23 +1,23 @@
-import ProviderIdentity = OpenFin.ProviderIdentity;
-export interface RTCEndpointChannels {
-    request: RTCDataChannel;
-    response: RTCDataChannel;
-}
-export interface RTCPacket {
-    rtcClient: RTCPeerConnection;
-    channels: RTCEndpointChannels;
-    channelsOpened: Promise<void>;
-}
-export declare class RTCEndpoint {
-    #private;
-    private rtc;
-    private endpointIdentity;
-    private responseMap;
-    constructor(rtc: RTCPacket, endpointIdentity: OpenFin.ClientIdentity | ProviderIdentity);
-    private connectionStateChangeHandler;
-    onDisconnect(listener: () => void): void;
-    receive(listener: (action: string, payload: any, identity: OpenFin.ClientIdentity | ProviderIdentity) => Promise<any>): void;
-    send: (action: string, payload: any) => Promise<any>;
-    close: () => void;
-    get connected(): boolean;
-}
+import ProviderIdentity = OpenFin.ProviderIdentity;
+export interface RTCEndpointChannels {
+    request: RTCDataChannel;
+    response: RTCDataChannel;
+}
+export interface RTCPacket {
+    rtcClient: RTCPeerConnection;
+    channels: RTCEndpointChannels;
+    channelsOpened: Promise<void>;
+}
+export declare class RTCEndpoint {
+    #private;
+    private rtc;
+    private endpointIdentity;
+    private responseMap;
+    constructor(rtc: RTCPacket, endpointIdentity: OpenFin.ClientIdentity | ProviderIdentity);
+    private connectionStateChangeHandler;
+    onDisconnect(listener: () => void): void;
+    receive(listener: (action: string, payload: any, identity: OpenFin.ClientIdentity | ProviderIdentity) => Promise<any>): void;
+    send: (action: string, payload: any) => Promise<any>;
+    close: () => void;
+    get connected(): boolean;
+}