@openfin/core 25.68.26

package/src/api/application/Instance.js

@@ -0,0 +1,412 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Application = void 0;
+/* eslint-disable import/prefer-default-export */
+const base_1 = require("../base");
+const window_1 = require("../window");
+const view_1 = require("../view");
+/**
+ * @classdesc An object representing an application. Allows the developer to create,
+ * execute, show/close an application as well as listen to <a href="tutorial-Application.EventEmitter.html">application events</a>.
+ * @class
+ * @hideconstructor
+ */
+class Application extends base_1.EmitterBase {
+    constructor(wire, identity) {
+        super(wire, 'application', identity.uuid);
+        this.identity = identity;
+        this.window = new window_1._Window(this.wire, {
+            uuid: this.identity.uuid,
+            name: this.identity.uuid
+        });
+    }
+    windowListFromIdentityList(identityList) {
+        const windowList = [];
+        identityList.forEach((identity) => {
+            windowList.push(new window_1._Window(this.wire, {
+                uuid: identity.uuid,
+                name: identity.name
+            }));
+        });
+        return windowList;
+    }
+    /**
+     * Adds a listener to the end of the listeners array for the specified event.
+     * @param { string | symbol } eventType  - The type of the event.
+     * @param { Function } listener - Called whenever an event of the specified type occurs.
+     * @param { SubOptions } [options] - Option to support event timestamps.
+     * @return {Promise.<this>}
+     * @function addListener
+     * @memberof Application
+     * @instance
+     * @tutorial Application.EventEmitter
+     */
+    /**
+     * Adds a listener to the end of the listeners array for the specified event.
+     * @param { string | symbol } eventType  - The type of the event.
+     * @param { Function } listener - Called whenever an event of the specified type occurs.
+     * @param { SubOptions } [options] - Option to support event timestamps.
+     * @return {Promise.<this>}
+     * @function on
+     * @memberof Application
+     * @instance
+     * @tutorial Application.EventEmitter
+     */
+    /**
+     * Adds a one time listener for the event. The listener is invoked only the first time the event is fired, after which it is removed.
+     * @param { string | symbol } eventType  - The type of the event.
+     * @param { Function } listener - The callback function.
+     * @param { SubOptions } [options] - Option to support event timestamps.
+     * @return {Promise.<this>}
+     * @function once
+     * @memberof Application
+     * @instance
+     * @tutorial Application.EventEmitter
+     */
+    /**
+     * Adds a listener to the beginning of the listeners array for the specified event.
+     * @param { string | symbol } eventType  - The type of the event.
+     * @param { Function } listener - The callback function.
+     * @param { SubOptions } [options] - Option to support event timestamps.
+     * @return {Promise.<this>}
+     * @function prependListener
+     * @memberof Application
+     * @instance
+     * @tutorial Application.EventEmitter
+     */
+    /**
+     * Adds a one time listener for the event. The listener is invoked only the first time the event is fired, after which it is removed.
+     * The listener is added to the beginning of the listeners array.
+     * @param { string | symbol } eventType  - The type of the event.
+     * @param { Function } listener - The callback function.
+     * @param { SubOptions } [options] - Option to support event timestamps.
+     * @return {Promise.<this>}
+     * @function prependOnceListener
+     * @memberof Application
+     * @instance
+     * @tutorial Application.EventEmitter
+     */
+    /**
+     * Remove a listener from the listener array for the specified event.
+     * Caution: Calling this method changes the array indices in the listener array behind the listener.
+     * @param { string | symbol } eventType  - The type of the event.
+     * @param { Function } listener - The callback function.
+     * @param { SubOptions } [options] - Option to support event timestamps.
+     * @return {Promise.<this>}
+     * @function removeListener
+     * @memberof Application
+     * @instance
+     * @tutorial Application.EventEmitter
+     */
+    /**
+     * Removes all listeners, or those of the specified event.
+     * @param { string | symbol } [eventType]  - The type of the event.
+     * @return {Promise.<this>}
+     * @function removeAllListeners
+     * @memberof Application
+     * @instance
+     * @tutorial Application.EventEmitter
+     */
+    /**
+     * Determines if the application is currently running.
+     * @return {Promise.<boolean>}
+     * @tutorial Application.isRunning
+     */
+    /**
+     * JumpListCategory interface
+     * @typedef { object } JumpListCategory
+     * @property { string } name The display title for the category. If omitted, items in this category will be placed into the standard 'Tasks' category. There can be only one such category, and it will always be displayed at the bottom of the JumpList.
+     * @property { JumpListItem[] } items Array of JumpListItem objects
+     */
+    /**
+     * JumpListItem interface
+     * @typedef { object } JumpListItem
+     * @property { string } type One of the following: "task" or "separator". Defaults to task.
+     * @property { string } title The text to be displayed for the JumpList Item. Should only be set if type is "task".
+     * @property { string } description Description of the task (displayed in a tooltip). Should only be set if type is "task".
+     * @property { string } deepLink Deep link to a manifest, i.e: fins://path.to/manifest.json?$$param1=value1. See {@link https://developers.openfin.co/docs/deep-linking deep-linking} for more information.
+     * @property { string } iconPath The absolute path to an icon to be displayed for the item, which can be an arbitrary resource file that contains an icon (e.g. .ico, .exe, .dll).
+     * @property { number } iconIndex The index of the icon in the resource file. If a resource file contains multiple icons this value can be used to specify the zero-based index of the icon that should be displayed for this task. If a resource file contains only one icon, this property should be set to zero.
+     */
+    isRunning() {
+        return this.wire.sendAction('is-application-running', this.identity).then(({ payload }) => payload.data);
+    }
+    /**
+     * Closes the application and any child windows created by the application.
+     * Cleans the application from state so it is no longer found in getAllApplications.
+     * @param { boolean } [force = false] Close will be prevented from closing when force is false and
+     *  ‘close-requested’ has been subscribed to for application’s main window.
+     * @return {Promise.<boolean>}
+     * @tutorial Application.quit
+     */
+    async quit(force = false) {
+        await this._close(force);
+        await this.wire.sendAction('destroy-application', { force, ...this.identity });
+    }
+    _close(force = false) {
+        return this.wire.sendAction('close-application', { force, ...this.identity }).then(() => undefined);
+    }
+    close(force = false) {
+        console.warn('Deprecation Warning: Application.close is deprecated Please use Application.quit');
+        this.wire.sendAction('application-close', this.identity).catch((e) => {
+            // we do not want to expose this error, just continue if this analytics-only call fails
+        });
+        return this._close(force);
+    }
+    /**
+     * Retrieves an array of wrapped fin.Windows for each of the application’s child windows.
+     * @return {Promise.Array.<_Window>}
+     * @tutorial Application.getChildWindows
+     */
+    getChildWindows() {
+        return this.wire.sendAction('get-child-windows', this.identity).then(({ payload }) => {
+            const identityList = [];
+            payload.data.forEach((winName) => {
+                identityList.push({ uuid: this.identity.uuid, name: winName });
+            });
+            return this.windowListFromIdentityList(identityList);
+        });
+    }
+    /**
+     * Retrieves the JSON manifest that was used to create the application. Invokes the error callback
+     * if the application was not created from a manifest.
+     * @return {Promise.<any>}
+     * @tutorial Application.getManifest
+     */
+    getManifest() {
+        return this.wire.sendAction('get-application-manifest', this.identity).then(({ payload }) => payload.data);
+    }
+    /**
+     * Retrieves UUID of the application that launches this application. Invokes the error callback
+     * if the application was created from a manifest.
+     * @return {Promise.<string>}
+     * @tutorial Application.getParentUuid
+     */
+    getParentUuid() {
+        return this.wire.sendAction('get-parent-application', this.identity).then(({ payload }) => payload.data);
+    }
+    /**
+     * Retrieves current application's shortcut configuration.
+     * @return {Promise.<ShortCutConfig>}
+     * @tutorial Application.getShortcuts
+     */
+    getShortcuts() {
+        return this.wire.sendAction('get-shortcuts', this.identity).then(({ payload }) => payload.data);
+    }
+    /**
+     * Retrieves current application's views.
+     * @experimental
+     * @return {Promise.Array.<View>}
+     * @tutorial Application.getViews
+     */
+    async getViews() {
+        const { payload } = await this.wire.sendAction('application-get-views', this.identity);
+        return payload.data.map((id) => new view_1.View(this.wire, id));
+    }
+    /**
+     * Returns the current zoom level of the application.
+     * @return {Promise.<number>}
+     * @tutorial Application.getZoomLevel
+     */
+    getZoomLevel() {
+        return this.wire.sendAction('get-application-zoom-level', this.identity).then(({ payload }) => payload.data);
+    }
+    /**
+     * Returns an instance of the main Window of the application
+     * @return {Promise.<_Window>}
+     * @tutorial Application.getWindow
+     */
+    getWindow() {
+        this.wire.sendAction('application-get-window', this.identity).catch((e) => {
+            // we do not want to expose this error, just continue if this analytics-only call fails
+        });
+        return Promise.resolve(this.window);
+    }
+    /**
+     * Manually registers a user with the licensing service. The only data sent by this call is userName and appName.
+     * @param { string } userName - username to be passed to the RVM.
+     * @param { string } appName - app name to be passed to the RVM.
+     * @return {Promise.<void>}
+     * @tutorial Application.registerUser
+     */
+    registerUser(userName, appName) {
+        return this.wire.sendAction('register-user', { userName, appName, ...this.identity }).then(() => undefined);
+    }
+    /**
+     * Removes the application’s icon from the tray.
+     * @return {Promise.<void>}
+     * @tutorial Application.removeTrayIcon
+     */
+    removeTrayIcon() {
+        return this.wire.sendAction('remove-tray-icon', this.identity).then(() => undefined);
+    }
+    /**
+     * Restarts the application.
+     * @return {Promise.<void>}
+     * @tutorial Application.restart
+     */
+    restart() {
+        return this.wire.sendAction('restart-application', this.identity).then(() => undefined);
+    }
+    /**
+     * DEPRECATED method to run the application.
+     * Needed when starting application via {@link Application.create}, but NOT needed when starting via {@link Application.start}.
+     * @return {Promise.<void>}
+     * @tutorial Application.run
+     * @ignore
+     */
+    run() {
+        console.warn('Deprecation Warning: Application.run is deprecated Please use fin.Application.start');
+        this.wire.sendAction('application-run', this.identity).catch((e) => {
+            // we do not want to expose this error, just continue if this analytics-only call fails
+        });
+        return this._run();
+    }
+    _run(opts = {}) {
+        return this.wire
+            .sendAction('run-application', {
+            manifestUrl: this._manifestUrl,
+            opts,
+            ...this.identity
+        })
+            .then(() => undefined);
+    }
+    /**
+     * Instructs the RVM to schedule one restart of the application.
+     * @return {Promise.<void>}
+     * @tutorial Application.scheduleRestart
+     */
+    scheduleRestart() {
+        return this.wire.sendAction('relaunch-on-close', this.identity).then(() => undefined);
+    }
+    /**
+     * Sends a message to the RVM to upload the application's logs. On success,
+     * an object containing logId is returned.
+     * @return {Promise.<LogInfo>}
+     * @tutorial Application.sendApplicationLog
+     */
+    async sendApplicationLog() {
+        const { payload } = await this.wire.sendAction('send-application-log', this.identity);
+        return payload.data;
+    }
+    /**
+     * Sets or removes a custom JumpList for the application. Only applicable in Windows OS.
+     * If categories is null the previously set custom JumpList (if any) will be replaced by the standard JumpList for the app (managed by Windows).
+     * Note: If the "name" property is omitted it defaults to "tasks".
+     * @param { Array.<JumpListCategory> | null } jumpListCategories An array of JumpList Categories to populate. If null, remove any existing JumpList configuration and set to Windows default.
+     * @return { Promise.<void> }
+     * @tutorial Application.setJumpList
+     */
+    async setJumpList(jumpListCategories) {
+        await this.wire.sendAction('set-jump-list', { config: jumpListCategories, ...this.identity });
+    }
+    /**
+     * Adds a customizable icon in the system tray.  To listen for a click on the icon use the `tray-icon-clicked` event.
+     * @param { string } icon Image URL or base64 encoded string to be used as the icon
+     * @return {Promise.<void>}
+     * @tutorial Application.setTrayIcon
+     */
+    setTrayIcon(icon) {
+        return this.wire
+            .sendAction('set-tray-icon', {
+            enabledIcon: icon,
+            ...this.identity
+        })
+            .then(() => undefined);
+    }
+    /**
+     * Sets new application's shortcut configuration. Windows only.
+     * @param { ShortCutConfig } config New application's shortcut configuration.
+     * @param { boolean } [config.desktop] - Enable/disable desktop shortcut.
+     * @param { boolean } [config.startMenu] - Enable/disable start menu shortcut.
+     * @param { boolean } [config.systemStartup] - Enable/disable system startup shortcut.
+     * @return {Promise.<void>}
+     * @tutorial Application.setShortcuts
+     */
+    setShortcuts(config) {
+        return this.wire.sendAction('set-shortcuts', { data: config, ...this.identity }).then(() => undefined);
+    }
+    /**
+     * Sets the query string in all shortcuts for this app. Requires RVM 5.5+.
+     * @param { string } queryString The new query string for this app's shortcuts.
+     * @return {Promise.<void>}
+     * @tutorial Application.setShortcutQueryParams
+     */
+    async setShortcutQueryParams(queryString) {
+        await this.wire.sendAction('set-shortcut-query-args', { data: queryString, ...this.identity });
+    }
+    /**
+     * Sets the zoom level of the application. The original size is 0 and each increment above or below represents zooming 20%
+     * larger or smaller to default limits of 300% and 50% of original size, respectively.
+     * @param { number } level The zoom level
+     * @return {Promise.<void>}
+     * @tutorial Application.setZoomLevel
+     */
+    setZoomLevel(level) {
+        return this.wire.sendAction('set-application-zoom-level', { level, ...this.identity }).then(() => undefined);
+    }
+    /**
+     * Sets a username to correlate with App Log Management.
+     * @param { string } username Username to correlate with App's Log.
+     * @return {Promise.<void>}
+     * @tutorial Application.setAppLogUsername
+     */
+    async setAppLogUsername(username) {
+        await this.wire.sendAction('set-app-log-username', { data: username, ...this.identity });
+    }
+    /**
+     * @summary Retrieves information about the system tray.
+     * @desc The only information currently returned is the position and dimensions.
+     * @return {Promise.<TrayInfo>}
+     * @tutorial Application.getTrayIconInfo
+     */
+    getTrayIconInfo() {
+        return this.wire.sendAction('get-tray-icon-info', this.identity).then(({ payload }) => payload.data);
+    }
+    /**
+     * Closes the application by terminating its process.
+     * @return {Promise.<void>}
+     * @tutorial Application.terminate
+     */
+    terminate() {
+        return this.wire.sendAction('terminate-application', this.identity).then(() => undefined);
+    }
+    /**
+     * Waits for a hanging application. This method can be called in response to an application
+     * "not-responding" to allow the application to continue and to generate another "not-responding"
+     * message after a certain period of time.
+     * @return {Promise.<void>}
+     * @ignore
+     */
+    wait() {
+        return this.wire.sendAction('wait-for-hung-application', this.identity).then(() => undefined);
+    }
+    /**
+     * Retrieves information about the application.
+     * @return {Promise.<ApplicationInfo>}
+     * @tutorial Application.getInfo
+     */
+    getInfo() {
+        return this.wire.sendAction('get-info', this.identity).then(({ payload }) => payload.data);
+    }
+    /**
+     * Retrieves all process information for entities (windows and views) associated with an application.
+     * @return {Promise.<AppProcessInfo>}
+     * @tutorial Application.getProcessInfo
+     * @experimental
+     */
+    async getProcessInfo() {
+        const { payload: { data } } = await this.wire.sendAction('application-get-process-info', this.identity);
+        return data;
+    }
+    /**
+     * Sets file auto download location.
+     * @param { string } downloadLocation file auto download location
+     * @return {Promise.<void>}
+     * @tutorial Application.setFileDownloadLocation
+     */
+    async setFileDownloadLocation(downloadLocation) {
+        await this.wire.sendAction('set-file-download-location', { downloadLocation, ...this.identity });
+    }
+}
+exports.Application = Application;

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

