@openfin/core 30.73.17 → 30.73.19

package/fdc3.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/fdc3.ts

@@ -0,0 +1,264 @@
+import * as OpenFin from './src/OpenFin';
+
+// eslint-disable-next-line @typescript-eslint/no-namespace
+export declare namespace FDC3 {
+    interface DesktopAgent {
+        addContextListener(contextType: string | null, handler: OpenFin.ContextHandler): Listener & Promise<Listener>;
+        broadcast(context: OpenFin.Context): Promise<void>;
+        getSystemChannels(): Promise<OpenFin.ContextGroupInfo[]>;
+        joinChannel(channelId: string): Promise<void>;
+        leaveCurrentChannel(): Promise<void>;
+        addIntentListener(intent: string, handler: OpenFin.ContextHandler): Listener & Promise<Listener>;
+        raiseIntent(intent: string, context: OpenFin.Context, app?: TargetApp): Promise<IntentResolution>;
+        findIntent(intent: string, context?: OpenFin.Context): Promise<AppIntent>;
+        findIntentsByContext(context: OpenFin.Context): Promise<Array<AppIntent>>;
+        raiseIntentForContext(context: OpenFin.Context, app?: TargetApp): Promise<IntentResolution>;
+        getInfo(): ImplementationMetadata;
+        open(app: FDC3.TargetApp, context?: OpenFin.Context): Promise<void>;
+        getOrCreateChannel(channelId: string): Promise<Channel>;
+        getCurrentChannel(): Promise<Channel | null>;
+    }
+
+    interface Listener {
+        unsubscribe(): void;
+    }
+
+    interface AppMetadata {
+        name: string;
+        appId?: string;
+        version?: string;
+        title?: string;
+        tooltip?: string;
+        description?: string;
+        icons?: Array<string>;
+        images?: Array<string>;
+    }
+
+    type TargetApp = string | AppMetadata;
+
+    type Intent = OpenFin.Intent<IntentMetadata>;
+
+    type IntentMetadata = OpenFin.IntentMetadata<TargetApp>;
+
+    interface IntentResolution {
+        source: TargetApp | null;
+        version: string | null;
+        data?: any;
+    }
+
+    interface DisplayMetadata {
+        name?: string;
+        color?: string;
+        glpyh?: string;
+    }
+    interface Channel {
+        id: string;
+        type: string;
+        displayMetadata?: DisplayMetadata;
+        addContextListener(contextType: string, handler: OpenFin.ContextHandler): Listener & Promise<Listener>;
+        broadcast(context: OpenFin.Context): Promise<void>;
+        getCurrentContext(contextType?: string): Promise<OpenFin.Context | null>;
+    }
+
+    interface AppIntent {
+        intent: Intent;
+        apps: Array<AppMetadata>;
+    }
+
+    interface ImplementationMetadata {
+        fdc3Version: string;
+        provider: string;
+        providerVersion?: string;
+    }
+}
+
+// eslint-disable-next-line @typescript-eslint/no-namespace
+export declare namespace FDC3v2 {
+    interface DesktopAgent {
+        // apps
+        open(app: AppIdentifier | FDC3.TargetApp, context?: OpenFin.Context): Promise<AppIdentifier | void>;
+        findInstances(app: AppIdentifier): Promise<Array<AppIdentifier>>;
+        getAppMetadata(app: AppIdentifier): Promise<AppMetadata>;
+
+        // context
+        broadcast(context: OpenFin.Context): Promise<void>;
+        addContextListener(contextType: string | null, handler: OpenFin.ContextHandler): Promise<FDC3.Listener>;
+
+        // intents
+        findIntent(intent: string, context?: OpenFin.Context, resultType?: string): Promise<AppIntent>;
+        findIntentsByContext(context: OpenFin.Context, resultType?: string): Promise<Array<AppIntent>>;
+        raiseIntent(
+            intent: string,
+            context: OpenFin.Context,
+            app?: AppIdentifier | FDC3.TargetApp
+        ): Promise<IntentResolution>;
+        raiseIntentForContext(
+            context: OpenFin.Context,
+            app?: AppIdentifier | FDC3.TargetApp
+        ): Promise<IntentResolution>;
+        addIntentListener(intent: string, handler: IntentHandler): Promise<FDC3.Listener>;
+
+        // channels
+        getOrCreateChannel(channelId: string): Promise<FDC3.Channel>;
+        createPrivateChannel(): Promise<PrivateChannel | void>;
+        getUserChannels(): Promise<Array<OpenFin.ContextGroupInfo>>;
+
+        // OPTIONAL channel management functions
+        joinUserChannel(channelId: string): Promise<void>;
+        getCurrentChannel(): Promise<FDC3.Channel | null>;
+        leaveCurrentChannel(): Promise<void>;
+
+        // implementation info
+        getInfo(): Promise<FDC3.ImplementationMetadata>;
+    }
+
+    interface AppIdentifier {
+        appId: string;
+        instanceId?: string;
+    }
+    interface Listener {
+        unsubscribe(): Promise<void>;
+    }
+
+    interface Channel {
+        id: string;
+        type: string;
+        displayMetadata?: FDC3.DisplayMetadata;
+        addContextListener(contextType: string, handler: OpenFin.ContextHandler): Promise<FDC3v2.Listener>;
+        broadcast(context: OpenFin.Context): Promise<void>;
+        getCurrentContext(contextType?: string): Promise<OpenFin.Context | null>;
+    }
+
+    interface PrivateChannel extends FDC3v2.Channel {
+        // methods
+        onAddContextListener(handler: (contextType?: string) => void): FDC3v2.Listener;
+        onUnsubscribe(handler: (contextType?: string) => void): FDC3v2.Listener;
+        onDisconnect(handler: () => void): FDC3v2.Listener;
+        disconnect(): void;
+    }
+
+    interface FindIntentsByContextOptions {
+        context: OpenFin.Context;
+        resultType?: string;
+    }
+
+    interface ContextMetadata {
+        /** Identifier for the app instance that sent the context and/or intent.
+         *  @experimental
+         */
+        readonly source: AppIdentifier;
+    }
+
+    interface IntentMetadata {
+        /** The unique name of the intent that can be invoked by the raiseIntent call. */
+        readonly name: string;
+
+        /** A friendly display name for the intent that should be used to render UI
+         *  elements.
+         */
+        readonly displayName: string;
+    }
+
+    type ContextHandler = (context: OpenFin.Context, metadata?: ContextMetadata) => void;
+    type IntentHandler = (context: OpenFin.Context, metadata?: ContextMetadata) => Promise<IntentResult> | void;
+
+    type IntentResult = OpenFin.Context | FDC3.Channel | PrivateChannel;
+    interface Icon {
+        src: string;
+        size?: string;
+        type?: string;
+    }
+
+    interface Image {
+        src: string;
+        size?: string;
+        type?: string;
+        label?: string;
+    }
+
+    interface AppMetadata extends AppIdentifier {
+        name?: string;
+        instanceMetadata?: Record<string, any>;
+        title?: string;
+        tooltip?: string;
+        description?: string;
+        icons?: Array<Icon>;
+        screenshots?: Array<Image>;
+        resultType?: string | null;
+    }
+
+    interface IntentResolution {
+        /** Identifier for the app instance that was selected (or started) to resolve
+         *  the intent. `source.instanceId` MUST be set, indicating the specific app
+         *  instance that received the intent.
+         */
+        readonly source: AppIdentifier;
+
+        /** The intent that was raised. May be used to determine which intent the user
+         *  chose in response to `fdc3.raiseIntentForContext()`.
+         */
+        readonly intent: string;
+
+        /** The version number of the Intents schema being used.
+         */
+        readonly version?: string;
+
+        /** Retrieves a promise that will resolve to either `Context` data returned
+         *  by the application that resolves the raised intent or a `Channel`
+         *  established and returned by the app resolving the intent.
+         *
+         *  A `Channel` returned MAY be of the `PrivateChannel` type. The
+         *  client can then `addContextListener()` on that channel to, for example,
+         *  receive a stream of data.
+         *
+         *  If an error occurs (i.e. an error is thrown by the handler function,
+         *  the promise it returns is rejected, or a promise is not returned by the
+         *  handler function) then the Desktop Agent MUST reject the promise returned
+         *  by the `getResult()` function of the `IntentResolution` with a string from
+         *  the `ResultError` enumeration.
+         */
+
+        // getResult() will be implemented in a future PR
+        getResult(): Promise<IntentResult>;
+    }
+
+    interface ImplementationMetadata {
+        /** The version number of the FDC3 specification that the implementation
+         *  provides. The string must be a numeric semver version, e.g. 1.2 or 1.2.1.
+         */
+        readonly fdc3Version: string;
+
+        /** The name of the provider of the FDC3 Desktop Agent Implementation
+         *  (e.g.Finsemble, Glue42, OpenFin etc.).
+         */
+        readonly provider: string;
+
+        /** The version of the provider of the FDC3 Desktop Agent Implementation
+         *  (e.g. 5.3.0).
+         */
+        readonly providerVersion?: string;
+
+        /** Metadata indicating whether the Desktop Agent implements optional features of
+         *  the Desktop Agent API.
+         */
+        readonly optionalFeatures: {
+            /** Used to indicate whether the exposure of 'originating app metadata' for
+             *  context and intent messages is supported by the Desktop Agent. */
+            OriginatingAppMetadata: boolean;
+            /** Used to indicate whether the optional `fdc3.joinUserChannel`,
+             *  `fdc3.getCurrentChannel` and `fdc3.leaveCurrentChannel` are implemented by
+             *  the Desktop Agent. */
+            UserChannelMembershipAPIs: boolean;
+        };
+
+        /** The calling application instance's own metadata, according to the
+         *  Desktop Agent (MUST include at least the `appId` and `instanceId`).
+         */
+        readonly appMetadata: AppMetadata;
+    }
+
+    interface AppIntent {
+        intent: IntentMetadata;
+        apps: Array<AppMetadata>;
+    }
+}

package/fin.d.ts

@@ -1,4 +1,3 @@
-/* eslint-disable spaced-comment */
-/* eslint-disable @typescript-eslint/triple-slash-reference */
-/// <reference path="./OpenFin.d.ts"/>
-declare const fin: import('./src/api/fin').FinApi<'window' | 'view'>;
+/// <reference path="./src/GlobalOpenFin.d.ts"/>
+
+declare const fin: import("./src/api/fin").FinApi<'window' | 'view'>;

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "@openfin/core",
-    "version": "30.73.17",
+    "version": "30.73.19",
     "license": "Apache-2.0",
     "main": "./src/mock.js",
     "types": "./src/mock.d.ts",

package/src/GlobalOpenFin.d.ts

@@ -0,0 +1,4 @@
+import * as OpenFin from './OpenFin';
+
+export = OpenFin;
+export as namespace OpenFin;