@openfin/core 31.74.19 → 31.74.22

package/package.json

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

package/src/api/api-exposer/api-consumer.d.ts

@@ -0,0 +1,28 @@
+import { ExposedProp } from "./decorators";
+export type ConsumeStrategy<TMetaConsumeOptions, TPropConsumeDefinition> = {
+    getExposedFunctions: (options: TMetaConsumeOptions) => Promise<ExposedProp<TPropConsumeDefinition>[]>;
+    createFunction: (options: ExposedProp<TPropConsumeDefinition>, meta: TMetaConsumeOptions) => Function;
+};
+type PickOfType<T extends Record<any, any>, TTarget> = {
+    [key in keyof T as T[key] extends TTarget | undefined ? key : never]: T[key];
+};
+export type ApiClient<T extends Record<any, any>> = {
+    [key in keyof PickOfType<T, Function>]: (...args: Parameters<T[key]>) => ReturnType<T[key]> extends Promise<any> ? ReturnType<T[key]> : Promise<ReturnType<T[key]>>;
+};
+/**
+ * Consumer for apis exposed with {@see ApiExposer}.
+ *
+ * A strategy that matches the strategy used to expose a target API must be provided.
+ */
+export declare class ApiConsumer<TMetaConsumeOptions = any, TPropConsumptionOptions = any> {
+    private strategy;
+    constructor(strategy: ConsumeStrategy<TMetaConsumeOptions, TPropConsumptionOptions>);
+    /**
+     * Consumes an api exposed using a given transport strategy, and generates a client
+     * for easy, type safe consumption of that client.
+     * @param options Strategy specific consumption options.
+     * @returns An api client matching the given type.
+     */
+    consume: <T extends Record<any, any>>(options: TMetaConsumeOptions) => Promise<ApiClient<T>>;
+}
+export {};

package/src/api/api-exposer/api-consumer.js

@@ -0,0 +1,28 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ApiConsumer = void 0;
+/**
+ * Consumer for apis exposed with {@see ApiExposer}.
+ *
+ * A strategy that matches the strategy used to expose a target API must be provided.
+ */
+class ApiConsumer {
+    // eslint-disable-next-line
+    constructor(strategy) {
+        this.strategy = strategy;
+        /**
+         * Consumes an api exposed using a given transport strategy, and generates a client
+         * for easy, type safe consumption of that client.
+         * @param options Strategy specific consumption options.
+         * @returns An api client matching the given type.
+         */
+        this.consume = async (options) => {
+            const exposedProperties = await this.strategy.getExposedFunctions(options);
+            return exposedProperties.reduce((client, prop) => ({
+                ...client,
+                [prop.key]: this.strategy.createFunction(prop, options)
+            }), {});
+        };
+    }
+}
+exports.ApiConsumer = ApiConsumer;

package/src/api/api-exposer/api-exposer.d.ts

@@ -0,0 +1,35 @@
+import { ExposedProp } from './decorators';
+export type ConsumptionConfig<T> = {
+    key: string;
+    options: T;
+};
+export type ExposeStrategy<TInstanceExposeOptions, TPropExposeOptions, TPropConsumeOptions> = {
+    /**
+     * Exposes the given function on the strategy.
+     */
+    exposeFunction: (target: Function, config: {
+        key: string;
+        options: TPropExposeOptions;
+        meta: TInstanceExposeOptions;
+    }) => Promise<TPropConsumeOptions>;
+    /**
+     * Exposes metadata to enable creation of client objects.
+     */
+    exposeMeta: (instanceOptions: TInstanceExposeOptions, props: ExposedProp<TPropConsumeOptions>[]) => Promise<void>;
+};
+/**
+ * Exposes api services on the transport of choice.
+ */
+export declare class ApiExposer<TInstanceExposeOptions = any, TPropExposeOptions = any, TPropConsumptionOptions = any> {
+    private strategy;
+    /**
+     * @param strategy The expose strategy to use to expose instances.
+     */
+    constructor(strategy: ExposeStrategy<TInstanceExposeOptions, TPropExposeOptions, TPropConsumptionOptions>);
+    /**
+     * Exposes an instance of a given api on
+     * @param instance Instance of a class which has been decorated to indicate which functions can be exposed.
+     * @param instanceOptions Transport strategy specific options to use when exposing.
+     */
+    exposeInstance: (instance: Record<any, any>, instanceOptions: TInstanceExposeOptions) => Promise<void>;
+}

