@openfin/core 32.75.13 → 32.75.18

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "@openfin/core",
-    "version": "32.75.13",
+    "version": "32.75.18",
     "license": "SEE LICENSE IN LICENSE.MD",
     "main": "./src/mock.js",
     "types": "./src/mock.d.ts",

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

@@ -19,22 +19,24 @@ const provider_1 = require("./provider");
 const base_1 = require("../../base");
 const connection_manager_1 = require("./connection-manager");
 const events_1 = require("events");
+const lazy_1 = require("../../../util/lazy");
 class Channel extends base_1.EmitterBase {
     constructor(wire) {
         super(wire, 'channel');
         _Channel_connectionManager.set(this, void 0);
         _Channel_internalEmitter.set(this, new events_1.EventEmitter());
-        _Channel_readyToConnect.set(this, void 0);
-        __classPrivateFieldSet(this, _Channel_connectionManager, new connection_manager_1.ConnectionManager(wire), "f");
         // OpenFin API has not been injected at construction time, *must* wait for API to be ready.
-        __classPrivateFieldSet(this, _Channel_readyToConnect, this.wire.environment.whenReady().then(() => {
-            this.on('disconnected', (eventPayload) => {
-                client_1.default.handleProviderDisconnect(eventPayload);
-            }).catch((e) => console.error('Error setting up a disconnected listener:', e));
-            return this.on('connected', (...args) => {
-                __classPrivateFieldGet(this, _Channel_internalEmitter, "f").emit('connected', ...args);
-            });
-        }), "f");
+        _Channel_readyToConnect.set(this, new lazy_1.AsyncRetryableLazy(async () => {
+            await Promise.all([
+                this.on('disconnected', (eventPayload) => {
+                    client_1.default.handleProviderDisconnect(eventPayload);
+                }),
+                this.on('connected', (...args) => {
+                    __classPrivateFieldGet(this, _Channel_internalEmitter, "f").emit('connected', ...args);
+                })
+            ]).catch(() => new Error('error setting up channel connection listeners'));
+        }));
+        __classPrivateFieldSet(this, _Channel_connectionManager, new connection_manager_1.ConnectionManager(wire), "f");
     }
     async channelExists(channelName) {
         const channels = await this.getAllChannels();
@@ -50,6 +52,9 @@ class Channel extends base_1.EmitterBase {
         await this.on('disconnected', listener);
     }
     async connect(channelName, options = {}) {
+        // Make sure we don't connect before listeners are set up
+        // This also errors if we're not in OpenFin, ensuring we don't run unnecessary code
+        await __classPrivateFieldGet(this, _Channel_readyToConnect, "f").getValue();
         if (!channelName || typeof channelName !== 'string') {
             throw new Error('Please provide a channelName string to connect to a channel.');
         }
@@ -59,8 +64,6 @@ class Channel extends base_1.EmitterBase {
             const channelExists = await this.channelExists(channelName);
             if (!channelExists) {
                 console.warn(`Channel not found for channelName: ${channelName}, waiting for channel connection.`);
-                // Safeguard to ensure 'connected' listener was already added if we need to wait.
-                await __classPrivateFieldGet(this, _Channel_readyToConnect, "f");
                 await new Promise((resolve) => {
                     const connectedListener = (payload) => {
                         if (channelName === payload.channelName) {

package/src/environment/mockEnvironment.d.ts

@@ -0,0 +1,27 @@
+import { Environment } from './environment';
+import type * as OpenFin from '../OpenFin';
+import { NewConnectConfig } from '../transport/wire';
+import { EntityType } from '../OpenFin';
+export declare class MockEnvironment implements Environment {
+    getDefaultChannelOptions(): {
+        create: OpenFin.ChannelCreateOptions;
+        connect: OpenFin.ChannelConnectOptions;
+    };
+    getRtcPeer(): RTCPeerConnection;
+    initLayout(): Promise<never>;
+    initPlatform(): Promise<never>;
+    observeBounds(): never;
+    writeToken(path: string, token: string): Promise<string>;
+    retrievePort(config: NewConnectConfig): Promise<number>;
+    getNextMessageId(): string;
+    getRandomId(): string;
+    createChildContent(options: any): Promise<any>;
+    getWebWindow(identity: OpenFin.Identity): globalThis.Window;
+    getCurrentEntityIdentity(): OpenFin.EntityInfo;
+    getCurrentEntityType(): EntityType;
+    raiseEvent(eventName: string, eventArgs: any): void;
+    getUrl(): string;
+    whenReady(): Promise<void>;
+    childViews: boolean;
+    getWsConstructor(): any;
+}

package/src/environment/mockEnvironment.js

@@ -0,0 +1,61 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.MockEnvironment = void 0;
+const me_1 = require("../api/me");
+class MockEnvironment {
+    constructor() {
+        this.childViews = true;
+    }
+    getDefaultChannelOptions() {
+        throw new Error(me_1.environmentUnsupportedMessage);
+    }
+    getRtcPeer() {
+        throw new Error(me_1.environmentUnsupportedMessage);
+    }
+    initLayout() {
+        throw new Error(me_1.environmentUnsupportedMessage);
+    }
+    initPlatform() {
+        throw new Error(me_1.environmentUnsupportedMessage);
+    }
+    observeBounds() {
+        throw new Error(me_1.environmentUnsupportedMessage);
+    }
+    writeToken(path, token) {
+        throw new Error(me_1.environmentUnsupportedMessage);
+    }
+    retrievePort(config) {
+        throw new Error(me_1.environmentUnsupportedMessage);
+    }
+    getNextMessageId() {
+        throw new Error(me_1.environmentUnsupportedMessage);
+    }
+    getRandomId() {
+        throw new Error(me_1.environmentUnsupportedMessage);
+    }
+    createChildContent(options) {
+        throw new Error(me_1.environmentUnsupportedMessage);
+    }
+    getWebWindow(identity) {
+        throw new Error(me_1.environmentUnsupportedMessage);
+    }
+    getCurrentEntityIdentity() {
+        throw new Error(me_1.environmentUnsupportedMessage);
+    }
+    getCurrentEntityType() {
+        return 'unknown';
+    }
+    raiseEvent(eventName, eventArgs) {
+        throw new Error(me_1.environmentUnsupportedMessage);
+    }
+    getUrl() {
+        throw new Error(me_1.environmentUnsupportedMessage);
+    }
+    whenReady() {
+        throw new Error(me_1.environmentUnsupportedMessage);
+    }
+    getWsConstructor() {
+        throw new Error('Method not implemented.');
+    }
+}
+exports.MockEnvironment = MockEnvironment;

package/src/mock.js

@@ -1,97 +1,15 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.fin = void 0;
-/* eslint-disable import/prefer-default-export */
-/* eslint-disable spaced-comment */
-/* eslint-disable @typescript-eslint/triple-slash-reference */
-/* eslint-disable @typescript-eslint/explicit-function-return-type */
-/* eslint-disable class-methods-use-this */
-const events_1 = require("events");
 const OpenFin = require("./OpenFin");
 const fin_1 = require("./api/fin");
 const transport_1 = require("./transport/transport");
-const me_1 = require("./api/me");
-class MockWire extends events_1.EventEmitter {
-    connect(address) {
-        throw new Error('You are not running in OpenFin.');
-    }
-    connectSync() {
-        throw new Error('You are not running in OpenFin.');
-    }
-    send(data) {
-        throw new Error('You are not running in OpenFin.');
-    }
-    shutdown() {
-        throw new Error('You are not running in OpenFin.');
-    }
-    getPort() {
-        throw new Error('This transport has no port');
-    }
-    // eslint-disable-next-line no-useless-constructor
-    constructor() {
-        super();
-    }
-}
-class MockEnvironment {
-    constructor() {
-        this.childViews = true;
-    }
-    getDefaultChannelOptions() {
-        throw new Error(me_1.environmentUnsupportedMessage);
-    }
-    getRtcPeer() {
-        throw new Error(me_1.environmentUnsupportedMessage);
-    }
-    initLayout() {
-        throw new Error(me_1.environmentUnsupportedMessage);
-    }
-    initPlatform() {
-        throw new Error(me_1.environmentUnsupportedMessage);
-    }
-    observeBounds() {
-        throw new Error(me_1.environmentUnsupportedMessage);
-    }
-    writeToken(path, token) {
-        throw new Error(me_1.environmentUnsupportedMessage);
-    }
-    retrievePort(config) {
-        throw new Error(me_1.environmentUnsupportedMessage);
-    }
-    getNextMessageId() {
-        throw new Error(me_1.environmentUnsupportedMessage);
-    }
-    getRandomId() {
-        throw new Error(me_1.environmentUnsupportedMessage);
-    }
-    createChildContent(options) {
-        throw new Error(me_1.environmentUnsupportedMessage);
-    }
-    getWebWindow(identity) {
-        throw new Error(me_1.environmentUnsupportedMessage);
-    }
-    getCurrentEntityIdentity() {
-        throw new Error(me_1.environmentUnsupportedMessage);
-    }
-    getCurrentEntityType() {
-        return 'unknown';
-    }
-    raiseEvent(eventName, eventArgs) {
-        throw new Error(me_1.environmentUnsupportedMessage);
-    }
-    getUrl() {
-        throw new Error(me_1.environmentUnsupportedMessage);
-    }
-    whenReady() {
-        throw new Error(me_1.environmentUnsupportedMessage);
-    }
-    getWsConstructor() {
-        throw new Error('Method not implemented.');
-    }
-}
+const mockEnvironment_1 = require("./environment/mockEnvironment");
+const mockWire_1 = require("./transport/mockWire");
 exports.fin = ((typeof window !== 'undefined' && (window === null || window === void 0 ? void 0 : window.fin)) ||
     (() => {
-        const environment = new MockEnvironment();
-        const transport = new transport_1.Transport(MockWire, environment, {
+        const environment = new mockEnvironment_1.MockEnvironment();
+        const transport = new transport_1.Transport(mockWire_1.MockWire, environment, {
             uuid: '',
             name: ''
         });

package/src/shapes/protocol.d.ts

@@ -82,10 +82,8 @@ export interface ProtocolMap extends ProtocolMapBase {
         };
         response: OpenFin.NativeWindowIntegrationProviderAuthorization;
     };
-    'get-permissions': {
-        request: void;
-        response: any;
-    };
+    'get-permissions': GetterCall<any>;
+    'get-all-channels': GetterCall<OpenFin.ProviderIdentity[]>;
     'set-file-download-location': {
         request: OpenFin.ApplicationIdentity & {
             downloadLocation: string;
@@ -160,10 +158,7 @@ export interface ProtocolMap extends ProtocolMapBase {
         };
         response: void;
     };
-    'system-get-printers': {
-        request: void;
-        response: OpenFin.PrinterInfo[];
-    };
+    'system-get-printers': GetterCall<OpenFin.PrinterInfo[]>;
     'system-register-shutdown-handler': VoidCall;
 }
 type ApiCall<Request, Response> = {
@@ -171,6 +166,7 @@ type ApiCall<Request, Response> = {
     response: Response;
 };
 type VoidCall = ApiCall<void, void>;
+type GetterCall<T> = ApiCall<void, T>;
 type IdentityCall<AdditionalPayload = {}, Response = void> = ApiCall<AdditionalPayload & OpenFin.Identity, Response>;
 interface ProtocolMapBase {
     [action: string]: {

package/src/transport/mockWire.d.ts

@@ -0,0 +1,11 @@
+/// <reference types="node" />
+import { EventEmitter } from 'events';
+import { Wire } from './wire';
+export declare class MockWire extends EventEmitter implements Wire {
+    connect(address: string): Promise<any>;
+    connectSync(): any;
+    send(data: any): Promise<any>;
+    shutdown(): Promise<void>;
+    getPort(): string;
+    constructor();
+}

package/src/transport/mockWire.js

@@ -0,0 +1,26 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.MockWire = void 0;
+const events_1 = require("events");
+class MockWire extends events_1.EventEmitter {
+    connect(address) {
+        throw new Error('You are not running in OpenFin.');
+    }
+    connectSync() {
+        throw new Error('You are not running in OpenFin.');
+    }
+    send(data) {
+        throw new Error('You are not running in OpenFin.');
+    }
+    shutdown() {
+        throw new Error('You are not running in OpenFin.');
+    }
+    getPort() {
+        throw new Error('This transport has no port');
+    }
+    // eslint-disable-next-line no-useless-constructor
+    constructor() {
+        super();
+    }
+}
+exports.MockWire = MockWire;

package/src/util/lazy.d.ts

@@ -14,3 +14,21 @@ export declare class Lazy<T> {
      */
     getValue(): T;
 }
+/**
+ * Handy class for managing asynchronous dependencies of classes.
+ *
+ * Will call asynchronous producer only after `getValue` is called.  If the
+ * deferred code errors, we can try it again by re-calling `getValue` after
+ * the promise rejects.
+ */
+export declare class AsyncRetryableLazy<T> {
+    private producerFn;
+    constructor(producerFn: () => Promise<T>);
+    private promise?;
+    /**
+     * Lazily get the value returned by the async producer.
+     *
+     * @returns The value returned from the producer function
+     */
+    getValue(): Promise<T>;
+}

package/src/util/lazy.js

@@ -1,6 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.Lazy = void 0;
+exports.AsyncRetryableLazy = exports.Lazy = void 0;
 /**
  * Handy class for managing asynchronous dependencies of classes.
  *
@@ -24,3 +24,31 @@ class Lazy {
     }
 }
 exports.Lazy = Lazy;
+/**
+ * Handy class for managing asynchronous dependencies of classes.
+ *
+ * Will call asynchronous producer only after `getValue` is called.  If the
+ * deferred code errors, we can try it again by re-calling `getValue` after
+ * the promise rejects.
+ */
+class AsyncRetryableLazy {
+    // eslint-disable-next-line
+    constructor(producerFn) {
+        this.producerFn = producerFn;
+    }
+    /**
+     * Lazily get the value returned by the async producer.
+     *
+     * @returns The value returned from the producer function
+     */
+    async getValue() {
+        if (!this.promise) {
+            this.promise = this.producerFn().catch((e) => {
+                delete this.promise;
+                throw e;
+            });
+        }
+        return this.promise;
+    }
+}
+exports.AsyncRetryableLazy = AsyncRetryableLazy;