@openfin/core 33.76.6 → 33.76.9

package/README.md

@@ -8,19 +8,19 @@ Libraries are also available for the following frameworks:
 * [.Net](https://developers.openfin.co/of-docs/docs/net-api)
 * [Java](https://developers.openfin.co/of-docs/docs/java-api)
 
-## Prerequsites
-
-None.
-
 ## Installation
 
 This package cannot be installed as a dev dependency because it is not types-only.
 
 With npm:
->npm i -S @openfin/core
+```bash
+$ npm i -S @openfin/core
+```
 
 With yarn:
->yarn add @openfin/core
+```bash
+$ yarn add @openfin/core
+```
 
 ## Usage
 
@@ -35,9 +35,38 @@ const showWindow = async (identity: OpenFin.Identity) => {
    const win = await fin.Window.wrap(identity);
    await win.show();
 
-const isOpenFin = fin.me.isOpenFin; // false if not in OpenFin
+   const isOpenFin = fin.me.isOpenFin; // false if not in OpenFin
+}
+```
+
+## Migrating to v30+
+
+Prior to v30, the `OpenFin` namespace was ambiently declared and always available. Starting with v30, you must import it directly or specify it in the tsconfig.
+
+### Importing the type
+
+To import the `OpenFin` namespace:
+```typescript
+import OpenFin from "@openfin/core"; 
+
+type OFWindow = OpenFin.Window;
+```
+
+### TSConfig types array
+
+To have the `OpenFin` available in your code automatically, just update your tsconfig `types` key:
+```json
+{
+  "compilerOptions": {
+    "target": ...,
+    "module": ...,
+    ...,
+    "types": ["@openfin/core/OpenFin"]
+  }
 }
+
 ```
+
 ## For more information
 
 - [Developer guide](https://developers.openfin.co/of-docs/docs/container-overview)
@@ -45,11 +74,10 @@ const isOpenFin = fin.me.isOpenFin; // false if not in OpenFin
 
 ## License
 
-Copyright 2020-2022 OpenFin
+Copyright 2020-2023 OpenFin
 
 The code in this package is distributed under the Apache License, Version 2.0.
 
 However, if you run this code, it may call on the OpenFin RVM or OpenFin Runtime, which are covered by OpenFin's Developer, Community, and Enterprise licenses. You can learn more about OpenFin licensing at the links listed below or email us at support@openfin.co with questions.
 
-- [Licensing](https://www.openfin.co/licensing/)
 - [Developer agreement](https://openfin.co/developer-agreement/)

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "@openfin/core",
-    "version": "33.76.6",
+    "version": "33.76.9",
     "license": "SEE LICENSE IN LICENSE.MD",
     "main": "./src/mock.js",
     "types": "./src/mock.d.ts",

package/src/OpenFin.d.ts

@@ -2002,27 +2002,66 @@ export type WindowViewsPrintOptions = {
     includeSelf?: boolean;
 };
 export type WindowPrintOptions = PrintOptions | ScreenshotPrintOptions | WindowViewsPrintOptions;
+export type ImageFormatOptions = {
+    format: 'dataURL' | 'png' | 'bmp';
+} | {
+    format: 'jpg';
+    /**
+     * Must be between 0-100, defaults to 100 if out of bounds or not specified
+     */
+    quality?: number;
+};
+/**
+ * The type of clipboard to write to, can be 'clipboard' or 'selection'.
+ * Defaults to 'clipboard'. Use 'selection' for linux only.
+ */
+export type ClipboardSelectionType = 'clipboard' | 'selection';
+export type BaseClipboardRequest = {
+    /**
+     * The type of clipboard to write to, can be 'clipboard' or 'selection'.
+     * Defaults to 'clipboard'. Use 'selection' for linux only.
+     */
+    type?: ClipboardSelectionType;
+};
 /**
  * A request to write data to the clipboard.
  */
-export type WriteRequestType = {
+export type WriteClipboardRequest = BaseClipboardRequest & {
     /**
      * Data to write to the clipboard.
      */
     data: string;
+};
+export type ReadImageClipboardRequest = BaseClipboardRequest & ImageFormatOptions;
+export type WriteImageClipboardRequest = BaseClipboardRequest & {
     /**
-     * The type of clipboard to write to.
+     * Must be a base-64 data URL string. Supported formats are `data:image/png[;base64],` and `data:image/jpeg[;base64],`
+     * // TODO: Named this `imageDataURL` but the other write request types use `data` - wanted to make it obvious it must be a dataURL string - thoughts?
      */
-    type?: string;
+    imageDataURL: string;
 };
-export type WriteAnyRequestType = {
+/**
+ * A generic request to write any supported data to the clipboard.
+ */
+export type WriteAnyClipboardRequest = BaseClipboardRequest & {
     data: {
         text?: string;
         html?: string;
         rtf?: string;
     };
-    type?: string;
 };
+/**
+ * @deprecated - instead use OpenFin.WriteClipboardRequest
+ *
+ * A request to write data to the clipboard.
+ */
+export type WriteRequestType = WriteClipboardRequest;
+/**
+ * @deprecated - instead use WriteAnyClipboardRequest
+ *
+ * A generic request to write any supported data to the clipboard.
+ */
+export type WriteAnyRequestType = WriteAnyClipboardRequest;
 export type SubscriptionOptions = {
     /**
      * The event timestamp.
@@ -3032,4 +3071,10 @@ export interface CapturePageOptions {
      */
     quality?: number;
 }
-export declare const Version: any;
+export interface ProcessLoggingOptions {
+    interval?: number;
+    outlierDetection?: {
+        interval?: number;
+        entries?: number;
+    };
+}

package/src/OpenFin.js

@@ -1,5 +1,2 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.Version = void 0;
-// eslint-disable-next-line global-require, @typescript-eslint/no-var-requires
-exports.Version = require('../package.json').version.split('.')[0];

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

@@ -7,6 +7,13 @@ import { Base } from '../base';
  * @property { string } data Data to be written
  * @property { string } [type] Clipboard Type
  */
+/**
+ * @PORTED
+ * OpenFin.WriteAnyClipboardRequest interface
+ * @typedef { object } OpenFin.WriteAnyClipboardRequest
+ * @property { string } data Data to be written
+ * @property { OpenFin.ClipboardSelectionType } [type] Clipboard Type defaults to 'clipboard', use 'selection' for linux
+ */
 /**
  * The Clipboard API allows reading and writing to the clipboard in multiple formats.
  * @namespace
@@ -14,58 +21,72 @@ import { Base } from '../base';
 export default class Clipboard extends Base {
     /**
      * Writes data into the clipboard as plain text
-     * @param { WriteRequestType } writeObj This object is described in the WriteRequestType typeof
-     * @return {Promise.<void>}
+     * @param { OpenFin.WriteClipboardRequest } writeObj The object for writing data into the clipboard
+     * @return { Promise.<void> }
      * @tutorial Clipboard.writeText
      */
-    writeText(writeObj: OpenFin.WriteRequestType): Promise<void>;
+    writeText(writeObj: OpenFin.WriteClipboardRequest): Promise<void>;
     /**
      * Read the content of the clipboard as plain text
-     * @param { string } type Clipboard Type
-     * @return {Promise.<string>}
+     * @param { OpenFin.ClipboardSelectionType } [type] Clipboard Type defaults to 'clipboard', use 'selection' for linux
+     * @return { Promise.<string> }
      * @tutorial Clipboard.readText
      */
-    readText(type?: string): Promise<string>;
+    readText(type?: OpenFin.ClipboardSelectionType): Promise<string>;
+    /**
+     * Writes data into the clipboard as an Image
+     * @param { OpenFin.WriteImageClipboardRequest } writeRequest The object to write an image to the clipboard
+     * @return { Promise.<void> }
+     * @tutorial Clipboard.writeImage
+     */
+    writeImage(writeRequest: OpenFin.WriteImageClipboardRequest): Promise<void>;
+    /**
+     * Read the content of the clipboard as a base64 string or a dataURL based on the input parameter 'format', defaults to 'dataURL'
+     * @param { OpenFin.ReadImageClipboardRequest } readRequest Clipboard Read Image request with formatting options
+     * @return { Promise.<string> }
+     * @tutorial Clipboard.readImage
+     */
+    readImage(readRequest?: OpenFin.ReadImageClipboardRequest): Promise<string>;
     /**
      * Writes data into the clipboard as Html
-     * @param { WriteRequestType } writeObj This object is described in the WriteRequestType typedef
-     * @return {Promise.<void>}
+     * @param { OpenFin.WriteClipboardRequest } writeObj The object for writing data into the clipboard
+     * @return { Promise.<void> }
      * @tutorial Clipboard.writeHtml
      */
-    writeHtml(writeObj: OpenFin.WriteRequestType): Promise<void>;
+    writeHtml(writeObj: OpenFin.WriteClipboardRequest): Promise<void>;
     /**
      * Read the content of the clipboard as Html
-     * @param { string } type Clipboard Type
-     * @return {Promise.<string>}
+     * @param { OpenFin.ClipboardSelectionType } [type] Clipboard Type defaults to 'clipboard', use 'selection' for linux
+     * @return { Promise.<string> }
      * @tutorial Clipboard.readHtml
      */
     readHtml(type?: string): Promise<string>;
     /**
      * Writes data into the clipboard as Rtf
-     * @param { WriteRequestType } writeObj This object is described in the WriteRequestType typedef
-     * @return {Promise.<void>}
+     * @param { OpenFin.WriteClipboardRequest } writeObj The object for writing data into the clipboard
+     * @return { Promise.<void> }
      * @tutorial Clipboard.writeRtf
      */
-    writeRtf(writeObj: OpenFin.WriteRequestType): Promise<void>;
+    writeRtf(writeObj: OpenFin.WriteClipboardRequest): Promise<void>;
     /**
      * Read the content of the clipboard as Rtf
-     * @param { string } type Clipboard Type
-     * @return {Promise.<string>}
+     * @param { OpenFin.ClipboardSelectionType } [type] Clipboard Type defaults to 'clipboard', use 'selection' for linux
+     * @return { Promise.<string> }
      * @tutorial Clipboard.readRtf
      */
-    readRtf(type?: string): Promise<string>;
+    readRtf(type?: OpenFin.ClipboardSelectionType): Promise<string>;
     /**
      * Writes data into the clipboard
-     * @param { WriteAnyRequestType } writeObj This object is described in the WriteAnyRequestType typedef
-     * @return {Promise.<void>}
+     * @param { OpenFin.WriteAnyClipboardRequest } writeObj The object for writing data into the clipboard
+     * @return { Promise.<void> }
      * @tutorial Clipboard.write
      */
-    write(writeObj: OpenFin.WriteAnyRequestType): Promise<void>;
+    write(writeObj: OpenFin.WriteAnyClipboardRequest): Promise<void>;
     /**
      * Reads available formats for the clipboard type
-     * @param { string } type Clipboard Type
-     * @return {Promise.Array.<string>}
+     * @param { OpenFin.ClipboardSelectionType } [type] Clipboard Type defaults to 'clipboard', use 'selection' for linux
+     * @return { Promise.Array.<string> }
      * @tutorial Clipboard.getAvailableFormats
      */
-    getAvailableFormats(type?: string): Promise<Array<string>>;
+    getAvailableFormats(type?: OpenFin.ClipboardSelectionType): Promise<Array<string>>;
 }

package/src/api/clipboard/index.js

@@ -8,6 +8,13 @@ const base_1 = require("../base");
  * @property { string } data Data to be written
  * @property { string } [type] Clipboard Type
  */
+/**
+ * @PORTED
+ * OpenFin.WriteAnyClipboardRequest interface
+ * @typedef { object } OpenFin.WriteAnyClipboardRequest
+ * @property { string } data Data to be written
+ * @property { OpenFin.ClipboardSelectionType } [type] Clipboard Type defaults to 'clipboard', use 'selection' for linux
+ */
 /**
  * The Clipboard API allows reading and writing to the clipboard in multiple formats.
  * @namespace
@@ -15,75 +22,99 @@ const base_1 = require("../base");
 class Clipboard extends base_1.Base {
     /**
      * Writes data into the clipboard as plain text
-     * @param { WriteRequestType } writeObj This object is described in the WriteRequestType typeof
-     * @return {Promise.<void>}
+     * @param { OpenFin.WriteClipboardRequest } writeObj The object for writing data into the clipboard
+     * @return { Promise.<void> }
      * @tutorial Clipboard.writeText
      */
-    writeText(writeObj) {
-        return this.wire.sendAction('clipboard-write-text', writeObj).then(() => undefined);
+    async writeText(writeObj) {
+        await this.wire.sendAction('clipboard-write-text', writeObj);
     }
     /**
      * Read the content of the clipboard as plain text
-     * @param { string } type Clipboard Type
-     * @return {Promise.<string>}
+     * @param { OpenFin.ClipboardSelectionType } [type] Clipboard Type defaults to 'clipboard', use 'selection' for linux
+     * @return { Promise.<string> }
      * @tutorial Clipboard.readText
      */
-    readText(type) {
-        return this.wire.sendAction('clipboard-read-text', type).then(({ payload }) => payload.data);
+    async readText(type) {
+        // NOTE: When we start supporting linux, we could detect the OS and choose 'selection' automatically for the user
+        const { payload } = await this.wire.sendAction('clipboard-read-text', { type });
+        return payload.data;
+    }
+    /**
+     * Writes data into the clipboard as an Image
+     * @param { OpenFin.WriteImageClipboardRequest } writeRequest The object to write an image to the clipboard
+     * @return { Promise.<void> }
+     * @tutorial Clipboard.writeImage
+     */
+    async writeImage(writeRequest) {
+        await this.wire.sendAction('clipboard-write-image', writeRequest);
+    }
+    /**
+     * Read the content of the clipboard as a base64 string or a dataURL based on the input parameter 'format', defaults to 'dataURL'
+     * @param { OpenFin.ReadImageClipboardRequest } readRequest Clipboard Read Image request with formatting options
+     * @return { Promise.<string> }
+     * @tutorial Clipboard.readImage
+     */
+    async readImage(readRequest = { format: 'dataURL' }) {
+        const { payload } = await this.wire.sendAction('clipboard-read-image', readRequest);
+        return payload.data;
     }
     /**
      * Writes data into the clipboard as Html
-     * @param { WriteRequestType } writeObj This object is described in the WriteRequestType typedef
-     * @return {Promise.<void>}
+     * @param { OpenFin.WriteClipboardRequest } writeObj The object for writing data into the clipboard
+     * @return { Promise.<void> }
      * @tutorial Clipboard.writeHtml
      */
-    writeHtml(writeObj) {
-        return this.wire.sendAction('clipboard-write-html', writeObj).then(() => undefined);
+    async writeHtml(writeObj) {
+        await this.wire.sendAction('clipboard-write-html', writeObj);
     }
     /**
      * Read the content of the clipboard as Html
-     * @param { string } type Clipboard Type
-     * @return {Promise.<string>}
+     * @param { OpenFin.ClipboardSelectionType } [type] Clipboard Type defaults to 'clipboard', use 'selection' for linux
+     * @return { Promise.<string> }
      * @tutorial Clipboard.readHtml
      */
-    readHtml(type) {
-        return this.wire.sendAction('clipboard-read-html', type).then(({ payload }) => payload.data);
+    async readHtml(type) {
+        const { payload } = await this.wire.sendAction('clipboard-read-html', { type });
+        return payload.data;
     }
     /**
      * Writes data into the clipboard as Rtf
-     * @param { WriteRequestType } writeObj This object is described in the WriteRequestType typedef
-     * @return {Promise.<void>}
+     * @param { OpenFin.WriteClipboardRequest } writeObj The object for writing data into the clipboard
+     * @return { Promise.<void> }
      * @tutorial Clipboard.writeRtf
      */
-    writeRtf(writeObj) {
-        return this.wire.sendAction('clipboard-write-rtf', writeObj).then(() => undefined);
+    async writeRtf(writeObj) {
+        await this.wire.sendAction('clipboard-write-rtf', writeObj);
     }
     /**
      * Read the content of the clipboard as Rtf
-     * @param { string } type Clipboard Type
-     * @return {Promise.<string>}
+     * @param { OpenFin.ClipboardSelectionType } [type] Clipboard Type defaults to 'clipboard', use 'selection' for linux
+     * @return { Promise.<string> }
      * @tutorial Clipboard.readRtf
      */
-    readRtf(type) {
-        return this.wire.sendAction('clipboard-read-rtf', type).then(({ payload }) => payload.data);
+    async readRtf(type) {
+        const { payload } = await this.wire.sendAction('clipboard-read-rtf', { type });
+        return payload.data;
     }
     /**
      * Writes data into the clipboard
-     * @param { WriteAnyRequestType } writeObj This object is described in the WriteAnyRequestType typedef
-     * @return {Promise.<void>}
+     * @param { OpenFin.WriteAnyClipboardRequest } writeObj The object for writing data into the clipboard
+     * @return { Promise.<void> }
      * @tutorial Clipboard.write
      */
-    write(writeObj) {
-        return this.wire.sendAction('clipboard-write', writeObj).then(() => undefined);
+    async write(writeObj) {
+        await this.wire.sendAction('clipboard-write', writeObj);
     }
     /**
      * Reads available formats for the clipboard type
-     * @param { string } type Clipboard Type
-     * @return {Promise.Array.<string>}
+     * @param { OpenFin.ClipboardSelectionType } [type] Clipboard Type defaults to 'clipboard', use 'selection' for linux
+     * @return { Promise.Array.<string> }
      * @tutorial Clipboard.getAvailableFormats
      */
-    getAvailableFormats(type) {
-        return this.wire.sendAction('clipboard-read-formats', type).then(({ payload }) => payload.data);
+    async getAvailableFormats(type) {
+        const { payload } = await this.wire.sendAction('clipboard-read-formats', { type });
+        return payload.data;
     }
 }
 exports.default = Clipboard;

package/src/api/interop/fdc3/shapes/fdc3v1.d.ts

@@ -1,13 +1,13 @@
-import type { DisplayMetadata } from 'fdc3v1/src/api/DisplayMetadata';
-import type { Listener } from 'fdc3v1/src/api/Listener';
-import type { AppMetadata } from 'fdc3v1/src/api/AppMetadata';
-import type { AppIntent } from 'fdc3v1/src/api/AppIntent';
-import type { ImplementationMetadata } from 'fdc3v1/src/api/ImplementationMetadata';
-export type { DisplayMetadata } from 'fdc3v1/src/api/DisplayMetadata';
-export type { Listener } from 'fdc3v1/src/api/Listener';
-export type { AppMetadata } from 'fdc3v1/src/api/AppMetadata';
-export type { AppIntent } from 'fdc3v1/src/api/AppIntent';
-export type { ImplementationMetadata } from 'fdc3v1/src/api/ImplementationMetadata';
+import type { DisplayMetadata } from 'fdc3v1/dist/api/DisplayMetadata';
+import type { Listener } from 'fdc3v1/dist/api/Listener';
+import type { AppMetadata } from 'fdc3v1/dist/api/AppMetadata';
+import type { AppIntent } from 'fdc3v1/dist/api/AppIntent';
+import type { ImplementationMetadata } from 'fdc3v1/dist/api/ImplementationMetadata';
+export type { DisplayMetadata } from 'fdc3v1/dist/api/DisplayMetadata';
+export type { Listener } from 'fdc3v1/dist/api/Listener';
+export type { AppMetadata } from 'fdc3v1/dist/api/AppMetadata';
+export type { AppIntent } from 'fdc3v1/dist/api/AppIntent';
+export type { ImplementationMetadata } from 'fdc3v1/dist/api/ImplementationMetadata';
 export type ContextHandler = (context: Context) => void;
 export type TargetApp = string | AppMetadata;
 export interface Context {

package/src/api/interop/fdc3/shapes/fdc3v2.d.ts

@@ -1,19 +1,19 @@
 import * as OpenFin from '../../../../OpenFin';
 import { Channel as ChannelV1, SystemChannel, TargetApp } from './fdc3v1';
-import type { Listener } from 'fdc3v2/src/api/Listener';
-import type { AppIntent } from 'fdc3v2/src/api/AppIntent';
-import type { ImplementationMetadata } from 'fdc3v2/src/api/ImplementationMetadata';
-import type { ContextMetadata } from 'fdc3v2/src/api/ContextMetadata';
-import type { AppIdentifier } from 'fdc3v2/src/api/AppIdentifier';
-import type { AppMetadata } from 'fdc3v2/src/api/AppMetadata';
-import type { DisplayMetadata } from 'fdc3v2/src/api/DisplayMetadata';
-export type { Listener } from 'fdc3v2/src/api/Listener';
-export type { AppIntent } from 'fdc3v2/src/api/AppIntent';
-export type { ImplementationMetadata } from 'fdc3v2/src/api/ImplementationMetadata';
-export type { ContextMetadata } from 'fdc3v2/src/api/ContextMetadata';
-export type { AppIdentifier } from 'fdc3v2/src/api/AppIdentifier';
-export type { AppMetadata } from 'fdc3v2/src/api/AppMetadata';
-export type { DisplayMetadata } from 'fdc3v2/src/api/DisplayMetadata';
+import type { Listener } from 'fdc3v2/dist/api/Listener';
+import type { AppIntent } from 'fdc3v2/dist/api/AppIntent';
+import type { ImplementationMetadata } from 'fdc3v2/dist/api/ImplementationMetadata';
+import type { ContextMetadata } from 'fdc3v2/dist/api/ContextMetadata';
+import type { AppIdentifier } from 'fdc3v2/dist/api/AppIdentifier';
+import type { AppMetadata } from 'fdc3v2/dist/api/AppMetadata';
+import type { DisplayMetadata } from 'fdc3v2/dist/api/DisplayMetadata';
+export type { Listener } from 'fdc3v2/dist/api/Listener';
+export type { AppIntent } from 'fdc3v2/dist/api/AppIntent';
+export type { ImplementationMetadata } from 'fdc3v2/dist/api/ImplementationMetadata';
+export type { ContextMetadata } from 'fdc3v2/dist/api/ContextMetadata';
+export type { AppIdentifier } from 'fdc3v2/dist/api/AppIdentifier';
+export type { AppMetadata } from 'fdc3v2/dist/api/AppMetadata';
+export type { DisplayMetadata } from 'fdc3v2/dist/api/DisplayMetadata';
 export type ContextHandler = (context: Context, metadata?: ContextMetadata) => void;
 export type IntentHandler = (context: Context, metadata?: ContextMetadata) => Promise<IntentResult> | void;
 export type IntentResult = Context | Channel | PrivateChannel;

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

@@ -506,5 +506,12 @@ export default class System extends EmitterBase<OpenFin.SystemEvent> {
      * @tutorial System.getPrinters
      */
     getPrinters(): Promise<PrinterInfo[]>;
+    /**
+     * Updates Process Logging values: periodic interval and outlier detection entries and interval.
+     * @param {ProcessLoggingOptions} options Process Logging updatable options.
+     * @return { Promise<void> }
+     * @tutorial System.updateProcessLoggingOptions
+     */
+    updateProcessLoggingOptions(options: OpenFin.ProcessLoggingOptions): Promise<void>;
 }
 export {};

package/src/api/system/index.js

@@ -882,5 +882,14 @@ class System extends base_1.EmitterBase {
         const { payload } = await this.wire.sendAction('system-get-printers');
         return payload.data;
     }
+    /**
+     * Updates Process Logging values: periodic interval and outlier detection entries and interval.
+     * @param {ProcessLoggingOptions} options Process Logging updatable options.
+     * @return { Promise<void> }
+     * @tutorial System.updateProcessLoggingOptions
+     */
+    async updateProcessLoggingOptions(options) {
+        await this.wire.sendAction('system-update-process-logging-options', { options });
+    }
 }
 exports.default = System;

package/src/shapes/protocol.d.ts

@@ -16,6 +16,20 @@ export interface ProtocolMap extends ProtocolMapBase {
         } & OpenFin.ApplicationIdentity;
         response: void;
     };
+    'clipboard-read-formats': {
+        request: {
+            type?: OpenFin.ClipboardSelectionType;
+        };
+        response: Array<string>;
+    };
+    'clipboard-read-image': {
+        request: OpenFin.ReadImageClipboardRequest;
+        response: string;
+    };
+    'clipboard-write-image': {
+        request: OpenFin.WriteImageClipboardRequest;
+        response: void;
+    };
     'get-view-window': IdentityCall<{}, OpenFin.Identity>;
     'create-view': IdentityCall<OpenFin.ViewCreationOptions & {
         uuid: string;

package/src/transport/wire.d.ts

@@ -1,4 +1,3 @@
-/// <reference types="mocha" />
 /// <reference types="node" />
 import EventEmitter = NodeJS.EventEmitter;
 export type Wire = EventEmitter & {