@openfin/core 33.76.31 → 33.76.38

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

@@ -1,20 +0,0 @@
-import { ChannelStrategy } from '../strategy';
-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;
-};
-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 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-class CombinedStrategy {
-    // 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);
-    }
-    // eslint-disable-next-line no-useless-constructor
-    constructor(primary, secondary) {
-        this.primary = primary;
-        this.secondary = secondary;
-    }
-    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,47 +0,0 @@
-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 type ProtocolOffer = ClassicProtocolOffer | RTCProtocolOffer;
-/**
- * Protocol values for determining channel messaging strategy.
- */
-export type MessagingProtocols = ProtocolOffer['type'];
-export 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 type ProtocolAnswer = ClassicProtocolAnswer | RTCProtocolAnswer;
-export interface ClientAnswer {
-    supportedProtocols: ProtocolAnswer[];
-}

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

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

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

@@ -1,10 +0,0 @@
-import { ExternalClientOffer, LocalSupportedProtocol, MessagingProtocols, ProtocolOffer } 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 +0,0 @@
-"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,25 +0,0 @@
-import type * as OpenFin from '../../../../../OpenFin';
-type 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;
-}
-export {};

package/src/api/interappbus/channel/protocols/rtc/endpoint.js

@@ -1,141 +0,0 @@
-"use strict";
-var __classPrivateFieldGet = (this && this.__classPrivateFieldGet) || function (receiver, state, kind, f) {
-    if (kind === "a" && !f) throw new TypeError("Private accessor was defined without a getter");
-    if (typeof state === "function" ? receiver !== state || !f : !state.has(receiver)) throw new TypeError("Cannot read private member from an object whose class did not declare it");
-    return kind === "m" ? f : kind === "a" ? f.call(receiver) : f ? f.value : state.get(receiver);
-};
-var __classPrivateFieldSet = (this && this.__classPrivateFieldSet) || function (receiver, state, value, kind, f) {
-    if (kind === "m") throw new TypeError("Private method is not writable");
-    if (kind === "a" && !f) throw new TypeError("Private accessor was defined without a setter");
-    if (typeof state === "function" ? receiver !== state || !f : !state.has(receiver)) throw new TypeError("Cannot write private member to an object whose class did not declare it");
-    return (kind === "a" ? f.call(receiver, value) : f ? f.value = value : state.set(receiver, value)), value;
-};
-var _RTCEndpoint_processAction, _RTCEndpoint_disconnectListener;
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.RTCEndpoint = void 0;
-/* eslint-disable @typescript-eslint/no-unused-vars */
-const errors_1 = require("../../../../../util/errors");
-/*
-This handles sending RTC messages between RTC connections over the request and response data channels.
-*/
-class RTCEndpoint {
-    constructor(rtc, endpointIdentity) {
-        this.rtc = rtc;
-        this.endpointIdentity = endpointIdentity;
-        this.responseMap = new Map();
-        _RTCEndpoint_processAction.set(this, null);
-        _RTCEndpoint_disconnectListener.set(this, void 0);
-        this.connectionStateChangeHandler = (event) => {
-            if (this.rtc.rtcClient.connectionState !== 'connected') {
-                this.rtc.rtcClient.removeEventListener('connectionstatechange', this.connectionStateChangeHandler);
-                this.close();
-                if (__classPrivateFieldGet(this, _RTCEndpoint_disconnectListener, "f")) {
-                    __classPrivateFieldGet(this, _RTCEndpoint_disconnectListener, "f").call(this);
-                }
-            }
-        };
-        this.send = async (action, payload) => {
-            const messageId = `message-${Math.random()}`;
-            const promise = new Promise((resolve, reject) => {
-                this.responseMap.set(messageId, { resolve, reject });
-            });
-            this.rtc.channels.request.send(JSON.stringify({ action, payload, messageId }));
-            return promise;
-        };
-        this.close = () => {
-            this.responseMap.forEach((response) => response.reject('Connection has closed.'));
-            this.responseMap = new Map();
-            this.rtc.channels.request.close();
-            this.rtc.channels.response.close();
-            this.rtc.rtcClient.close();
-        };
-        this.rtc.channels.response.addEventListener('message', (e) => {
-            var _a;
-            let { data } = e;
-            if (e.data instanceof ArrayBuffer) {
-                data = new TextDecoder().decode(e.data);
-            }
-            const { messageId, payload, success, error } = JSON.parse(data);
-            const { resolve, reject } = (_a = this.responseMap.get(messageId)) !== null && _a !== void 0 ? _a : {};
-            if (resolve && reject) {
-                this.responseMap.delete(messageId);
-                if (success) {
-                    resolve(payload);
-                }
-                else {
-                    reject(error);
-                }
-            }
-            else {
-                console.log('Could not find id in responseMap.');
-                console.log(e);
-            }
-        });
-        this.rtc.channels.request.addEventListener('message', async (e) => {
-            let { data } = e;
-            if (e.data instanceof ArrayBuffer) {
-                data = new TextDecoder().decode(e.data);
-            }
-            const { messageId, action, payload } = JSON.parse(data);
-            if (__classPrivateFieldGet(this, _RTCEndpoint_processAction, "f")) {
-                try {
-                    const res = await __classPrivateFieldGet(this, _RTCEndpoint_processAction, "f").call(this, action, payload, endpointIdentity);
-                    this.rtc.channels.response.send(JSON.stringify({
-                        messageId,
-                        payload: res,
-                        success: true
-                    }));
-                }
-                catch (error) {
-                    // Check if RTCDataChannel is open before sending, error gets swallowed here in the case where
-                    // client dispatched then closed or disconnected before the dispatch resolves.
-                    if (this.rtc.channels.response.readyState === 'open') {
-                        this.rtc.channels.response.send(JSON.stringify({
-                            messageId,
-                            error: (0, errors_1.errorToPOJO)(error),
-                            success: false
-                        }));
-                    }
-                }
-                // Check if RTCDataChannel is open for same reason as catch block above.
-            }
-            else if (this.rtc.channels.response.readyState === 'open') {
-                this.rtc.channels.response.send(JSON.stringify({
-                    messageId,
-                    success: false,
-                    error: 'Connection not ready.'
-                }));
-            }
-        });
-        this.rtc.rtcClient.addEventListener('connectionstatechange', this.connectionStateChangeHandler);
-        // Disconnect if data channels close unexpectedly, e.g. can happen due to message size > ~255kB (RTCPeerConnection.sctp.maxMessageSizeLimit: 262144)
-        Object.values(this.rtc.channels).forEach((datachannel) => {
-            datachannel.onclose = (e) => {
-                [...this.responseMap.values()].forEach((promise) => promise.reject(new Error('RTCDataChannel closed unexpectedly, this is most commonly caused by message size. Note: RTC Channels have a message size limit of ~255kB.')));
-                this.close();
-                if (__classPrivateFieldGet(this, _RTCEndpoint_disconnectListener, "f")) {
-                    __classPrivateFieldGet(this, _RTCEndpoint_disconnectListener, "f").call(this);
-                }
-            };
-        });
-    }
-    onDisconnect(listener) {
-        if (!__classPrivateFieldGet(this, _RTCEndpoint_disconnectListener, "f")) {
-            __classPrivateFieldSet(this, _RTCEndpoint_disconnectListener, listener, "f");
-        }
-        else {
-            throw new Error('RTCEndpoint disconnectListener cannot be set twice.');
-        }
-    }
-    receive(listener) {
-        if (__classPrivateFieldGet(this, _RTCEndpoint_processAction, "f")) {
-            throw new Error('You have already set a listener for this RTC Endpoint.');
-        }
-        __classPrivateFieldSet(this, _RTCEndpoint_processAction, listener, "f");
-    }
-    get connected() {
-        return this.rtc.rtcClient.connectionState === 'connected';
-    }
-}
-exports.RTCEndpoint = RTCEndpoint;
-_RTCEndpoint_processAction = new WeakMap(), _RTCEndpoint_disconnectListener = new WeakMap();

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

