@openfin/core 25.68.30 → 25.70.2

package/src/transport/transport.d.ts

@@ -1,43 +1,56 @@
-/// <reference types="node" />
-import { EventEmitter } from 'events';
-import EventAggregator from '../api/events/eventAggregator';
-import { EntityTypeHelpers } from '../api/me';
-import { Environment } from '../environment/environment';
-import EntityType = OpenFin.EntityType;
-import Message = OpenFin.Message;
-import Payload = OpenFin.Payload;
-import ProtocolMap = OpenFin.ProtocolMap;
-import MessageHandler = OpenFin.MessageHandler;
-import Wire = OpenFin.Wire;
-import WireConstructor = OpenFin.WireConstructor;
-import InternalConnectConfig = OpenFin.InternalConnectConfig;
-import ExistingConnectConfig = OpenFin.ExistingConnectConfig;
-declare class Transport<MeType extends EntityType = EntityType> extends EventEmitter {
-    #private;
-    protected wireListeners: Map<number, {
-        resolve: Function;
-        reject: Function;
-    }>;
-    protected uncorrelatedListener: Function;
-    me: OpenFin.EntityInfo & EntityTypeHelpers<MeType>;
-    environment: Environment;
-    topicRefMap: Map<string, number>;
-    sendRaw: Wire['send'];
-    eventAggregator: EventAggregator;
-    protected messageHandlers: MessageHandler[];
-    constructor(WireType: WireConstructor, environment: Environment, config: OpenFin.Identity);
-    connectSync: () => void;
-    getPort: () => string;
-    shutdown(): Promise<void>;
-    connect(config: InternalConnectConfig): Promise<string | void>;
-    connectByPort(config: ExistingConnectConfig): Promise<string>;
-    sendAction<T extends keyof ProtocolMap = string>(action: T, payload?: ProtocolMap[T]['request'], uncorrelated?: boolean): Promise<Message<{
-        data: ProtocolMap[T]['response'];
-    } & ProtocolMap[T]['specialResponse']>>;
-    ferryAction(origData: any): Promise<Message<any>>;
-    registerMessageHandler(handler: MessageHandler): void;
-    protected addWireListener(id: number, resolve: Function, reject: Function, uncorrelated: boolean): void;
-    protected onmessage(data: Message<Payload>): void;
-    protected handleMessage(data: Message<Payload>): boolean;
-}
-export default Transport;
+/// <reference types="node" />
+import { EventEmitter } from 'events';
+import { Wire, WireConstructor, ExistingConnectConfig, InternalConnectConfig } from './wire';
+import { Environment } from '../environment/environment';
+import { RuntimeEvent } from '../api/events/base';
+import EventAggregator from '../api/events/eventAggregator';
+import { EntityTypeHelpers } from '../api/me';
+import { ProtocolMap } from '../shapes/protocol';
+import EntityType = OpenFin.EntityType;
+export declare type MessageHandler = (data: any) => boolean;
+declare class Transport<MeType extends EntityType = EntityType> extends EventEmitter {
+    #private;
+    protected wireListeners: Map<number, {
+        resolve: Function;
+        reject: Function;
+    }>;
+    protected uncorrelatedListener: Function;
+    me: OpenFin.EntityInfo & EntityTypeHelpers<MeType>;
+    environment: Environment;
+    topicRefMap: Map<string, number>;
+    sendRaw: Wire['send'];
+    eventAggregator: EventAggregator;
+    protected messageHandlers: MessageHandler[];
+    constructor(WireType: WireConstructor, environment: Environment, config: OpenFin.Identity);
+    connectSync: () => void;
+    getPort: () => string;
+    shutdown(): Promise<void>;
+    connect(config: InternalConnectConfig): Promise<string | void>;
+    connectByPort(config: ExistingConnectConfig): Promise<string>;
+    sendAction<T extends keyof ProtocolMap = string>(action: T, payload?: ProtocolMap[T]['request'], uncorrelated?: boolean): Promise<Message<{
+        data: ProtocolMap[T]['response'];
+    } & ProtocolMap[T]['specialResponse']>>;
+    ferryAction(origData: any): Promise<Message<any>>;
+    registerMessageHandler(handler: MessageHandler): void;
+    protected addWireListener(id: number, resolve: Function, reject: Function, uncorrelated: boolean): void;
+    protected onmessage(data: Message<Payload>): void;
+    protected handleMessage(data: Message<Payload>): boolean;
+}
+export default Transport;
+export interface Message<T> {
+    action: string;
+    payload: T;
+    correlationId?: number;
+}
+export interface EventMessage extends Message<RuntimeEvent> {
+    action: 'process-desktop-event';
+    payload: RuntimeEvent;
+}
+export interface Payload {
+    success: boolean;
+    data: any;
+}
+export interface AuthorizationPayload {
+    token: string;
+    file: string;
+}