package/src/api/api-exposer/api-exposer.js

@@ -0,0 +1,38 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ApiExposer = void 0;
+const decorators_1 = require("./decorators");
+/**
+ * Exposes api services on the transport of choice.
+ */
+class ApiExposer {
+    /**
+     * @param strategy The expose strategy to use to expose instances.
+     */
+    // eslint-disable-next-line
+    constructor(strategy) {
+        this.strategy = strategy;
+        /**
+         * Exposes an instance of a given api on
+         * @param instance Instance of a class which has been decorated to indicate which functions can be exposed.
+         * @param instanceOptions Transport strategy specific options to use when exposing.
+         */
+        this.exposeInstance = async (instance, instanceOptions) => {
+            const exposableProps = (0, decorators_1.getExposedProperties)(instance);
+            const exposedProps = await Promise.all(exposableProps.map(async ({ key, options }) => {
+                const customConsumptionOptions = await this.strategy.exposeFunction(instance[key].bind(instance), {
+                    key,
+                    options,
+                    meta: instanceOptions
+                });
+                return {
+                    key,
+                    options: customConsumptionOptions
+                };
+            }));
+            await this.strategy.exposeMeta(instanceOptions, exposedProps);
+        };
+    }
+    ;
+}
+exports.ApiExposer = ApiExposer;

package/src/api/api-exposer/decorators.d.ts

@@ -0,0 +1,10 @@
+export type ExposedProp<T> = {
+    key: string;
+    options: T;
+};
+export declare const getExposedProperties: <T>(target: Record<any, any>) => ExposedProp<T>[];
+/**
+ * Indicates that a class member function can be exposed using {@link ApiExposer}.
+ * @param options Options specific to the strategy used in {@link ApiExposer}
+ */
+export declare const expose: <T = undefined>(options?: T) => any;

package/src/api/api-exposer/decorators.js

@@ -0,0 +1,18 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.expose = exports.getExposedProperties = void 0;
+const exposedProperties = Symbol('exposedProperties');
+const getExposedProperties = (target) => {
+    return target[exposedProperties] || target.prototype[exposedProperties] || [];
+};
+exports.getExposedProperties = getExposedProperties;
+/**
+ * Indicates that a class member function can be exposed using {@link ApiExposer}.
+ * @param options Options specific to the strategy used in {@link ApiExposer}
+ */
+// Returns any as decorator typing is weird.
+const expose = (options) => (target, key, descriptor) => {
+    target[exposedProperties] = target[exposedProperties] || [];
+    target[exposedProperties].push({ key, descriptor, options });
+};
+exports.expose = expose;

package/src/api/api-exposer/index.d.ts

@@ -0,0 +1,4 @@
+export * from './api-consumer';
+export * from './api-exposer';
+export * from './strategies';
+export * from './decorators';

package/src/api/api-exposer/index.js

@@ -0,0 +1,20 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = 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" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("./api-consumer"), exports);
+__exportStar(require("./api-exposer"), exports);
+__exportStar(require("./strategies"), exports);
+__exportStar(require("./decorators"), exports);

package/src/api/api-exposer/strategies/index.d.ts

@@ -0,0 +1 @@
+export * from './openfin-channels';

package/src/api/api-exposer/strategies/index.js

@@ -0,0 +1,17 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = 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" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("./openfin-channels"), exports);

package/src/api/api-exposer/strategies/openfin-channels/channels-consumer.d.ts

@@ -0,0 +1,14 @@
+import { ConsumeStrategy } from "../../api-consumer";
+import { ExposedProp } from "../../decorators";
+export type ChannelConsumeOptions = {
+    id: string;
+};
+export type ChannelsPropConfig = {
+    action: string;
+};
+export declare class ChannelsConsumer implements ConsumeStrategy<ChannelConsumeOptions, ChannelsPropConfig> {
+    private channel;
+    constructor(channel: any);
+    getExposedFunctions: (options: ChannelConsumeOptions) => Promise<ExposedProp<ChannelsPropConfig>[]>;
+    createFunction: (prop: ExposedProp<ChannelsPropConfig>) => Function;
+}

package/src/api/api-exposer/strategies/openfin-channels/channels-consumer.js