@@ -1,30 +0,0 @@
-import { Transport } from '../../../../../transport/transport';
-import { EmitterBase } from '../../../../base';
-import { RTCEndpointChannels } from './endpoint';
-export declare class RTCICEManager extends EmitterBase<any> {
-    constructor(wire: Transport);
-    static createDataChannelPromise(label: string, rtcClient: RTCPeerConnection): Promise<RTCDataChannel>;
-    ensureChannelOpened: (channel: RTCDataChannel) => Promise<void>;
-    listenForProviderIce(rtcConnectionId: string, listener: any): Promise<void>;
-    raiseProviderIce(rtcConnectionId: string, payload: any): Promise<void>;
-    listenForClientIce(rtcConnectionId: string, listener: any): Promise<void>;
-    raiseClientIce(rtcConnectionId: string, payload: any): Promise<void>;
-    private cleanupIceListeners;
-    private createClientEventName;
-    private createProviderEventName;
-    private createRouteString;
-    private createRtcPeer;
-    startClientOffer(): Promise<{
-        rtcClient: RTCPeerConnection;
-        offer: RTCSessionDescriptionInit;
-        channels: RTCEndpointChannels;
-        rtcConnectionId: string;
-        channelsOpened: Promise<void>;
-    }>;
-    finishClientOffer(rtcClient: RTCPeerConnection, answer: RTCSessionDescriptionInit, providerReady: Promise<void>): Promise<boolean>;
-    createProviderAnswer(rtcConnectionId: string, offer: RTCSessionDescriptionInit): Promise<{
-        rtcClient: RTCPeerConnection;
-        answer: RTCSessionDescriptionInit;
-        channels: Promise<RTCEndpointChannels>;
-    }>;
-}