@@ -0,0 +1,3 @@
+import ApplicationModule from './Factory';
+export * from './Instance';
+export default ApplicationModule;

package/src/api/application/index.js

@@ -0,0 +1,15 @@
+"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]; } });
+}) : (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);
+}
+Object.defineProperty(exports, "__esModule", { value: true });
+const Factory_1 = require("./Factory");
+__exportStar(require("./Instance"), exports);
+exports.default = Factory_1.default;

package/src/api/base.d.ts

@@ -0,0 +1,43 @@
+import { EventEmitter } from 'events';
+import Transport from '../transport/transport';
+import { BaseEventMap } from './events/base';
+import Fin from './fin';
+import ApplicationIdentity = OpenFin.ApplicationIdentity;
+import Identity = OpenFin.Identity;
+export declare class Base {
+    wire: Transport;
+    constructor(wire: Transport);
+    protected get fin(): Fin;
+    get me(): Identity;
+    protected isNodeEnvironment: () => boolean;
+    protected isOpenFinEnvironment: () => boolean;
+}
+export declare class EmitterBase<EventTypes extends BaseEventMap> 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;
+    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 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>;
+    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 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>;
+    prependListener: <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>;
+    prependOnceListener: <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>;
+    removeListener: <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>;
+    protected deregisterAllListeners: (eventType: Extract<keyof EventTypes, string> | string | symbol) => Promise<EventEmitter | void>;
+    removeAllListeners: (eventType?: Extract<keyof EventTypes, string> | string | symbol) => Promise<this>;
+    private deleteEmitterIfNothingRegistered;
+}
+export declare class Reply<TOPIC extends string, TYPE extends string | void> implements Identity {
+    topic: TOPIC;
+    type: TYPE;
+    uuid: string;
+    name: string;
+}

