@openfin/core 30.73.5 → 30.73.7

package/src/OpenFin.js

@@ -0,0 +1,4 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const snapshot_source_1 = require("./api/snapshot-source");
+const window_1 = require("./api/window");

package/src/api/application/Factory.d.ts

@@ -1,5 +1,7 @@
+import type * as OpenFin from '../../OpenFin';
 import { Base } from '../base';
 /**
+ * @PORTED
  * @typedef {object} ApplicationOptions
  * @summary Application creation options.
  * @desc This is the options object required by {@link Application.start Application.start}.

package/src/api/application/Factory.js

@@ -4,6 +4,7 @@ const base_1 = require("../base");
 const validate_1 = require("../../util/validate");
 const Instance_1 = require("./Instance");
 /**
+ * @PORTED
  * @typedef {object} ApplicationOptions
  * @summary Application creation options.
  * @desc This is the options object required by {@link Application.start Application.start}.
@@ -89,7 +90,7 @@ class ApplicationModule extends base_1.Base {
         this.wire.sendAction('wrap-application').catch((e) => {
             // we do not want to expose this error, just continue if this analytics-only call fails
         });
-        const errorMsg = validate_1.validateIdentity(identity);
+        const errorMsg = (0, validate_1.validateIdentity)(identity);
         if (errorMsg) {
             throw new Error(errorMsg);
         }
@@ -106,7 +107,7 @@ class ApplicationModule extends base_1.Base {
         this.wire.sendAction('wrap-application-sync').catch((e) => {
             // we do not want to expose this error, just continue if this analytics-only call fails
         });
-        const errorMsg = validate_1.validateIdentity(identity);
+        const errorMsg = (0, validate_1.validateIdentity)(identity);
         if (errorMsg) {
             throw new Error(errorMsg);
         }
@@ -202,7 +203,7 @@ class ApplicationModule extends base_1.Base {
             // we do not want to expose this error, just continue if this analytics-only call fails
         });
         const app = await this._createFromManifest(manifestUrl);
-        // eslint-disable-next-line @typescript-eslint/ban-ts-ignore
+        // eslint-disable-next-line @typescript-eslint/ban-ts-comment
         // @ts-ignore using private method without warning.
         await app._run(opts); // eslint-disable-line no-underscore-dangle
         return app;

package/src/api/application/Instance.d.ts

@@ -1,3 +1,4 @@
+import type * as OpenFin from '../../OpenFin';
 import { EmitterBase } from '../base';
 import Transport from '../../transport/transport';
 /**
@@ -6,7 +7,7 @@ import Transport from '../../transport/transport';
  * @class
  * @hideconstructor
  */
