@adaptabletools/adaptable-plugin-interopio 18.0.0-canary.0

package/README.md

@@ -0,0 +1,13 @@
+# AdapTable Interop Plugin Read Me
+
+## Help
+
+Developers can learn how to access AdapTable programmatically at [AdapTable Documentation](https://docs.adaptabletools.com).
+
+## More Information
+
+General information about Adaptable Tools is available at our [Website](http://www.adaptabletools.com)
+
+## Support
+
+For all support enquiries please email [`support@adaptabletools.com`](mailto:support@adaptabletools.com) or [raise a Support Ticket](https://adaptabletools.zendesk.com/hc/en-us/requests/new).

package/package.json

@@ -0,0 +1,18 @@
+{
+  "name": "@adaptabletools/adaptable-plugin-interopio",
+  "version": "18.0.0-canary.0",
+  "description": "",
+  "homepage": "http://www.adaptabletools.com/",
+  "author": {
+    "name": "Jonny Wolfson",
+    "email": "jonny.wolfson@adaptabletools.com"
+  },
+  "typings": "src/index.d.ts",
+  "dependencies": {
+    "@interopio/browser": "^3.1.2",
+    "tslib": "^2.3.0",
+    "@adaptabletools/adaptable": "18.0.0-canary.0"
+  },
+  "type": "module",
+  "module": "src/index.js"
+}

package/src/InteropioApiImpl.d.ts

@@ -0,0 +1,9 @@
+import { ApiBase } from '@adaptabletools/adaptable/src/Api/Implementation/ApiBase';
+import { InteropioPluginApi } from '@adaptabletools/adaptable/src/Api/InteropioPluginApi';
+import { IAdaptable } from '@adaptabletools/adaptable/src/AdaptableInterfaces/IAdaptable';
+import { InteropioPluginOptions } from '../../../adaptable/src/AdaptableOptions/InteropioPluginOptions';
+export declare class InteropioApiImpl extends ApiBase implements InteropioPluginApi {
+    private options;
+    constructor(adaptable: IAdaptable, options: InteropioPluginOptions);
+    getPluginOptions(): InteropioPluginOptions;
+}

package/src/InteropioApiImpl.js

@@ -0,0 +1,10 @@
+import { ApiBase } from '@adaptabletools/adaptable/src/Api/Implementation/ApiBase';
+export class InteropioApiImpl extends ApiBase {
+    constructor(adaptable, options) {
+        super(adaptable);
+        this.options = options;
+    }
+    getPluginOptions() {
+        return this.options;
+    }
+}

package/src/index.d.ts

@@ -0,0 +1,28 @@
+import { AdaptablePlugin } from '@adaptabletools/adaptable/types';
+import { IAdaptable } from '@adaptabletools/adaptable/src/AdaptableInterfaces/IAdaptable';
+import { InteropioApiImpl } from './InteropioApiImpl';
+import { InteropioPluginOptions } from '../../../adaptable/src/AdaptableOptions/InteropioPluginOptions';
+import * as Interop from '@interopio/browser';
+declare class InteropioPlugin extends AdaptablePlugin {
+    options: InteropioPluginOptions;
+    pluginId: string;
+    adaptableInteropApi: InteropioApiImpl;
+    private adaptable?;
+    private interopApi;
+    constructor(options: InteropioPluginOptions, interopApi: Interop.IOConnectBrowser.API);
+    onAdaptableReady(adaptable: IAdaptable): void;
+    afterInitApi(adaptable: IAdaptable): void;
+    /**
+     * Interopio Notifications logic has two main parts:
+     * - a handler that is registered using the interop API;
+     * -- This handler is invoked when a notification action is clicked.
+     * -- We have a map in which we register actions for a given alert.
+     * - rising a notification using the Interopio API
+     * -- here for each action an interop method is registered
+     * -- information is passed to indicate which button and lert was clicked
+     * -- using this information the action map is populated
+     */
+    private integrateAdaptableAlerts;
+}
+declare const _default: (options: InteropioPluginOptions, interopioApi: Interop.IOConnectBrowser.API) => InteropioPlugin;
+export default _default;

package/src/index.js

@@ -0,0 +1,109 @@
+import { AdaptablePlugin, } from '@adaptabletools/adaptable/types';
+import { InteropioApiImpl } from './InteropioApiImpl';
+// if (version !== coreVersion) {
+//   console.warn(`
+// !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
+// !!!!!!! "@adaptabletools/adaptable-plugin-interopio" (v @${version}) and "@adaptabletools/adaptable" (v @${coreVersion}) have different versions - they should have the exact same version.
+// !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
+// `);
+// }
+const defaultOptions = {
+    showAdaptableAlertsAsNotifications: true,
+    applicationName: 'Adaptable',
+};
+class InteropioPlugin extends AdaptablePlugin {
+    constructor(options, interopApi) {
+        super(options);
+        this.pluginId = 'interop';
+        this.options = Object.assign(Object.assign({}, defaultOptions), options);
+        this.interopApi = interopApi;
+    }
+    onAdaptableReady(adaptable) {
+        this.adaptable = adaptable;
+        this.integrateAdaptableAlerts();
+    }
+    afterInitApi(adaptable) {
+        this.adaptableInteropApi = new InteropioApiImpl(adaptable, this.options);
+        this.registerProperty('api', () => this.adaptableInteropApi);
+    }
+    /**
+     * Interopio Notifications logic has two main parts:
+     * - a handler that is registered using the interop API;
+     * -- This handler is invoked when a notification action is clicked.
+     * -- We have a map in which we register actions for a given alert.
+     * - rising a notification using the Interopio API
+     * -- here for each action an interop method is registered
+     * -- information is passed to indicate which button and lert was clicked
+     * -- using this information the action map is populated
+     */
+    async integrateAdaptableAlerts() {
+        var _a;
+        if (!this.options.showAdaptableAlertsAsNotifications) {
+            return;
+        }
+        /**
+         * A way to keep in memory what actions were registered for a given alert.
+         */
+        const actionsMap = new Map();
+        const ADAPTABLE_INTEROP_NOTIFICATION_HANDLER = `ADAPTABLE_INTEROP_NOTIFICATION_HANDLER_${Date.now()}}`;
+        const adaptableInteropNotificationHandler = ({ buttonId }) => {
+            const memoAction = actionsMap.get(buttonId);
+            if (memoAction) {
+                const { alert, button } = memoAction;
+                const context = {
+                    alert: alert,
+                    adaptableApi: this.adaptable.api,
+                    userName: this.adaptable.adaptableOptions.userName,
+                    adaptableId: this.adaptable.adaptableOptions.adaptableId,
+                    formData: {},
+                };
+                this.adaptable.api.alertApi.internalApi.executeAlertButton(button, context);
+                // we need to delete all actions for the given alert
+                // because once the button is clicked, the notification is closed
+                for (const [key, value] of actionsMap.entries()) {
+                    if (value.alert === alert) {
+                        actionsMap.delete(key);
+                    }
+                }
+            }
+        };
+        await this.interopApi.interop.register(ADAPTABLE_INTEROP_NOTIFICATION_HANDLER, adaptableInteropNotificationHandler);
+        (_a = this.adaptable) === null || _a === void 0 ? void 0 : _a.api.eventApi.on('AlertFired', (alertInfo) => {
+            var _a;
+            const adaptableAlert = alertInfo.alert;
+            const { header, message } = adaptableAlert;
+            const adaptableActions = [];
+            if (adaptableAlert.alertDefinition.AlertForm &&
+                typeof adaptableAlert.alertDefinition.AlertForm !== 'string' &&
+                Array.isArray((_a = adaptableAlert.alertDefinition.AlertForm) === null || _a === void 0 ? void 0 : _a.Buttons)) {
+                adaptableAlert.alertDefinition.AlertForm.Buttons.forEach(async (button, index) => {
+                    const buttonId = `${button.Label}.${Date.now()}`;
+                    const action = `adaptable-action-button-${button.Label}-${index}-${Date.now()}`;
+                    const notificationAction = {
+                        title: button.Label,
+                        action,
+                    };
+                    if (button.Action) {
+                        notificationAction.interop = {
+                            method: ADAPTABLE_INTEROP_NOTIFICATION_HANDLER,
+                            arguments: {
+                                buttonId: buttonId,
+                            },
+                        };
+                    }
+                    actionsMap.set(buttonId, { alert: adaptableAlert, button });
+                    adaptableActions.push(notificationAction);
+                });
+            }
+            const notificationOptions = {
+                title: header,
+                body: message,
+                actions: adaptableActions,
+            };
+            this.interopApi.notifications.raise(notificationOptions);
+            // Returning false prevents adaptable from showing the alert notification.
+            return false;
+        });
+    }
+}
+export default (options, interopioApi) => new InteropioPlugin(options, interopioApi);