package/src/transport/transport.js

@@ -1,181 +1,181 @@
-"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 _wire;
-Object.defineProperty(exports, "__esModule", { value: true });
-const events_1 = require("events");
-const wire_1 = require("./wire");
-const transport_errors_1 = require("./transport-errors");
-const eventAggregator_1 = require("../api/events/eventAggregator");
-const me_1 = require("../api/me");
-class Transport extends events_1.EventEmitter {
-    constructor(WireType, environment, config) {
-        super();
-        this.wireListeners = new Map();
-        this.topicRefMap = new Map();
-        this.eventAggregator = new eventAggregator_1.default();
-        this.messageHandlers = [this.eventAggregator.dispatchEvent];
-        _wire.set(this, void 0);
-        this.connectSync = () => {
-            const wire = __classPrivateFieldGet(this, _wire);
-            wire.connectSync();
-        };
-        // 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, _wire);
-            return wire.wire.url.split(':').slice(-1)[0];
-        };
-        __classPrivateFieldSet(this, _wire, new WireType(this.onmessage.bind(this)));
-        this.environment = environment;
-        this.sendRaw = __classPrivateFieldGet(this, _wire).send.bind(__classPrivateFieldGet(this, _wire));
-        this.registerMessageHandler(this.handleMessage.bind(this));
-        __classPrivateFieldGet(this, _wire).on('disconnected', () => {
-            for (const [, { reject }] of this.wireListeners) {
-                reject('Remote connection has closed');
-            }
-            this.wireListeners.clear();
-            this.emit('disconnected');
-        });
-        const { uuid, name } = config;
-        const entityType = this.environment.getCurrentEntityType();
-        this.me = me_1.getBaseMe(entityType, uuid, name);
-    }
-    shutdown() {
-        const wire = __classPrivateFieldGet(this, _wire);
-        return wire.shutdown();
-    }
-    async connect(config) {
-        if (wire_1.isExistingConnectConfig(config)) {
-            return this.connectByPort(config);
-        }
-        if (wire_1.isNewConnectConfig(config)) {
-            const port = await this.environment.retrievePort(config);
-            return this.connectByPort({ ...config, address: `ws://localhost:${port}` });
-        }
-        return undefined;
-    }
-    async connectByPort(config) {
-        const { address, uuid } = config;
-        const reqAuthPayload = { ...config, type: 'file-token' };
-        const wire = __classPrivateFieldGet(this, _wire);
-        await wire.connect(address);
-        const requestExtAuthRet = await this.sendAction('request-external-authorization', {
-            uuid,
-            type: 'file-token'
-        }, true);
-        if (requestExtAuthRet.action !== 'external-authorization-response') {
-            throw new transport_errors_1.UnexpectedActionError(requestExtAuthRet.action);
-        }
-        const { token } = requestExtAuthRet.payload;
-        await this.environment.writeToken(requestExtAuthRet.payload.file, requestExtAuthRet.payload.token);
-        const requestAuthRet = await this.sendAction('request-authorization', reqAuthPayload, true);
-        if (requestAuthRet.action !== 'authorization-response') {
-            throw new transport_errors_1.UnexpectedActionError(requestAuthRet.action);
-        }
-        else if (requestAuthRet.payload.success !== true) {
-            throw new transport_errors_1.RuntimeError(requestAuthRet.payload);
-        }
-        else {
-            return token;
-        }
-    }
-    sendAction(action, payload = {}, uncorrelated = false
-    // specialResponse type is only used for 'requestAuthorization'
-    ) {
-        return new Promise((resolve, reject) => {
-            const id = this.environment.getNextMessageId();
-            const msg = {
-                action,
-                payload,
-                messageId: id
-            };
-            const wire = __classPrivateFieldGet(this, _wire);
-            this.addWireListener(id, resolve, reject, uncorrelated);
-            return wire.send(msg).catch(reject);
-        });
-    }
-    ferryAction(origData) {
-        return new Promise((resolve, reject) => {
-            const id = this.environment.getNextMessageId();
-            origData.messageId = id;
-            const resolver = (data) => {
-                resolve(data.payload);
-            };
-            const wire = __classPrivateFieldGet(this, _wire);
-            return wire
-                .send(origData)
-                .then(() => this.addWireListener(id, resolver, reject, false))
-                .catch(reject);
-        });
-    }
-    registerMessageHandler(handler) {
-        this.messageHandlers.push(handler);
-    }
-    addWireListener(id, resolve, reject, uncorrelated) {
-        if (uncorrelated) {
-            this.uncorrelatedListener = resolve;
-        }
-        else if (this.wireListeners.has(id)) {
-            reject(new transport_errors_1.DuplicateCorrelationError(String(id)));
-        }
-        else {
-            this.wireListeners.set(id, { resolve, reject });
-        }
-        // Timeout and reject()?
-    }
-    // This method executes message handlers until the _one_ that handles the message (returns truthy) has run
-    onmessage(data) {
-        for (const h of this.messageHandlers) {
-            h.call(null, data);
-        }
-    }
-    handleMessage(data) {
-        const id = data.correlationId || NaN;
-        if (!('correlationId' in data)) {
-            if (this.uncorrelatedListener) {
-                this.uncorrelatedListener.call(null, data);
-            }
-            this.uncorrelatedListener = () => {
-                // empty block
-            };
-        }
-        else if (!this.wireListeners.has(id)) {
-            return false;
-        }
-        else {
-            // We just checked for existence above
-            // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
-            const { resolve, reject } = this.wireListeners.get(id);
-            if (data.action !== 'ack') {
-                reject(new transport_errors_1.NoAckError(data.action));
-            }
-            else if (!('payload' in data)) {
-                reject(new transport_errors_1.RuntimeError(data));
-            }
-            else if (!data.payload.success) {
-                reject(new transport_errors_1.RuntimeError(data.payload));
-            }
-            else {
-                resolve.call(null, data);
-            }
-            this.wireListeners.delete(id);
-        }
-        return true;
-    }
-}
-_wire = new WeakMap();
-exports.default = Transport;
+"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 _wire;
+Object.defineProperty(exports, "__esModule", { value: true });
+const events_1 = require("events");
+const wire_1 = require("./wire");
+const transport_errors_1 = require("./transport-errors");
+const eventAggregator_1 = require("../api/events/eventAggregator");
+const me_1 = require("../api/me");
+class Transport extends events_1.EventEmitter {
+    constructor(WireType, environment, config) {
+        super();
+        this.wireListeners = new Map();
+        this.topicRefMap = new Map();
+        this.eventAggregator = new eventAggregator_1.default();
+        this.messageHandlers = [this.eventAggregator.dispatchEvent];
+        _wire.set(this, void 0);
+        this.connectSync = () => {
+            const wire = __classPrivateFieldGet(this, _wire);
+            wire.connectSync();
+        };
+        // 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, _wire);
+            return wire.wire.url.split(':').slice(-1)[0];
+        };
+        __classPrivateFieldSet(this, _wire, new WireType(this.onmessage.bind(this)));
+        this.environment = environment;
+        this.sendRaw = __classPrivateFieldGet(this, _wire).send.bind(__classPrivateFieldGet(this, _wire));
+        this.registerMessageHandler(this.handleMessage.bind(this));
+        __classPrivateFieldGet(this, _wire).on('disconnected', () => {
+            for (const [, { reject }] of this.wireListeners) {
+                reject('Remote connection has closed');
+            }
+            this.wireListeners.clear();
+            this.emit('disconnected');
+        });
+        const { uuid, name } = config;
+        const entityType = this.environment.getCurrentEntityType();
+        this.me = me_1.getBaseMe(entityType, uuid, name);
+    }
+    shutdown() {
+        const wire = __classPrivateFieldGet(this, _wire);
+        return wire.shutdown();
+    }
+    async connect(config) {
+        if (wire_1.isExistingConnectConfig(config)) {
+            return this.connectByPort(config);
+        }
+        if (wire_1.isNewConnectConfig(config)) {
+            const port = await this.environment.retrievePort(config);
+            return this.connectByPort({ ...config, address: `ws://localhost:${port}` });
+        }
+        return undefined;
+    }
+    async connectByPort(config) {
+        const { address, uuid } = config;
+        const reqAuthPayload = { ...config, type: 'file-token' };
+        const wire = __classPrivateFieldGet(this, _wire);
+        await wire.connect(address);
+        const requestExtAuthRet = await this.sendAction('request-external-authorization', {
+            uuid,
+            type: 'file-token'
+        }, true);
+        if (requestExtAuthRet.action !== 'external-authorization-response') {
+            throw new transport_errors_1.UnexpectedActionError(requestExtAuthRet.action);
+        }
+        const { token } = requestExtAuthRet.payload;
+        await this.environment.writeToken(requestExtAuthRet.payload.file, requestExtAuthRet.payload.token);
+        const requestAuthRet = await this.sendAction('request-authorization', reqAuthPayload, true);
+        if (requestAuthRet.action !== 'authorization-response') {
+            throw new transport_errors_1.UnexpectedActionError(requestAuthRet.action);
+        }
+        else if (requestAuthRet.payload.success !== true) {
+            throw new transport_errors_1.RuntimeError(requestAuthRet.payload);
+        }
+        else {
+            return token;
+        }
+    }
+    sendAction(action, payload = {}, uncorrelated = false
+    // specialResponse type is only used for 'requestAuthorization'
+    ) {
+        return new Promise((resolve, reject) => {
+            const id = this.environment.getNextMessageId();
+            const msg = {
+                action,
+                payload,
+                messageId: id
+            };
+            const wire = __classPrivateFieldGet(this, _wire);
+            this.addWireListener(id, resolve, reject, uncorrelated);
+            return wire.send(msg).catch(reject);
+        });
+    }
+    ferryAction(origData) {
+        return new Promise((resolve, reject) => {
+            const id = this.environment.getNextMessageId();
+            origData.messageId = id;
+            const resolver = (data) => {
+                resolve(data.payload);
+            };
+            const wire = __classPrivateFieldGet(this, _wire);
+            return wire
+                .send(origData)
+                .then(() => this.addWireListener(id, resolver, reject, false))
+                .catch(reject);
+        });
+    }
+    registerMessageHandler(handler) {
+        this.messageHandlers.push(handler);
+    }
+    addWireListener(id, resolve, reject, uncorrelated) {
+        if (uncorrelated) {
+            this.uncorrelatedListener = resolve;
+        }
+        else if (this.wireListeners.has(id)) {
+            reject(new transport_errors_1.DuplicateCorrelationError(String(id)));
+        }
+        else {
+            this.wireListeners.set(id, { resolve, reject });
+        }
+        // Timeout and reject()?
+    }
+    // This method executes message handlers until the _one_ that handles the message (returns truthy) has run
+    onmessage(data) {
+        for (const h of this.messageHandlers) {
+            h.call(null, data);
+        }
+    }
+    handleMessage(data) {
+        const id = data.correlationId || NaN;
+        if (!('correlationId' in data)) {
+            if (this.uncorrelatedListener) {
+                this.uncorrelatedListener.call(null, data);
+            }
+            this.uncorrelatedListener = () => {
+                // empty block
+            };
+        }
+        else if (!this.wireListeners.has(id)) {
+            return false;
+        }
+        else {
+            // We just checked for existence above
+            // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
+            const { resolve, reject } = this.wireListeners.get(id);
+            if (data.action !== 'ack') {
+                reject(new transport_errors_1.NoAckError(data.action));
+            }
+            else if (!('payload' in data)) {
+                reject(new transport_errors_1.RuntimeError(data));
+            }
+            else if (!data.payload.success) {
+                reject(new transport_errors_1.RuntimeError(data.payload));
+            }
+            else {
+                resolve.call(null, data);
+            }
+            this.wireListeners.delete(id);
+        }
+        return true;
+    }
+}
+_wire = new WeakMap();
+exports.default = Transport;