-export declare class Application extends EmitterBase<OpenFin.ApplicationEvents> {
+export declare class Application extends EmitterBase<OpenFin.ApplicationEvent> {
     identity: OpenFin.ApplicationIdentity;
     _manifestUrl?: string;
     private window;
@@ -101,6 +102,7 @@ export declare class Application extends EmitterBase<OpenFin.ApplicationEvents>
      * @property { JumpListItem[] } items Array of JumpListItem objects
      */
     /**
+     * @PORTED
      * JumpListItem interface
      * @typedef { object } JumpListItem
      * @property { string } type One of the following: "task" or "separator". Defaults to task.

package/src/api/application/Instance.js

@@ -119,6 +119,7 @@ class Application extends base_1.EmitterBase {
      * @property { JumpListItem[] } items Array of JumpListItem objects
      */
     /**
+     * @PORTED
      * JumpListItem interface
      * @typedef { object } JumpListItem
      * @property { string } type One of the following: "task" or "separator". Defaults to task.

package/src/api/application/index.js

@@ -1,14 +1,18 @@
 "use strict";
 var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
     if (k2 === undefined) k2 = k;
-    Object.defineProperty(o, k2, { enumerable: true, get: function() { return m[k]; } });
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
 }) : (function(o, m, k, k2) {
     if (k2 === undefined) k2 = k;
     o[k2] = m[k];
 }));
 var __exportStar = (this && this.__exportStar) || function(m, exports) {
-    for (var p in m) if (p !== "default" && !exports.hasOwnProperty(p)) __createBinding(exports, m, p);
-}
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
 Object.defineProperty(exports, "__esModule", { value: true });
 const Factory_1 = require("./Factory");
 __exportStar(require("./Instance"), exports);

package/src/api/base.d.ts

@@ -1,10 +1,11 @@
 /// <reference types="node" />
 import { EventEmitter } from 'events';
 import Transport from '../transport/transport';
+import type * as OpenFin from '../OpenFin';
 import Fin from './fin';
-import { BaseEventMap } from './events/base';
-import ApplicationIdentity = OpenFin.ApplicationIdentity;
-import Identity = OpenFin.Identity;
+import { BaseEvent, EventHandler } from './events/base';
+declare type ApplicationIdentity = OpenFin.ApplicationIdentity;
+declare type Identity = OpenFin.Identity;
 export declare class Base {
     wire: Transport;
     constructor(wire: Transport);
@@ -14,27 +15,29 @@ export declare class Base {
     protected isOpenFinEnvironment: () => boolean;
     protected isBrowserEnvironment: () => boolean;
 }
-export declare class EmitterBase<EventTypes extends BaseEventMap> extends Base {
+export declare class EmitterBase<EmitterEvent extends BaseEvent, EmitterEventType extends EmitterEvent['type'] = EmitterEvent['type']> extends Base {
     #private;
     private topic;
     protected identity: ApplicationIdentity;
     constructor(wire: Transport, topic: string, ...additionalAccessors: string[]);
     eventNames: () => (string | symbol)[];
-    emit: <E extends string | symbol | Extract<keyof EventTypes, string>>(eventName: E, payload: E extends Extract<keyof EventTypes, string> ? EventTypes[E] : any, ...args: any[]) => boolean;
+    emit: <EventType extends EmitterEventType>(eventType: EventType, payload: Extract<EmitterEvent, {
+        type: EventType;
+    }>, ...args: any[]) => boolean;
     private hasEmitter;
     private getOrCreateEmitter;
     listeners: (type: string | symbol) => Function[];
     listenerCount: (type: string | symbol) => number;
-    protected registerEventListener: (eventType: Extract<keyof EventTypes, string> | string | symbol, options: OpenFin.SubscriptionOptions, applySubscription: (emitter: EventEmitter) => void, undoSubscription: (emitter: EventEmitter) => void) => Promise<void>;
-    protected deregisterEventListener: (eventType: Extract<keyof EventTypes, string> | string | symbol, options?: OpenFin.SubscriptionOptions) => Promise<void | EventEmitter>;
-    on<E extends Extract<keyof EventTypes, string> | string | symbol>(eventType: E, listener: (payload: E extends keyof EventTypes ? EventTypes[E] : any, ...args: any[]) => void, options?: OpenFin.SubscriptionOptions): Promise<this>;
-    addListener: <E extends string | symbol | Extract<keyof EventTypes, string>>(eventType: E, listener: (payload: E extends keyof EventTypes ? EventTypes[E] : any, ...args: any[]) => void, options?: OpenFin.SubscriptionOptions) => Promise<this>;
-    once<E extends Extract<keyof EventTypes, string> | string | symbol>(eventType: E, listener: (payload: E extends keyof EventTypes ? EventTypes[E] : any, ...args: any[]) => void, options?: OpenFin.SubscriptionOptions): Promise<this>;
-    prependListener<E extends Extract<keyof EventTypes, string> | string | symbol>(eventType: E, listener: (payload: E extends keyof EventTypes ? EventTypes[E] : any, ...args: any[]) => void, options?: OpenFin.SubscriptionOptions): Promise<this>;
-    prependOnceListener<E extends Extract<keyof EventTypes, string> | string | symbol>(eventType: E, listener: (payload: E extends keyof EventTypes ? EventTypes[E] : any, ...args: any[]) => void, options?: OpenFin.SubscriptionOptions): Promise<this>;
-    removeListener<E extends Extract<keyof EventTypes, string> | string | symbol>(eventType: E, listener: (payload: E extends keyof EventTypes ? EventTypes[E] : any, ...args: any[]) => void, options?: OpenFin.SubscriptionOptions): Promise<this>;
-    protected deregisterAllListeners(eventType: Extract<keyof EventTypes, string> | string | symbol): Promise<EventEmitter | void>;
-    removeAllListeners(eventType?: Extract<keyof EventTypes, string> | string | symbol): Promise<this>;
+    protected registerEventListener: (eventType: EmitterEventType, options: OpenFin.SubscriptionOptions, applySubscription: (emitter: EventEmitter) => void, undoSubscription: (emitter: EventEmitter) => void) => Promise<void>;
+    protected deregisterEventListener: (eventType: EmitterEventType, options?: OpenFin.SubscriptionOptions) => Promise<void | EventEmitter>;
+    on<EventType extends EmitterEventType>(eventType: EventType, listener: EventHandler<EmitterEvent, EventType>, options?: OpenFin.SubscriptionOptions): Promise<this>;
+    addListener: <EventType extends EmitterEventType>(eventType: EventType, listener: OpenFin.BaseEvents.EventHandler<EmitterEvent, EventType>, options?: OpenFin.SubscriptionOptions) => Promise<this>;
+    once<EventType extends EmitterEventType>(eventType: EventType, listener: EventHandler<EmitterEvent, EventType>, options?: OpenFin.SubscriptionOptions): Promise<this>;
+    prependListener<EventType extends EmitterEventType>(eventType: EventType, listener: EventHandler<EmitterEvent, EventType>, options?: OpenFin.SubscriptionOptions): Promise<this>;
+    prependOnceListener<EventType extends EmitterEventType>(eventType: EventType, listener: EventHandler<EmitterEvent, EventType>, options?: OpenFin.SubscriptionOptions): Promise<this>;
+    removeListener<EventType extends EmitterEventType>(eventType: EventType, listener: EventHandler<EmitterEvent, EventType>, options?: OpenFin.SubscriptionOptions): Promise<this>;
+    protected deregisterAllListeners(eventType: EmitterEventType): Promise<EventEmitter | void>;
+    removeAllListeners(eventType?: EmitterEventType): Promise<this>;
     private deleteEmitterIfNothingRegistered;
 }
 export declare class Reply<TOPIC extends string, TYPE extends string | void> implements Identity {
@@ -43,3 +46,4 @@ export declare class Reply<TOPIC extends string, TYPE extends string | void> imp
     uuid: string;
     name: string;
 }
+export {};

package/src/api/base.js

@@ -1,18 +1,16 @@
 "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 __classPrivateFieldSet = (this && this.__classPrivateFieldSet) || function (receiver, state, value, kind, f) {
+    if (kind === "m") throw new TypeError("Private method is not writable");
+    if (kind === "a" && !f) throw new TypeError("Private accessor was defined without a setter");
+    if (typeof state === "function" ? receiver !== state || !f : !state.has(receiver)) throw new TypeError("Cannot write private member to an object whose class did not declare it");
+    return (kind === "a" ? f.call(receiver, value) : f ? f.value = value : state.set(receiver, value)), 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 __classPrivateFieldGet = (this && this.__classPrivateFieldGet) || function (receiver, state, kind, f) {
+    if (kind === "a" && !f) throw new TypeError("Private accessor was defined without a getter");
+    if (typeof state === "function" ? receiver !== state || !f : !state.has(receiver)) throw new TypeError("Cannot read private member from an object whose class did not declare it");
+    return kind === "m" ? f : kind === "a" ? f.call(receiver) : f ? f.value : state.get(receiver);
 };
-var _emitterAccessor;
+var _EmitterBase_emitterAccessor;
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.Reply = exports.EmitterBase = exports.Base = void 0;
 const promises_1 = require("../util/promises");
@@ -31,7 +29,7 @@ class Base {
         this.wire = wire;
     }
     get fin() {
-        return fin_store_1.getFin(this.wire);
+        return (0, fin_store_1.getFin)(this.wire);
     }
     get me() {
         return this.wire.me;
@@ -42,13 +40,13 @@ class EmitterBase extends Base {
     constructor(wire, topic, ...additionalAccessors) {
         super(wire);
         this.topic = topic;
-        _emitterAccessor.set(this, void 0);
+        _EmitterBase_emitterAccessor.set(this, void 0);
         this.eventNames = () => (this.hasEmitter() ? this.getOrCreateEmitter().eventNames() : []);
-        this.emit = (eventName, payload, ...args) => {
-            return this.hasEmitter() ? this.getOrCreateEmitter().emit(eventName, payload, ...args) : false;
+        this.emit = (eventType, payload, ...args) => {
+            return this.hasEmitter() ? this.getOrCreateEmitter().emit(eventType, payload, ...args) : false;
         };
-        this.hasEmitter = () => this.wire.eventAggregator.has(__classPrivateFieldGet(this, _emitterAccessor));
-        this.getOrCreateEmitter = () => this.wire.eventAggregator.getOrCreate(__classPrivateFieldGet(this, _emitterAccessor));
+        this.hasEmitter = () => this.wire.eventAggregator.has(__classPrivateFieldGet(this, _EmitterBase_emitterAccessor, "f"));
+        this.getOrCreateEmitter = () => this.wire.eventAggregator.getOrCreate(__classPrivateFieldGet(this, _EmitterBase_emitterAccessor, "f"));
         this.listeners = (type) => this.hasEmitter() ? this.getOrCreateEmitter().listeners(type) : [];
         this.listenerCount = (type) => this.hasEmitter() ? this.getOrCreateEmitter().listenerCount(type) : 0;
         this.registerEventListener = async (eventType, options = {}, applySubscription, undoSubscription) => {
@@ -87,7 +85,7 @@ class EmitterBase extends Base {
             return Promise.resolve();
         };
         this.addListener = this.on;
-        __classPrivateFieldSet(this, _emitterAccessor, [topic, ...additionalAccessors]);
+        __classPrivateFieldSet(this, _EmitterBase_emitterAccessor, [topic, ...additionalAccessors], "f");
         this.listeners = (event) => this.hasEmitter() ? this.getOrCreateEmitter().listeners(event) : [];
     }
     async on(eventType, listener, options) {
@@ -163,18 +161,18 @@ class EmitterBase extends Base {
         }
         else if (this.hasEmitter()) {
             const events = this.getOrCreateEmitter().eventNames();
-            await promises_1.promiseMap(events, removeByEvent);
+            await (0, promises_1.promiseMap)(events, removeByEvent);
         }
         return this;
     }
     deleteEmitterIfNothingRegistered(emitter) {
         if (emitter.eventNames().length === 0) {
-            this.wire.eventAggregator.delete(__classPrivateFieldGet(this, _emitterAccessor));
+            this.wire.eventAggregator.delete(__classPrivateFieldGet(this, _EmitterBase_emitterAccessor, "f"));
         }
     }
 }
 exports.EmitterBase = EmitterBase;
-_emitterAccessor = new WeakMap();
+_EmitterBase_emitterAccessor = new WeakMap();
 class Reply {
 }
 exports.Reply = Reply;

package/src/api/clipboard/index.d.ts

@@ -1,5 +1,7 @@
+import type * as OpenFin from '../../OpenFin';
 import { Base } from '../base';
 /**
+ * @PORTED
  * WriteRequestType interface
  * @typedef { object } WriteRequestType
  * @property { string } data Data to be written

package/src/api/clipboard/index.js

@@ -2,6 +2,7 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 const base_1 = require("../base");
 /**
+ * @PORTED
  * WriteRequestType interface
  * @typedef { object } WriteRequestType
  * @property { string } data Data to be written

package/src/api/events/application.d.ts

@@ -1,69 +1,79 @@
-import { WindowEvent, BaseEventMap, ApplicationEvent } from './base';
-import { WindowAlertRequestedEvent, WindowAuthRequestedEvent, WindowEndLoadEvent, PropagatedWindowEvents, WindowPerformanceReport } from './window';
-import { PropagatedViewEvents } from './view';
-export interface CrashedEvent {
+import type * as OpenFin from '../../OpenFin';
+import { IdentityEvent, NamedEvent, PropagatedEvent } from './base';
+import { PropagatedWindowEvent } from './window';
+import { PropagatedViewEvent } from './view';
+export declare type CrashedEvent = NamedEvent & {
+    type: 'crashed';
     reason: 'normal-termination' | 'abnormal-termination' | 'killed' | 'crashed' | 'still-running' | 'launch-failed' | 'out-of-memory' | 'integrity-failure';
     exitCode: number;
     details: {
         reason: string;
         exitCode: number;
     };
-}
-export interface RunRequestedEvent<Topic, Type> extends ApplicationEvent<Topic, Type> {
-    userAppConfigArgs: any;
+};
+export declare type RunRequestedEvent = IdentityEvent & {
+    type: 'run-requested';
+    userAppConfigArgs: Record<string, any>;
     manifest: OpenFin.ManifestInfo;
-}
-export interface TrayIconClicked<Topic, Type> extends ApplicationEvent<Topic, Type> {
+};
+export declare type TrayIconClickedEvent = IdentityEvent & {
+    type: 'tray-icon-clicked';
     button: 0 | 1 | 2;
     bounds: OpenFin.Rectangle;
     x: number;
     y: number;
     monitorInfo: any;
-}
-export interface ApplicationEventMapping<Topic = string, Type = string> extends BaseEventMap {
-    'closed': ApplicationEvent<Topic, Type>;
-    'connected': ApplicationEvent<Topic, Type>;
-    'crashed': CrashedEvent & ApplicationEvent<Topic, Type>;
-    'initialized': ApplicationEvent<Topic, Type>;
-    'manifest-changed': ApplicationEvent<Topic, Type>;
-    'not-responding': ApplicationEvent<Topic, Type>;
-    'responding': ApplicationEvent<Topic, Type>;
-    'run-requested': RunRequestedEvent<Topic, Type>;
-    'started': ApplicationEvent<Topic, Type>;
-    'tray-icon-clicked': TrayIconClicked<Topic, Type>;
-    'window-alert-requested': WindowAlertRequestedEvent<Topic, Type>;
-    'window-auth-requested': WindowAuthRequestedEvent<Topic, Type>;
-    'window-created': WindowEvent<Topic, Type>;
-    'window-end-load': WindowEndLoadEvent<Topic, Type>;
-    'window-not-responding': WindowEvent<Topic, Type>;
-    'window-performance-report': WindowPerformanceReport<Topic, Type>;
-    'window-responding': WindowEvent<Topic, Type>;
-    'window-show-requested': WindowEvent<Topic, Type>;
-    'window-start-load': WindowEvent<Topic, Type>;
-}
-export interface PropagatedApplicationEventMapping<Topic = string, Type = string> {
-    'application-closed': ApplicationEvent<Topic, Type>;
-    'application-connected': ApplicationEvent<Topic, Type>;
-    'application-crashed': CrashedEvent & ApplicationEvent<Topic, Type>;
-    'application-initialized': ApplicationEvent<Topic, Type>;
-    'application-manifest-changed': ApplicationEvent<Topic, Type>;
-    'application-not-responding': ApplicationEvent<Topic, Type>;
-    'application-responding': ApplicationEvent<Topic, Type>;
-    'application-started': ApplicationEvent<Topic, Type>;
-    'application-tray-icon-clicked': TrayIconClicked<Topic, Type>;
-    'window-created': WindowEvent<Topic, Type>;
-    'window-did-change-theme-color': WindowEvent<Topic, Type>;
-    'window-end-load': WindowEndLoadEvent<Topic, Type>;
-    'window-not-responding': WindowEvent<Topic, Type>;
-    'window-page-favicon-updated': WindowEvent<Topic, Type>;
-    'window-page-title-updated': WindowEvent<Topic, Type>;
-    'window-performance-report': WindowPerformanceReport<Topic, Type>;
-    'window-responding': WindowEvent<Topic, Type>;
-    'window-start-load': WindowEvent<Topic, Type>;
-}
-export declare type ApplicationEvents = PropagatedWindowEvents<'application'> & PropagatedViewEvents<'application'> & {
-    [Type in keyof ApplicationEventMapping]: ApplicationEventMapping<'application', Type>[Type];
-};
-export declare type PropagatedApplicationEvents<Topic> = {
-    [Type in keyof PropagatedApplicationEventMapping]: PropagatedApplicationEventMapping<Topic, Type>[Type];
 };
+export declare type WindowAlertRequestedEvent = NamedEvent & {
+    type: 'window-alert-requested';
+};
+export declare type WindowCreatedEvent = NamedEvent & {
+    type: 'window-created';
+};
+export declare type WindowEndLoadEvent = NamedEvent & {
+    type: 'window-end-load';
+};
+export declare type WindowNotRespondingEvent = NamedEvent & {
+    type: 'window-not-responding';
+};
+export declare type WindowRespondingEvent = NamedEvent & {
+    type: 'window-responding';
+};
+export declare type WindowStartLoadEvent = NamedEvent & {
+    type: 'window-start-load';
+};
+/**
+ * A Window event that is natively published at the Application level (not Window).
+ */
+export declare type ApplicationWindowEvent = WindowAlertRequestedEvent | WindowCreatedEvent | WindowEndLoadEvent | WindowNotRespondingEvent | WindowRespondingEvent | WindowStartLoadEvent;
+export declare type ClosedEvent = IdentityEvent & {
+    type: 'closed';
+};
+export declare type ApplicationConnectedEvent = IdentityEvent & {
+    type: 'connected';
+};
+export declare type InitializedEvent = IdentityEvent & {
+    type: 'initialized';
+};
+export declare type ManifestChangedEvent = IdentityEvent & {
+    type: 'manifest-changed';
+};
+export declare type NotRespondingEvent = IdentityEvent & {
+    type: 'not-responding';
+};
+export declare type RespondingEvent = IdentityEvent & {
+    type: 'responding';
+};
+export declare type StartedEvent = IdentityEvent & {
+    type: 'started';
+};
+/**
+ * An Application event that does propagate to (republish on) parent topics.
+ */
+export declare type WillPropagateApplicationEvent = ClosedEvent | ApplicationConnectedEvent | CrashedEvent | InitializedEvent | ManifestChangedEvent | NotRespondingEvent | RespondingEvent | RunRequestedEvent | StartedEvent | TrayIconClickedEvent;
+export declare type ApplicationEvent = {
+    topic: 'application';
+} & (PropagatedViewEvent | PropagatedWindowEvent | ApplicationWindowEvent | WillPropagateApplicationEvent);
+export declare type ApplicationEventType = ApplicationEvent['type'];
+export declare type PropagatedApplicationEvent = PropagatedEvent<'application', WillPropagateApplicationEvent> | ApplicationWindowEvent;
+export declare type PropagatedApplicationEventType = PropagatedApplicationEvent['type'];

package/src/api/events/base.d.ts

@@ -1,17 +1,35 @@
-import { FrameEvent } from './frame';
-export declare type RuntimeEvent<Topic = string, Type = string> = Topic extends 'window' | 'view' ? WindowEvent<Topic, Type> : Topic extends 'frame' ? FrameEvent<Type> : Topic extends 'application' ? ApplicationEvent<Topic, Type> : BaseEvent<Topic, Type>;
-export interface BaseEvent<Topic, Type> {
-    topic: Topic;
-    type: Type;
-}
-export interface ApplicationEvent<Topic, Type> extends BaseEvent<Topic, Type> {
+import type * as OpenFin from '../../OpenFin';
+/**
+ * Modifies an event key to reflect propagation by prefixing with the topic.
+ */
+export declare type PropagatedEventType<Topic extends string, Type extends string> = `${Topic}-${Type}`;
+/**
+ * Modifies an event shape to reflect propagation to a parent topic.  The 'type' field
+ * is prefixed with the original topic, and a new property is added with the original topic's identity.
+ */
+export declare type PropagatedEvent<Topic extends string, Event extends {
+    type: string;
+}> = Event extends infer E extends {
+    type: string;
+} ? Omit<E, 'type'> & {
+    type: PropagatedEventType<Topic, E['type']>;
+} & {
+    [topic in `${Topic}Identity`]: OpenFin.Identity;
+} : never;
+/**
+ * Handler for an event on an EventEmitter; selects the correct type for the event
+ * payload from the provided union based on the provided string literal type.
+ */
+export declare type EventHandler<EmitterEvent extends BaseEvent, EventType extends string> = (payload: Extract<EmitterEvent, {
+    type: EventType;
+}>, ...args: any[]) => void;
+export declare type BaseEvent = {
+    topic: string;
+    type: string;
+};
+export declare type IdentityEvent = BaseEvent & {
     uuid: string;
-}
-export interface WindowEvent<Topic, Type> extends ApplicationEvent<Topic, Type> {
+};
+export declare type NamedEvent = IdentityEvent & {
     name: string;
-}
-export interface BaseEventMap {
-    [name: string]: any;
-    newListener: string;
-    listenerRemoved: string;
-}
+};

package/src/api/events/channel.d.ts

@@ -1,10 +1,15 @@
-import { BaseEventMap, ApplicationEvent } from './base';
-export interface ChannelEvent<Type> extends ApplicationEvent<'channel', Type> {
+import { NamedEvent } from './base';
+export declare type BaseChannelEvent = NamedEvent & {
     channelName: string;
     channelId: string;
-    name: string;
-}
-export interface ChannelEvents extends BaseEventMap {
-    connected: ChannelEvent<'connected'>;
-    disconnected: ChannelEvent<'disconnected'>;
-}
+};
+export declare type ChannelConnectedEvent = BaseChannelEvent & {
+    type: 'connected';
+};
+export declare type ChannelDisconnectedEvent = BaseChannelEvent & {
+    type: 'disconnected';
+};
+export declare type ChannelEvent = {
+    topic: 'channel';
+} & (ChannelConnectedEvent | ChannelDisconnectedEvent);
+export declare type ChannelEventType = ChannelEvent['type'];

package/src/api/events/eventAggregator.js

@@ -6,11 +6,7 @@ function isEventMessage(message) {
 }
 function mapKeyFromEvent(event) {
     const { topic } = event;
-    if (topic === 'frame') {
-        const { uuid, name } = event;
-        return [topic, uuid, name];
-    }
-    if (topic === 'window') {
+    if (topic === 'frame' || topic === 'window' || topic === 'view') {
         const { uuid, name } = event;
         return [topic, uuid, name];
     }
@@ -18,10 +14,6 @@ function mapKeyFromEvent(event) {
         const { uuid } = event;
         return [topic, uuid];
     }
-    if (topic === 'view') {
-        const { uuid, name } = event;
-        return [topic, uuid, name];
-    }
     return [topic];
 }
 class EventAggregator extends emitterMap_1.EmitterMap {

package/src/api/events/externalApplication.d.ts

@@ -1,5 +1,10 @@
-import { RuntimeEvent, BaseEventMap } from './base';
-export interface ExternalApplicationEvents extends BaseEventMap {
-    connected: RuntimeEvent<'externalapplication', 'connected'>;
-    disconnected: RuntimeEvent<'externalapplication', 'disconnected'>;
-}
+import { BaseEvent } from './base';
+export declare type ExternalApplicationConnectedEvent = BaseEvent & {
+    type: 'connected';
+};
+export declare type ExternalApplicationDisconnectedEvent = BaseEvent & {
+    type: 'disconnected';
+};
+export declare type ExternalApplicationEvent = {
+    topic: 'externalapplication';
+} & (ExternalApplicationConnectedEvent | ExternalApplicationDisconnectedEvent);

package/src/api/events/frame.d.ts

@@ -1,9 +1,15 @@
-import { BaseEventMap, WindowEvent } from './base';
-export interface FrameEvent<Type> extends WindowEvent<'frame', Type> {
+import { NamedEvent } from './base';
+export declare type BaseFrameEvent = NamedEvent & {
     entityType: 'iframe';
     frameName: string;
-}
-export interface FrameEvents extends BaseEventMap {
-    connected: FrameEvent<'connected'>;
-    disconnected: FrameEvent<'disconnected'>;
-}
+};
+export declare type FrameConnectedEvent = BaseFrameEvent & {
+    type: 'connected';
+};
+export declare type FrameDisconnectedEvent = BaseFrameEvent & {
+    type: 'disconnected';
+};
+export declare type FrameEvent = {
+    topic: 'frame';
+} & (FrameConnectedEvent | FrameDisconnectedEvent);
+export declare type FrameEventType = FrameEvent['type'];

package/src/api/events/globalHotkey.d.ts

@@ -1,10 +1,11 @@
-import { RuntimeEvent, BaseEventMap } from './base';
-import Identity = OpenFin.Identity;
-export interface GlobalHotkeyEvent<Type> extends RuntimeEvent<'global-hotkey', Type> {
-    identity: Identity;
-    hotkey: string;
-}
-export interface GlobalHotkeyEvents extends BaseEventMap {
-    registered: GlobalHotkeyEvent<'registered'>;
-    unregistered: GlobalHotkeyEvent<'unregistered'>;
-}
+import { BaseEvent } from './base';
+export declare type RegisteredEvent = BaseEvent & {
+    type: 'registered';
+};
+export declare type UnregisteredEvent = BaseEvent & {
+    type: 'unregistered';
+};
+export declare type GlobalHotkeyEvent = {
+    topic: 'global-hotkey';
+    hotkey: 'string';
+} & (RegisteredEvent | UnregisteredEvent);

package/src/api/events/platform.d.ts

@@ -1,18 +1,12 @@
-import { ApplicationEvent } from './base';
-import { PropagatedWindowEvents } from './window';
-import { PropagatedViewEvents } from './view';
-import { ApplicationEventMapping, PropagatedApplicationEventMapping } from './application';
-export interface PlatformEventMapping<Topic = string, Type = string> extends ApplicationEventMapping {
-    'platform-api-ready': ApplicationEvent<Topic, Type>;
-    'platform-snapshot-applied': ApplicationEvent<Topic, Type>;
-}
-export interface PropagatedPlatformEventMapping<Topic = string, Type = string> extends PropagatedApplicationEventMapping {
-    'platform-api-ready': ApplicationEvent<Topic, Type>;
-    'platform-snapshot-applied': ApplicationEvent<Topic, Type>;
-}
-export declare type PlatformEvents = PropagatedWindowEvents<'application'> & PropagatedViewEvents<'application'> & {
-    [Type in keyof PlatformEventMapping]: PlatformEventMapping<'application', Type>[Type];
+import { BaseEvent } from './base';
+import { PropagatedViewEvent } from './view';
+import { PropagatedWindowEvent } from './window';
+export declare type PlatformApiReadyEvent = BaseEvent & {
+    type: 'platform-api-ready';
 };
-export declare type PropagatedPlatformEvents<Topic> = {
-    [Type in keyof PropagatedPlatformEventMapping]: PropagatedPlatformEventMapping<Topic, Type>[Type];
+export declare type PlatformSnapshotAppliedEvent = BaseEvent & {
+    type: 'platform-snapshot-applied';
 };
+export declare type PlatformEvent = {
+    topic: 'platform';
+} & (PropagatedWindowEvent | PropagatedViewEvent | PlatformApiReadyEvent | PlatformSnapshotAppliedEvent);