@genesislcap/foundation-openfin 14.214.1-FUI-2233.1

package/MODULE_FEDERATION.md

@@ -0,0 +1,11 @@
+# Genesis Foundation FDC3
+
+## [Module Federation](https://webpack.js.org/concepts/module-federation)
+
+This package is federated locally during development by running the webpack part of the build.
+
+| Remote Name     | Port  |
+|-----------------| ----- |
+| foundationFdc3  | 4000  |
+
+Default production enablement remains dependent on [pending architectural decisions](https://bit.ly/3LLHUhK).

package/README.md

@@ -0,0 +1,59 @@
+# Genesis Foundation Openfin
+
+This provides a robust implementation of the Openfin workspace container
+
+## API Documentation
+
+For more detailed information on API and configurations, please refer to the [API documentation](docs/api/index.md) in the `docs/api` directory.
+
+## Installation
+
+To include `@genesislcap/foundation-openfin` in your project, add it as a dependency in your `package.json` file and follow your project's routine for dependency installation.
+
+```json
+{
+  "dependencies": {
+    "@genesislcap/foundation-openfin": "latest"
+  }
+}
+```
+
+## Key Features
+
+- **Openfin Notifications:** Implements a component to create openfin notifications
+
+## Usage Examples
+
+### Adding Intent Listeners
+
+```html
+<openfin-notifications
+  resource-name="ALL_NOTIFY_ALERT_RECORDS"
+  data-pbc-asset-id="interop-notification-listener"
+  :notificationsPlatform="${() => ({
+  id: PLATFORM_ID,
+    icon: PLATFORM_ICON,
+    title: PLATFORM_TITLE
+  })}"
+  :toastButtons="${x => [
+  {
+    condition: ({details}) => details.HEADER === 'Trade added',
+      action: ({details, buttonElement }) => {
+    Route.path.push('/trades')
+    if (buttonElement) {
+      buttonElement.$emit(STORE_EVENTS_ENUM.TRADE_SELECTED, details.TABLE_ENTITY_ID);
+    }
+  },
+    placeholder: 'View Trade',
+    task: 'view-trade'
+  }
+  ]}"
+></openfin-notifications>
+```
+
+## License
+
+Note: this project provides front-end dependencies and uses licensed components listed in the next section; thus, licenses for those components are required during development. Contact [Genesis Global](https://genesis.global/contact-us/) for more details.
+
+### Licensed components
+Genesis low-code platform

package/dist/dts/index.d.ts

@@ -0,0 +1,8 @@
+declare global {
+    interface Window {
+        fin: any;
+    }
+}
+export * from './notifications/openfin-notifications-listener';
+export * from './utils';
+//# sourceMappingURL=index.d.ts.map

package/dist/dts/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/index.ts"],"names":[],"mappings":"AAAA,OAAO,CAAC,MAAM,CAAC;IACb,UAAU,MAAM;QACd,GAAG,EAAE,GAAG,CAAC;KACV;CACF;AAGD,cAAc,gDAAgD,CAAC;AAC/D,cAAc,SAAS,CAAC"}

package/dist/dts/notifications/openfin-notifications-listener.d.ts

@@ -0,0 +1,125 @@
+import { NotificationDataRow, ToastButton } from '@genesislcap/foundation-notifications';
+import { NotificationListener } from '@genesislcap/foundation-ui';
+import { NotificationsPlatform } from '@openfin/workspace/notifications';
+/**
+ * @public
+ * @remarks
+ * OpenfinToastButton interface which extends ToastButton.
+ * Adds the task property which is used in mapping button actions to their corresponding callbacks
+ */
+export interface OpenfinToastButton extends ToastButton {
+    task: string;
+    cta?: boolean;
+    message?: string;
+}
+/**
+ * @public
+ * @remarks
+ * Openfin Notifications custom element
+ */
+export declare class OpenfinNotifications extends NotificationListener {
+    /**
+     * @beta
+     * @remarks
+     * Config for registering a workspace with the Openfin notifications component
+     * @example
+     * Create your notifications platform constant
+     * ```ts
+     * const notificationsPlatform: NotificationsPlatform = {
+     *   id: 'platform-id', // the id of your openfin workspace
+     *   icon: 'https://localhost:8080/path/to/icon.svg', // the url to the icon for your workspace
+     *   title: 'Platform title' // the platform title which will appear in notifications
+     * }
+     * ```
+     * Setting the property in an html view template
+     * ```html
+     * <openfin-notifications-listener
+     *   ...
+     *   :notificationsPlatform="${() => notificationsPlatform}"
+     * >
+     * </openfin-notifications-listener>
+     * ```
+     */
+    notificationsPlatform: NotificationsPlatform;
+    /**
+     *  @beta
+     *  @remarks
+     *  The notification type of toast messages
+     */
+    toast: 'transient' | 'sticky' | 'none';
+    /**
+     *  @beta
+     *  @remarks
+     *  The notification sound mode
+     */
+    mode: 'default' | 'silent';
+    /**
+     * Array of button configs for openfin notification toasts
+     * @public
+     * @example
+     * In these examples you could
+     * 1. View a trade, this is done by routing to the corresponding route. Dispatching the highlighted record id to the store and retrieving it in the view from the store.
+     * 2. Call an endpoint to approve a trade
+     * 3. Call an endpoint to reject a trade
+     * ```html
+     * <openfin-notifications-listener
+     *   ...
+     *   :toastButtons="${x => [
+     *     {
+     *       {
+     *         condition: ({details}) => details.HEADER === 'Trade added',
+     *         action: ({details, buttonElement }) => {
+     *           Route.path.push('/some-route') // redirect to a route
+     *           buttonElement.$emit('some-store-event', details.TABLE_ENTITY_ID); //emit the entity id to the store
+     *         }
+     *       },
+     *       placeholder: 'View Trade',
+     *       task: 'view-trade'
+     *    },
+     *    {
+     *       {
+     *         condition: ({details}) => details.HEADER === 'Trade added',
+     *         action: ({details, buttonElement }) => {
+     *           const connect = getConnect();
+     *           connect.commitEvent('approve-trade', {
+     *             DETAILS: {
+     *               TRADE_ID: details.TABLE_ENTITY_ID,
+     *               APPROVED: true
+     *             }
+     *           })
+     *         }
+     *       },
+     *       placeholder: 'Approve Trade',
+     *       task: 'approve-trade'
+     *    },
+     *    {
+     *       {
+     *         condition: ({details}) => details.HEADER === 'Trade added',
+     *         action: ({details, buttonElement }) => {
+     *           const connect = getConnect();
+     *           connect.commitEvent('approve-trade', {
+     *             DETAILS: {
+     *               TRADE_ID: details.TABLE_ENTITY_ID,
+     *               APPROVED: false
+     *             }
+     *           })
+     *         }
+     *       },
+     *       placeholder: 'Reject Trade',
+     *       task: 'reject-trade'
+     *    },
+     *
+     *  ]
+     * >
+     * </openfin-notifications-listener>
+     * ```
+  
+     *
+     */
+    toastButtons: OpenfinToastButton[];
+    connectedCallback(): Promise<void>;
+    private addButtonListeners;
+    protected showNotificationToast(row: NotificationDataRow): Promise<void>;
+    private mapToastButtons;
+}
+//# sourceMappingURL=openfin-notifications-listener.d.ts.map

package/dist/dts/notifications/openfin-notifications-listener.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"openfin-notifications-listener.d.ts","sourceRoot":"","sources":["../../../src/notifications/openfin-notifications-listener.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,mBAAmB,EAAE,WAAW,EAAE,MAAM,uCAAuC,CAAC;AAEzF,OAAO,EAAE,oBAAoB,EAAE,MAAM,4BAA4B,CAAC;AAElE,OAAO,EAOL,qBAAqB,EAEtB,MAAM,kCAAkC,CAAC;AAiB1C;;;;;GAKG;AACH,MAAM,WAAW,kBAAmB,SAAQ,WAAW;IACrD,IAAI,EAAE,MAAM,CAAC;IACb,GAAG,CAAC,EAAE,OAAO,CAAC;IACd,OAAO,CAAC,EAAE,MAAM,CAAC;CAClB;AAUD;;;;GAIG;AACH,qBAQa,oBAAqB,SAAQ,oBAAoB;IAC5D;;;;;;;;;;;;;;;;;;;;;OAqBG;IACH,qBAAqB,EAAE,qBAAqB,CAAC;IAE7C;;;;OAIG;IACG,KAAK,EAAE,WAAW,GAAG,QAAQ,GAAG,MAAM,CAAe;IAE3D;;;;OAIG;IACG,IAAI,EAAE,SAAS,GAAG,QAAQ,CAAY;IAE5C;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;OA8DG;IACH,YAAY,EAAE,kBAAkB,EAAE,CAAC;IAE7B,iBAAiB;YAMT,kBAAkB;cAiBhB,qBAAqB,CAAC,GAAG,EAAE,mBAAmB,GAAG,OAAO,CAAC,IAAI,CAAC;IA8B9E,OAAO,CAAC,eAAe;CA+BxB"}

package/dist/dts/tsdoc-metadata.json

@@ -0,0 +1,11 @@
+// This file is read by tools that parse documentation comments conforming to the TSDoc standard.
+// It should be published with your NPM package.  It should not be tracked by Git.
+{
+  "tsdocVersion": "0.12",
+  "toolPackages": [
+    {
+      "packageName": "@microsoft/api-extractor",
+      "packageVersion": "7.34.9"
+    }
+  ]
+}

package/dist/dts/utils.d.ts

@@ -0,0 +1,7 @@
+/**
+ * @public
+ * @remarks
+ * Util method to check whether an application is running in an openfin workspace container
+ */
+export declare const isOpenFin: () => boolean;
+//# sourceMappingURL=utils.d.ts.map

package/dist/dts/utils.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"utils.d.ts","sourceRoot":"","sources":["../../src/utils.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AACH,eAAO,MAAM,SAAS,QAAO,OAAuB,CAAC"}

package/dist/esm/index.js

@@ -0,0 +1,3 @@
+window.fin = window.fin || null;
+export * from './notifications/openfin-notifications-listener';
+export * from './utils';

package/dist/esm/notifications/openfin-notifications-listener.js

@@ -0,0 +1,148 @@
+import { __awaiter, __decorate } from "tslib";
+import { NotificationListener } from '@genesislcap/foundation-ui';
+import { attr, customElement, html, ref } from '@genesislcap/web-core';
+import { register, addEventListener, create, IndicatorColor, } from '@openfin/workspace/notifications';
+import { logger } from '@genesislcap/foundation-utils';
+const OpenfinGenesisPriorityMap = {
+    Information: 1,
+    Warning: 2,
+    Serious: 3,
+    Critical: 4,
+};
+const OpenfinGenesisColorMap = {
+    Information: IndicatorColor.BLUE,
+    Warning: IndicatorColor.YELLOW,
+    Serious: IndicatorColor.MAGENTA,
+    Critical: IndicatorColor.RED,
+};
+function initializeNotifications(notificationsPlatformOptions) {
+    return __awaiter(this, void 0, void 0, function* () {
+        yield register({
+            notificationsPlatformOptions,
+        });
+    });
+}
+/**
+ * @public
+ * @remarks
+ * Openfin Notifications custom element
+ */
+let OpenfinNotifications = class OpenfinNotifications extends NotificationListener {
+    constructor() {
+        super(...arguments);
+        /**
+         *  @beta
+         *  @remarks
+         *  The notification type of toast messages
+         */
+        this.toast = 'transient';
+        /**
+         *  @beta
+         *  @remarks
+         *  The notification sound mode
+         */
+        this.mode = 'silent';
+    }
+    connectedCallback() {
+        const _super = Object.create(null, {
+            connectedCallback: { get: () => super.connectedCallback }
+        });
+        return __awaiter(this, void 0, void 0, function* () {
+            yield _super.connectedCallback.call(this);
+            yield initializeNotifications(this.notificationsPlatform);
+            yield this.addButtonListeners();
+        });
+    }
+    addButtonListeners() {
+        return __awaiter(this, void 0, void 0, function* () {
+            try {
+                yield addEventListener('notification-action', (event) => {
+                    var _a;
+                    const button = (_a = this.toastButtons) === null || _a === void 0 ? void 0 : _a.find((t) => t.task === event.result.task);
+                    if (!button) {
+                        return;
+                    }
+                    button.action({ details: event.result.customData.details, buttonElement: this });
+                });
+            }
+            catch (e) {
+                console.log(e);
+            }
+        });
+    }
+    showNotificationToast(row) {
+        var _a;
+        return __awaiter(this, void 0, void 0, function* () {
+            const { HEADER: title, MESSAGE: body, NOTIFY_SEVERITY: type, ALERT_ID } = row;
+            const notification = {
+                title,
+                body,
+                priority: OpenfinGenesisPriorityMap[type],
+                toast: this.toast || 'transient',
+                category: type,
+                template: 'markdown',
+                id: ALERT_ID,
+                soundOptions: {
+                    mode: this.mode,
+                },
+                indicator: {
+                    text: title,
+                    color: OpenfinGenesisColorMap[type],
+                    fallback: OpenfinGenesisColorMap[type],
+                },
+                buttons: this.mapToastButtons(this.toastButtons, row),
+                platform: (_a = this.notificationsPlatform) === null || _a === void 0 ? void 0 : _a.id,
+            };
+            try {
+                yield create(notification);
+            }
+            catch (e) {
+                console.error('Openfin notifications error', e);
+            }
+        });
+    }
+    mapToastButtons(toastButtons, row) {
+        if (!toastButtons) {
+            return null;
+        }
+        return toastButtons
+            .filter((t) => {
+            if (!t.task) {
+                logger.warn('Interop Toast button config has no task specified');
+                return false;
+            }
+            return !!t.condition({ details: row });
+        })
+            .map((t) => {
+            return {
+                title: t.placeholder,
+                type: 'button',
+                cta: t.cta,
+                onClick: {
+                    task: t.task,
+                    customData: {
+                        message: t.message,
+                        details: row,
+                    },
+                },
+            };
+        });
+    }
+};
+__decorate([
+    attr
+], OpenfinNotifications.prototype, "toast", void 0);
+__decorate([
+    attr
+], OpenfinNotifications.prototype, "mode", void 0);
+OpenfinNotifications = __decorate([
+    customElement({
+        name: 'openfin-notifications',
+        template: html `
+    <template ${ref('notificationListener')}>
+      <slot></slot>
+    </template>
+  `,
+    })
+], OpenfinNotifications);
+export { OpenfinNotifications };

package/dist/esm/utils.js

@@ -0,0 +1,6 @@
+/**
+ * @public
+ * @remarks
+ * Util method to check whether an application is running in an openfin workspace container
+ */
+export const isOpenFin = () => !!window.fin;