package/src/transport/wire.d.ts

@@ -1,11 +1,71 @@
-import ConnectConfig = OpenFin.ConnectConfig;
-import ExternalConfig = OpenFin.ExternalConfig;
-import ExistingConnectConfig = OpenFin.ExistingConnectConfig;
-import NewConnectConfig = OpenFin.NewConnectConfig;
-import PortDiscoveryConfig = OpenFin.PortDiscoveryConfig;
-import InternalConnectConfig = OpenFin.InternalConnectConfig;
-export declare function isExternalConfig(config: ConnectConfig): config is ExternalConfig;
-export declare function isExistingConnectConfig(config: any): config is ExistingConnectConfig;
-export declare function isNewConnectConfig(config: any): config is NewConnectConfig;
-export declare function isPortDiscoveryConfig(config: any): config is PortDiscoveryConfig;
-export declare function isInternalConnectConfig(config: any): config is InternalConnectConfig;
+/// <reference types="mocha" />
+/// <reference types="node" />
+import EventEmitter = NodeJS.EventEmitter;
+export declare type Wire = EventEmitter & {
+    connect(address: string): Promise<any>;
+    connectSync(): any;
+    send(data: any): Promise<any>;
+    shutdown(): Promise<void>;
+};
+export declare type WireConstructor = {
+    new (onmessage: (data: any) => void): Wire;
+};
+export declare type RuntimeConfig = {
+    version: string;
+    fallbackVersion?: string;
+    securityRealm?: string;
+    verboseLogging?: boolean;
+    arguments?: string;
+    rvmDir?: string;
+};
+export declare type ServiceConfig = {
+    name: string;
+    manifestUrl: string;
+};
+export declare type BaseConfig = {
+    uuid?: string;
+    address?: string;
+    name?: string;
+    nonPersistent?: boolean;
+    runtimeClient?: boolean;
+    licenseKey?: string;
+    client?: any;
+    manifestUrl?: string;
+    startupApp?: any;
+    lrsUrl?: string;
+    assetsUrl?: string;
+    devToolsPort?: number;
+    installerUI?: boolean;
+    runtime?: RuntimeConfig;
+    services?: ServiceConfig[];
+    appAssets?: [{
+        src: string;
+        alias: string;
+        target: string;
+        version: string;
+        args: string;
+    }];
+    customItems?: [any];
+    timeout?: number;
+};
+export declare type ConfigWithUuid = BaseConfig & {
+    uuid: string;
+};
+export declare type ExistingConnectConfig = ConfigWithUuid & {
+    address: string;
+};
+export declare type ConfigWithRuntime = BaseConfig & {
+    runtime: RuntimeConfig;
+};
+export declare 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 declare function isExternalConfig(config: ConnectConfig): config is ExternalConfig;
+export declare function isExistingConnectConfig(config: any): config is ExistingConnectConfig;
+export declare function isNewConnectConfig(config: any): config is NewConnectConfig;
+export declare function isPortDiscoveryConfig(config: any): config is PortDiscoveryConfig;
+export declare function isInternalConnectConfig(config: any): config is InternalConnectConfig;

