@openfin/core 29.71.10 → 29.71.15

package/OpenFin.d.ts

@@ -1429,6 +1429,7 @@ declare namespace OpenFin {
 
     export type IntentMetadata<TargetType = any> = {
         target?: TargetType;
+        resultType?: string;
     };
 
     export type IntentHandler = (intent: OpenFin.Intent) => void;
@@ -1482,9 +1483,15 @@ declare namespace OpenFin {
         metadata?: MetadataType;
     };
 
-    export type InfoForIntentOptions = {
+    export type InfoForIntentOptions<MetadataType = IntentMetadata> = {
         name: string;
         context?: OpenFin.Context;
+        metadata?: MetadataType;
+    };
+
+    export type FindIntentsByContextOptions<MetadataType = IntentMetadata> = {
+        context: OpenFin.Context;
+        metadata?: MetadataType;
     };
 
     export type ProviderIdentity = Identity & {

package/package.json

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

package/src/api/interop/InteropBroker.d.ts

@@ -304,7 +304,7 @@ export declare class InteropBroker extends Base {
      * @tutorial interop.handleInfoForIntentsByContext
      * @experimental
      */
-    handleInfoForIntentsByContext(context: OpenFin.Context, clientIdentity: OpenFin.ClientIdentity): Promise<unknown>;
+    handleInfoForIntentsByContext(context: OpenFin.Context | OpenFin.FindIntentsByContextOptions, clientIdentity: OpenFin.ClientIdentity): Promise<unknown>;
     /**
      * Responsible for resolving an Intent based on a specific Context.
      * Must be overridden.
@@ -332,6 +332,8 @@ export declare class InteropBroker extends Base {
         app: FDC3.TargetApp;
         context: OpenFin.Context;
     }, clientIdentity: OpenFin.ClientIdentity): Promise<void>;
+    fdc3HandleFindInstances(app: FDC3v2.AppIdentifier, clientIdentity: OpenFin.ClientIdentity): Promise<unknown>;
+    fdc3HandleGetAppMetadata(app: FDC3v2.AppIdentifier, clientIdentity: OpenFin.ClientIdentity): Promise<unknown>;
     decorateSnapshot(snapshot: OpenFin.Snapshot): OpenFin.Snapshot;
     applySnapshot(snapshot: OpenFin.Snapshot, options: OpenFin.ApplySnapshotOptions): void;
     updateExistingClients(contextGroupStates: OpenFin.ContextGroupStates): void;

package/src/api/interop/InteropBroker.js

@@ -628,6 +628,18 @@ class InteropBroker extends base_1.Base {
         console.warn(warning);
         throw new Error(utils_1.BROKER_ERRORS.fdc3Open);
     }
+    // eslint-disable-next-line class-methods-use-this
+    async fdc3HandleFindInstances(app, clientIdentity) {
+        const warning = utils_1.generateOverrideWarning('fdc3.open', 'InteropBroker.fdc3HandleFindInstances', clientIdentity);
+        console.warn(warning);
+        throw new Error(utils_1.BROKER_ERRORS.fdc3FindInstances);
+    }
+    // eslint-disable-next-line class-methods-use-this
+    async fdc3HandleGetAppMetadata(app, clientIdentity) {
+        const warning = utils_1.generateOverrideWarning('fdc3.getAppMetadata', 'InteropBroker.fdc3HandleGetAppMetadata', clientIdentity);
+        console.warn(warning);
+        throw new Error(utils_1.BROKER_ERRORS.fdc3FindInstances);
+    }
     /*
     Snapshot APIs
     */
@@ -936,6 +948,9 @@ class InteropBroker extends base_1.Base {
         channel.register('sessionContextGroup:createIfNeeded', this.handleJoinSessionContextGroup.bind(this));
         // fdc3 only methods
         channel.register('fdc3Open', this.fdc3HandleOpen.bind(this));
+        channel.register('fdc3v2FindIntentsByContext', this.handleInfoForIntentsByContext.bind(this));
+        channel.register('fdc3FindInstances', this.fdc3HandleFindInstances.bind(this));
+        channel.register('fdc3GetAppMetadata', this.fdc3HandleGetAppMetadata.bind(this));
     }
     /**
      * Can be used to completely prevent a connection. Return false to prevent connections. Allows all connections by default.

package/src/api/interop/InteropClient.d.ts

@@ -217,7 +217,7 @@ export declare class InteropClient extends Base {
      * @tutorial interop.registerIntentHandler
      * @experimental
      */
-    registerIntentHandler(handler: OpenFin.IntentHandler, intentName: string): Promise<{
+    registerIntentHandler(handler: OpenFin.IntentHandler, intentName: string, options?: any): Promise<{
         unsubscribe: () => Promise<void>;
     }>;
     /**

package/src/api/interop/InteropClient.js

@@ -324,7 +324,7 @@ class InteropClient extends base_1.Base {
      * @tutorial interop.registerIntentHandler
      * @experimental
      */
-    async registerIntentHandler(handler, intentName) {
+    async registerIntentHandler(handler, intentName, options) {
         this.wire.sendAction('interop-client-register-intent-handler').catch((e) => {
             // don't expose, this is only for api analytics purposes
         });
@@ -333,7 +333,7 @@ class InteropClient extends base_1.Base {
         const wrappedHandler = utils_1.wrapIntentHandler(handler, handlerId);
         try {
             await client.register(handlerId, wrappedHandler);
-            await client.dispatch('intentHandlerRegistered', { handlerId });
+            await client.dispatch('intentHandlerRegistered', { handlerId, ...options });
         }
         catch (error) {
             throw new Error('Unable to register intent handler');

package/src/api/interop/fdc3/fdc3-1.2.js

@@ -215,7 +215,9 @@ class Fdc3Module extends base_1.Base {
         const contextHandler = (raisedIntent) => {
             handler(raisedIntent.context);
         };
-        const listener = this.fin.me.interop.registerIntentHandler(contextHandler, intent);
+        const listener = this.fin.me.interop.registerIntentHandler(contextHandler, intent, {
+            fdc3Version: '1.2'
+        });
         return {
             ...listener,
             unsubscribe: () => listener.then((l) => l.unsubscribe())

package/src/api/interop/fdc3/fdc3-2.0.d.ts

@@ -0,0 +1,24 @@
+import { Base } from '../../base';
+import Transport from '../../../transport/transport';
+export default class Fdc3Module2 extends Base implements FDC3v2.DesktopAgent {
+    private fdc3Module;
+    constructor(wire: Transport);
+    open(app: FDC3v2.AppIdentifier | FDC3.TargetApp, context?: OpenFin.Context): Promise<FDC3v2.AppIdentifier | void>;
+    findInstances(app: FDC3v2.AppIdentifier): Promise<Array<FDC3v2.AppIdentifier>>;
+    getAppMetadata(app: FDC3v2.AppIdentifier): Promise<FDC3.AppMetadata>;
+    broadcast(context: OpenFin.Context): Promise<void>;
+    addContextListener(contextType: string | null, handler: OpenFin.ContextHandler): Promise<FDC3.Listener>;
+    findIntent(intent: string, context?: OpenFin.Context, resultType?: string): Promise<FDC3.AppIntent>;
+    findIntentsByContext(context: OpenFin.Context, resultType?: string): Promise<Array<FDC3.AppIntent>>;
+    raiseIntent(intent: string, context: OpenFin.Context, app?: FDC3v2.AppIdentifier | FDC3.TargetApp): Promise<FDC3.IntentResolution>;
+    raiseIntentForContext(context: OpenFin.Context, app?: FDC3v2.AppIdentifier | FDC3.TargetApp): Promise<FDC3.IntentResolution>;
+    addIntentListener(intent: string, handler: FDC3v2.IntentHandler): Promise<FDC3.Listener>;
+    getOrCreateChannel(channelId: string): Promise<FDC3.Channel>;
+    createPrivateChannel(): Promise<FDC3v2.PrivateChannel | void>;
+    getUserChannels(): Promise<Array<OpenFin.ContextGroupInfo>>;
+    getSystemChannels(): Promise<Array<OpenFin.ContextGroupInfo>>;
+    joinUserChannel(channelId: string): Promise<void>;
+    getCurrentChannel(): Promise<FDC3.Channel | null>;
+    leaveCurrentChannel(): Promise<void>;
+    getInfo(): Promise<FDC3.ImplementationMetadata>;
+}

package/src/api/interop/fdc3/fdc3-2.0.js

@@ -0,0 +1,126 @@
+"use strict";
+// THIS IS NOT PRODUCTION-READY. Until we implement the missing features: getResult, Private Channels and Instance Management we should not document this.
+Object.defineProperty(exports, "__esModule", { value: true });
+const base_1 = require("../../base");
+const utils_1 = require("../utils");
+const InteropClient_1 = require("../InteropClient");
+const fdc3_1_2_1 = require("./fdc3-1.2");
+class Fdc3Module2 extends base_1.Base {
+    constructor(wire) {
+        super(wire);
+        // we get the module for fdc 1.2 here so we can reuse it wherever we can
+        this.fdc3Module = new fdc3_1_2_1.default(this.wire);
+    }
+    async open(app, context) {
+        return this.fdc3Module.open(app, context);
+    }
+    async findInstances(app) {
+        this.wire.sendAction('fdc3-find-instances').catch((e) => {
+            // we do not want to expose this error, just continue if this analytics-only call fails
+        });
+        try {
+            return await InteropClient_1.InteropClient.ferryFdc3Call(fin.me.interop, 'fdc3FindInstances', app);
+        }
+        catch (error) {
+            const errorToThrow = error.message === utils_1.BROKER_ERRORS.fdc3FindInstances ? 'ResolverUnavailable' : error;
+            throw new Error(errorToThrow);
+        }
+    }
+    async getAppMetadata(app) {
+        this.wire.sendAction('fdc3-get-app-metadata').catch((e) => {
+            // we do not want to expose this error, just continue if this analytics-only call fails
+        });
+        try {
+            return await InteropClient_1.InteropClient.ferryFdc3Call(fin.me.interop, 'fdc3GetAppMetadata', app);
+        }
+        catch (error) {
+            const errorToThrow = error.message === utils_1.BROKER_ERRORS.fdc3GetAppMetadata ? 'ResolverUnavailable' : error;
+            throw new Error(errorToThrow);
+        }
+    }
+    async broadcast(context) {
+        return this.fdc3Module.broadcast(context);
+    }
+    async addContextListener(contextType, handler) {
+        this.wire.sendAction('fdc3-add-context-listener').catch((e) => {
+            // we do not want to expose this error, just continue if this analytics-only call fails
+        });
+        let listener;
+        if (typeof contextType === 'function') {
+            console.warn('addContextListener(handler) has been deprecated. Please use addContextListener(null, handler)');
+            listener = await this.fin.me.interop.addContextHandler(contextType);
+        }
+        else {
+            listener = await this.fin.me.interop.addContextHandler(handler, contextType === null ? undefined : contextType);
+        }
+        return listener;
+    }
+    async findIntent(intent, context, resultType) {
+        this.wire.sendAction('fdc3-find-intent').catch((e) => {
+            // we do not want to expose this error, just continue if this analytics-only call fails
+        });
+        try {
+            return await this.fin.me.interop.getInfoForIntent({ name: intent, context, metadata: { resultType } });
+        }
+        catch (error) {
+            const errorToThrow = error.message === utils_1.BROKER_ERRORS.getInfoForIntent ? 'ResolverUnavailable' : error;
+            throw new Error(errorToThrow);
+        }
+    }
+    async findIntentsByContext(context, resultType) {
+        this.wire.sendAction('fdc3-find-intents-by-context').catch((e) => {
+            // we do not want to expose this error, just continue if this analytics-only call fails
+        });
+        try {
+            return await InteropClient_1.InteropClient.ferryFdc3Call(fin.me.interop, 'fdc3v2FindIntentsByContext', {
+                context,
+                resultType
+            });
+        }
+        catch (error) {
+            const errorToThrow = error.message === utils_1.BROKER_ERRORS.getInfoForIntentsByContext ? 'ResolverUnavailable' : error;
+            throw new Error(errorToThrow);
+        }
+    }
+    async raiseIntent(intent, context, app) {
+        return this.fdc3Module.raiseIntent(intent, context, app);
+    }
+    async raiseIntentForContext(context, app) {
+        return this.fdc3Module.raiseIntentForContext(context, app);
+    }
+    async addIntentListener(intent, handler) {
+        this.wire.sendAction('fdc3-add-intent-listener').catch((e) => {
+            // we do not want to expose this error, just continue if this analytics-only call fails
+        });
+        const contextHandler = (raisedIntent) => {
+            handler(raisedIntent.context);
+        };
+        return this.fin.me.interop.registerIntentHandler(contextHandler, intent, { fdc3Version: '2.0' });
+    }
+    async getOrCreateChannel(channelId) {
+        return this.fdc3Module.getOrCreateChannel(channelId);
+    }
+    // eslint-disable-next-line class-methods-use-this
+    async createPrivateChannel() {
+        // private channels will be implemented in another PR
+    }
+    async getUserChannels() {
+        return this.fdc3Module.getSystemChannels();
+    }
+    async getSystemChannels() {
+        return this.fdc3Module.getSystemChannels();
+    }
+    async joinUserChannel(channelId) {
+        return this.fdc3Module.joinChannel(channelId);
+    }
+    async getCurrentChannel() {
+        return this.fdc3Module.getCurrentChannel();
+    }
+    async leaveCurrentChannel() {
+        return this.leaveCurrentChannel();
+    }
+    async getInfo() {
+        return this.fdc3Module.getInfo();
+    }
+}
+exports.default = Fdc3Module2;

package/src/api/interop/fdc3/fdc3.js

@@ -2,8 +2,10 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.registerFdc3Shim = exports.versionMap = void 0;
 const fdc3_1_2_1 = require("./fdc3-1.2");
+const fdc3_2_0_1 = require("./fdc3-2.0");
 exports.versionMap = {
-    '1.2': fdc3_1_2_1.default
+    '1.2': fdc3_1_2_1.default,
+    '2.0': fdc3_2_0_1.default
 };
 function registerFdc3Shim(version, transport) {
     if (Object.keys(exports.versionMap).includes(version)) {

package/src/api/interop/utils.d.ts

@@ -10,5 +10,7 @@ export declare const BROKER_ERRORS: {
     getInfoForIntentsByContext: string;
     joinSessionContextGroupWithJoinContextGroup: string;
     fdc3Open: string;
+    fdc3FindInstances: string;
+    fdc3GetAppMetadata: string;
 };
 export declare const wrapIntentHandler: (handler: OpenFin.IntentHandler, handlerId: string) => (intent: OpenFin.Intent) => Promise<void>;

package/src/api/interop/utils.js

@@ -37,7 +37,9 @@ exports.BROKER_ERRORS = {
     getInfoForIntent: exports.generateOverrideError('getInfoForIntent', 'handleInfoForIntent'),
     getInfoForIntentsByContext: exports.generateOverrideError('getInfoForIntentsByContext', 'handleInfoForIntentsByContext'),
     joinSessionContextGroupWithJoinContextGroup: 'The Context Group you have tried to join is a Session Context Group. Custom Context Groups can only be defined by the Interop Broker through code or manifest configuration. Please use joinSessionContextGroup.',
-    fdc3Open: exports.generateOverrideError('fdc3.open', 'fdc3HandleOpen')
+    fdc3Open: exports.generateOverrideError('fdc3.open', 'fdc3HandleOpen'),
+    fdc3FindInstances: exports.generateOverrideError('fdc3.findInstances', 'fdc3HandleFindInstances'),
+    fdc3GetAppMetadata: exports.generateOverrideError('fdc3.getAppMetadata', 'fdc3HandleGetAppMetadata')
 };
 exports.wrapIntentHandler = (handler, handlerId) => {
     return async (intent) => {