package/src/api/interappbus/channel/protocols/rtc/ice-manager.js

@@ -1,130 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.RTCICEManager = void 0;
-const base_1 = require("../../../../base");
-/*
-Singleton that facilitates Offer and Answer exchange required for establishing RTC connections.
-*/
-class RTCICEManager extends base_1.EmitterBase {
-    constructor(wire) {
-        super(wire, 'channel');
-        this.ensureChannelOpened = (channel) => {
-            return new Promise((resolve, reject) => {
-                if (channel.readyState === 'open') {
-                    resolve();
-                }
-                else if (channel.readyState === 'connecting') {
-                    const listener = () => {
-                        channel.removeEventListener('open', listener);
-                        resolve();
-                    };
-                    channel.addEventListener('open', listener);
-                }
-                else {
-                    reject(new Error('This Channel has already closed'));
-                }
-            });
-        };
-    }
-    static createDataChannelPromise(label, rtcClient) {
-        let resolver;
-        const promise = new Promise((resolve) => {
-            resolver = resolve;
-        });
-        const listener = (e) => {
-            const openListener = () => {
-                e.channel.removeEventListener('open', openListener);
-                resolver(e.channel);
-            };
-            if (e.channel.label === label) {
-                e.channel.addEventListener('open', openListener);
-                rtcClient.removeEventListener('datachannel', listener);
-            }
-        };
-        rtcClient.addEventListener('datachannel', listener);
-        return promise;
-    }
-    async listenForProviderIce(rtcConnectionId, listener) {
-        await this.on(this.createProviderEventName(rtcConnectionId), listener, { timestamp: Date.now() });
-    }
-    async raiseProviderIce(rtcConnectionId, payload) {
-        await this.wire.environment.raiseEvent(this.createRouteString(this.createProviderEventName(rtcConnectionId)), payload);
-    }
-    async listenForClientIce(rtcConnectionId, listener) {
-        await this.on(this.createClientEventName(rtcConnectionId), listener, { timestamp: Date.now() });
-    }
-    async raiseClientIce(rtcConnectionId, payload) {
-        await this.wire.environment.raiseEvent(this.createRouteString(this.createClientEventName(rtcConnectionId)), payload);
-    }
-    cleanupIceListeners(rtcConnectionId) {
-        this.removeAllListeners(this.createClientEventName(rtcConnectionId));
-        this.removeAllListeners(this.createProviderEventName(rtcConnectionId));
-    }
-    createClientEventName(rtcConnectionId) {
-        return `ice-client-${rtcConnectionId}`;
-    }
-    createProviderEventName(rtcConnectionId) {
-        return `ice-provider-${rtcConnectionId}`;
-    }
-    createRouteString(name) {
-        return `channel/${name}`;
-    }
-    createRtcPeer() {
-        return this.wire.environment.getRtcPeer();
-    }
-    async startClientOffer() {
-        // TODO replace with real guid.
-        const rtcConnectionId = Math.random().toString();
-        const rtcClient = this.createRtcPeer();
-        rtcClient.addEventListener('icecandidate', async (e) => {
-            var _a;
-            if (e.candidate) {
-                await this.raiseClientIce(rtcConnectionId, { candidate: (_a = e.candidate) === null || _a === void 0 ? void 0 : _a.toJSON() });
-            }
-        });
-        await this.listenForProviderIce(rtcConnectionId, async (payload) => {
-            await rtcClient.addIceCandidate(payload.candidate);
-        });
-        const channels = {
-            request: rtcClient.createDataChannel('request'),
-            response: rtcClient.createDataChannel('response')
-        };
-        const offer = await rtcClient.createOffer();
-        await rtcClient.setLocalDescription(offer);
-        const channelsOpened = Promise.all([channels.request, channels.response].map(this.ensureChannelOpened)).then(() => undefined);
-        return { rtcClient, channels, offer, rtcConnectionId, channelsOpened };
-    }
-    async finishClientOffer(rtcClient, answer, providerReady) {
-        await rtcClient.setRemoteDescription(answer);
-        await providerReady;
-        return true;
-    }
-    async createProviderAnswer(rtcConnectionId, offer) {
-        const rtcClient = this.createRtcPeer();
-        const requestChannelPromise = RTCICEManager.createDataChannelPromise('request', rtcClient);
-        const responseChannelPromise = RTCICEManager.createDataChannelPromise('response', rtcClient);
-        rtcClient.addEventListener('icecandidate', async (e) => {
-            var _a;
-            if (e.candidate) {
-                await this.raiseProviderIce(rtcConnectionId, { candidate: (_a = e.candidate) === null || _a === void 0 ? void 0 : _a.toJSON() });
-            }
-        });
-        await this.listenForClientIce(rtcConnectionId, async (payload) => {
-            await rtcClient.addIceCandidate(payload.candidate);
-        });
-        await rtcClient.setRemoteDescription(offer);
-        const answer = await rtcClient.createAnswer();
-        await rtcClient.setLocalDescription(answer);
-        const channels = Promise.all([requestChannelPromise, responseChannelPromise]).then(([request, response]) => {
-            // Clean up ice events.
-            this.cleanupIceListeners(rtcConnectionId);
-            return { request, response };
-        });
-        return {
-            rtcClient,
-            answer,
-            channels
-        };
-    }
-}
-exports.RTCICEManager = RTCICEManager;

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

