@openfin/core 25.68.30 → 25.70.2

package/src/api/interappbus/channel/client.d.ts

@@ -1,22 +1,22 @@
-import { ChannelBase } from './channel';
-import Transport from '../../../transport/transport';
-import { AnyStrategy } from './protocols/strategy-types';
-import ProviderIdentity = OpenFin.ProviderIdentity;
-declare type DisconnectionListener = (providerIdentity: ProviderIdentity) => any;
-interface RoutingInfo extends ProviderIdentity {
-    endpointId: string;
-}
-export default class ChannelClient extends ChannelBase {
-    #private;
-    private disconnectListener;
-    private endpointId;
-    static closeChannelByEndpointId(id: string): void;
-    static handleProviderDisconnect(channel: ChannelClient, eventPayload: ProviderIdentity): void;
-    constructor(routingInfo: RoutingInfo, wire: Transport, strategy: AnyStrategy);
-    protected processAction: (action: string, payload: any, senderIdentity: ProviderIdentity | OpenFin.ClientIdentity) => Promise<any>;
-    get providerIdentity(): ProviderIdentity;
-    dispatch(action: string, payload?: any): Promise<any>;
-    onDisconnection(listener: DisconnectionListener): void;
-    disconnect(): Promise<void>;
-}
-export {};
+import { ChannelBase } from './channel';
+import Transport from '../../../transport/transport';
+import { AnyStrategy } from './protocols/strategy-types';
+import ProviderIdentity = OpenFin.ProviderIdentity;
+declare type DisconnectionListener = (providerIdentity: ProviderIdentity) => any;
+interface RoutingInfo extends ProviderIdentity {
+    endpointId: string;
+}
+export default class ChannelClient extends ChannelBase {
+    #private;
+    private disconnectListener;
+    private endpointId;
+    static closeChannelByEndpointId(id: string): void;
+    static handleProviderDisconnect(channel: ChannelClient, eventPayload: ProviderIdentity): void;
+    constructor(routingInfo: RoutingInfo, wire: Transport, strategy: AnyStrategy);
+    protected processAction: (action: string, payload: any, senderIdentity: ProviderIdentity | OpenFin.ClientIdentity) => Promise<any>;
+    get providerIdentity(): ProviderIdentity;
+    dispatch(action: string, payload?: any): Promise<any>;
+    onDisconnection(listener: DisconnectionListener): void;
+    disconnect(): Promise<void>;
+}
+export {};

package/src/api/interappbus/channel/client.js

