@openfin/core 31.74.1 → 31.74.2

package/src/transport/wire.d.ts

@@ -1,16 +1,17 @@
 /// <reference types="mocha" />
 /// <reference types="node" />
 import EventEmitter = NodeJS.EventEmitter;
-export declare type Wire = EventEmitter & {
+export type Wire = EventEmitter & {
     connect(address: string, WsConstructor: typeof WebSocket): Promise<any>;
     connectSync(): any;
     send(data: any): Promise<any>;
     shutdown(): Promise<void>;
+    getPort(): string;
 };
-export declare type WireConstructor = {
+export type WireConstructor = {
     new (onmessage: (data: any) => void): Wire;
 };
-export declare type RuntimeConfig = {
+export type RuntimeConfig = {
     version: string;
     fallbackVersion?: string;
     securityRealm?: string;
@@ -18,11 +19,11 @@ export declare type RuntimeConfig = {
     arguments?: string;
     rvmDir?: string;
 };
-export declare type ServiceConfig = {
+export type ServiceConfig = {
     name: string;
     manifestUrl: string;
 };
-export declare type BaseConfig = {
+export type BaseConfig = {
     uuid?: string;
     address?: string;
     name?: string;
@@ -50,22 +51,22 @@ export declare type BaseConfig = {
     customItems?: [any];
     timeout?: number;
 };
-export declare type ConfigWithUuid = BaseConfig & {
+export type ConfigWithUuid = BaseConfig & {
     uuid: string;
 };
-export declare type ExistingConnectConfig = ConfigWithUuid & {
+export type ExistingConnectConfig = ConfigWithUuid & {
     address: string;
 };
-export declare type ConfigWithRuntime = BaseConfig & {
+export type ConfigWithRuntime = BaseConfig & {
     runtime: RuntimeConfig;
 };
-export declare type ExternalConfig = BaseConfig & {
+export type ExternalConfig = BaseConfig & {
     manifestUrl: string;
 };
-export declare type NewConnectConfig = ConfigWithUuid & ConfigWithRuntime;
-export declare type PortDiscoveryConfig = (ExternalConfig & ConfigWithRuntime) | NewConnectConfig;
-export declare type ConnectConfig = ExistingConnectConfig | NewConnectConfig | ExternalConfig;
-export declare type InternalConnectConfig = ExistingConnectConfig | NewConnectConfig;
+export type NewConnectConfig = ConfigWithUuid & ConfigWithRuntime;
+export type PortDiscoveryConfig = (ExternalConfig & ConfigWithRuntime) | NewConnectConfig;
+export type ConnectConfig = ExistingConnectConfig | NewConnectConfig | ExternalConfig;
+export type InternalConnectConfig = ExistingConnectConfig | NewConnectConfig;
 export interface RemoteConfig extends ExistingConnectConfig {
     token: string;
 }

package/src/util/channel-api-relay.d.ts

@@ -0,0 +1,13 @@
+import type * as OpenFin from '../OpenFin';
+/**
+ * @internal
+ * Create a channel relay for a given channel exposition, allowing a single provider to route
+ * actions to the designated clients.
+ *
+ * Designed to be used in conjunction with @expose
+ *
+ * @param channelProvider The channel provider to relay the actions on.
+ * @param config Determines which actions to relay. Please ensure action prefix matches the exposed api.
+ */
+export declare const relayChannelClientApi: (channelProvider: OpenFin.ChannelProvider, relayId: string) => Promise<void>;
+export declare const createRelayedDispatch: (client: OpenFin.ChannelClient, target: OpenFin.Identity, relayId: string, relayErrorMsg?: string) => OpenFin.ChannelClient['dispatch'];

package/src/util/channel-api-relay.js

@@ -0,0 +1,37 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createRelayedDispatch = exports.relayChannelClientApi = void 0;
+/**
+ * @internal
+ * Create a channel relay for a given channel exposition, allowing a single provider to route
+ * actions to the designated clients.
+ *
+ * Designed to be used in conjunction with @expose
+ *
+ * @param channelProvider The channel provider to relay the actions on.
+ * @param config Determines which actions to relay. Please ensure action prefix matches the exposed api.
+ */
+const relayChannelClientApi = async (channelProvider, relayId) => {
+    channelProvider.register(`relay:${relayId}`, ({ action, target, payload }) => {
+        return channelProvider.dispatch(target, action, payload);
+    });
+    await Promise.resolve();
+};
+exports.relayChannelClientApi = relayChannelClientApi;
+const createRelayedDispatch = (client, target, relayId, relayErrorMsg) => async (action, payload) => {
+    try {
+        return await client.dispatch(`relay:${relayId}`, {
+            action,
+            payload,
+            target
+        });
+    }
+    catch (e) {
+        if (e.message.includes('no longer connected') && relayErrorMsg) {
+            throw new Error(relayErrorMsg);
+        }
+        ;
+        throw e;
+    }
+};
+exports.createRelayedDispatch = createRelayedDispatch;

package/src/util/errors.d.ts

@@ -1,8 +1,8 @@
 /**
  * This function converts JS errors into plain objects
  */
-export declare type ErrorPlainObject = {
-    stack: string;
+export type ErrorPlainObject = {
+    stack?: string;
     message: string;
     toString(): string;
 };

package/src/util/http.js

@@ -38,9 +38,10 @@ const getRequestOptions = (url) => {
 };
 exports.getRequestOptions = getRequestOptions;
 const fetch = async (url) => {
+    var _a;
     const requestUrl = getProxyVar() ? getProxyVar() : url;
     const proto = (0, url_1.parse)(requestUrl).protocol.slice(0, -1) === 'http' ? 'http' : 'https';
-    const fetcher = await Promise.resolve().then(() => require(proto));
+    const fetcher = await (_a = proto, Promise.resolve().then(() => require(_a)));
     return new Promise((resolve, reject) => {
         const options = (0, exports.getRequestOptions)(url);
         const request = fetcher.get(options, (response) => {
@@ -60,9 +61,10 @@ const fetch = async (url) => {
 };
 exports.fetch = fetch;
 const downloadFile = async (url, writeLocation) => {
+    var _a;
     const requestUrl = getProxyVar() ? getProxyVar() : url;
     const proto = (0, url_1.parse)(requestUrl).protocol.slice(0, -1) === 'http' ? 'http' : 'https';
-    const fetcher = await Promise.resolve().then(() => require(proto));
+    const fetcher = await (_a = proto, Promise.resolve().then(() => require(_a)));
     return new Promise((resolve, reject) => {
         try {
             const options = (0, exports.getRequestOptions)(url);

package/src/util/lazy.d.ts

@@ -0,0 +1,16 @@
+/**
+ * Handy class for managing asynchronous dependencies of classes.
+ *
+ * Will call the producer function once and only once when getValue is called,
+ * returning the resultant value for every subsequent call.
+ */
+export declare class Lazy<T> {
+    private producerFn;
+    constructor(producerFn: () => T);
+    private value;
+    /**
+     * Lazily get the value returned by the producer.
+     * @returns The value returned from the producer function
+     */
+    getValue(): T;
+}

package/src/util/lazy.js

@@ -0,0 +1,26 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Lazy = void 0;
+/**
+ * Handy class for managing asynchronous dependencies of classes.
+ *
+ * Will call the producer function once and only once when getValue is called,
+ * returning the resultant value for every subsequent call.
+ */
+class Lazy {
+    // eslint-disable-next-line
+    constructor(producerFn) {
+        this.producerFn = producerFn;
+    }
+    /**
+     * Lazily get the value returned by the producer.
+     * @returns The value returned from the producer function
+     */
+    getValue() {
+        if (!this.value) {
+            this.value = this.producerFn();
+        }
+        return this.value;
+    }
+}
+exports.Lazy = Lazy;

package/src/util/promises.d.ts

@@ -1,5 +1,5 @@
 export declare function promisify(func: Function): (...args: any[]) => Promise<any>;
 export declare function promiseMap<T, S>(arr: T[], asyncF: (x: T, i: number, r: T[]) => Promise<S>): Promise<S[]>;
-export declare type asyncF<T> = (...args: any[]) => Promise<T>;
+export type asyncF<T> = (...args: any[]) => Promise<T>;
 export declare function serial<T>(arr: asyncF<T>[]): Promise<T[]>;
 export declare function promiseMapSerial<T>(arr: any[], func: asyncF<T>): Promise<T[]>;

package/src/util/reversible-map.d.ts

@@ -0,0 +1,11 @@
+export declare class ReversibleMap<TKey extends string | number | symbol, TValue extends Object | string | number> {
+    private readonly valueToKey;
+    private readonly keyToValue;
+    setUnique: (key: TKey, value: TValue) => void;
+    getKey: (value: TValue) => TKey;
+    getValue(key: TKey): TValue;
+    deleteKey: (key: TKey) => TValue | undefined;
+    deleteValue: (value: TValue) => TKey | undefined;
+    hasKey: (key: TKey) => boolean;
+    hasValue: (value: TValue) => boolean;
+}

package/src/util/reversible-map.js

@@ -0,0 +1,49 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ReversibleMap = void 0;
+class ReversibleMap {
+    constructor() {
+        this.valueToKey = new Map();
+        this.keyToValue = new Map();
+        this.setUnique = (key, value) => {
+            if (this.hasKey(key) || this.hasValue(value)) {
+                throw new Error('Key or value already in the map.');
+            }
+            this.keyToValue.set(key, value);
+            this.valueToKey.set(value, key);
+        };
+        this.getKey = (value) => {
+            const existingKey = this.valueToKey.get(value);
+            if (!existingKey) {
+                throw new Error('Value not found in the map.');
+            }
+            return existingKey;
+        };
+        this.deleteKey = (key) => {
+            const value = this.getValue(key);
+            this.keyToValue.delete(key);
+            this.valueToKey.delete(value);
+            return value;
+        };
+        this.deleteValue = (value) => {
+            const key = this.getKey(value);
+            this.keyToValue.delete(key);
+            this.valueToKey.delete(value);
+            return key;
+        };
+        this.hasKey = (key) => {
+            return this.keyToValue.has(key);
+        };
+        this.hasValue = (value) => {
+            return this.valueToKey.has(value);
+        };
+    }
+    getValue(key) {
+        const item = this.keyToValue.get(key);
+        if (!item) {
+            throw new Error('Key not found in the map.');
+        }
+        return item;
+    }
+}
+exports.ReversibleMap = ReversibleMap;

package/src/util/utilTypes.d.ts

@@ -3,6 +3,6 @@
  * which are always populated in certain contexts.  A `DeepPick` type would be even better,
  * but no reliable implementation of one appears to exist yet.
  */
-export declare type Complete<T extends {}> = T & {
+export type Complete<T extends {}> = T & {
     [MK in keyof T]-?: Complete<NonNullable<T[MK]>>;
 };