@@ -1,24 +0,0 @@
-import type * as OpenFin from '../../../../../OpenFin';
-import { ChannelStrategy } from '../strategy';
-import { RTCPacket } from './endpoint';
-import { LocalSupportedProtocol } from '..';
-type ProviderIdentity = OpenFin.ProviderIdentity;
-export interface RTCStrategyEndpointPayload {
-    endpointIdentity: OpenFin.ClientIdentity | ProviderIdentity;
-    rtc: RTCPacket;
-}
-export declare class RTCStrategy implements ChannelStrategy<RTCStrategyEndpointPayload> {
-    #private;
-    onEndpointDisconnect(endpointId: string, listener: () => void): void;
-    receive(listener: (action: string, payload: any, identity: OpenFin.ClientIdentity | OpenFin.ClientIdentityMultiRuntime | ProviderIdentity) => Promise<any>): void;
-    send: (endpointId: string, action: string, payload: any) => Promise<any>;
-    close: () => Promise<void>;
-    private getEndpointById;
-    get connected(): boolean;
-    isEndpointConnected(endpointId: string): boolean;
-    addEndpoint(endpointId: string, payload: RTCStrategyEndpointPayload): void;
-    closeEndpoint(endpointId: string): Promise<void>;
-    isValidEndpointPayload(payload: any): payload is RTCStrategyEndpointPayload;
-}
-export declare const RTCInfo: LocalSupportedProtocol;
-export {};

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

