@openfin/core 31.74.1 → 31.74.3

package/src/environment/openfin-env.d.ts

@@ -2,7 +2,7 @@ import type * as OpenFin from '../OpenFin';
 import { ChildContentOptions, Environment } from './environment';
 import { NewConnectConfig } from '../transport/wire';
 import { BrowserEnvironment } from './browser';
-declare type EntityType = OpenFin.EntityType;
+type EntityType = OpenFin.EntityType;
 export default class OpenFinEnvironment extends BrowserEnvironment implements Environment {
     #private;
     private raiseEventAsync;

package/src/mock.d.ts

@@ -1,3 +1,3 @@
-import type * as OpenFin from './OpenFin';
+import * as OpenFin from './OpenFin';
 export declare const fin: OpenFin.Fin<"window" | "view">;
 export default OpenFin;

package/src/mock.js

@@ -1,13 +1,13 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.fin = void 0;
-const events_1 = require("events");
 /* 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 */
-/// <reference path="../OpenFin.d.ts"/>
+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");
@@ -24,6 +24,9 @@ class MockWire extends events_1.EventEmitter {
     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();

package/src/shapes/ERROR_BOX_TYPES.d.ts

@@ -1 +1 @@
-export declare type ERROR_BOX_TYPES = 'OF_error_box:app_initialization' | 'OF_error_box:main_process' | 'OF_error_box:renderer_crash';
+export type ERROR_BOX_TYPES = 'OF_error_box:app_initialization' | 'OF_error_box:main_process' | 'OF_error_box:renderer_crash';

package/src/shapes/protocol.d.ts

@@ -149,12 +149,12 @@ export interface ProtocolMap extends ProtocolMapBase {
         response: OpenFin.PrinterInfo[];
     };
 }
-declare type ApiCall<Request, Response> = {
+type ApiCall<Request, Response> = {
     request: Request;
     response: Response;
 };
-declare type VoidCall = ApiCall<void, void>;
-declare type IdentityCall<AdditionalPayload = {}, Response = void> = ApiCall<AdditionalPayload & OpenFin.Identity, Response>;
+type VoidCall = ApiCall<void, void>;
+type IdentityCall<AdditionalPayload = {}, Response = void> = ApiCall<AdditionalPayload & OpenFin.Identity, Response>;
 interface ProtocolMapBase {
     [action: string]: {
         request: any;

package/src/transport/transport-errors.d.ts

@@ -1,5 +1,5 @@
 import { ErrorPlainObject } from '../util/errors';
-export declare type ReadyState = 'CONNECTING' | 'OPEN' | 'CLOSING' | 'CLOSED';
+export type ReadyState = 'CONNECTING' | 'OPEN' | 'CLOSING' | 'CLOSED';
 export declare class DisconnectedError extends Error {
     constructor(readyState: ReadyState);
     readyState: ReadyState;
@@ -14,7 +14,7 @@ export declare class NotImplementedError extends Error {
 }
 export declare class NotSupportedError extends Error {
 }
-export declare type RuntimeErrorPayload = {
+export type RuntimeErrorPayload = {
     reason: string;
     error?: ErrorPlainObject;
 };

package/src/transport/transport.d.ts

@@ -8,8 +8,8 @@ import { EntityTypeHelpers } from '../api/me';
 import { ProtocolMap } from '../shapes/protocol';
 import { NamedEvent } from '../api/events/base';
 import { ErrorPlainObject } from '../util/errors';
-declare type EntityType = OpenFin.EntityType;
-export declare type MessageHandler = (data: any) => boolean;
+type EntityType = OpenFin.EntityType;
+export type MessageHandler = (data: any) => boolean;
 export declare class Transport<MeType extends EntityType = EntityType> extends EventEmitter {
     #private;
     protected wireListeners: Map<number, {
@@ -49,7 +49,7 @@ export interface EventMessage extends Message<NamedEvent> {
     action: 'process-desktop-event';
     payload: NamedEvent;
 }
-export declare type Payload<Success extends boolean = boolean, Data = any> = {
+export type Payload<Success extends boolean = boolean, Data = any> = {
     success: Success;
     data: Success extends true ? Data : never;
     reason: Success extends false ? string : never;

package/src/transport/transport.js

@@ -32,11 +32,8 @@ class Transport extends events_1.EventEmitter {
         };
         // This function is only used in our tests.
         this.getPort = () => {
-            if (this.environment.constructor.name !== 'NodeEnvironment') {
-                throw new transport_errors_1.NotImplementedError('Not Implemented');
-            }
             const wire = __classPrivateFieldGet(this, _Transport_wire, "f");
-            return wire.wire.url.split(':').slice(-1)[0];
+            return wire.getPort();
         };
         __classPrivateFieldSet(this, _Transport_wire, new WireType(this.onmessage.bind(this)), "f");
         this.environment = environment;

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]>>;
 };