@openfin/core 33.76.36 → 33.77.1

package/src/OpenFin.js

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

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

@@ -1,28 +0,0 @@
-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

@@ -1,28 +0,0 @@
-"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

@@ -1,35 +0,0 @@
-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

@@ -1,38 +0,0 @@
-"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

@@ -1,10 +0,0 @@
-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

@@ -1,18 +0,0 @@
-"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

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

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

@@ -1,20 +0,0 @@
-"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

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

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

@@ -1,17 +0,0 @@
-"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

@@ -1,14 +0,0 @@
-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

@@ -1,20 +0,0 @@
-"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

@@ -1,20 +0,0 @@
-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

@@ -1,23 +0,0 @@
-"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

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

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

@@ -1,18 +0,0 @@
-"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/application/Factory.d.ts

@@ -1,196 +0,0 @@
-import type * as OpenFin from '../../OpenFin';
-import { Base } from '../base';
-export default class ApplicationModule extends Base {
-    /**
-     * Asynchronously returns an Application object that represents an existing application.
-     * @param identity
-     *
-     * @example
-     *
-     * ```js
-     * fin.Application.wrap({ uuid: 'testapp' })
-     * .then(app => app.isRunning())
-     * .then(running => console.log('Application is running: ' + running))
-     * .catch(err => console.log(err));
-     * ```
-     *
-     * @static
-     */
-    wrap(identity: OpenFin.ApplicationIdentity): Promise<OpenFin.Application>;
-    /**
-     * Synchronously returns an Application object that represents an existing application.
-     * @param identity
-     *
-     * @example
-     *
-     * ```js
-     * const app = fin.Application.wrapSync({ uuid: 'testapp' });
-     * await app.close();
-     * ```
-     *
-     * @static
-     */
-    wrapSync(identity: OpenFin.ApplicationIdentity): OpenFin.Application;
-    private _create;
-    /**
-     * DEPRECATED method to create a new Application. Use {@link Application.ApplicationModule.start Application.start} instead.
-     * @param appOptions
-     *
-     *
-     * @example
-     *
-     * ```js
-     * async function createApp() {
-     *     const app = await fin.Application.create({
-     *         name: 'myApp',
-     *         uuid: 'app-3',
-     *         url: 'https://cdn.openfin.co/docs/javascript/stable/tutorial-Application.create.html',
-     *         autoShow: true
-     *     });
-     *     await app.run();
-     * }
-     *
-     * createApp().then(() => console.log('Application is created')).catch(err => console.log(err));
-     * ```
-     *
-     * @ignore
-     */
-    create(appOptions: OpenFin.ApplicationCreationOptions): Promise<OpenFin.Application>;
-    /**
-     * Creates and starts a new Application.
-     * @param appOptions
-     *
-     * @example
-     *
-     * ```js
-     * async function start() {
-     *     return fin.Application.start({
-     *         name: 'app-1',
-     *         uuid: 'app-1',
-     *         url: 'https://cdn.openfin.co/docs/javascript/stable/tutorial-Application.start.html',
-     *         autoShow: true
-     *     });
-     * }
-     * start().then(() => console.log('Application is running')).catch(err => console.log(err));
-     * ```
-     *
-     *
-     * @static
-     */
-    start(appOptions: OpenFin.ApplicationCreationOptions): Promise<OpenFin.Application>;
-    /**
-     * Asynchronously starts a batch of applications given an array of application identifiers and manifestUrls.
-     * Returns once the RVM is finished attempting to launch the applications.
-     * @param applications
-     * @param opts - Parameters that the RVM will use.
-     *
-     * @static
-     * @example
-     *
-     * ```js
-     *
-     * const applicationInfoArray = [
-     *     {
-     *         "uuid": 'App-1',
-     *         "manifestUrl": 'http://localhost:5555/app1.json',
-     *     },
-     *     {
-     *         "uuid": 'App-2',
-     *         "manifestUrl": 'http://localhost:5555/app2.json',
-     *     },
-     *     {
-     *         "uuid": 'App-3',
-     *         "manifestUrl": 'http://localhost:5555/app3.json',
-     *     }
-     * ]
-     *
-     * fin.Application.startManyManifests(applicationInfoArray)
-     *     .then(() => {
-     *         console.log('RVM has finished launching the application list.');
-     *     })
-     *     .catch((err) => {
-     *         console.log(err);
-     *     })
-     * ```
-     *
-     * @experimental
-     */
-    startManyManifests(applications: Array<OpenFin.ManifestInfo>, opts?: OpenFin.RvmLaunchOptions): Promise<void>;
-    /**
-     * Asynchronously returns an Application object that represents the current application
-     *
-     * @example
-     *
-     * ```js
-     * async function isCurrentAppRunning () {
-     *     const app = await fin.Application.getCurrent();
-     *     return app.isRunning();
-     * }
-     *
-     * isCurrentAppRunning().then(running => {
-     *     console.log(`Current app is running: ${running}`);
-     * }).catch(err => {
-     *     console.error(err);
-     * });
-     *
-     * ```
-     *
-     * @static
-     */
-    getCurrent(): Promise<OpenFin.Application>;
-    /**
-     * Synchronously returns an Application object that represents the current application
-     *
-     * @example
-     *
-     * ```js
-     * async function isCurrentAppRunning () {
-     *     const app = fin.Application.getCurrentSync();
-     *     return app.isRunning();
-     * }
-     *
-     * isCurrentAppRunning().then(running => {
-     *     console.log(`Current app is running: ${running}`);
-     * }).catch(err => {
-     *     console.error(err);
-     * });
-     *
-     * ```
-     *
-     * @static
-     */
-    getCurrentSync(): OpenFin.Application;
-    /**
-     * Retrieves application's manifest and returns a running instance of the application.
-     * @param manifestUrl - The URL of app's manifest.
-     * @param opts - Parameters that the RVM will use.
-     *
-     * @example
-     *
-     * ```js
-     * fin.Application.startFromManifest('http://localhost:5555/app.json').then(app => console.log('App is running')).catch(err => console.log(err));
-     *
-     * // For a local manifest file:
-     * fin.Application.startFromManifest('file:///C:/somefolder/app.json').then(app => console.log('App is running')).catch(err => console.log(err));
-     * ```
-     *
-     * @static
-     */
-    startFromManifest(manifestUrl: string, opts?: OpenFin.RvmLaunchOptions): Promise<OpenFin.Application>;
-    /**
-     * @deprecated Use {@link Application.ApplicationModule.startFromManifest Application.startFromManifest} instead.
-     * Retrieves application's manifest and returns a wrapped application.
-     * @param manifestUrl - The URL of app's manifest.
-     * @param callback - called if the method succeeds.
-     * @param errorCallback - called if the method fails. The reason for failure is passed as an argument.
-     *
-     * @example
-     *
-     * ```js
-     * fin.Application.createFromManifest('http://localhost:5555/app.json').then(app => console.log(app)).catch(err => console.log(err));
-     * ```
-     * @ignore
-     */
-    createFromManifest(manifestUrl: string): Promise<OpenFin.Application>;
-    private _createFromManifest;
-}