@blackbaud/sky-addin-client 1.1.5 → 1.2.1

package/bundles/sky-addin-client.global.js

@@ -0,0 +1,1106 @@
+/******/ (() => { // webpackBootstrap
+/******/ 	"use strict";
+/******/ 	var __webpack_modules__ = ([
+/* 0 */
+/***/ (function(__unused_webpack_module, exports, __webpack_require__) {
+
+
+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(__webpack_require__(1), exports);
+
+
+/***/ }),
+/* 1 */
+/***/ (function(__unused_webpack_module, exports, __webpack_require__) {
+
+
+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(__webpack_require__(2), exports);
+__exportStar(__webpack_require__(3), exports);
+__exportStar(__webpack_require__(31), exports);
+
+
+/***/ }),
+/* 2 */
+/***/ ((__unused_webpack_module, exports) => {
+
+
+Object.defineProperty(exports, "__esModule", ({ value: true }));
+exports.AddinClient = void 0;
+/**
+ * Collection of regexs for our whitelist of host origins.
+ */
+var allowedOrigins = [
+    /^https\:\/\/[\w\-\.]+\.blackbaud\.com$/,
+    /^https\:\/\/[\w\-\.]+\.blackbaud\-dev\.com$/,
+    /^http\:\/\/[\w\-\.]+\.blackbaud\-dev\.com$/,
+    /^https\:\/\/[\w\-\.]+\.blackbaudhosting\.com$/,
+    /^https\:\/\/[\w\-\.]+\.bbcloudservices\.com$/,
+    /^https\:\/\/localhost(\:[0-9]+)?$/,
+    /^https\:\/\/secure[2|3|8]\.convio\.net$/,
+    /^https\:\/\/testweb\.convio\.com$/,
+    /^https\:\/\/[\w\-\.]+\.conviocloud\.com$/,
+    /^https\:\/\/[\w\-\.]+\.blackbaudcloud\.com$/,
+    /^https\:\/\/[\w\-\.]+\.blackbaudfaith\.com$/,
+    /^https\:\/\/[\w\-\.]+\.blackbaudportal\.com$/,
+    /^https\:\/\/[\w\-\.]+\.bbk12\.com$/,
+    /^https\:\/\/[\w\-\.]+\.mycampus\-app\.com$/,
+    /^https\:\/\/[\w\-\.]+\.myschoolapp\.com$/,
+    /^https\:\/\/[\w\-\.]+\.myschoolautomation\.com$/,
+    /^https\:\/\/[\w\-\.]+\.myschooldemo\.com$/,
+    /^https\:\/\/[\w\-\.]+\.myschooltraining\.com$/
+];
+/**
+ * Client for interacting with the parent page hosting the add-in.
+ */
+var AddinClient = /** @class */ (function () {
+    function AddinClient(args) {
+        var _this = this;
+        this.args = args;
+        /**
+         * Tracks pending request to reeceive an auth-token from the host.
+         */
+        this.authTokenRequests = [];
+        /**
+         * Counter to provide unique ids for each auth token request.
+         */
+        this.lastAuthTokenRequestId = 0;
+        /**
+         * Tracks modal add-ins that have been launched from this add-in.
+         */
+        this.modalRequests = [];
+        /**
+         * Counter to provide unique ids for each modal request.
+         */
+        this.lastModalRequestId = 0;
+        /**
+         * Stores the registered add-in events.
+         * Key - the event type.
+         * Value - The callback function to be executed when the event type occurs.
+         */
+        this.registeredAddinEvents = {};
+        /**
+         * Stores the add-in events that have been sent to the host page.
+         * Key - the event request ID.
+         * Value - The Promise resolve function to be executed when the event is received by the host.
+         */
+        this.sentEvents = {};
+        /**
+         * Stores the pending add-in events that are queued to be sent to the host page after 200
+         * milliseconds have expired.
+         * Key - the event type.
+         * Value - The Promise reject function to be executed if the event fails to be sent to the host page.
+         */
+        this.pendingSentEvents = {};
+        /**
+         * The event request ID counter.
+         * The ID is incremented and assigned to each event that is sent.
+         */
+        this.eventRequestId = 0;
+        /**
+         * An array of event types that are supported by the host page.
+         * The add-in client will throw an error if an event is attempted but not one the supported types.
+         */
+        this.supportedEventTypes = [];
+        this.windowMessageHandler = function (event) {
+            _this.handleMessage(event);
+        };
+        // Listen to messages from the host page.
+        window.addEventListener('message', this.windowMessageHandler);
+        // Inform the host page that the add-in is loaded and listening for messages.
+        this.raiseAddinReadyMessage();
+    }
+    /* istanbul ignore next */
+    /**
+     * @returns {string}  Returns the current query string path for the window, prefixed with ?.
+     */
+    AddinClient.getQueryString = function () {
+        return window.location.search;
+    };
+    /**
+     * Cleans up the AddinClient, releasing all resources.
+     */
+    AddinClient.prototype.destroy = function () {
+        window.removeEventListener('message', this.windowMessageHandler);
+        if (this.heightChangeIntervalId) {
+            clearInterval(this.heightChangeIntervalId);
+        }
+    };
+    /**
+     * Requests the host page to navigate.
+     * @param args Arguments describing the navigation request.
+     */
+    AddinClient.prototype.navigate = function (args) {
+        this.postMessageToHostPage({
+            message: {
+                url: args.url
+            },
+            messageType: 'navigate'
+        });
+    };
+    /**
+     * Requests an authentication token for the current user.
+     * @deprecated Use getUserIdentityToken() instead.
+     * @returns {Promise<any>} Returns a promise which will resolve with the token value.
+     */
+    AddinClient.prototype.getAuthToken = function () {
+        return this.getUserIdentityToken();
+    };
+    /**
+     * Requests a user identity token for the current user.
+     * @returns {Promise<any>} Returns a promise which will resolve with the token value.
+     */
+    AddinClient.prototype.getUserIdentityToken = function () {
+        var _this = this;
+        return new Promise(function (resolve, reject) {
+            var authTokenRequestId = ++_this.lastAuthTokenRequestId;
+            _this.authTokenRequests[authTokenRequestId] = {
+                reject: reject,
+                resolve: resolve
+            };
+            _this.postMessageToHostPage({
+                message: {
+                    authTokenRequestId: authTokenRequestId
+                },
+                messageType: 'get-auth-token'
+            });
+        });
+    };
+    /**
+     * Requests the host page to launch a modal add-in.
+     * @param args Arguments for launching the modal.
+     * @returns {Promise<any>} Returns a promise that will be resolved when the modal add-in is closed.
+     * Promise will resolve with context data passed by from the modal add-in's closeModal call.
+     */
+    AddinClient.prototype.showModal = function (args) {
+        var _this = this;
+        return {
+            modalClosed: new Promise(function (resolve, reject) {
+                var modalRequestId = ++_this.lastModalRequestId;
+                _this.modalRequests[modalRequestId] = {
+                    reject: reject,
+                    resolve: resolve
+                };
+                _this.postMessageToHostPage({
+                    message: {
+                        args: args,
+                        modalRequestId: modalRequestId
+                    },
+                    messageType: 'show-modal'
+                });
+            })
+        };
+    };
+    /**
+     * Informs the host to close this modal add-in.
+     * Should only be used from within the modal add-in and not the parent add-in.
+     * @param args Arguments to provide a context object back to the parent add-in.
+     */
+    AddinClient.prototype.closeModal = function (args) {
+        this.postMessageToHostPage({
+            message: args,
+            messageType: 'close-modal'
+        });
+    };
+    /**
+     * Informs the host to open the help tab with the specified help key.
+     * @param args Arguments for launching the help tab.
+     */
+    AddinClient.prototype.openHelp = function (args) {
+        this.postMessageToHostPage({
+            message: {
+                helpKey: args.helpKey
+            },
+            messageType: 'open-help'
+        });
+    };
+    /**
+     * Informs the host to show a toast message.
+     * @param args Arguments for showing a toast.
+     */
+    AddinClient.prototype.showToast = function (args) {
+        this.postMessageToHostPage({
+            message: args,
+            messageType: 'show-toast'
+        });
+    };
+    /**
+     * Requests the host page to launch a flyout add-in.
+     * @param args Arguments for launching the flyout.
+     * @returns {Promise<any>} Returns a promise that will be resolved when the flyout add-in is closed.
+     */
+    AddinClient.prototype.showFlyout = function (args) {
+        var _this = this;
+        return {
+            flyoutClosed: new Promise(function (resolve, reject) {
+                // host page will apply default values when not provided
+                args.defaultWidth = args.defaultWidth;
+                args.maxWidth = args.maxWidth;
+                args.minWidth = args.minWidth;
+                _this.flyoutRequest = {
+                    reject: reject,
+                    resolve: resolve
+                };
+                _this.postMessageToHostPage({
+                    message: args,
+                    messageType: 'show-flyout'
+                });
+            })
+        };
+    };
+    /**
+     * Requests the host page to close the flyout add-in.
+     */
+    AddinClient.prototype.closeFlyout = function () {
+        this.postMessageToHostPage({
+            messageType: 'close-flyout'
+        });
+    };
+    /**
+     * Requests the host page to show a confirm dialog.
+     * @param args Arguments for showing a confirm dialog.
+     * @returns {Promise<string>} Returns a promise that will resolve with the
+     * confirm action when the dialog is closed.
+     */
+    AddinClient.prototype.showConfirm = function (args) {
+        var _this = this;
+        return new Promise(function (resolve, reject) {
+            _this.confirmRequest = {
+                reject: reject,
+                resolve: resolve
+            };
+            _this.postMessageToHostPage({
+                message: args,
+                messageType: 'show-confirm'
+            });
+        });
+    };
+    /**
+     * Informs the host to show an error dialog.
+     * @param args Arguments for showing an error dialog.
+     */
+    AddinClient.prototype.showError = function (args) {
+        this.postMessageToHostPage({
+            message: args,
+            messageType: 'show-error'
+        });
+    };
+    /**
+     * Requests the host page to show the page blocking wait indicator.
+     */
+    AddinClient.prototype.showWait = function () {
+        this.postMessageToHostPage({
+            messageType: 'show-wait'
+        });
+    };
+    /**
+     * Requests the host page to hide the page blocking wait indicator.
+     */
+    AddinClient.prototype.hideWait = function () {
+        this.postMessageToHostPage({
+            messageType: 'hide-wait'
+        });
+    };
+    /**
+     * Registers a callback to be executed when the specified event type occurs.
+     * @param eventType The event type to process.
+     * @param callback The callback to execute when the event occurs.
+     */
+    AddinClient.prototype.addEventHandler = function (eventType, callback) {
+        this.registeredAddinEvents[eventType] = callback;
+    };
+    /**
+     * Sends an event to be handled by the host page.
+     * @returns {Promise<void>} Returns a Promise which will resolve when the add-in host page receives the message, or
+     * rejects if a subsequent event occurs, for the same event type, within 200 milliseconds.
+     * The Promise also rejects if an event type is not one of the supported types from the host page.
+     * @see AddinClientInitArgs#supportedEventTypes
+     */
+    AddinClient.prototype.sendEvent = function (args) {
+        var _this = this;
+        return new Promise(function (resolve, reject) {
+            var eventType = args.type;
+            if (!_this.supportedEventTypes.includes(eventType)) {
+                reject('Event type not supported');
+            }
+            var pendingEvent = _this.pendingSentEvents[eventType];
+            if (pendingEvent) {
+                // cancel and reject pending event
+                clearTimeout(pendingEvent.timeoutId);
+                pendingEvent.reject('Event cancelled');
+            }
+            var timeoutId = setTimeout(function () {
+                delete _this.pendingSentEvents[eventType];
+                _this.postMessageToHostPage({
+                    message: {
+                        event: args,
+                        eventRequestId: _this.eventRequestId
+                    },
+                    messageType: 'client-event'
+                });
+                _this.sentEvents[_this.eventRequestId] = resolve;
+                _this.eventRequestId++;
+            }, 200);
+            _this.pendingSentEvents[eventType] = {
+                reject: reject,
+                timeoutId: timeoutId
+            };
+        });
+    };
+    /**
+     * Post a message to the host page informing it that the add-in is
+     * now started and listening for messages from the host.
+     */
+    AddinClient.prototype.raiseAddinReadyMessage = function () {
+        // No sensitive data should be provided with this message!  This is the initial
+        // message posted to the host page to establish whether the host origin is a
+        // trusted origin and therefore will post to any host, trusted or untrusted.
+        // The host should respond with a host-ready message which will include the origin
+        // and will be validated against a whitelist of allowed origins so that subsequent
+        // messages can be posted only to that trusted origin.
+        this.postMessageToHostPage({
+            messageType: 'ready'
+        }, '*');
+    };
+    /**
+     * Handles the modal-closed message from the host.
+     * This is emitted to add-ins which have previously launched a modal, which is now
+     * closing.
+     * @param message The message data, which includes a context object from the closing modal, which should be passed
+     * to the calling modal in the showModal promise.
+     */
+    AddinClient.prototype.handleModalClosedMessage = function (message) {
+        var modalRequests = this.modalRequests;
+        var modalRequestId = message.modalRequestId;
+        var modalRequest = modalRequests[modalRequestId];
+        modalRequest.resolve(message.context);
+        modalRequests[modalRequestId] = undefined;
+    };
+    /**
+     * Handles host message responses to a get-auth-token request.
+     * @param data The message.
+     */
+    AddinClient.prototype.handleAuthTokenMessage = function (data) {
+        var authTokenRequests = this.authTokenRequests;
+        var authTokenRequestId = data.message.authTokenRequestId;
+        var authTokenRequest = authTokenRequests[authTokenRequestId];
+        /* tslint:disable-next-line switch-default */
+        switch (data.messageType) {
+            case 'auth-token':
+                var authToken = data.message.authToken;
+                authTokenRequest.resolve(authToken);
+                break;
+            case 'auth-token-fail':
+                authTokenRequest.reject(data.message.reason);
+                break;
+        }
+        authTokenRequests[authTokenRequestId] = undefined;
+    };
+    /**
+     * Handles message events received from the add-in host page.
+     * @param event The event posted from the host.
+     */
+    AddinClient.prototype.handleMessage = function (event) {
+        var _this = this;
+        var data = event.data;
+        if (data && data.source === 'bb-addin-host') {
+            if (data.messageType === 'host-ready') {
+                // The 'host-ready' message is the only message that's not validated against
+                // the host origin since that is what's being established in the message.
+                // This MUST be the first message posted by the host page or all further
+                // communications with the host page will be blocked.
+                this.setKnownAllowedHostOrigin(event.origin);
+                this.trackHeightChangesOfAddinContent();
+                // set the supported event types
+                this.supportedEventTypes = data.message.supportedEventTypes;
+                // Pass key data to the add-in for it to initiailze.
+                this.args.callbacks.init({
+                    context: data.message.context,
+                    envId: data.message.envId,
+                    ready: function (args) {
+                        // Do an immediate height check since the add-in may render something
+                        // due to the context provided.  No need to wait a full second to reflect.
+                        _this.checkForHeightChangesOfAddinContent();
+                        _this.postMessageToHostPage({
+                            message: args,
+                            messageType: 'addin-ready'
+                        });
+                    },
+                    supportedEventTypes: data.message.supportedEventTypes,
+                    themeSettings: data.message.themeSettings
+                });
+            }
+            else if (this.isFromValidOrigin(event)) {
+                /* tslint:disable-next-line switch-default */
+                switch (data.messageType) {
+                    case 'auth-token':
+                    case 'auth-token-fail':
+                        this.handleAuthTokenMessage(data);
+                        break;
+                    case 'modal-closed':
+                        this.handleModalClosedMessage(data.message);
+                        break;
+                    case 'button-click':
+                        if (this.args.callbacks.buttonClick) {
+                            this.args.callbacks.buttonClick();
+                        }
+                        break;
+                    case 'update-context':
+                        if (this.args.callbacks.updateContext) {
+                            this.args.callbacks.updateContext(data.message);
+                        }
+                        break;
+                    case 'confirm-closed':
+                        if (this.confirmRequest) {
+                            this.confirmRequest.resolve(data.message.reason);
+                            this.confirmRequest = undefined;
+                        }
+                        break;
+                    case 'flyout-closed':
+                        if (this.flyoutRequest) {
+                            this.flyoutRequest.resolve();
+                            this.flyoutRequest = undefined;
+                        }
+                        break;
+                    case 'flyout-next-click':
+                        if (this.args.callbacks.flyoutNextClick) {
+                            this.args.callbacks.flyoutNextClick();
+                        }
+                        break;
+                    case 'flyout-previous-click':
+                        if (this.args.callbacks.flyoutPreviousClick) {
+                            this.args.callbacks.flyoutPreviousClick();
+                        }
+                        break;
+                    // TODO remove support for this message type when help support is removed in next major release
+                    case 'help-click':
+                        if (this.args.callbacks.helpClick) {
+                            this.args.callbacks.helpClick();
+                        }
+                        break;
+                    case 'settings-click':
+                        if (this.args.callbacks.settingsClick) {
+                            this.args.callbacks.settingsClick();
+                        }
+                        break;
+                    case 'theme-change':
+                        if (this.args.callbacks.themeChange) {
+                            this.args.callbacks.themeChange(data.message.themeSettings);
+                        }
+                        break;
+                    case 'host-event':
+                        this.processHostEvent(data.message);
+                        break;
+                    case 'event-received':
+                        this.resolveClientEvent(data.message);
+                        break;
+                }
+            }
+            else {
+                this.warnInvalidOrigin();
+            }
+        }
+    };
+    /**
+     * Validates and registers a value as the origin of the parent page hosting the add-in.
+     * If the provided origin matches against our trusted whitelist, then it will be saved.
+     * Post messages will implicitly go to this origin and received messages will be filtered
+     * to just messages from this origin.
+     * @param hostOrigin
+     */
+    AddinClient.prototype.setKnownAllowedHostOrigin = function (hostOrigin) {
+        for (var _i = 0, allowedOrigins_1 = allowedOrigins; _i < allowedOrigins_1.length; _i++) {
+            var allowedOrigin = allowedOrigins_1[_i];
+            if (allowedOrigin.test(hostOrigin)) {
+                this.trustedOrigin = hostOrigin;
+                return;
+            }
+        }
+    };
+    /**
+     * Checks if the height of the iFrame has changed since it was last
+     * posted to the host page (or if it hasn't been posted yet) and initiates
+     * a new post if so.
+     */
+    AddinClient.prototype.checkForHeightChangesOfAddinContent = function () {
+        // after some discussion and experimentation, using offsetHeight appears to be sufficient
+        var newHeight = document.documentElement.offsetHeight;
+        if (newHeight !== this.lastPostedIframeHeight) {
+            this.lastPostedIframeHeight = newHeight;
+            this.postMessageToHostPage({
+                message: {
+                    height: newHeight + 'px'
+                },
+                messageType: 'height-change'
+            });
+        }
+    };
+    /**
+     * Starts a timeout interval to watch for height changes
+     * of the iframe content.
+     */
+    AddinClient.prototype.trackHeightChangesOfAddinContent = function () {
+        var _this = this;
+        this.heightChangeIntervalId = setInterval(function () {
+            _this.checkForHeightChangesOfAddinContent();
+        }, 1000);
+    };
+    /**
+     * Posts a message to the parent window.
+     * @param message The message content to post.
+     * @param targetOrigin Optional. If provided, then the message will be posted to this origin.
+     *                     If not, then it will post to the pre-determined host page origin.
+     */
+    AddinClient.prototype.postMessageToHostPage = function (message, targetOrigin) {
+        message.source = 'bb-addin-client';
+        message.addinId = this.getQueryVariable('addinId');
+        targetOrigin = targetOrigin || this.trustedOrigin;
+        if (targetOrigin) {
+            window.parent.postMessage(message, targetOrigin);
+        }
+        else {
+            this.warnInvalidOrigin();
+        }
+    };
+    /**
+     * Processes an add-in event that occurs from the host and responds
+     * back to the host with an 'event-received' message.
+     * @param message The message to process by looking up executing the registered callback
+     * that matches the event type.
+     */
+    AddinClient.prototype.processHostEvent = function (message) {
+        var _this = this;
+        var eventArgs = message.context;
+        var callback = this.registeredAddinEvents[eventArgs.type];
+        var promise;
+        if (callback) {
+            if (this.isBlockingEventType(eventArgs.type)) {
+                promise = new Promise(function (resolve) {
+                    callback(eventArgs.context, function () {
+                        resolve();
+                    });
+                });
+            }
+            else {
+                promise = new Promise(function (resolve) {
+                    callback(eventArgs.context);
+                    resolve();
+                });
+            }
+        }
+        else {
+            promise = Promise.resolve();
+        }
+        promise.then(function () { return _this.postEventReceivedMessage(message.eventRequestId); });
+    };
+    /**
+     * Checks whether an event type is blocking and requires a response from the client
+     * before responding to the host.
+     * @param type The event type.
+     */
+    AddinClient.prototype.isBlockingEventType = function (type) {
+        switch (type) {
+            case 'form-save':
+            case 'form-cancel':
+                return true;
+            default: break;
+        }
+        return false;
+    };
+    /**
+     * Posts a message to the host page to indicate that a certain event has been received.
+     * @param eventRequestId The ID of the event request that was received.
+     */
+    AddinClient.prototype.postEventReceivedMessage = function (eventRequestId) {
+        this.postMessageToHostPage({
+            message: {
+                eventRequestId: eventRequestId
+            },
+            messageType: 'event-received'
+        });
+    };
+    /**
+     * Attemps to resolve the Promise for a client event that has been received by the host page.
+     * @param message Message data that includes the ID of the event that was received.
+     */
+    AddinClient.prototype.resolveClientEvent = function (message) {
+        var requestId = message.eventRequestId;
+        var promiseResolve = this.sentEvents[requestId];
+        if (promiseResolve) {
+            promiseResolve();
+            delete this.sentEvents[requestId];
+        }
+    };
+    /**
+     * Checks whether a MessageEvent is from the execetd host origin.
+     * @param event
+     */
+    AddinClient.prototype.isFromValidOrigin = function (event) {
+        return event.origin === this.trustedOrigin;
+    };
+    /**
+     * Log that a message was received with an invalid origin.
+     */
+    AddinClient.prototype.warnInvalidOrigin = function () {
+        console.warn('The origin is not trusted because the host-ready message has not been ' +
+            'sent or because the host origin is not a whitelisted origin.');
+    };
+    /**
+     * Reads a query string value from the current window location.
+     * @param variable  Name of the query string parameter to ready.
+     * @returns         The value of the query string parameter.
+     */
+    AddinClient.prototype.getQueryVariable = function (variable) {
+        var query = AddinClient.getQueryString().substring(1);
+        var vars = query.split('&');
+        for (var _i = 0, vars_1 = vars; _i < vars_1.length; _i++) {
+            var v = vars_1[_i];
+            var pair = v.split('=');
+            if (decodeURIComponent(pair[0]) === variable) {
+                return decodeURIComponent(pair[1]);
+            }
+        }
+    };
+    return AddinClient;
+}());
+exports.AddinClient = AddinClient;
+
+
+/***/ }),
+/* 3 */
+/***/ (function(__unused_webpack_module, exports, __webpack_require__) {
+
+
+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(__webpack_require__(4), exports);
+__exportStar(__webpack_require__(5), exports);
+__exportStar(__webpack_require__(6), exports);
+__exportStar(__webpack_require__(7), exports);
+__exportStar(__webpack_require__(8), exports);
+__exportStar(__webpack_require__(9), exports);
+__exportStar(__webpack_require__(10), exports);
+__exportStar(__webpack_require__(11), exports);
+__exportStar(__webpack_require__(12), exports);
+__exportStar(__webpack_require__(13), exports);
+__exportStar(__webpack_require__(14), exports);
+__exportStar(__webpack_require__(15), exports);
+__exportStar(__webpack_require__(16), exports);
+__exportStar(__webpack_require__(17), exports);
+__exportStar(__webpack_require__(18), exports);
+__exportStar(__webpack_require__(19), exports);
+__exportStar(__webpack_require__(20), exports);
+__exportStar(__webpack_require__(21), exports);
+__exportStar(__webpack_require__(22), exports);
+__exportStar(__webpack_require__(23), exports);
+__exportStar(__webpack_require__(24), exports);
+__exportStar(__webpack_require__(25), exports);
+__exportStar(__webpack_require__(26), exports);
+__exportStar(__webpack_require__(27), exports);
+__exportStar(__webpack_require__(28), exports);
+__exportStar(__webpack_require__(29), exports);
+__exportStar(__webpack_require__(30), exports);
+
+
+/***/ }),
+/* 4 */
+/***/ ((__unused_webpack_module, exports) => {
+
+
+Object.defineProperty(exports, "__esModule", ({ value: true }));
+
+
+/***/ }),
+/* 5 */
+/***/ ((__unused_webpack_module, exports) => {
+
+
+Object.defineProperty(exports, "__esModule", ({ value: true }));
+exports.AddinButtonStyle = void 0;
+/*
+ * Defines the style of the button
+ */
+var AddinButtonStyle;
+(function (AddinButtonStyle) {
+    // No style (default)
+    AddinButtonStyle[AddinButtonStyle["None"] = 0] = "None";
+    // The button represents an "add" operation
+    AddinButtonStyle[AddinButtonStyle["Add"] = 1] = "Add";
+    // The button represents an "edit" operation
+    AddinButtonStyle[AddinButtonStyle["Edit"] = 2] = "Edit";
+    // The button represents a "delete" operation
+    AddinButtonStyle[AddinButtonStyle["Delete"] = 3] = "Delete";
+})(AddinButtonStyle = exports.AddinButtonStyle || (exports.AddinButtonStyle = {}));
+
+
+/***/ }),
+/* 6 */
+/***/ ((__unused_webpack_module, exports) => {
+
+
+Object.defineProperty(exports, "__esModule", ({ value: true }));
+
+
+/***/ }),
+/* 7 */
+/***/ ((__unused_webpack_module, exports) => {
+
+
+Object.defineProperty(exports, "__esModule", ({ value: true }));
+
+
+/***/ }),
+/* 8 */
+/***/ ((__unused_webpack_module, exports) => {
+
+
+Object.defineProperty(exports, "__esModule", ({ value: true }));
+
+
+/***/ }),
+/* 9 */
+/***/ ((__unused_webpack_module, exports) => {
+
+
+Object.defineProperty(exports, "__esModule", ({ value: true }));
+
+
+/***/ }),
+/* 10 */
+/***/ ((__unused_webpack_module, exports) => {
+
+
+Object.defineProperty(exports, "__esModule", ({ value: true }));
+
+
+/***/ }),
+/* 11 */
+/***/ ((__unused_webpack_module, exports) => {
+
+
+Object.defineProperty(exports, "__esModule", ({ value: true }));
+
+
+/***/ }),
+/* 12 */
+/***/ ((__unused_webpack_module, exports) => {
+
+
+Object.defineProperty(exports, "__esModule", ({ value: true }));
+
+
+/***/ }),
+/* 13 */
+/***/ ((__unused_webpack_module, exports) => {
+
+
+Object.defineProperty(exports, "__esModule", ({ value: true }));
+
+
+/***/ }),
+/* 14 */
+/***/ ((__unused_webpack_module, exports) => {
+
+
+Object.defineProperty(exports, "__esModule", ({ value: true }));
+
+
+/***/ }),
+/* 15 */
+/***/ ((__unused_webpack_module, exports) => {
+
+
+Object.defineProperty(exports, "__esModule", ({ value: true }));
+
+
+/***/ }),
+/* 16 */
+/***/ ((__unused_webpack_module, exports) => {
+
+
+Object.defineProperty(exports, "__esModule", ({ value: true }));
+
+
+/***/ }),
+/* 17 */
+/***/ ((__unused_webpack_module, exports) => {
+
+
+Object.defineProperty(exports, "__esModule", ({ value: true }));
+
+
+/***/ }),
+/* 18 */
+/***/ ((__unused_webpack_module, exports) => {
+
+
+Object.defineProperty(exports, "__esModule", ({ value: true }));
+
+
+/***/ }),
+/* 19 */
+/***/ ((__unused_webpack_module, exports) => {
+
+
+Object.defineProperty(exports, "__esModule", ({ value: true }));
+
+
+/***/ }),
+/* 20 */
+/***/ ((__unused_webpack_module, exports) => {
+
+
+Object.defineProperty(exports, "__esModule", ({ value: true }));
+
+
+/***/ }),
+/* 21 */
+/***/ ((__unused_webpack_module, exports) => {
+
+
+Object.defineProperty(exports, "__esModule", ({ value: true }));
+
+
+/***/ }),
+/* 22 */
+/***/ ((__unused_webpack_module, exports) => {
+
+
+Object.defineProperty(exports, "__esModule", ({ value: true }));
+
+
+/***/ }),
+/* 23 */
+/***/ ((__unused_webpack_module, exports) => {
+
+
+Object.defineProperty(exports, "__esModule", ({ value: true }));
+
+
+/***/ }),
+/* 24 */
+/***/ ((__unused_webpack_module, exports) => {
+
+
+Object.defineProperty(exports, "__esModule", ({ value: true }));
+
+
+/***/ }),
+/* 25 */
+/***/ ((__unused_webpack_module, exports) => {
+
+
+Object.defineProperty(exports, "__esModule", ({ value: true }));
+exports.AddinConfirmButtonStyle = void 0;
+/**
+ * Defines the style of a confirm dialog button.
+ */
+var AddinConfirmButtonStyle;
+(function (AddinConfirmButtonStyle) {
+    // The button represents a "secondary" action (default)
+    AddinConfirmButtonStyle[AddinConfirmButtonStyle["Default"] = 0] = "Default";
+    // The button represents a "primary" action
+    AddinConfirmButtonStyle[AddinConfirmButtonStyle["Primary"] = 1] = "Primary";
+    // The button represents a "link" action, often used
+    // to trigger an action to cancel/close a confirm dialog
+    AddinConfirmButtonStyle[AddinConfirmButtonStyle["Link"] = 2] = "Link";
+})(AddinConfirmButtonStyle = exports.AddinConfirmButtonStyle || (exports.AddinConfirmButtonStyle = {}));
+
+
+/***/ }),
+/* 26 */
+/***/ ((__unused_webpack_module, exports) => {
+
+
+Object.defineProperty(exports, "__esModule", ({ value: true }));
+
+
+/***/ }),
+/* 27 */
+/***/ ((__unused_webpack_module, exports) => {
+
+
+Object.defineProperty(exports, "__esModule", ({ value: true }));
+exports.AddinTabSummaryStyle = void 0;
+/*
+ * Defines the style of the tab summary
+ */
+var AddinTabSummaryStyle;
+(function (AddinTabSummaryStyle) {
+    // No style (default)
+    AddinTabSummaryStyle[AddinTabSummaryStyle["None"] = 0] = "None";
+    // Show summary text next to the tab caption (the value shown will be the 'summary' property)
+    AddinTabSummaryStyle[AddinTabSummaryStyle["Text"] = 1] = "Text";
+})(AddinTabSummaryStyle = exports.AddinTabSummaryStyle || (exports.AddinTabSummaryStyle = {}));
+
+
+/***/ }),
+/* 28 */
+/***/ ((__unused_webpack_module, exports) => {
+
+
+Object.defineProperty(exports, "__esModule", ({ value: true }));
+
+
+/***/ }),
+/* 29 */
+/***/ ((__unused_webpack_module, exports) => {
+
+
+Object.defineProperty(exports, "__esModule", ({ value: true }));
+exports.AddinTileSummaryStyle = void 0;
+/*
+ * Defines the style of the tile summary
+ */
+var AddinTileSummaryStyle;
+(function (AddinTileSummaryStyle) {
+    // No style (default)
+    AddinTileSummaryStyle[AddinTileSummaryStyle["None"] = 0] = "None";
+    // Show a text summary for the tile (the value to show will be the 'summary' property)
+    AddinTileSummaryStyle[AddinTileSummaryStyle["Text"] = 1] = "Text";
+    // Show a check summary for the tile (the check will show based on the 'checked' property)
+    AddinTileSummaryStyle[AddinTileSummaryStyle["Check"] = 2] = "Check";
+})(AddinTileSummaryStyle = exports.AddinTileSummaryStyle || (exports.AddinTileSummaryStyle = {}));
+
+
+/***/ }),
+/* 30 */
+/***/ ((__unused_webpack_module, exports) => {
+
+
+Object.defineProperty(exports, "__esModule", ({ value: true }));
+exports.AddinToastStyle = void 0;
+/*
+ * Defines the style of the toast
+ */
+var AddinToastStyle;
+(function (AddinToastStyle) {
+    // The toast style for a critical error
+    AddinToastStyle[AddinToastStyle["Danger"] = 0] = "Danger";
+    // The toast style for informational purposes (default)
+    AddinToastStyle[AddinToastStyle["Info"] = 1] = "Info";
+    // The toast style for a successful operation
+    AddinToastStyle[AddinToastStyle["Success"] = 2] = "Success";
+    // The toast style for a non-critical error
+    AddinToastStyle[AddinToastStyle["Warning"] = 3] = "Warning";
+})(AddinToastStyle = exports.AddinToastStyle || (exports.AddinToastStyle = {}));
+
+
+/***/ }),
+/* 31 */
+/***/ (function(__unused_webpack_module, exports, __webpack_require__) {
+
+
+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(__webpack_require__(32), exports);
+__exportStar(__webpack_require__(33), exports);
+
+
+/***/ }),
+/* 32 */
+/***/ ((__unused_webpack_module, exports) => {
+
+
+Object.defineProperty(exports, "__esModule", ({ value: true }));
+
+
+/***/ }),
+/* 33 */
+/***/ ((__unused_webpack_module, exports) => {
+
+
+Object.defineProperty(exports, "__esModule", ({ value: true }));
+
+
+/***/ })
+/******/ 	]);
+/************************************************************************/
+/******/ 	// The module cache
+/******/ 	var __webpack_module_cache__ = {};
+/******/ 	
+/******/ 	// The require function
+/******/ 	function __webpack_require__(moduleId) {
+/******/ 		// Check if module is in cache
+/******/ 		var cachedModule = __webpack_module_cache__[moduleId];
+/******/ 		if (cachedModule !== undefined) {
+/******/ 			return cachedModule.exports;
+/******/ 		}
+/******/ 		// Create a new module (and put it into the cache)
+/******/ 		var module = __webpack_module_cache__[moduleId] = {
+/******/ 			// no module.id needed
+/******/ 			// no module.loaded needed
+/******/ 			exports: {}
+/******/ 		};
+/******/ 	
+/******/ 		// Execute the module function
+/******/ 		__webpack_modules__[moduleId].call(module.exports, module, module.exports, __webpack_require__);
+/******/ 	
+/******/ 		// Return the exports of the module
+/******/ 		return module.exports;
+/******/ 	}
+/******/ 	
+/************************************************************************/
+/******/ 	
+/******/ 	// startup
+/******/ 	// Load entry module and return exports
+/******/ 	// This entry module is referenced by other modules so it can't be inlined
+/******/ 	var __webpack_exports__ = __webpack_require__(0);
+/******/ 	window.BBSkyAddinClient = __webpack_exports__;
+/******/ 	
+/******/ })()
+;