package/src/transport/wire.js

@@ -1,32 +1,32 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.isInternalConnectConfig = exports.isPortDiscoveryConfig = exports.isNewConnectConfig = exports.isExistingConnectConfig = exports.isExternalConfig = void 0;
-function isExternalConfig(config) {
-    if (typeof config.manifestUrl === 'string') {
-        return true;
-    }
-    return false;
-}
-exports.isExternalConfig = isExternalConfig;
-function isExistingConnectConfig(config) {
-    return hasUuid(config) && typeof config.address === 'string';
-}
-exports.isExistingConnectConfig = isExistingConnectConfig;
-function hasUuid(config) {
-    return typeof config.uuid === 'string';
-}
-function hasRuntimeVersion(config) {
-    return config.runtime && typeof config.runtime.version === 'string';
-}
-function isNewConnectConfig(config) {
-    return hasUuid(config) && hasRuntimeVersion(config);
-}
-exports.isNewConnectConfig = isNewConnectConfig;
-function isPortDiscoveryConfig(config) {
-    return (isExternalConfig(config) && hasRuntimeVersion(config)) || isNewConnectConfig(config);
-}
-exports.isPortDiscoveryConfig = isPortDiscoveryConfig;
-function isInternalConnectConfig(config) {
-    return isExistingConnectConfig(config) || isNewConnectConfig(config);
-}
-exports.isInternalConnectConfig = isInternalConnectConfig;
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.isInternalConnectConfig = exports.isPortDiscoveryConfig = exports.isNewConnectConfig = exports.isExistingConnectConfig = exports.isExternalConfig = void 0;
+function isExternalConfig(config) {
+    if (typeof config.manifestUrl === 'string') {
+        return true;
+    }
+    return false;
+}
+exports.isExternalConfig = isExternalConfig;
+function isExistingConnectConfig(config) {
+    return hasUuid(config) && typeof config.address === 'string';
+}
+exports.isExistingConnectConfig = isExistingConnectConfig;
+function hasUuid(config) {
+    return typeof config.uuid === 'string';
+}
+function hasRuntimeVersion(config) {
+    return config.runtime && typeof config.runtime.version === 'string';
+}
+function isNewConnectConfig(config) {
+    return hasUuid(config) && hasRuntimeVersion(config);
+}
+exports.isNewConnectConfig = isNewConnectConfig;
+function isPortDiscoveryConfig(config) {
+    return (isExternalConfig(config) && hasRuntimeVersion(config)) || isNewConnectConfig(config);
+}
+exports.isPortDiscoveryConfig = isPortDiscoveryConfig;
+function isInternalConnectConfig(config) {
+    return isExistingConnectConfig(config) || isNewConnectConfig(config);
+}
+exports.isInternalConnectConfig = isInternalConnectConfig;

