@blackbaud/skyux-lib-addin-client 14.1.0 → 15.0.0

package/fesm2022/blackbaud-skyux-lib-addin-client.mjs

@@ -1,344 +1,507 @@
-import * as i0 from '@angular/core';
-import { EventEmitter, inject, RendererFactory2, Injectable } from '@angular/core';
-import { AddinClient } from '@blackbaud/sky-addin-client';
-import { SkyAppConfig } from '@skyux/config';
-import { SkyThemeService, SkyThemeSettings, SkyTheme, SkyThemeMode } from '@skyux/theme';
-import { AsyncSubject, from } from 'rxjs';
-import { SkyHelpService } from '@skyux/core';
-
-/**
- * Implement this class with your own data to initialize the add-in client service.
- */
-class AddinClientConfigService {
-    /**
-     * Gets the AddinClientConfig object that will be injected the
-     * AddinClient instance when instantiated.
-     */
-    getAddinClientConfig() {
-        return {};
-    }
+import { DOCUMENT } from "@angular/common";
+import * as i0 from "@angular/core";
+import { CSP_NONCE, EventEmitter, Injectable, RendererFactory2, inject } from "@angular/core";
+import { AddinClient } from "@blackbaud/sky-addin-client";
+import { SkyAppConfig } from "@skyux/config";
+import { SkyTheme, SkyThemeMode, SkyThemeService, SkyThemeSettings } from "@skyux/theme";
+import { AsyncSubject, from } from "rxjs";
+import { SkyHelpService } from "@skyux/core";
+var AddinClientConfigService = class {
+	getAddinClientConfig() {
+		return {};
+	}
+	getHostedSurfaceMode(context) {
+		return "automatic";
+	}
+};
+var AddinEvent = class {};
+var AddinEventHandlerInstance = class {
+	constructor() {
+		this.addinEvent = new EventEmitter();
+	}
+};
+const NESTED_MODAL_BACKDROP_DEPTH = 2;
+function resolveModalBackdrop(modalDepth, forceNormal) {
+	return forceNormal || modalDepth >= NESTED_MODAL_BACKDROP_DEPTH ? "normal" : "transparent";
 }
-
-/**
- * Contains data for an add-in event and allows you to indicate that an event
- * has been processed
- */
-class AddinEvent {
+const CANONICAL_ADDIN_TYPE_TREATMENT = {
+	"action-button": "preserve",
+	box: "container",
+	button: "preserve",
+	dataset: "preserve",
+	flyout: "container",
+	generic: "preserve",
+	modal: "modal",
+	page: "preserve",
+	tab: "preserve",
+	tile: "container",
+	"vertical-tab-form": "container"
+};
+const READY_ARGS_ADDIN_TYPES = [
+	["modalConfig", "modal"],
+	["boxConfig", "box"],
+	["tabConfig", "tab"],
+	["tileConfig", "tile"],
+	["buttonConfig", "button"],
+	["actionButtonConfig", "action-button"]
+];
+const UNIDENTIFIED_RESOLUTION = {
+	backdrop: "preserve",
+	restoreBackdropDisplay: false,
+	treatment: "container"
+};
+const FULL_PAGE_RESOLUTION = {
+	backdrop: "preserve",
+	restoreBackdropDisplay: false,
+	treatment: "full-page"
+};
+function inferAddinType(readyArgs) {
+	return READY_ARGS_ADDIN_TYPES.find(([field]) => readyArgs[field] !== void 0)?.[1];
+}
+function resolveAddinType(addinType, readyArgs, modalDepth, hostReportsType) {
+	if (addinType === "modal") return readyArgs.modalConfig?.fullPage === true ? FULL_PAGE_RESOLUTION : modalResolution(hostReportsType, modalDepth);
+	return {
+		backdrop: "preserve",
+		restoreBackdropDisplay: false,
+		treatment: CANONICAL_ADDIN_TYPE_TREATMENT[addinType]
+	};
+}
+function modalResolution(compatibleHost, modalDepth) {
+	return {
+		backdrop: resolveModalBackdrop(modalDepth, compatibleHost),
+		inferredModalStyle: compatibleHost ? {
+			hostOverlay: false,
+			transparentBackground: true
+		} : { transparentBackground: true },
+		restoreBackdropDisplay: true,
+		treatment: "modal"
+	};
+}
+function resolveHostedSurface(input) {
+	const { addinType, modalState, mode, readyArgs } = input;
+	if (mode === "preserve" || mode === "container") return {
+		backdrop: "preserve",
+		restoreBackdropDisplay: false,
+		treatment: mode
+	};
+	const style = readyArgs.modalConfig?.style;
+	if (style !== void 0) return {
+		backdrop: addinType === void 0 && style.hostOverlay === false && style.transparentBackground === true ? resolveModalBackdrop(modalState.modalDepth, false) : "preserve",
+		restoreBackdropDisplay: false,
+		treatment: "preserve"
+	};
+	if (addinType !== void 0) return resolveAddinType(addinType, readyArgs, modalState.modalDepth, true);
+	const inferredAddinType = inferAddinType(readyArgs);
+	if (inferredAddinType !== void 0) return resolveAddinType(inferredAddinType, readyArgs, modalState.modalDepth, false);
+	if (modalState.fullPageModalOpen) return FULL_PAGE_RESOLUTION;
+	if (modalState.modalOpen) return {
+		backdrop: resolveModalBackdrop(modalState.modalDepth, false),
+		restoreBackdropDisplay: true,
+		treatment: "modal"
+	};
+	return UNIDENTIFIED_RESOLUTION;
+}
+function withInferredModalStyle(readyArgs, style) {
+	if (style === void 0) return readyArgs;
+	return {
+		...readyArgs,
+		modalConfig: {
+			...readyArgs.modalConfig,
+			style
+		}
+	};
+}
+const HOSTED_SURFACE_CLASSES = {
+	container: "bb-skyux-addin-client-container-background",
+	restoreBackdrop: "bb-skyux-addin-client-modal-backdrop-rendered",
+	transparent: "bb-skyux-addin-client-modal-background-transparent",
+	transparentBackdrop: "bb-skyux-addin-client-modal-backdrop-transparent"
+};
+const HOSTED_SURFACE_STYLE_ATTRIBUTE = "data-bb-skyux-addin-client-hosted-surface";
+const MODAL_MARKER_CLASSES = ["sky-modal-body-open", "sky-modal-body-full-page"];
+const STYLE_TEXT = `
+body.${HOSTED_SURFACE_CLASSES.container} {
+  background-color: var(
+    --sky-theme-color-background-container-default,
+    var(--sky-background-color-container-default)
+  ) !important;
 }
 
-/**
- * Allows you to process events from an event handler.
- */
-class AddinEventHandlerInstance {
+body.${HOSTED_SURFACE_CLASSES.transparent} {
+  background-color: transparent !important;
 }
 
-class AddinClientService {
-    #config;
-    #rendererFactory;
-    #themeService;
-    #addinClientConfigService;
-    constructor() {
-        // Init args
-        this._args = new AsyncSubject();
-        this.args = this._args.asObservable();
-        // Addin Client Events
-        /**
-         * Event emitted for box add-ins indicating that a control action button was clicked.
-         */
-        this.actionClick = new EventEmitter(true);
-        /**
-         * Event emitted for button add-ins indicating that the button was clicked.
-         */
-        this.buttonClick = new EventEmitter(true);
-        /**
-         * Event emitted for add-ins when context information has been updated
-         */
-        this.updateContext = new EventEmitter();
-        /**
-         * Event emitted for flyout add-ins indicating that the next button was clicked.
-         */
-        this.flyoutNextClick = new EventEmitter(true);
-        /**
-         * Event emitted for flyout add-ins indicating that the previous button was clicked.
-         */
-        this.flyoutPreviousClick = new EventEmitter(true);
-        /**
-         * Event emitted for tile add-ins indicating that the help button was clicked.
-         * @deprecated Use tile inline help instead and handle the {@link inlineHelpClick} emitter.
-         */
-        this.helpClick = new EventEmitter(true);
-        /**
-         * Event emitted indicating that the inline help button was clicked.
-         */
-        this.inlineHelpClick = new EventEmitter(true);
-        /**
-         * Event emitted for tile add-ins indicating that the settings button was clicked.
-         */
-        this.settingsClick = new EventEmitter(true);
-        this.#config = inject(SkyAppConfig, { optional: true });
-        this.#rendererFactory = inject(RendererFactory2);
-        this.#themeService = inject(SkyThemeService);
-        this.#addinClientConfigService = inject(AddinClientConfigService, { optional: true });
-        this.addinClient = new AddinClient({
-            callbacks: {
-                init: (args) => {
-                    this.initializeTheme(args?.themeSettings);
-                    this._args.next(args);
-                    this._args.complete();
-                },
-                actionClick: (action) => {
-                    this.actionClick.emit(action);
-                },
-                buttonClick: () => {
-                    this.buttonClick.emit();
-                },
-                flyoutNextClick: () => {
-                    this.flyoutNextClick.emit();
-                },
-                flyoutPreviousClick: () => {
-                    this.flyoutPreviousClick.emit();
-                },
-                helpClick: () => {
-                    this.helpClick.emit();
-                },
-                inlineHelpClick: () => {
-                    this.inlineHelpClick.emit();
-                },
-                settingsClick: () => {
-                    this.settingsClick.emit();
-                },
-                updateContext: (context) => {
-                    this.updateContext.emit(context);
-                },
-                themeChange: (settings) => {
-                    this.setTheme(settings);
-                }
-            },
-            config: this.#addinClientConfigService?.getAddinClientConfig()
-        });
-    }
-    /**
-     * 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.
-     */
-    closeModal(args) {
-        this.addinClient.closeModal(args);
-    }
-    /**
-     * Requests the host page to launch a modal add-in.
-     * @param args Arguments for launching the modal.
-     * @returns Returns an observable that will publish a value when the modal add-in is closed.
-     * Observables will publish values with context data passed from the modal add-in's closeModal call.
-     */
-    showModal(args) {
-        let modalReturn = this.addinClient.showModal(args);
-        return from(modalReturn.modalClosed);
-    }
-    /**
-     * Cleans up the AddinClient, releasing all resources.
-     */
-    destroy() {
-        this.addinClient.destroy();
-    }
-    /**
-     * Requests the host page to navigate.
-     * @param args Arguments describing the navigation request.
-     */
-    navigate(args) {
-        this.addinClient.navigate(args);
-    }
-    /**
-     * Informs the host to open the help tab with the specified help key.
-     * @param args Arguments for launching the help tab.
-     */
-    openHelp(args) {
-        this.addinClient.openHelp(args);
-    }
-    /**
-     * Requests a user identity token for the current user.
-     * @returns Returns an observable which will publish the token value.
-     */
-    getUserIdentityToken() {
-        return from(this.addinClient.getUserIdentityToken());
-    }
-    /**
-     * @deprecated Use getUserIdentityToken
-     */
-    getAuthToken() {
-        return from(this.addinClient.getUserIdentityToken());
-    }
-    /**
-     * Informs the host to show a toast message.
-     * @param args Arguments for showing a toast.
-     */
-    showToast(args) {
-        this.addinClient.showToast(args);
-    }
-    /**
-     * Requests the host page to launch a flyout add-in.
-     * @param args Arguments for launching the flyout.
-     * @returns Returns an observable that will notify when the flyout add-in is closed.
-     */
-    showFlyout(args) {
-        const flyoutReturn = this.addinClient.showFlyout(args);
-        return from(flyoutReturn.flyoutClosed);
-    }
-    /**
-     * Requests the host page to close the flyout add-in.
-     */
-    closeFlyout() {
-        this.addinClient.closeFlyout();
-    }
-    /**
-     * Requests the host page to show a confirm dialog.
-     * @param args Arguments for showing a confirm dialog.
-     * @returns Returns an observable which will publish the confirm action value.
-     */
-    showConfirm(args) {
-        return from(this.addinClient.showConfirm(args));
-    }
-    /**
-     * Informs the host to show an error dialog.
-     * @param args Arguments for showing an error dialog.
-     */
-    showError(args) {
-        this.addinClient.showError(args);
-    }
-    /**
-     * Requests the host page to show a page blocking wait indicator.
-     */
-    showWait() {
-        this.addinClient.showWait();
-    }
-    /**
-     * Requests the host page to hide a page blocking wait indicator.
-     */
-    hideWait() {
-        this.addinClient.hideWait();
-    }
-    /**
-     * Registers an event handler for the provided event type.
-     * @param eventType The event type to register.
-     * @returns AddinEventHandlerInstance
-     */
-    addEventHandler(eventType) {
-        let eventHandlerInstance = new AddinEventHandlerInstance();
-        eventHandlerInstance.addinEvent = new EventEmitter();
-        const eventCallback = (context, done) => {
-            eventHandlerInstance.addinEvent.emit({
-                context,
-                done
-            });
-        };
-        this.addinClient.addEventHandler(eventType, eventCallback);
-        return eventHandlerInstance;
-    }
-    /**
-     * Sends an event to be handled by the host page.
-     * @param args The event arguments to be sent to the host page.
-     * @returns Returns an observable which will complete when the add-in host page receives the
-     * message. The request will fail if a subsequent event occurs, for the same event type, within
-     * 200 milliseconds. A failure can also occur if an event type is not one of the supported types
-     * from the host page.
-     * @see AddinClientInitArgs#supportedEventTypes
-     */
-    sendEvent(args) {
-        return from(this.addinClient.sendEvent(args));
-    }
-    initializeTheme(themeSettings) {
-        if (!themeSettings) {
-            return;
-        }
-        const hostThemeSettings = AddinClientService.toSkyThemeSettings(themeSettings);
-        if (!this.#config) {
-            // no app config, initialize host theme
-            this.initializeTheme_(hostThemeSettings);
-            return;
-        }
-        const themingConfig = this.#config.skyux.app?.theming;
-        if (themingConfig?.supportedThemes &&
-            themingConfig.supportedThemes.indexOf(themeSettings.theme) !== -1) {
-            // app supports host theme, initialize host theme
-            this.initializeTheme_(hostThemeSettings);
-            return;
-        }
-        // app does not support host theme, do nothing to initialize the app's default theme
-    }
-    initializeTheme_(themeSettings) {
-        this.#themeService.init(document.body, this.#rendererFactory.createRenderer(undefined, undefined), themeSettings);
-    }
-    setTheme(settings) {
-        if (!settings) {
-            return;
-        }
-        const hostThemeSettings = AddinClientService.toSkyThemeSettings(settings);
-        this.#themeService.setTheme(hostThemeSettings);
-    }
-    static toSkyThemeSettings(settings) {
-        if (settings.skyThemeSettings) {
-            // If the settings contain a serialized SkyThemeSettings object, deserialize it.
-            return SkyThemeSettings.deserialize(settings.skyThemeSettings);
-        }
-        return new SkyThemeSettings(AddinClientService.toSkyTheme(settings.theme), AddinClientService.toSkyThemeMode(settings.mode));
-    }
-    static toSkyTheme(theme) {
-        switch (theme) {
-            case 'modern':
-                return SkyTheme.presets.modern;
-            default:
-                return SkyTheme.presets.default;
-        }
-    }
-    static toSkyThemeMode(mode) {
-        switch (mode) {
-            case 'dark':
-                return SkyThemeMode.presets.dark;
-            default:
-                return SkyThemeMode.presets.light;
-        }
-    }
-    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "21.2.8", ngImport: i0, type: AddinClientService, deps: [], target: i0.ɵɵFactoryTarget.Injectable }); }
-    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "21.2.8", ngImport: i0, type: AddinClientService, providedIn: 'root' }); }
+body.${HOSTED_SURFACE_CLASSES.restoreBackdrop}
+  .sky-modal-host-backdrop:not([hidden]) {
+  display: block !important;
 }
-i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "21.2.8", ngImport: i0, type: AddinClientService, decorators: [{
-            type: Injectable,
-            args: [{
-                    providedIn: 'root'
-                }]
-        }], ctorParameters: () => [] });
 
-class AddinClientHelpService extends SkyHelpService {
-    constructor() {
-        super(...arguments);
-        this.skyAddinClientService = inject(AddinClientService);
-    }
-    /** @inheritdoc */
-    openHelp(args) {
-        if (!args) {
-            return;
-        }
-        this.skyAddinClientService.openHelp(args);
-    }
-    /** @inheritdoc */
-    updateHelp() {
-        throw new Error('Not implemented');
-    }
-    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "21.2.8", ngImport: i0, type: AddinClientHelpService, deps: null, target: i0.ɵɵFactoryTarget.Injectable }); }
-    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "21.2.8", ngImport: i0, type: AddinClientHelpService, providedIn: 'root' }); }
+body.${HOSTED_SURFACE_CLASSES.transparentBackdrop}
+  .sky-modal-host-backdrop {
+  --sky-override-modal-host-backdrop-color: transparent;
 }
-i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "21.2.8", ngImport: i0, type: AddinClientHelpService, decorators: [{
-            type: Injectable,
-            args: [{ providedIn: 'root' }]
-        }] });
-/** Provide addin client help service */
+`;
+var HostedSurfaceStyleController = class {
+	#document;
+	#nonce;
+	#ownedClasses = /* @__PURE__ */ new Set();
+	#input;
+	#observer;
+	#styleElement;
+	constructor(documentRef, nonce = null) {
+		this.#document = documentRef;
+		this.#nonce = nonce;
+	}
+	update(addinType, readyArgs, mode = "automatic") {
+		const input = {
+			addinType,
+			mode,
+			readyArgs
+		};
+		this.#input = input;
+		this.#observe();
+		return this.#applyResolution(input);
+	}
+	refresh() {
+		if (this.#input !== void 0) this.#applyResolution(this.#input);
+	}
+	destroy() {
+		this.#observer?.disconnect();
+		this.#observer = void 0;
+		this.#input = void 0;
+		for (const className of this.#ownedClasses) this.#document.body.classList.remove(className);
+		this.#ownedClasses.clear();
+		this.#styleElement?.remove();
+		this.#styleElement = void 0;
+	}
+	#applyResolution(input) {
+		const resolution = resolveHostedSurface({
+			...input,
+			modalState: {
+				fullPageModalOpen: this.#document.body.classList.contains("sky-modal-body-full-page"),
+				modalDepth: this.#document.body.querySelectorAll("sky-modal").length,
+				modalOpen: this.#document.body.classList.contains("sky-modal-body-open")
+			}
+		});
+		this.#setClass(HOSTED_SURFACE_CLASSES.container, resolution.treatment === "container");
+		this.#setClass(HOSTED_SURFACE_CLASSES.transparent, resolution.treatment === "modal");
+		this.#setClass(HOSTED_SURFACE_CLASSES.restoreBackdrop, resolution.restoreBackdropDisplay);
+		this.#setClass(HOSTED_SURFACE_CLASSES.transparentBackdrop, resolution.backdrop === "transparent");
+		if (resolution.treatment === "container" || resolution.treatment === "modal" || resolution.restoreBackdropDisplay || resolution.backdrop === "transparent") this.#ensureStyle();
+		else {
+			this.#styleElement?.remove();
+			this.#styleElement = void 0;
+		}
+		return resolution;
+	}
+	#ensureStyle() {
+		if (this.#styleElement?.parentNode) return;
+		const style = this.#document.createElement("style");
+		style.setAttribute(HOSTED_SURFACE_STYLE_ATTRIBUTE, "");
+		if (this.#nonce) style.setAttribute("nonce", this.#nonce);
+		style.textContent = STYLE_TEXT;
+		this.#document.head.appendChild(style);
+		this.#styleElement = style;
+	}
+	#observe() {
+		if (this.#observer !== void 0) return;
+		this.#observer = new MutationObserver((records) => this.#handleMutations(records));
+		this.#observer.observe(this.#document.body, {
+			attributeFilter: ["class"],
+			attributeOldValue: true,
+			attributes: true,
+			childList: true,
+			subtree: true
+		});
+	}
+	#handleMutations(records) {
+		for (const record of records) if (this.#isRelevantMutation(record)) {
+			this.refresh();
+			return;
+		}
+	}
+	#isRelevantMutation(record) {
+		if (record.type === "attributes") return record.target === this.#document.body && this.#modalMarkerPresenceChanged(record.oldValue);
+		return this.#containsModalNode(record.addedNodes) || this.#containsModalNode(record.removedNodes);
+	}
+	#modalMarkerPresenceChanged(oldValue) {
+		const previousClasses = new Set((oldValue ?? "").split(/\s+/).filter((value) => value.length > 0));
+		const currentClasses = this.#document.body.classList;
+		return MODAL_MARKER_CLASSES.some((marker) => previousClasses.has(marker) !== currentClasses.contains(marker));
+	}
+	#containsModalNode(nodes) {
+		for (let index = 0; index < nodes.length; index++) {
+			const node = nodes[index];
+			if (node.nodeType !== Node.ELEMENT_NODE) continue;
+			const element = node;
+			if (element.localName === "sky-modal" || element.querySelector("sky-modal")) return true;
+		}
+		return false;
+	}
+	#setClass(className, enabled) {
+		if (enabled) {
+			if (!this.#document.body.classList.contains(className)) {
+				this.#document.body.classList.add(className);
+				this.#ownedClasses.add(className);
+			}
+			return;
+		}
+		if (this.#ownedClasses.delete(className)) this.#document.body.classList.remove(className);
+	}
+};
+var AddinClientService = class AddinClientService {
+	#config;
+	#document;
+	#rendererFactory;
+	#themeService;
+	#addinClientConfigService;
+	constructor() {
+		this._args = new AsyncSubject();
+		this.args = this._args.asObservable();
+		this.actionClick = new EventEmitter(true);
+		this.buttonClick = new EventEmitter(true);
+		this.updateContext = new EventEmitter();
+		this.flyoutNextClick = new EventEmitter(true);
+		this.flyoutPreviousClick = new EventEmitter(true);
+		this.helpClick = new EventEmitter(true);
+		this.inlineHelpClick = new EventEmitter(true);
+		this.settingsClick = new EventEmitter(true);
+		this.#config = inject(SkyAppConfig, { optional: true });
+		this.#document = inject(DOCUMENT);
+		this.#rendererFactory = inject(RendererFactory2);
+		this.#themeService = inject(SkyThemeService);
+		this.#addinClientConfigService = inject(AddinClientConfigService, { optional: true });
+		this.destroyed = false;
+		this.hostedSurfaceController = new HostedSurfaceStyleController(this.#document, inject(CSP_NONCE, { optional: true }));
+		this.addinClient = new AddinClient({
+			callbacks: {
+				init: (args) => {
+					const preparedArgs = this.prepareInitArgs(args);
+					this.initializeTheme(preparedArgs.themeSettings);
+					this._args.next(preparedArgs);
+					this._args.complete();
+				},
+				actionClick: (action) => {
+					this.actionClick.emit(action);
+				},
+				buttonClick: () => {
+					this.buttonClick.emit();
+				},
+				flyoutNextClick: () => {
+					this.flyoutNextClick.emit();
+				},
+				flyoutPreviousClick: () => {
+					this.flyoutPreviousClick.emit();
+				},
+				helpClick: () => {
+					this.helpClick.emit();
+				},
+				inlineHelpClick: () => {
+					this.inlineHelpClick.emit();
+				},
+				settingsClick: () => {
+					this.settingsClick.emit();
+				},
+				updateContext: (context) => {
+					this.updateContext.emit(context);
+				},
+				themeChange: (settings) => {
+					this.setTheme(settings);
+				}
+			},
+			config: this.#addinClientConfigService?.getAddinClientConfig()
+		});
+	}
+	closeModal(args) {
+		this.addinClient.closeModal(args);
+	}
+	showModal(args) {
+		let modalReturn = this.addinClient.showModal(args);
+		return from(modalReturn.modalClosed);
+	}
+	destroy() {
+		if (this.destroyed) return;
+		this.destroyed = true;
+		this.hostedSurfaceController.destroy();
+		this.addinClient.destroy();
+	}
+	prepareInitArgs(args) {
+		const ready = args.ready;
+		args.ready = (readyArgs) => {
+			if (this.destroyed || !this.#document.body) {
+				ready(readyArgs);
+				return;
+			}
+			const resolution = this.hostedSurfaceController.update(args.addinType, readyArgs, this.getHostedSurfaceMode({
+				addinType: args.addinType,
+				readyArgs
+			}));
+			ready(withInferredModalStyle(readyArgs, resolution.inferredModalStyle));
+		};
+		return args;
+	}
+	getHostedSurfaceMode(context) {
+		return this.#addinClientConfigService?.getHostedSurfaceMode?.(context) ?? "automatic";
+	}
+	navigate(args) {
+		this.addinClient.navigate(args);
+	}
+	openHelp(args) {
+		this.addinClient.openHelp(args);
+	}
+	getUserIdentityToken() {
+		return from(this.addinClient.getUserIdentityToken());
+	}
+	getAuthToken() {
+		return from(this.addinClient.getUserIdentityToken());
+	}
+	showToast(args) {
+		this.addinClient.showToast(args);
+	}
+	showFlyout(args) {
+		const flyoutReturn = this.addinClient.showFlyout(args);
+		return from(flyoutReturn.flyoutClosed);
+	}
+	closeFlyout() {
+		this.addinClient.closeFlyout();
+	}
+	showConfirm(args) {
+		return from(this.addinClient.showConfirm(args));
+	}
+	showError(args) {
+		this.addinClient.showError(args);
+	}
+	showWait() {
+		this.addinClient.showWait();
+	}
+	hideWait() {
+		this.addinClient.hideWait();
+	}
+	addEventHandler(eventType) {
+		let eventHandlerInstance = new AddinEventHandlerInstance();
+		const eventCallback = (context, done) => {
+			eventHandlerInstance.addinEvent.emit({
+				context,
+				done
+			});
+		};
+		this.addinClient.addEventHandler(eventType, eventCallback);
+		return eventHandlerInstance;
+	}
+	sendEvent(args) {
+		return from(this.addinClient.sendEvent(args));
+	}
+	initializeTheme(themeSettings) {
+		if (!themeSettings || !this.supportsHostTheme(themeSettings)) return;
+		this.initializeTheme_(AddinClientService.toSkyThemeSettings(themeSettings));
+	}
+	initializeTheme_(themeSettings) {
+		this.#themeService.init(document.body, this.#rendererFactory.createRenderer(null, null), themeSettings);
+	}
+	setTheme(settings) {
+		if (!settings || !this.supportsHostTheme(settings)) return;
+		this.#themeService.setTheme(AddinClientService.toSkyThemeSettings(settings));
+	}
+	supportsHostTheme(settings) {
+		if (!this.#config) return true;
+		const supportedThemes = this.#config.skyux.app?.theming?.supportedThemes;
+		return !!supportedThemes && supportedThemes.indexOf(settings.theme) !== -1;
+	}
+	static toSkyThemeSettings(settings) {
+		if (settings.skyThemeSettings) return SkyThemeSettings.deserialize(settings.skyThemeSettings);
+		return new SkyThemeSettings(AddinClientService.toSkyTheme(settings.theme), AddinClientService.toSkyThemeMode(settings.mode));
+	}
+	static toSkyTheme(theme) {
+		switch (theme) {
+			case "modern": return SkyTheme.presets.modern;
+			default: return SkyTheme.presets.default;
+		}
+	}
+	static toSkyThemeMode(mode) {
+		switch (mode) {
+			case "dark": return SkyThemeMode.presets.dark;
+			default: return SkyThemeMode.presets.light;
+		}
+	}
+	static {
+		this.ɵfac = i0.ɵɵngDeclareFactory({
+			minVersion: "12.0.0",
+			version: "22.1.2",
+			ngImport: i0,
+			type: AddinClientService,
+			deps: [],
+			target: i0.ɵɵFactoryTarget.Injectable
+		});
+	}
+	static {
+		this.ɵprov = i0.ɵɵngDeclareInjectable({
+			minVersion: "12.0.0",
+			version: "22.1.2",
+			ngImport: i0,
+			type: AddinClientService,
+			providedIn: "root"
+		});
+	}
+};
+i0.ɵɵngDeclareClassMetadata({
+	minVersion: "12.0.0",
+	version: "22.1.2",
+	ngImport: i0,
+	type: AddinClientService,
+	decorators: [{
+		type: Injectable,
+		args: [{ providedIn: "root" }]
+	}],
+	ctorParameters: () => []
+});
+var AddinClientHelpService = class AddinClientHelpService extends SkyHelpService {
+	constructor() {
+		super(...arguments);
+		this.skyAddinClientService = inject(AddinClientService);
+	}
+	openHelp(args) {
+		if (!args) return;
+		this.skyAddinClientService.openHelp(args);
+	}
+	updateHelp() {
+		throw new Error("Not implemented");
+	}
+	static {
+		this.ɵfac = i0.ɵɵngDeclareFactory({
+			minVersion: "12.0.0",
+			version: "22.1.2",
+			ngImport: i0,
+			type: AddinClientHelpService,
+			deps: null,
+			target: i0.ɵɵFactoryTarget.Injectable
+		});
+	}
+	static {
+		this.ɵprov = i0.ɵɵngDeclareInjectable({
+			minVersion: "12.0.0",
+			version: "22.1.2",
+			ngImport: i0,
+			type: AddinClientHelpService,
+			providedIn: "root"
+		});
+	}
+};
+i0.ɵɵngDeclareClassMetadata({
+	minVersion: "12.0.0",
+	version: "22.1.2",
+	ngImport: i0,
+	type: AddinClientHelpService,
+	decorators: [{
+		type: Injectable,
+		args: [{ providedIn: "root" }]
+	}]
+});
 function provideAddinClientHelp() {
-    return [{ provide: SkyHelpService, useClass: AddinClientHelpService }];
+	return [{
+		provide: SkyHelpService,
+		useClass: AddinClientHelpService
+	}];
 }
-
-/**
- * Generated bundle index. Do not edit.
- */
-
 export { AddinClientConfigService, AddinClientHelpService, AddinClientService, AddinEvent, AddinEventHandlerInstance, provideAddinClientHelp };
-//# sourceMappingURL=blackbaud-skyux-lib-addin-client.mjs.map
+
+//# sourceMappingURL=blackbaud-skyux-lib-addin-client.mjs.map