@@ -1,84 +1,84 @@
-"use strict";
-var __classPrivateFieldSet = (this && this.__classPrivateFieldSet) || function (receiver, privateMap, value) {
-    if (!privateMap.has(receiver)) {
-        throw new TypeError("attempted to set private field on non-instance");
-    }
-    privateMap.set(receiver, value);
-    return value;
-};
-var __classPrivateFieldGet = (this && this.__classPrivateFieldGet) || function (receiver, privateMap) {
-    if (!privateMap.has(receiver)) {
-        throw new TypeError("attempted to get private field on non-instance");
-    }
-    return privateMap.get(receiver);
-};
-var _protectedObj, _strategy, _close;
-Object.defineProperty(exports, "__esModule", { value: true });
-const channel_1 = require("./channel");
-const channelClientsByEndpointId = new Map();
-class ChannelClient extends channel_1.ChannelBase {
-    constructor(routingInfo, wire, strategy) {
-        super();
-        _protectedObj.set(this, void 0);
-        _strategy.set(this, void 0);
-        // needs to be bound;
-        this.processAction = (action, payload, senderIdentity) => super.processAction(action, payload, senderIdentity);
-        _close.set(this, () => {
-            channelClientsByEndpointId.delete(this.endpointId);
-            __classPrivateFieldGet(this, _strategy).close();
-        });
-        __classPrivateFieldSet(this, _protectedObj, new channel_1.ProtectedItems(routingInfo, wire));
-        this.disconnectListener = () => undefined;
-        this.endpointId = routingInfo.endpointId;
-        __classPrivateFieldSet(this, _strategy, strategy);
-        channelClientsByEndpointId.set(this.endpointId, this);
-        strategy.receive(this.processAction);
-    }
-    static closeChannelByEndpointId(id) {
-        const channel = channelClientsByEndpointId.get(id);
-        if (channel) {
-            __classPrivateFieldGet(channel, _close).call(channel);
-        }
-    }
-    // closes the channel and invokes the disconnect listener if an event payload is passed.
-    static handleProviderDisconnect(channel, eventPayload) {
-        channel.disconnectListener(eventPayload);
-        __classPrivateFieldGet(channel, _close).call(channel);
-    }
-    get providerIdentity() {
-        const protectedObj = __classPrivateFieldGet(this, _protectedObj);
-        return protectedObj.providerIdentity;
-    }
-    async dispatch(action, payload) {
-        if (__classPrivateFieldGet(this, _strategy).isEndpointConnected(this.providerIdentity.channelId)) {
-            return __classPrivateFieldGet(this, _strategy).send(this.providerIdentity.channelId, action, payload);
-        }
-        throw new Error('The client you are trying to dispatch from is disconnected from the target provider.');
-    }
-    onDisconnection(listener) {
-        this.disconnectListener = (payload) => {
-            try {
-                listener(payload);
-            }
-            catch (err) {
-                throw new Error(`Error while calling the onDisconnection callback: ${err.message}`);
-            }
-            finally {
-                this.disconnectListener = () => undefined;
-            }
-        };
-    }
-    async disconnect() {
-        const protectedObj = __classPrivateFieldGet(this, _protectedObj);
-        const { channelName, uuid, name } = protectedObj.providerIdentity;
-        await protectedObj.wire.sendAction('disconnect-from-channel', {
-            channelName,
-            uuid,
-            name,
-            endpointId: this.endpointId
-        });
-        __classPrivateFieldGet(this, _close).call(this);
-    }
-}
-exports.default = ChannelClient;
-_protectedObj = new WeakMap(), _strategy = new WeakMap(), _close = new WeakMap();
+"use strict";
+var __classPrivateFieldSet = (this && this.__classPrivateFieldSet) || function (receiver, privateMap, value) {
+    if (!privateMap.has(receiver)) {
+        throw new TypeError("attempted to set private field on non-instance");
+    }
+    privateMap.set(receiver, value);
+    return value;
+};
+var __classPrivateFieldGet = (this && this.__classPrivateFieldGet) || function (receiver, privateMap) {
+    if (!privateMap.has(receiver)) {
+        throw new TypeError("attempted to get private field on non-instance");
+    }
+    return privateMap.get(receiver);
+};
+var _protectedObj, _strategy, _close;
+Object.defineProperty(exports, "__esModule", { value: true });
+const channel_1 = require("./channel");
+const channelClientsByEndpointId = new Map();
+class ChannelClient extends channel_1.ChannelBase {
+    constructor(routingInfo, wire, strategy) {
+        super();
+        _protectedObj.set(this, void 0);
+        _strategy.set(this, void 0);
+        // needs to be bound;
+        this.processAction = (action, payload, senderIdentity) => super.processAction(action, payload, senderIdentity);
+        _close.set(this, () => {
+            channelClientsByEndpointId.delete(this.endpointId);
+            __classPrivateFieldGet(this, _strategy).close();
+        });
+        __classPrivateFieldSet(this, _protectedObj, new channel_1.ProtectedItems(routingInfo, wire));
+        this.disconnectListener = () => undefined;
+        this.endpointId = routingInfo.endpointId;
+        __classPrivateFieldSet(this, _strategy, strategy);
+        channelClientsByEndpointId.set(this.endpointId, this);
+        strategy.receive(this.processAction);
+    }
+    static closeChannelByEndpointId(id) {
+        const channel = channelClientsByEndpointId.get(id);
+        if (channel) {
+            __classPrivateFieldGet(channel, _close).call(channel);
+        }
+    }
+    // closes the channel and invokes the disconnect listener if an event payload is passed.
+    static handleProviderDisconnect(channel, eventPayload) {
+        channel.disconnectListener(eventPayload);
+        __classPrivateFieldGet(channel, _close).call(channel);
+    }
+    get providerIdentity() {
+        const protectedObj = __classPrivateFieldGet(this, _protectedObj);
+        return protectedObj.providerIdentity;
+    }
+    async dispatch(action, payload) {
+        if (__classPrivateFieldGet(this, _strategy).isEndpointConnected(this.providerIdentity.channelId)) {
+            return __classPrivateFieldGet(this, _strategy).send(this.providerIdentity.channelId, action, payload);
+        }
+        throw new Error('The client you are trying to dispatch from is disconnected from the target provider.');
+    }
+    onDisconnection(listener) {
+        this.disconnectListener = (payload) => {
+            try {
+                listener(payload);
+            }
+            catch (err) {
+                throw new Error(`Error while calling the onDisconnection callback: ${err.message}`);
+            }
+            finally {
+                this.disconnectListener = () => undefined;
+            }
+        };
+    }
+    async disconnect() {
+        const protectedObj = __classPrivateFieldGet(this, _protectedObj);
+        const { channelName, uuid, name } = protectedObj.providerIdentity;
+        await protectedObj.wire.sendAction('disconnect-from-channel', {
+            channelName,
+            uuid,
+            name,
+            endpointId: this.endpointId
+        });
+        __classPrivateFieldGet(this, _close).call(this);
+    }
+}
+exports.default = ChannelClient;
+_protectedObj = new WeakMap(), _strategy = new WeakMap(), _close = new WeakMap();