package/src/util/asyncFilter.d.ts

@@ -1 +1 @@
-export declare function asyncFilter<T>(values: T[], callback: (value: T) => Promise<boolean>): Promise<T[]>;
+export declare function asyncFilter<T>(values: T[], callback: (value: T) => Promise<boolean>): Promise<T[]>;

package/src/util/asyncFilter.js

@@ -1,7 +1,7 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.asyncFilter = void 0;
-async function asyncFilter(values, callback) {
-    return Promise.all(values.map(callback)).then((results) => values.filter((_, i) => results[i]));
-}
-exports.asyncFilter = asyncFilter;
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.asyncFilter = void 0;
+async function asyncFilter(values, callback) {
+    return Promise.all(values.map(callback)).then((results) => values.filter((_, i) => results[i]));
+}
+exports.asyncFilter = asyncFilter;

package/src/util/errors.d.ts

@@ -1,5 +1,9 @@
-/**
- * This function converts JS errors into plain objects
- */
-import ErrorPlainObject = OpenFin.ErrorPlainObject;
-export declare function errorToPOJO(error: Error): ErrorPlainObject;
+/**
+ * This function converts JS errors into plain objects
+ */
+export declare type ErrorPlainObject = {
+    stack: string;
+    message: string;
+    toString(): string;
+};
+export declare function errorToPOJO(error: Error): ErrorPlainObject;