openfin-notifications 1.12.2 → 1.13.0-alpha-898

package/README.md

@@ -8,23 +8,32 @@ The OpenFin Notification Center provides developers with a uniform way to create
 
 Notifications will be displayed as toasts as well as being listed and organized in a Notification Center. The Notification Center can be accessed by clicking on the Notifications icon in the system tray.
 
-This project consist of 2 parts:
+This project consist of 3 parts:
 
 1. The Notification Center, displaying and managing notifications
 2. The Notification Center Client Library, exposing APIs for applications to create and manage notifications
+3. The Notification Studio, A visual editor for user notifications.
 
 ### Dependencies
 
-- OpenFin version for applications using the Notification Center >= 9.61.38.41
-- OpenFin version used by the Notifications Provider = 14.78.45.31
-- RVM >= 4.7
+- OpenFin version used by the Notifications Provider = 23.96.68.3
+- OpenFin RVM >= 4.7
 
 ### Features
 
-- Create notifications
-- Clear and dismiss notifications
-- Attach handlers for when notifications are created, closed, and interacted with
-- Persist notifications in the Notification Center
+- Create notifications.
+- Clear and dismiss notifications.
+- Attach handlers for when notifications are created, closed, and interacted with.
+- Attach indicators and buttons with actions to notifications.
+- Persist notifications in the Notification Center.
+- Persist notification toasts.
+- Create expiring and/or future notifications.
+- Search notifications in the Notification Center.
+- Create notifications with markdown, form, premade or custom templated notification content.
+- Create grouping streams for notifications.
+- Create pop-out frame windows for individiual notification senders and streams.
+- Customize to specify the Notification Center and notification toast corners on screen.
+- Customize Notification Center theme via Workspace Platforms.
 
 ## Getting Started
 

package/dist/client/index.d.ts

@@ -21,6 +21,7 @@ export * from './source';
 export * from './forms';
 export * from './stream';
 export * from './templates';
+export * from './platform';
 export { provider, NotificationOptions };
 export { NotificationIndicator, IndicatorColor, IndicatorType as NotificationIndicatorType };
 /**

package/dist/client/internal.d.ts

@@ -10,8 +10,7 @@
 import { NotificationActionResult, ActionTrigger } from './actions';
 import { ProviderStatus } from './provider';
 import { NotificationSource } from './source';
-import { NotificationOptions, Notification, NotificationActionEvent, NotificationClosedEvent, NotificationCreatedEvent, NotificationsCountChanged, NotificationFormSubmittedEvent, UpdatableNotification } from './index';
-import { UpdatableNotificationOptions } from './templates/update';
+import { NotificationOptions, Notification, NotificationActionEvent, NotificationClosedEvent, NotificationCreatedEvent, NotificationsCountChanged, NotificationFormSubmittedEvent, UpdatableNotification, NotificationPlatform, UpdatableNotificationOptions } from './index';
 /**
  * The identity of the main application window of the service provider
  */