@@ -1,85 +0,0 @@
-"use strict";
-var __classPrivateFieldGet = (this && this.__classPrivateFieldGet) || function (receiver, state, kind, f) {
-    if (kind === "a" && !f) throw new TypeError("Private accessor was defined without a getter");
-    if (typeof state === "function" ? receiver !== state || !f : !state.has(receiver)) throw new TypeError("Cannot read private member from an object whose class did not declare it");
-    return kind === "m" ? f : kind === "a" ? f.call(receiver) : f ? f.value : state.get(receiver);
-};
-var __classPrivateFieldSet = (this && this.__classPrivateFieldSet) || function (receiver, state, value, kind, f) {
-    if (kind === "m") throw new TypeError("Private method is not writable");
-    if (kind === "a" && !f) throw new TypeError("Private accessor was defined without a setter");
-    if (typeof state === "function" ? receiver !== state || !f : !state.has(receiver)) throw new TypeError("Cannot write private member to an object whose class did not declare it");
-    return (kind === "a" ? f.call(receiver, value) : f ? f.value = value : state.set(receiver, value)), value;
-};
-var _RTCStrategy_processAction, _RTCStrategy_rtcEndpointMap, _RTCStrategy_connected;
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.RTCInfo = exports.RTCStrategy = void 0;
-const endpoint_1 = require("./endpoint");
-/*
-This is used to abstract out rtc messaging from the channels implementation using RTCEndpoints.
-*/
-class RTCStrategy {
-    constructor() {
-        _RTCStrategy_processAction.set(this, null);
-        _RTCStrategy_rtcEndpointMap.set(this, new Map());
-        _RTCStrategy_connected.set(this, true);
-        this.send = async (endpointId, action, payload) => {
-            return this.getEndpointById(endpointId).send(action, payload);
-        };
-        this.close = async () => {
-            if (__classPrivateFieldGet(this, _RTCStrategy_connected, "f")) {
-                __classPrivateFieldGet(this, _RTCStrategy_rtcEndpointMap, "f").forEach((rtcEndpoint) => rtcEndpoint.close());
-                __classPrivateFieldSet(this, _RTCStrategy_rtcEndpointMap, new Map(), "f");
-            }
-            __classPrivateFieldSet(this, _RTCStrategy_connected, false, "f");
-        };
-    }
-    onEndpointDisconnect(endpointId, listener) {
-        this.getEndpointById(endpointId).onDisconnect(listener);
-    }
-    receive(listener) {
-        if (__classPrivateFieldGet(this, _RTCStrategy_processAction, "f")) {
-            throw new Error('You have already set a listener for this RTC Strategy');
-        }
-        __classPrivateFieldSet(this, _RTCStrategy_processAction, listener, "f");
-        __classPrivateFieldGet(this, _RTCStrategy_rtcEndpointMap, "f").forEach((rtcEndpoint) => rtcEndpoint.receive(__classPrivateFieldGet(this, _RTCStrategy_processAction, "f")));
-    }
-    getEndpointById(endpointId) {
-        const endpoint = __classPrivateFieldGet(this, _RTCStrategy_rtcEndpointMap, "f").get(endpointId);
-        if (!endpoint) {
-            throw new Error(`Client with endpoint id ${endpointId} is not connected`);
-        }
-        return endpoint;
-    }
-    get connected() {
-        return __classPrivateFieldGet(this, _RTCStrategy_connected, "f");
-    }
-    isEndpointConnected(endpointId) {
-        return __classPrivateFieldGet(this, _RTCStrategy_rtcEndpointMap, "f").has(endpointId);
-    }
-    addEndpoint(endpointId, payload) {
-        if (!__classPrivateFieldGet(this, _RTCStrategy_connected, "f")) {
-            console.warn('Adding endpoint to disconnected RTC Strategy');
-            return;
-        }
-        const clientStrat = new endpoint_1.RTCEndpoint(payload.rtc, payload.endpointIdentity);
-        if (__classPrivateFieldGet(this, _RTCStrategy_processAction, "f")) {
-            clientStrat.receive(__classPrivateFieldGet(this, _RTCStrategy_processAction, "f"));
-        }
-        __classPrivateFieldGet(this, _RTCStrategy_rtcEndpointMap, "f").set(endpointId, clientStrat);
-    }
-    async closeEndpoint(endpointId) {
-        __classPrivateFieldGet(this, _RTCStrategy_rtcEndpointMap, "f").delete(endpointId);
-    }
-    isValidEndpointPayload(payload) {
-        const isObject = (x) => {
-            return typeof x === 'object' && x !== null;
-        };
-        return (isObject(payload) &&
-            isObject(payload.endpointIdentity) &&
-            isObject(payload.rtc) &&
-            typeof payload.endpointIdentity.endpointId === 'string');
-    }
-}
-exports.RTCStrategy = RTCStrategy;
-_RTCStrategy_processAction = new WeakMap(), _RTCStrategy_rtcEndpointMap = new WeakMap(), _RTCStrategy_connected = new WeakMap();
-exports.RTCInfo = { version: 2, minimumVersion: 0, type: 'rtc' };