package/src/api/base.js

@@ -0,0 +1,177 @@
+"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 _emitterAccessor;
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Reply = exports.EmitterBase = exports.Base = void 0;
+const promises_1 = require("../util/promises");
+const fin_store_1 = require("../transport/fin_store");
+class Base {
+    constructor(wire) {
+        this.isNodeEnvironment = () => {
+            return this.wire.environment.constructor.name === 'NodeEnvironment';
+        };
+        this.isOpenFinEnvironment = () => {
+            return this.wire.environment.constructor.name === 'OpenFinEnvironment';
+        };
+        this.wire = wire;
+    }
+    get fin() {
+        return fin_store_1.getFin(this.wire);
+    }
+    get me() {
+        return this.wire.me;
+    }
+}
+exports.Base = Base;
+class EmitterBase extends Base {
+    constructor(wire, topic, ...additionalAccessors) {
+        super(wire);
+        this.topic = topic;
+        _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.hasEmitter = () => this.wire.eventAggregator.has(__classPrivateFieldGet(this, _emitterAccessor));
+        this.getOrCreateEmitter = () => this.wire.eventAggregator.getOrCreate(__classPrivateFieldGet(this, _emitterAccessor));
+        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) => {
+            const runtimeEvent = {
+                ...this.identity,
+                timestamp: options.timestamp || Date.now(),
+                topic: this.topic,
+                type: eventType
+            };
+            const emitter = this.getOrCreateEmitter();
+            // We apply the subscription and then undo if the async call fails to avoid
+            // indeterminacy in subscription application order, which can break things elsewhere
+            applySubscription(emitter);
+            try {
+                await this.wire.sendAction('subscribe-to-desktop-event', runtimeEvent);
+            }
+            catch (e) {
+                undoSubscription(emitter);
+                this.deleteEmitterIfNothingRegistered(emitter);
+                throw e;
+            }
+        };
+        this.deregisterEventListener = async (eventType, options = {}) => {
+            if (this.hasEmitter()) {
+                const runtimeEvent = {
+                    ...this.identity,
+                    timestamp: options.timestamp || Date.now(),
+                    topic: this.topic,
+                    type: eventType
+                };
+                await this.wire.sendAction('unsubscribe-to-desktop-event', runtimeEvent).catch(() => null);
+                const emitter = this.getOrCreateEmitter();
+                return emitter;
+            }
+            // This will only be reached if unsubscribe from event that does not exist but do not want to error here
+            return Promise.resolve();
+        };
+        this.on = async (eventType, listener, options) => {
+            await this.registerEventListener(eventType, options, (emitter) => {
+                emitter.on(eventType, listener);
+            }, (emitter) => {
+                emitter.removeListener(eventType, listener);
+            });
+            return this;
+        };
+        this.addListener = this.on;
+        this.once = async (eventType, listener, options) => {
+            const deregister = () => this.deregisterEventListener(eventType);
+            await this.registerEventListener(eventType, options, (emitter) => {
+                emitter.once(eventType, deregister);
+                emitter.once(eventType, listener);
+            }, (emitter) => {
+                emitter.removeListener(eventType, deregister);
+                emitter.removeListener(eventType, listener);
+            });
+            return this;
+        };
+        this.prependListener = async (eventType, listener, options) => {
+            await this.registerEventListener(eventType, options, (emitter) => {
+                emitter.prependListener(eventType, listener);
+            }, (emitter) => {
+                emitter.removeListener(eventType, listener);
+            });
+            return this;
+        };
+        this.prependOnceListener = async (eventType, listener, options) => {
+            const deregister = () => this.deregisterEventListener(eventType);
+            await this.registerEventListener(eventType, options, (emitter) => {
+                emitter.prependOnceListener(eventType, listener);
+                emitter.once(eventType, deregister);
+            }, (emitter) => {
+                emitter.removeListener(eventType, listener);
+                emitter.removeListener(eventType, deregister);
+            });
+            return this;
+        };
+        this.removeListener = async (eventType, listener, options) => {
+            const emitter = await this.deregisterEventListener(eventType, options);
+            if (emitter) {
+                emitter.removeListener(eventType, listener);
+                this.deleteEmitterIfNothingRegistered(emitter);
+            }
+            return this;
+        };
+        this.deregisterAllListeners = async (eventType) => {
+            const runtimeEvent = { ...this.identity, type: eventType, topic: this.topic };
+            if (this.hasEmitter()) {
+                const emitter = this.getOrCreateEmitter();
+                const refCount = emitter.listenerCount(runtimeEvent.type);
+                const unsubscribePromises = [];
+                for (let i = 0; i < refCount; i++) {
+                    unsubscribePromises.push(this.wire.sendAction('unsubscribe-to-desktop-event', runtimeEvent).catch(() => null));
+                }
+                await Promise.all(unsubscribePromises);
+                return emitter;
+            }
+            return undefined;
+        };
+        this.removeAllListeners = async (eventType) => {
+            const removeByEvent = async (event) => {
+                const emitter = await this.deregisterAllListeners(event);
+                if (emitter) {
+                    emitter.removeAllListeners(event);
+                    this.deleteEmitterIfNothingRegistered(emitter);
+                }
+            };
+            if (eventType) {
+                await removeByEvent(eventType);
+            }
+            else if (this.hasEmitter()) {
+                const events = this.getOrCreateEmitter().eventNames();
+                await promises_1.promiseMap(events, removeByEvent);
+            }
+            return this;
+        };
+        __classPrivateFieldSet(this, _emitterAccessor, [topic, ...additionalAccessors]);
+        this.listeners = (event) => this.hasEmitter() ? this.getOrCreateEmitter().listeners(event) : [];
+    }
+    deleteEmitterIfNothingRegistered(emitter) {
+        if (emitter.eventNames().length === 0) {
+            this.wire.eventAggregator.delete(__classPrivateFieldGet(this, _emitterAccessor));
+        }
+    }
+}
+exports.EmitterBase = EmitterBase;
+_emitterAccessor = new WeakMap();
+class Reply {
+}
+exports.Reply = Reply;