@@ -33,7 +32,9 @@ export declare const enum APITopic {
     ADD_EVENT_LISTENER = "add-event-listener",
     REMOVE_EVENT_LISTENER = "remove-event-listener",
     GET_PROVIDER_STATUS = "get-provider-status",
-    GET_NOTIFICATIONS_COUNT = "get-notifications-count"
+    GET_NOTIFICATIONS_COUNT = "get-notifications-count",
+    REGISTER_PLATFORM = "register-notifications-platform",
+    DEREGISTER_PLATFORM = "deregister-notifications-platform"
 }
 export interface API {
     [APITopic.CREATE_NOTIFICATION]: [CreatePayload, NotificationInternal];
@@ -46,6 +47,8 @@ export interface API {
     [APITopic.REMOVE_EVENT_LISTENER]: [Events['type'], void];
     [APITopic.GET_PROVIDER_STATUS]: [undefined, ProviderStatus];
     [APITopic.GET_NOTIFICATIONS_COUNT]: [undefined, number];
+    [APITopic.REGISTER_PLATFORM]: [PlatformRegisterPayload, void];
+    [APITopic.DEREGISTER_PLATFORM]: [PlatformDeregisterPayload, void];
 }
 export declare type Events = NotificationActionEvent | NotificationClosedEvent | NotificationCreatedEvent | NotificationsCountChanged | NotificationFormSubmittedEvent;
 export declare type TransportMappings<T> = T extends NotificationActionEvent ? NotificationActionEventTransport : never;
@@ -66,6 +69,10 @@ export declare type UpdatableNotificationInternal<T extends UpdatableNotificatio
 export interface ClearPayload {
     id: string;
 }
+export declare type PlatformRegisterPayload<T extends NotificationPlatform = NotificationPlatform> = T;
+export interface PlatformDeregisterPayload {
+    id: string;
+}
 export interface NotificationActionEventTransport {
     type: 'notification-action';
     notification: Readonly<NotificationInternal>;

package/dist/client/main-bundle.js

@@ -128,6 +128,8 @@ var APITopic;
     APITopic["REMOVE_EVENT_LISTENER"] = "remove-event-listener";
     APITopic["GET_PROVIDER_STATUS"] = "get-provider-status";
     APITopic["GET_NOTIFICATIONS_COUNT"] = "get-notifications-count";
+    APITopic["REGISTER_PLATFORM"] = "register-notifications-platform";
+    APITopic["DEREGISTER_PLATFORM"] = "deregister-notifications-platform";
 })(APITopic = exports.APITopic || (exports.APITopic = {}));
 
 
@@ -137,159 +139,6 @@ var APITopic;
 
 "use strict";
 