@@ -0,0 +1,20 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ChannelsConsumer = void 0;
+class ChannelsConsumer {
+    // eslint-disable-next-line
+    constructor(channel) {
+        this.channel = channel;
+        this.getExposedFunctions = async (options) => {
+            const { id } = options;
+            const { props } = await this.channel.dispatch(`api-meta:${id}`);
+            return props;
+        };
+        this.createFunction = (prop) => (...args) => {
+            const { action } = prop.options;
+            return this.channel.dispatch(action, { args });
+        };
+    }
+    ;
+}
+exports.ChannelsConsumer = ChannelsConsumer;

package/src/api/api-exposer/strategies/openfin-channels/channels-exposer.d.ts

@@ -0,0 +1,20 @@
+import { ExposeStrategy } from '../../api-exposer';
+import { ExposedProp } from '../../decorators';
+import { ChannelsPropConfig } from './channels-consumer';
+type ChannelInstanceExposeOptions = {
+    id: string;
+};
+export type ChannelsPropOptions = {
+    action?: string;
+} | undefined;
+export declare class ChannelsExposer implements ExposeStrategy<ChannelInstanceExposeOptions, ChannelsPropOptions, ChannelsPropConfig> {
+    private channelProviderOrClient;
+    constructor(channelProviderOrClient: any);
+    exposeFunction: (target: Function, config: {
+        key: string;
+        options: ChannelsPropOptions;
+        meta: ChannelInstanceExposeOptions;
+    }) => Promise<ChannelsPropConfig>;
+    exposeMeta: ({ id }: ChannelInstanceExposeOptions, props: ExposedProp<ChannelsPropOptions>[]) => Promise<void>;
+}
+export {};

package/src/api/api-exposer/strategies/openfin-channels/channels-exposer.js

@@ -0,0 +1,23 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ChannelsExposer = void 0;
+class ChannelsExposer {
+    // eslint-disable-next-line
+    constructor(channelProviderOrClient) {
+        this.channelProviderOrClient = channelProviderOrClient;
+        this.exposeFunction = async (target, config) => {
+            const { key, options, meta } = config;
+            const { id } = meta;
+            const action = `${id}.${(options === null || options === void 0 ? void 0 : options.action) || key}`;
+            await this.channelProviderOrClient.register(action, async ({ args }) => {
+                return target(...args);
+            });
+            return { action };
+        };
+        this.exposeMeta = async ({ id }, props) => {
+            const action = `api-meta:${id}`;
+            await this.channelProviderOrClient.register(action, () => ({ props }));
+        };
+    }
+}
+exports.ChannelsExposer = ChannelsExposer;

package/src/api/api-exposer/strategies/openfin-channels/index.d.ts

@@ -0,0 +1,2 @@
+export * from './channels-consumer';
+export * from './channels-exposer';

package/src/api/api-exposer/strategies/openfin-channels/index.js

@@ -0,0 +1,18 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = 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" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("./channels-consumer"), exports);
+__exportStar(require("./channels-exposer"), exports);

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