package/src/api/interappbus/channel/protocols/strategy-types.d.ts

@@ -1,13 +0,0 @@
-import { MessagingProtocols } from '.';
-import { ClassicStrategy } from './classic/strategy';
-import CombinedStrategy from './combined/strategy';
-import { RTCStrategy } from './rtc/strategy';
-import { ChannelStrategy } from './strategy';
-type StrategyMap = {
-    rtc: RTCStrategy;
-    classic: ClassicStrategy;
-};
-export type StrategyByProtocol<T extends MessagingProtocols> = StrategyMap[T];
-export type PayloadTypeByStrategy<T extends ChannelStrategy<unknown>> = T extends ChannelStrategy<infer U> ? U : never;
-export type AnyStrategy = ClassicStrategy | RTCStrategy | CombinedStrategy<PayloadTypeByStrategy<RTCStrategy>, PayloadTypeByStrategy<ClassicStrategy>>;
-export {};

package/src/api/interappbus/channel/protocols/strategy-types.js

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

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

@@ -1,17 +0,0 @@
-import type * as OpenFin from '../../../../OpenFin';
-type ProviderIdentity = OpenFin.ProviderIdentity;
-export interface ChannelStrategy<T extends unknown> {
-    onEndpointDisconnect(endpointId: string, listener: () => void): void;
-    receive(listener: (action: string, payload: any, identity: any) => Promise<any>): void;
-    send(endpointId: string, action: string, payload: any): Promise<any>;
-    closeEndpoint(endpointId: string): Promise<void>;
-    close(): Promise<void>;
-    isEndpointConnected(endpointId: string): boolean;
-    addEndpoint(endpointId: string, payload: T): void;
-    isValidEndpointPayload(payload: unknown): payload is T;
-}
-export type EndpointIdentity = OpenFin.ClientIdentity | ProviderIdentity;
-export type EndpointPayload = {
-    endpointIdentity: EndpointIdentity;
-};
-export {};