-/**
- * Actions are the mechanism through which notifications send messages back to the application that created them. The
- * service defines a number of ways in which actions can be raised (a notification being interacted with by the user,
- * being closed, expiring, etc.), and it is up to each application to decide if it wishes to be informed when each of
- * these triggers occur.
- *
- * For an action to be raised when one of these triggers occurs, the application must specify an
- * {@link NotificationActionResult|action result} for each trigger it is interested in. The application should then
- * listen for when these actions are raised by listening for the {@link NotificationActionEvent|`notification-action`}
- * event.
- *
- * This event is fired once each time an action is raised, and will contain the
- * {@link NotificationActionResult|action result} the application specified for that trigger. The application may then
- * use the {@link NotificationActionResult|action result} to determine which trigger occurred and respond appropriately.
- *
- * If an {@link NotificationActionResult|action result} is not specified for a particular trigger, or it is set to
- * `null`, the application will not receive a corresponding {@link NotificationActionEvent|`notification-action`} when
- * that trigger occurs.
- *
- * Unlike other event types, {@link NotificationActionEvent|`notification-action`} events will be buffered by the
- * service until the application has added a listener for this event type, at which point it will receive all buffered
- * {@link NotificationActionEvent|`notification-action`} events. The service will also attempt to restart the
- * application if it is not running when the event is fired.
- *
- * For an overview of actions, consider the sample notification below:
- * ```ts
- * import {addEventListener, create} from 'openfin-notifications';
- *
- * // Create a notification with two buttons
- * create({
- *     // Basic info
- *     title: 'Reminder',
- *     body: 'Event "Weekly Meeting" is starting soon...',
- *     category: 'Upcoming Events',
- *
- *     // We'll use the 'customData' field to store metadata about the event
- *     customData: {eventId: '12345'},
- *
- *     // We want the user clicking the notification to open the associated event, so register an 'onSelect' action
- *     onSelect: {task: 'view-calendar-event', target: 'popup'},
- *
- *     buttons: [
- *         // A button that will schedule another reminder for 5 minutes from now. Since the application will be
- *         // responsible for snoozing the event, it will need to know about the user clicking this button. By setting
- *         // a NotificationActionResult for 'onClick', the service will raise a "notification-action" event when this
- *         // button is clicked, and will pass the value of 'onClick' as the 'result' field within the event
- *         {
- *             title: 'Snooze for 5 minutes',
- *             iconUrl: 'https://www.example.com/timer.png',
- *             onClick: {
- *                 task: 'schedule-reminder',
- *                 intervalMs: 5 * 60 * 1000
- *             }
- *         },
- *
- *         // A button that closes the notification and doesn't prompt the user about this event again. Since the
- *         // application doesn't need to do anything when the user clicks this button, we leave 'onClick' undefined
- *         // rather than specifying a NotificationActionResult. This means that no action will be raised when the
- *         // button is clicked, and hence no "notification-action" event will be fired
- *         {
- *             title: 'Dismiss',
- *             iconUrl: 'https://www.example.com/cancel.png'
- *         }
- *     ]
- * });
- *
- * // Create a listener that will be called for each action
- * // Note: This handler will be used for ALL actions, from ALL notifications that are created by this application.
- * addEventListener('notification-action', (event: NotificationActionEvent) => {
- *     const {result, notification} = event;
- *
- *     if (result['task'] === 'view-calendar-event') {
- *         // Open a window with full details of the associated event
- *         openEventDetails(notification.customData.eventId, result['target']);
- *     } else if (result['task'] === 'schedule-reminder') {
- *         // Schedule a new notification
- *         scheduleReminder(notification.customData.eventId, Date.now() + result['intervalMs']);
- *     } // Etc...
- * });
- * ```
- *
- * The example above uses `customData` to store details about the notification subject (in this case, a calendar
- * event), and `onClick` actions to inform the application about how it should respond when the user interacts with the
- * notification. This is our intended usage and recommended best-practice, but the service doesn't require applications
- * to follow this convention - application developers are free to decide how to manage notification state.
- *
- * Within the `notification-action` handler, the application must be able to understand which notification is being
- * handled, and how to decide what it should do next. The example above uses an application-defined `action` field to
- * determine the correct action, but the notification's `id`, `category`, `customData` and other fields are also useful
- * selectors.
- *
- * @module Actions
- */
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.ActionNoopType = exports.ActionTrigger = void 0;
-/**
- * Lists the different triggers that can raise an {@link Actions|action}. Each action that is raised will result in a
- * {@link NotificationActionEvent|`notification-action`} event, which can be captured by the application that created
- * the notification.
- */
-var ActionTrigger;
-(function (ActionTrigger) {
-    /**
-     * The user interacted with one of the controls within the notification. This currently means a button click, but
-     * other control types will be added in future releases.
-     */
-    ActionTrigger["CONTROL"] = "control";
-    /**
-     * The user clicked the body of the notification itself. Any clicks of the notification that don't hit a control
-     * or the close button will fire an event with the `'select'` action trigger.
-     */
-    ActionTrigger["SELECT"] = "select";
-    /**
-     * The notification was closed, either by user interaction, programmatically by an application, or by the notification expiring.
-     */
-    ActionTrigger["CLOSE"] = "close";
-    /**
-     * The notification expired.
-     */
-    ActionTrigger["EXPIRE"] = "expire";
-    /**
-     * The action was triggered programmatically by an application.
-     *
-     * *Not currently supported - will be implemented in a future release*
-     */
-    ActionTrigger["PROGRAMMATIC"] = "programmatic";
-})(ActionTrigger = exports.ActionTrigger || (exports.ActionTrigger = {}));
-/**
- * Noop action types see {@link ActionNoop|ActionNoop}.
- */
-var ActionNoopType;
-(function (ActionNoopType) {
-    /**
-     * No event will be raised and no dismissal of the notification on action.
-     */
-    ActionNoopType["EVENT_DISMISS"] = "event_dismiss";
-    /**
-     * No event will be raised, but the notification will be dismissed on action.
-     */
-    // EVENT = 'event',
-    /**
-     * No dismissal of the notification, but the action event will be raised on action.
-     */
-    // DISMISS = 'dismiss',
-})(ActionNoopType = exports.ActionNoopType || (exports.ActionNoopType = {}));
-
-
-/***/ }),
-/* 2 */
-/***/ (function(module, exports, __webpack_require__) {
-
-"use strict";
-
 /**
  * @hidden
  */
@@ -319,7 +168,7 @@ let channelPromise;
 const hasDOMContentLoaded = new openfin_service_async_1.DeferredPromise();
 let reconnect = false;
 const MIN_API_VERSION = 53;
-if (typeof fin !== 'undefined') {
+if (typeof fin !== 'undefined' && typeof window !== 'undefined') {
     launchSystemApp();
     getServicePromise();
     if (document.readyState !== 'loading') {
@@ -392,7 +241,7 @@ async function getServicePromise() {
             }, 5000);
             channelPromise = fin.InterApplicationBus.Channel.connect(internal_1.SERVICE_CHANNEL, {
                 wait: true,
-                payload: { version: '1.12.2' },
+                payload: { version: '1.13.0-alpha-898' },
             }).then((channel) => {
                 window.clearTimeout(timeoutHandle);
                 const eventRouter = getEventRouter();
@@ -447,6 +296,159 @@ function getEventRouter() {
 exports.getEventRouter = getEventRouter;
 
 
+/***/ }),
+/* 2 */
+/***/ (function(module, exports, __webpack_require__) {
+
+"use strict";
+
+/**
+ * Actions are the mechanism through which notifications send messages back to the application that created them. The
+ * service defines a number of ways in which actions can be raised (a notification being interacted with by the user,
+ * being closed, expiring, etc.), and it is up to each application to decide if it wishes to be informed when each of
+ * these triggers occur.
+ *
+ * For an action to be raised when one of these triggers occurs, the application must specify an
+ * {@link NotificationActionResult|action result} for each trigger it is interested in. The application should then
+ * listen for when these actions are raised by listening for the {@link NotificationActionEvent|`notification-action`}
+ * event.
+ *
+ * This event is fired once each time an action is raised, and will contain the
+ * {@link NotificationActionResult|action result} the application specified for that trigger. The application may then
+ * use the {@link NotificationActionResult|action result} to determine which trigger occurred and respond appropriately.
+ *
+ * If an {@link NotificationActionResult|action result} is not specified for a particular trigger, or it is set to
+ * `null`, the application will not receive a corresponding {@link NotificationActionEvent|`notification-action`} when
+ * that trigger occurs.
+ *
+ * Unlike other event types, {@link NotificationActionEvent|`notification-action`} events will be buffered by the
+ * service until the application has added a listener for this event type, at which point it will receive all buffered
+ * {@link NotificationActionEvent|`notification-action`} events. The service will also attempt to restart the
+ * application if it is not running when the event is fired.
+ *
+ * For an overview of actions, consider the sample notification below:
+ * ```ts
+ * import {addEventListener, create} from 'openfin-notifications';
+ *
+ * // Create a notification with two buttons
+ * create({
+ *     // Basic info
+ *     title: 'Reminder',
+ *     body: 'Event "Weekly Meeting" is starting soon...',
+ *     category: 'Upcoming Events',
+ *
+ *     // We'll use the 'customData' field to store metadata about the event
+ *     customData: {eventId: '12345'},
+ *
+ *     // We want the user clicking the notification to open the associated event, so register an 'onSelect' action
+ *     onSelect: {task: 'view-calendar-event', target: 'popup'},
+ *
+ *     buttons: [
+ *         // A button that will schedule another reminder for 5 minutes from now. Since the application will be
+ *         // responsible for snoozing the event, it will need to know about the user clicking this button. By setting
+ *         // a NotificationActionResult for 'onClick', the service will raise a "notification-action" event when this
+ *         // button is clicked, and will pass the value of 'onClick' as the 'result' field within the event
+ *         {
+ *             title: 'Snooze for 5 minutes',
+ *             iconUrl: 'https://www.example.com/timer.png',
+ *             onClick: {
+ *                 task: 'schedule-reminder',
+ *                 intervalMs: 5 * 60 * 1000
+ *             }
+ *         },
+ *
+ *         // A button that closes the notification and doesn't prompt the user about this event again. Since the
+ *         // application doesn't need to do anything when the user clicks this button, we leave 'onClick' undefined
+ *         // rather than specifying a NotificationActionResult. This means that no action will be raised when the
+ *         // button is clicked, and hence no "notification-action" event will be fired
+ *         {
+ *             title: 'Dismiss',
+ *             iconUrl: 'https://www.example.com/cancel.png'
+ *         }
+ *     ]
+ * });
+ *
+ * // Create a listener that will be called for each action
+ * // Note: This handler will be used for ALL actions, from ALL notifications that are created by this application.
+ * addEventListener('notification-action', (event: NotificationActionEvent) => {
+ *     const {result, notification} = event;
+ *
+ *     if (result['task'] === 'view-calendar-event') {
+ *         // Open a window with full details of the associated event
+ *         openEventDetails(notification.customData.eventId, result['target']);
+ *     } else if (result['task'] === 'schedule-reminder') {
+ *         // Schedule a new notification
+ *         scheduleReminder(notification.customData.eventId, Date.now() + result['intervalMs']);
+ *     } // Etc...
+ * });
+ * ```
+ *
+ * The example above uses `customData` to store details about the notification subject (in this case, a calendar
+ * event), and `onClick` actions to inform the application about how it should respond when the user interacts with the
+ * notification. This is our intended usage and recommended best-practice, but the service doesn't require applications
+ * to follow this convention - application developers are free to decide how to manage notification state.
+ *
+ * Within the `notification-action` handler, the application must be able to understand which notification is being
+ * handled, and how to decide what it should do next. The example above uses an application-defined `action` field to
+ * determine the correct action, but the notification's `id`, `category`, `customData` and other fields are also useful
+ * selectors.
+ *
+ * @module Actions
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ActionNoopType = exports.ActionTrigger = void 0;
+/**
+ * Lists the different triggers that can raise an {@link Actions|action}. Each action that is raised will result in a
+ * {@link NotificationActionEvent|`notification-action`} event, which can be captured by the application that created
+ * the notification.
+ */
+var ActionTrigger;
+(function (ActionTrigger) {
+    /**
+     * The user interacted with one of the controls within the notification. This currently means a button click, but
+     * other control types will be added in future releases.
+     */
+    ActionTrigger["CONTROL"] = "control";
+    /**
+     * The user clicked the body of the notification itself. Any clicks of the notification that don't hit a control
+     * or the close button will fire an event with the `'select'` action trigger.
+     */
+    ActionTrigger["SELECT"] = "select";
+    /**
+     * The notification was closed, either by user interaction, programmatically by an application, or by the notification expiring.
+     */
+    ActionTrigger["CLOSE"] = "close";
+    /**
+     * The notification expired.
+     */
+    ActionTrigger["EXPIRE"] = "expire";
+    /**
+     * The action was triggered programmatically by an application.
+     *
+     * *Not currently supported - will be implemented in a future release*
+     */
+    ActionTrigger["PROGRAMMATIC"] = "programmatic";
+})(ActionTrigger = exports.ActionTrigger || (exports.ActionTrigger = {}));
+/**
+ * Noop action types see {@link ActionNoop|ActionNoop}.
+ */
+var ActionNoopType;
+(function (ActionNoopType) {
+    /**
+     * No event will be raised and no dismissal of the notification on action.
+     */
+    ActionNoopType["EVENT_DISMISS"] = "event_dismiss";
+    /**
+     * No event will be raised, but the notification will be dismissed on action.
+     */
+    // EVENT = 'event',
+    /**
+     * No dismissal of the notification, but the action event will be raised on action.
+     */
+    // DISMISS = 'dismiss',
+})(ActionNoopType = exports.ActionNoopType || (exports.ActionNoopType = {}));
+
+
 /***/ }),
 /* 3 */
 /***/ (function(module, exports, __webpack_require__) {
@@ -569,8 +571,8 @@ exports.getNotificationsCount = exports.toggleNotificationCenter = exports.clear
  *
  * @hidden
  */
-const actions_1 = __webpack_require__(1);
-const connection_1 = __webpack_require__(2);
+const actions_1 = __webpack_require__(2);
+const connection_1 = __webpack_require__(1);
 const internal_1 = __webpack_require__(0);
 const provider = __importStar(__webpack_require__(10));
 exports.provider = provider;
@@ -581,18 +583,19 @@ Object.defineProperty(exports, "NotificationIndicatorType", { enumerable: true,
 Object.defineProperty(exports, "IndicatorColor", { enumerable: true, get: function () { return indicator_1.IndicatorColor; } });
 const templates_1 = __webpack_require__(5);
 Object.defineProperty(exports, "NotificationOptions", { enumerable: true, get: function () { return templates_1.NotificationOptions; } });
-__exportStar(__webpack_require__(1), exports);
+__exportStar(__webpack_require__(2), exports);
 __exportStar(__webpack_require__(14), exports);
 __exportStar(__webpack_require__(15), exports);
 __exportStar(__webpack_require__(16), exports);
 __exportStar(__webpack_require__(19), exports);
 __exportStar(__webpack_require__(20), exports);
+__exportStar(__webpack_require__(24), exports);
 /**
  * The Notification Client library's version in semver format.
  *
  * This is the version which you are currently using.
  */
-exports.VERSION = '1.12.2';
+exports.VERSION = '1.13.0-alpha-898';
 const eventHandler = connection_1.getEventRouter();
 function parseEventWithNotification(event) {
     const { notification } = event;
@@ -1532,7 +1535,7 @@ exports.isConnectedToAtLeast = exports.getStatus = void 0;
  */
 const semver_compare_1 = __importDefault(__webpack_require__(11));
 const openfin_service_async_1 = __webpack_require__(3);
-const connection_1 = __webpack_require__(2);
+const connection_1 = __webpack_require__(1);
 const internal_1 = __webpack_require__(0);
 /**
  * Retrieves the connection status and version semver of the Service Provider in the shape of a {@link ProviderStatus} object.
@@ -1896,6 +1899,44 @@ Object.defineProperty(exports, "__esModule", { value: true });
 Object.defineProperty(exports, "__esModule", { value: true });
 
 
+/***/ }),
+/* 24 */
+/***/ (function(module, exports, __webpack_require__) {
+
+"use strict";
+
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.deregisterPlatform = exports.registerPlatform = void 0;
+const connection_1 = __webpack_require__(1);
+const internal_1 = __webpack_require__(0);
+/**
+ *  These are internal methods to facilitate the connection with the Workspace API.
+ */
+/**
+ *  @ignore
+ */
+async function registerPlatform(platform) {
+    if (typeof platform !== 'object' || platform === null) {
+        throw new Error('Invalid argument passed to registerPlatform: argument must be an object and must not be null');
+    }
+    if (!platform.id) {
+        throw new Error('Invalid argument passed to registerPlatform: "id" must be a non-empty string in platform info.');
+    }
+    return connection_1.tryServiceDispatch(internal_1.APITopic.REGISTER_PLATFORM, Object.assign({}, platform));
+}
+exports.registerPlatform = registerPlatform;
+/**
+ *  @ignore
+ */
+async function deregisterPlatform(id) {
+    if (!id) {
+        throw new Error('Invalid argument passed to deregisterPlatform: "id" must be a non-empty string.');
+    }
+    return connection_1.tryServiceDispatch(internal_1.APITopic.DEREGISTER_PLATFORM, { id });
+}
+exports.deregisterPlatform = deregisterPlatform;
+
+
 /***/ })
 /******/ ]);
 });