package/src/api/interappbus/channel/connection-manager.d.ts

@@ -1,28 +1,28 @@
-import { ChannelMessage } from '.';
-import Transport from '../../../transport/transport';
-import { Base } from '../../base';
-import { ClientOffer, LocalSupportedProtocol } from './protocols/index';
-import { RTCPacket } from './protocols/rtc/endpoint';
-import { ChannelProvider } from './provider';
-import { AnyStrategy } from './protocols/strategy-types';
-export declare type ProviderEntry = {
-    provider: ChannelProvider;
-    strategy: AnyStrategy;
-    supportedProtocols: LocalSupportedProtocol[];
-};
-export declare class ConnectionManager extends Base {
-    #private;
-    private protocolManager;
-    private providerMap;
-    private static getProtocolOptionsFromStrings;
-    constructor(wire: Transport);
-    createProvider(options: OpenFin.ChannelCreateOptions | undefined, providerIdentity: any): ChannelProvider;
-    createClientOffer(options?: OpenFin.ChannelConnectOptions): Promise<{
-        offer: ClientOffer;
-        rtc?: RTCPacket;
-    }>;
-    createClientStrategy(rtcPacket: RTCPacket | undefined, routingInfo: any): Promise<AnyStrategy>;
-    removeChannelFromProviderMap: (channelId: string) => void;
-    onmessage: (msg: ChannelMessage) => boolean;
-    private processChannelConnection;
-}
+import { ChannelMessage } from '.';
+import Transport from '../../../transport/transport';
+import { Base } from '../../base';
+import { ClientOffer, LocalSupportedProtocol } from './protocols/index';
+import { RTCPacket } from './protocols/rtc/endpoint';
+import { ChannelProvider } from './provider';
+import { AnyStrategy } from './protocols/strategy-types';
+export declare type ProviderEntry = {
+    provider: ChannelProvider;
+    strategy: AnyStrategy;
+    supportedProtocols: LocalSupportedProtocol[];
+};
+export declare class ConnectionManager extends Base {
+    #private;
+    private protocolManager;
+    private providerMap;
+    private static getProtocolOptionsFromStrings;
+    constructor(wire: Transport);
+    createProvider(options: OpenFin.ChannelCreateOptions | undefined, providerIdentity: any): ChannelProvider;
+    createClientOffer(options?: OpenFin.ChannelConnectOptions): Promise<{
+        offer: ClientOffer;
+        rtc?: RTCPacket;
+    }>;
+    createClientStrategy(rtcPacket: RTCPacket | undefined, routingInfo: any): Promise<AnyStrategy>;
+    removeChannelFromProviderMap: (channelId: string) => void;
+    onmessage: (msg: ChannelMessage) => boolean;
+    private processChannelConnection;
+}