@@ -169,11 +169,15 @@ class Fdc3Module extends base_1.Base {
         }
         catch (error) {
             if (error.message === utils_2.BROKER_ERRORS.joinSessionContextGroupWithJoinContextGroup) {
-                throw new Error('The Channel you have tried to join is an App Channel. Custom Channels can only be defined by the Interop Broker through code or manifest configuration. Please use getOrCreateChannel.');
+                console.error('The Channel you have tried to join is an App Channel. Custom Channels can only be defined by the Interop Broker through code or manifest configuration. Please use getOrCreateChannel.');
             }
             else {
-                throw new Error(error.message);
+                console.error(error.message);
             }
+            if (error.message.startsWith('Attempting to join a context group that does not exist')) {
+                throw new Error(utils_1.ChannelError.NoChannelFound);
+            }
+            throw new Error(utils_1.ChannelError.AccessDenied);
         }
     }
     /**
@@ -317,8 +321,19 @@ class Fdc3Module extends base_1.Base {
         this.wire.sendAction('fdc3-get-or-create-channel').catch((e) => {
             // we do not want to expose this error, just continue if this analytics-only call fails
         });
-        const sessionContextGroup = await this.fin.me.interop.joinSessionContextGroup(channelId);
-        return (0, utils_1.buildAppChannelObject)(sessionContextGroup);
+        const systemChannels = await this.getSystemChannels();
+        const userChannel = systemChannels.find((channel) => channel.id === channelId);
+        if (userChannel) {
+            return { ...userChannel, type: 'system', ...(0, utils_1.getUnsupportedChannelApis)() };
+        }
+        try {
+            const sessionContextGroup = await this.fin.me.interop.joinSessionContextGroup(channelId);
+            return (0, utils_1.buildAppChannelObject)(sessionContextGroup);
+        }
+        catch (error) {
+            console.error(error.message);
+            throw new Error(utils_1.ChannelError.CreationFailed);
+        }
     }
     /**
      * Returns metadata relating to the FDC3 object and its provider, including the supported version of the FDC3 specification and the name of the provider of the implementation.

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

@@ -348,27 +348,27 @@ class Fdc3Module2 extends base_1.Base {
         // The FDC3 Intenter handler only expects the context and contextMetadata to be passed to the handler,
         // so we wrap it here and only pass those paramaters.
         const contextHandler = async (raisedIntent) => {
+            let intentResult;
+            let intentResultToSend;
             const { context, metadata: intentMetadata } = raisedIntent;
             const { contextMetadata, metadata, ...rest } = context;
-            let intentResult;
+            const intentResolutionResultId = (intentMetadata === null || intentMetadata === void 0 ? void 0 : intentMetadata.intentResolutionResultId) || (metadata === null || metadata === void 0 ? void 0 : metadata.intentResolutionResultId);
             try {
                 const newContext = metadata ? { metadata, ...rest } : { ...rest };
                 intentResult = await handler(newContext, contextMetadata);
+                intentResultToSend = intentResult;
             }
             catch (error) {
                 intentResult = error;
+                intentResultToSend = { error: true };
             }
-            const intentResolutionResultId = (intentMetadata === null || intentMetadata === void 0 ? void 0 : intentMetadata.intentResolutionResultId) || (metadata === null || metadata === void 0 ? void 0 : metadata.intentResolutionResultId);
             if (intentResolutionResultId) {
-                // Send whatever the result is.
-                this.fin.InterApplicationBus.publish(intentResolutionResultId, intentResult);
+                this.fin.InterApplicationBus.publish(intentResolutionResultId, intentResultToSend);
             }
             if (intentResult instanceof Error) {
                 throw new Error(intentResult.message);
             }
-            else {
-                return intentResult;
-            }
+            return intentResult;
         };
         return this.fin.me.interop.registerIntentHandler(contextHandler, intent, { fdc3Version: '2.0' });
     }

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

@@ -21,8 +21,25 @@ export declare enum ResultError {
      */
     IntentHandlerRejected = "IntentHandlerRejected"
 }
+export declare enum ChannelError {
+    /** Returned if the specified channel is not found when attempting to join a
+     *  channel via the `joinUserChannel` function of the DesktopAgent (`fdc3`).
+     */
+    NoChannelFound = "NoChannelFound",
+    /** SHOULD be returned when a request to join a user channel or to a retrieve
+     *  a Channel object via the `joinUserChannel` or `getOrCreateChannel` methods
+     *  of the DesktopAgent (`fdc3`) object is denied.
+     */
+    AccessDenied = "AccessDenied",
+    /** SHOULD be returned when a channel cannot be created or retrieved via the
+     *  `getOrCreateChannel` method of the DesktopAgent (`fdc3`).
+     */
+    CreationFailed = "CreationFailed"
+}
 export declare const buildPrivateChannelObject: (privateChannelClient: PrivateChannelClient) => PrivateChannel;
 export declare const buildAppChannelObject: (sessionContextGroup: OpenFin.SessionContextGroup) => Channel;
 export declare const connectPrivateChannel: (channelId: string) => Promise<PrivateChannel>;
+export declare const isContext: (context: unknown) => context is Context;
+export declare const isChannel: (channel: unknown) => channel is Channel;
 export declare const getIntentResolution: (interopModule: OpenFin.InteropClient, context: Context, app?: AppIdentifier | TargetApp, intent?: string) => Promise<IntentResolution>;
 export {};

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

@@ -1,6 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.getIntentResolution = exports.connectPrivateChannel = exports.buildAppChannelObject = exports.buildPrivateChannelObject = exports.ResultError = exports.UnsupportedChannelApiError = exports.getUnsupportedChannelApis = void 0;
+exports.getIntentResolution = exports.isChannel = exports.isContext = exports.connectPrivateChannel = exports.buildAppChannelObject = exports.buildPrivateChannelObject = exports.ChannelError = exports.ResultError = exports.UnsupportedChannelApiError = exports.getUnsupportedChannelApis = void 0;
 const utils_1 = require("../utils");
 const PrivateChannelClient_1 = require("./PrivateChannelClient");
 const getUnsupportedChannelApis = (channelType) => {
@@ -35,6 +35,22 @@ var ResultError;
      */
     ResultError["IntentHandlerRejected"] = "IntentHandlerRejected";
 })(ResultError = exports.ResultError || (exports.ResultError = {}));
+var ChannelError;
+(function (ChannelError) {
+    /** Returned if the specified channel is not found when attempting to join a
+     *  channel via the `joinUserChannel` function of the DesktopAgent (`fdc3`).
+     */
+    ChannelError["NoChannelFound"] = "NoChannelFound";
+    /** SHOULD be returned when a request to join a user channel or to a retrieve
+     *  a Channel object via the `joinUserChannel` or `getOrCreateChannel` methods
+     *  of the DesktopAgent (`fdc3`) object is denied.
+     */
+    ChannelError["AccessDenied"] = "AccessDenied";
+    /** SHOULD be returned when a channel cannot be created or retrieved via the
+     *  `getOrCreateChannel` method of the DesktopAgent (`fdc3`).
+     */
+    ChannelError["CreationFailed"] = "CreationFailed";
+})(ChannelError = exports.ChannelError || (exports.ChannelError = {}));
 const buildPrivateChannelObject = (privateChannelClient) => {
     let clientDisconnected = false;
     const checkIfClientDisconnected = () => {
@@ -122,6 +138,22 @@ const connectPrivateChannel = async (channelId) => {
     }
 };
 exports.connectPrivateChannel = connectPrivateChannel;
+const isContext = (context) => {
+    if (context && typeof context === 'object' && 'type' in context) {
+        const { type } = context;
+        return typeof type === 'string';
+    }
+    return false;
+};
+exports.isContext = isContext;
+const isChannel = (channel) => {
+    if (channel && typeof channel === 'object' && 'type' in channel && 'id' in channel) {
+        const { type, id } = channel;
+        return (typeof type === 'string' && typeof id === 'string' && (type === 'app' || type === 'private'));
+    }
+    return false;
+};
+exports.isChannel = isChannel;
 const getIntentResolution = async (interopModule, context, app, intent) => {
     // Generate an ID to make a session context group with. We will pass that ID to the Broker.
     // The broker will then setContext on that session context group later with our Intent Result,
@@ -138,31 +170,33 @@ const getIntentResolution = async (interopModule, context, app, intent) => {
     // Set up the getResult call.
     const getResult = async () => {
         let intentResult = await getResultPromise;
-        if (!intentResult) {
+        if (!intentResult || typeof intentResult !== 'object') {
             throw new Error(ResultError.NoResultReturned);
         }
-        if (intentResult instanceof Error) {
+        const { error } = intentResult;
+        if (error) {
             throw new Error(ResultError.IntentHandlerRejected);
         }
-        if (typeof intentResult === 'object') {
+        if ((0, exports.isChannel)(intentResult)) {
             const { id, type } = intentResult;
-            if (type && id && typeof id === 'string') {
-                switch (type) {
-                    case 'private': {
-                        intentResult = await (0, exports.connectPrivateChannel)(id);
-                        break;
-                    }
-                    case 'app': {
-                        const sessionContextGroup = await interopModule.joinSessionContextGroup(id);
-                        intentResult = (0, exports.buildAppChannelObject)(sessionContextGroup);
-                        break;
-                    }
-                    default: {
-                        break;
-                    }
+            switch (type) {
+                case 'private': {
+                    intentResult = await (0, exports.connectPrivateChannel)(id);
+                    break;
+                }
+                case 'app': {
+                    const sessionContextGroup = await interopModule.joinSessionContextGroup(id);
+                    intentResult = (0, exports.buildAppChannelObject)(sessionContextGroup);
+                    break;
+                }
+                default: {
+                    break;
                 }
             }
         }
+        else if (!(0, exports.isContext)(intentResult)) {
+            throw new Error(ResultError.NoResultReturned);
+        }
         return intentResult;
     };
     // Finally fire the intent.